# Accent

[![Build Status](](
[![Coverage Status](](

## Installation

This package can be installed by adding `accent` to your list of dependencies in

def deps do
  [{:accent, "~> 0.2"}]

Please note that you will need to provide `accent` with a JSON codec. Both
[`poison`]( and
[`jason`]( are supported.

## Usage

This project provides two plugs for handling the conversion of JSON keys to
different cases: `Accent.Plug.Request` and `Accent.Plug.Response`

### `Accent.Plug.Request`

Transforms the keys of an HTTP request's params to the same or a different

You can specify what case to convert keys to by passing in a `:transformer`

Accent supports the following transformers out of the box:

* `Accent.Transformer.CamelCase` (e.g. `CamelCase`)
* `Accent.Transformer.PascalCase` (e.g. `pascalCase`)
* `Accent.Transformer.SnakeCase` (e.g. `snake_case`)

If no transformer is provided then `Accent.Transformer.SnakeCase` will be

Please note that this plug will need to be executed after the request has
been parsed.

### Example

Given this request:

curl -X POST \
  -H "Content-Type: application/json" \
  -d '{"helloWorld": "value"}'

a router with this configuration:

plug Plug.Parsers, parsers: [:urlencoded, :multipart, :json],
                   pass: ["*/*"],
                   json_decoder: Poison

plug Accent.Plug.Request

could expect to receive a `conn.params` value of:

%{"hello_world" => "value"}

### `Accent.Plug.Response`

Transforms the keys of an HTTP response to the case requested by the client.

A client can request what case the keys are formatted in by passing the case
as a header in the request. By default the header key is `Accent`. If the
client does not request a case or requests an unsupported case then no
conversion will happen. By default the supported cases are `camel`, `pascal`
and `snake`.

### Options

* `:header` - the HTTP header used to determine the case to convert the
  response body to before sending the response (default: `Accent`)
* `:json_encoder` - module used to encode JSON. The module is expected to
  define a `encode!/1` function for encoding the response body as JSON.
* `:json_decoder` - module used to decode JSON. The module is expected to
  define a `decode!/1` function for decoding JSON into a map. (required)
* `:supported_cases` - map that defines what cases a client can request. By
  default `camel`, `pascal` and `snake` are supported.

### Examples

Given this request:

curl -X POST \
  -H "Content-Type: application/json" \
  -H "Accent: pascal" \
  -d '{"helloWorld": "value"}'

with this router:

defmodule MyAPI.Router do
  use Plug.Router

  plug Accent.Plug.Response, json_encoder: Poison,
                             json_decoder: Poison

  post "/endpoints" do
    send_resp(conn, 200, Poison.encode!(%{hello_world: "value"}))

a client could expect a JSON response of:

  "helloWorld": "value"

## Contributors

A special thanks to all of our contributors!

* [@anthonator](
* [@maxsalven](
* [@szajbus](