extend "accepts" to accept a Proc. about http

[tarcieri]

The current state of response parsing is up in the air. See #39.

Right now the body should get parsed automatically if the JSON gem is loaded. In the new API, I'd propose:

HTTP.accept(:json).get(url).parse_body

looks good. could parse() accept a Proc to override the default handler?

[tarcieri]

Well, the point of #parse_body is it can know the Content-Type from the response and choose an appropriate parser. I'm not sure what an arbitrary Proc would get you... you could use #body.to_s to obtain a string and parse it however you want at that point ;)

yeah, #to_s and checking the content-type manually works. my idea was flawed because i was assuming 'Accept' would guarantee a response of the same Content-Type but of course that isn't true. I was thinking about someone who wanted to use a (custom) JSON parser whenever that Content-Type is encountered though. is it going to be possible to extend the content-types that the HTTP library will understand and automatically parse as JSON?

maybe company X has defined their own content-type to describe the schema of a JSON document and would like to take advantage of the letting the http library parse the body. otherwise they're back to checking the Content-Type manually & doing the parsing themselves (i would figure).

[tarcieri]

@robgleeson the MIME type handlers are pluggable. See:

https://github.com/tarcieri/http/blob/master/lib/http/mime_types/json.rb

Arguably they could have a better API

yeah, i think there should probably be an easy way to alias a custom content-type as being understood as JSON(or XML, CSV, or …) by the http lib if it has predefined handlers for JSON/XML/CSV. it would also be nice if I could extend the http lib to understand new content-types and define custom handlers so that the http lib interface doesn't end up being inconsistent or needing a different API for content-type's it doesn't account for.

by "different API" I mean if I think I might get a content-type that http lib doesn't understand I need to check the content-type and handle the parsing myself, even if response could have a content-type that is understood, there's a chance it doesn't so i cannot rely on #parsed.

[tarcieri]

I also like this style of registering API adapters:

https://github.com/copiousfreetime/qup/blob/master/lib/qup/adapter/redis.rb#L10

So it would work like:

class MyHandler < HTTP::MimeType
  register 'application/myformat'

  def parse(data)
    do_awesome_stuff(data)
  end
end

[tarcieri]

If that's all you want, you could do it like this:

response = HTTP.accept(:json).get(url)
body = response.body.to_s

case response['Content-Type']
when 'application/myformat'
  ...
end

yeah, I could, but then the parsed doesn't handle that case, so I can't use it (but I'd like to).
I'd be cool with registering new types as a subclass as long as I can register the type with http so that it is understood and used when #parsed is called.

something like HTTP::Handler["application/myformat"] = MyHandler.new might be nice (that'd let me re-assign and re-use other handlers that the #parsed method uses).

gonna close, original idea didn't make sense.