Alchemy API for Elixir

alchemy.ex

defmodule Foo.Alchemy do
  use HTTPoison.Base

  def process_url(url) do
    URI.encode(Application.get_env(:foo, :alchemy_url) <> url)
  end

  def request(url, text) do
    querystring = params(text) |> to_querystring
    case post(url, querystring, headers) do
      {:ok, response} -> {:ok, response.body}
      error -> error
    end
  end

  def emotion(text) do
    start
    case request("TextGetEmotion", text) do
      {:ok, response} -> {:ok, response[:docEmotions]}
      error -> error
    end
  end

  def sentiment(text) do
    start
    case request("TextGetTextSentiment", text) do
      {:ok, response} -> {:ok, response[:docSentiment]}
      error -> error
    end
  end

  def ranked_keywords(text) do
    start
    case request("TextGetRankedKeywords", text) do
      {:ok, response} -> {:ok, response[:keywords]}
      error -> error
    end
  end

  def ranked_name_entities(text) do
    start
    case request("TextGetRankedNamedEntities", text) do
      {:ok, response} -> {:ok, response[:entities]}
      error -> error
    end
  end

  def ranked_taxonomy(text) do
    start
    case request("TextGetRankedTaxonomy", text) do
      {:ok, response} -> {:ok, response[:taxonomy]}
      error -> error
    end
  end

  def ranked_concepts(text) do
    start
    case request("TextGetRankedConcepts", text) do
      {:ok, response} -> {:ok, response[:concepts]}
      error -> error
    end
  end

  defp to_querystring(params) do
    params
    |> Enum.map(fn {k, v} -> "#{k}=#{v}" end)
    |> Enum.join("&")
  end

  def process_response_body(body) do
    body
    |> Poison.decode!
    |> Enum.map(fn({k, v}) -> {String.to_atom(k), v} end)
  end

  def headers do
    [
      {"Content-Type", "application/x-www-form-urlencoded"},
      {"Accept", "application/json"}
    ]
  end

  def params(text) do
    [
      apikey: Application.get_env(:foo, :alchemy_api_key),
      text: text,
      language: "english",
      outputMode: "json"
    ]
  end
end