Additional API

[0xAX]

Hello @josevalim,

Would be good to have following cowboy wrappers in plug:

• :cowboy_req.path(req)/1
• :cowboy_req.body/1
• ::cowboy_req.cookie/2
• :cowboy_req.cookies/1

If there are already in plug, sorry, and let me know please where to find it.

[josevalim]

path is already as path_info (it returns a list though). You can easily convert it back to a path though. We won't have a body/1 but we will have built-in parameter parsing. I will add cookies (both request and response cookies) when I am done with parameter parsing. Thanks!

[0xAX]

If request will have json body payload, how to get it?

[josevalim]

You just need to create a parser like this one:

https://github.com/elixir-lang/plug/blob/master/lib/plug/parsers/urlencoded.ex

I am working on the api for plugging different parsers (I will be done with it today) but you will need to do something like:

alias Plug.Parsers, as: P
P.call(conn, parsers: [P.URLENCODED, P.MULTIPART, P.MY_JSON_PARSER], limit: 8_000_000)

[josevalim]

Ok, the parsing API is done. You can use urlencoded above as an example for your own json parsing and calling parsing works as shown above. Tests can be found here (and you can use similar to test your own parsers):

https://github.com/elixir-lang/plug/blob/master/test/plug/parsers_test.exs

/cc @devinus

[josevalim]

Now I am starting work on cookies. :)

[glesica]

Hijacking this instead of opening a new issue. It's not entirely clear to me how one would go about adding a new parser, as mentioned above. So, for instance, I want to implement a JSON parser. It seemed pretty simple:

defmodule Mineshaft.Parsers.JSON do
  @moduledoc false
  alias Plug.Conn

  def parse(Conn[] = conn, "application", "json", _headers, opts) do
    read_body(conn, Keyword.fetch!(opts, :limit))
  end

  def parse(conn, _type, _subtype, _headers, _opts) do
    { :next, conn }
  end

  defp read_body(Conn[adapter: { adapter, state }] = conn, limit) do
    case read_body({ :ok, "", state }, "", limit, adapter) do
      { :too_large, state } ->
        { :too_large, conn.adapter({ adapter, state }) }
      { :ok, body, state } ->
        { :ok, JSEX.decode(body), conn.adapter({ adapter, state }) }
    end
  end

  defp read_body({ :ok, buffer, state }, acc, limit, adapter) when limit >= 0,
    do: read_body(adapter.stream_req_body(state, 1_000_000), acc <> buffer, limit - byte_size(buffer), adapter)
  defp read_body({ :ok, _, state }, _acc, _limit, _adapter),
    do: { :too_large, state }

  defp read_body({ :done, state }, acc, limit, _adapter) when limit >= 0,
    do: { :ok, acc, state }
  defp read_body({ :done, state }, _acc, _limit, _adapter),
    do: { :too_large, state }
end

However this results in an error at runtime, specifically Plug.Parsers.UnsupportedMediaTypeError gets raised. I suspect I'm missing something, anyone have any thoughts? This might be a simple documentation issue (or user error on my part...).

[ericmj]

@glesica Here is an example of a working JSON parser:

https://github.com/ericmj/explex_web/blob/aa9e0e5fc1afeaf2769b0d6a43a3373f0e3e3700/lib/explex_web/util/json_decoder.ex
https://github.com/ericmj/explex_web/blob/aa9e0e5fc1afeaf2769b0d6a43a3373f0e3e3700/lib/explex_web/router/api.ex#L12

[josevalim]

@glesica after you implement the parser you need to hook it up, as @ericmj did in the second example, and you should be good to go. :)

[glesica]

Copied the example above (changing the bits that were specific to Explex) but I still get the same error. I was not positive where to put the second part where the parser gets hooked up, so I stuck it in the sugar router module, which seemed to be the closest to the example. It runs, but it errors out in the same place it was erroring out before.