No OneTemporary
Actions

Size

14 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/tesla.ex b/lib/tesla.ex
	index eee6ac1..50f20c2 100644
	--- a/lib/tesla.ex
	+++ b/lib/tesla.ex
	@@ -1,404 +1,408 @@
	defmodule Tesla.Error do
	defexception message: "", reason: nil
	end

	defmodule Tesla.Env do
	@type client :: (t,stack -> t)
	@type method :: :head \| :get \| :delete \| :trace \| :options \| :post \| :put \| :patch
	@type url :: binary
	@type param :: binary \| [{(binary \| atom), param}]
	@type query :: [{(binary \| atom), param}]
	@type headers :: %{binary => binary}
	@type body :: any #
	@type status :: integer
	@type opts :: [any]
	+ @type __module__ :: atom

	@type stack :: [{atom, atom, any}]

	@type t :: %__MODULE__{
	- method: method,
	- query: query,
	- url: url,
	- headers: headers,
	- body: body,
	- status: status
	+ method: method,
	+ query: query,
	+ url: url,
	+ headers: headers,
	+ body: body,
	+ status: status,
	+ opts: opts,
	+ __module__: __module__
	}

	- defstruct method: nil,
	- url: "",
	- query: [],
	- headers: %{},
	- body: nil,
	- status: nil,
	- opts: []
	+ defstruct method: nil,
	+ url: "",
	+ query: [],
	+ headers: %{},
	+ body: nil,
	+ status: nil,
	+ opts: [],
	+ __module__: nil
	end

	defmodule Tesla.Builder do
	@http_verbs ~w(head get delete trace options post put patch)a

	defmacro __using__(_opts) do
	quote do
	Module.register_attribute(__MODULE__, :__middleware__, accumulate: true)
	Module.register_attribute(__MODULE__, :__adapter__, [])

	@type option :: {:method, Tesla.Env.method} \|
	{:url, Tesla.Env.url} \|
	{:query, Tesla.Env.query} \|
	{:headers, Tesla.Env.headers} \|
	{:body, Tesla.Env.body} \|
	{:opts, Tesla.Env.opts}

	@doc """
	Perform a request using client function

	Options:
	- `:method` - the request method, one of [:head, :get, :delete, :trace, :options, :post, :put, :patch]
	- `:url` - either full url e.g. "http://example.com/some/path" or just "/some/path" if using `Tesla.Middleware.BaseUrl`
	- `:query` - a keyword list of query params, e.g. `[page: 1, per_page: 100]`
	- `:headers` - a keyworld list of headers, e.g. `[{"content-type", "text/plain"}]`
	- `:body` - depends on used middleware:
	- by default it can be a binary
	- if using e.g. JSON encoding middleware it can be a nested map
	- if adapter supports it it can be a Stream with any of the above
	- `:opts` - custom, per-request middleware or adapter options

	Examples:

	iex> ExampleApi.request(method: :get, url: "/users/path")

	You can also use shortcut methods like:

	iex> ExampleApi.get("/users/1")

	or

	iex> myclient \|> ExampleApi.post("/users", %{name: "Jon"})
	"""
	@spec request(Tesla.Env.client, [option]) :: Tesla.Env.t
	def request(client, options) do
	Tesla.perform_request(__MODULE__, client, options)
	end

	@doc """
	Perform a request. See `request/2` for available options.
	"""
	@spec request([option]) :: Tesla.Env.t
	def request(options) do
	Tesla.perform_request(__MODULE__, options)
	end

	unquote(generate_http_verbs())

	import Tesla.Builder, only: [plug: 1, plug: 2, adapter: 1, adapter: 2]
	@before_compile Tesla.Builder
	end
	end

	@doc """
	Attach middleware to your API client

	```ex
	defmodule ExampleApi do
	use Tesla

	# plug middleware module with options
	plug Tesla.Middleware.BaseURL, "http://api.example.com"
	plug Tesla.Middleware.JSON, engine: Poison

	# plug middleware function
	plug :handle_errors

	# middleware function gets two parameters: Tesla.Env and the rest of middleware call stack
	# and must return Tesla.Env
	def handle_errors(env, next) do
	env
	\|> modify_env_before_request
	\|> Tesla.run(next) # run the rest of stack
	\|> modify_env_after_request
	end
	end
	"""
	defmacro plug(middleware, opts \\ nil) do
	opts = Macro.escape(opts)
	middleware = Tesla.alias(middleware)
	quote do: @__middleware__ {unquote(middleware), unquote(opts)}
	end

	@doc """
	Choose adapter for your API client

	```ex
	defmodule ExampleApi do
	use Tesla

	# set adapter as module
	adapter Tesla.Adapter.Hackney

	# set adapter as function
	adapter :local_adapter

	# set adapter as anonymous function
	adapter fn env ->
	...
	env
	end


	# adapter function gets Tesla.Env as parameter and must return Tesla.Env
	def local_adapter(env) do
	...
	env
	end
	end
	"""
	defmacro adapter({:fn, _, _} = adapter) do
	adapter = Macro.escape(adapter)
	quote do: @__adapter__ unquote(adapter)
	end
	defmacro adapter(adapter, opts \\ nil) do
	adapter = Tesla.alias(adapter)
	quote do: @__adapter__ {unquote(adapter), unquote(opts)}
	end

	defp generate_http_verbs do
	Enum.map @http_verbs, &generate_api/1
	end

	defp generate_api(method) when method in [:post, :put, :patch] do
	quote do
	@doc """
	Perform a #{unquote(method \|> to_string \|> String.upcase)} request.
	See `request/1` or `request/2` for options definition.

	Example
	iex> myclient \|> ExampleApi.#{unquote(method)}("/users", %{name: "Jon"}, query: [scope: "admin"])
	"""
	@spec unquote(method)(Tesla.Env.client, Tesla.Env.url, Tesla.Env.body, [option]) :: Tesla.Env.t
	def unquote(method)(client, url, body, options) when is_function(client) do
	request(client, [method: unquote(method), url: url, body: body] ++ options)
	end

	@doc """
	Perform a #{unquote(method \|> to_string \|> String.upcase)} request.
	See `request/1` or `request/2` for options definition.

	Example
	iex> myclient \|> ExampleApi.#{unquote(method)}("/users", %{name: "Jon"})
	iex> ExampleApi.#{unquote(method)}("/users", %{name: "Jon"}, query: [scope: "admin"])
	"""
	@spec unquote(method)(Tesla.Env.client, Tesla.Env.url, Tesla.Env.body) :: Tesla.Env.t
	def unquote(method)(client, url, body) when is_function(client) do
	request(client, method: unquote(method), url: url, body: body)
	end
	@spec unquote(method)(Tesla.Env.url, Tesla.Env.body, [option]) :: Tesla.Env.t
	def unquote(method)(url, body, options) do
	request([method: unquote(method), url: url, body: body] ++ options)
	end

	@doc """
	Perform a #{unquote(method \|> to_string \|> String.upcase)} request.
	See `request/1` or `request/2` for options definition.

	Example
	iex> ExampleApi.#{unquote(method)}("/users", %{name: "Jon"})
	"""
	@spec unquote(method)(Tesla.Env.url, Tesla.Env.body) :: Tesla.Env.t
	def unquote(method)(url, body) do
	request(method: unquote(method), url: url, body: body)
	end
	end
	end

	defp generate_api(method) when method in [:head, :get, :delete, :trace, :options] do
	quote do
	@doc """
	Perform a #{unquote(method \|> to_string \|> String.upcase)} request.
	See `request/1` or `request/2` for options definition.

	Example
	iex> myclient \|> ExampleApi.#{unquote(method)}("/users", query: [page: 1])
	"""
	@spec unquote(method)(Tesla.Env.client, Tesla.Env.url, [option]) :: Tesla.Env.t
	def unquote(method)(client, url, options) when is_function(client) do
	request(client, [method: unquote(method), url: url] ++ options)
	end

	@doc """
	Perform a #{unquote(method \|> to_string \|> String.upcase)} request.
	See `request/1` or `request/2` for options definition.

	Example
	iex> myclient \|> ExampleApi.#{unquote(method)}("/users")
	iex> ExampleApi.#{unquote(method)}("/users", query: [page: 1])
	"""
	@spec unquote(method)(Tesla.Env.client, Tesla.Env.url) :: Tesla.Env.t
	def unquote(method)(client, url) when is_function(client) do
	request(client, method: unquote(method), url: url)
	end
	@spec unquote(method)(Tesla.Env.url, [option]) :: Tesla.Env.t
	def unquote(method)(url, options) do
	request([method: unquote(method), url: url] ++ options)
	end

	@doc """
	Perform a #{unquote(method \|> to_string \|> String.upcase)} request.
	See `request/1` or `request/2` for options definition.

	Example
	iex> ExampleApi.#{unquote(method)}("/users")
	"""
	@spec unquote(method)(Tesla.Env.url) :: Tesla.Env.t
	def unquote(method)(url) do
	request(method: unquote(method), url: url)
	end
	end
	end

	defmacro __before_compile__(env) do
	adapter = Module.get_attribute(env.module, :__adapter__) \|\| quote(do: Tesla.default_adapter)
	middleware = Module.get_attribute(env.module, :__middleware__) \|> Enum.reverse

	quote do
	def __middleware__, do: unquote(middleware)
	def __adapter__, do: unquote(adapter)
	end
	end
	end

	defmodule Tesla do
	use Tesla.Builder

	@moduledoc """
	A HTTP toolkit for building API clients using middlewares

	Include Tesla module in your api client:

	```ex
	defmodule ExampleApi do
	use Tesla

	plug Tesla.Middleware.BaseURL, "http://api.example.com"
	plug Tesla.Middleware.JSON
	end
	"""

	- defmacro __using__(opts) do
	+ defmacro __using__(_opts) do
	quote do
	- use Tesla.Builder, unquote(opts)
	+ use Tesla.Builder, module: __MODULE__
	end
	end

	@aliases [
	httpc: Tesla.Adapter.Httpc,
	hackney: Tesla.Adapter.Hackney,
	ibrowse: Tesla.Adapter.Ibrowse,

	base_url: Tesla.Middleware.BaseUrl,
	headers: Tesla.Middleware.Headers,
	query: Tesla.Middleware.Query,
	decode_rels: Tesla.Middleware.DecodeRels,
	json: Tesla.Middleware.JSON,
	logger: Tesla.Middleware.Logger,
	debug_logger: Tesla.Middleware.DebugLogger
	]
	def alias(key) when is_atom(key), do: Keyword.get(@aliases, key, key)
	def alias(key), do: key

	def perform_request(module, client, options), do: do_request(module, [client], options)
	def perform_request(module, options), do: do_request(module, [], options)

	defp do_request(module, clients, options) do
	stack = prepare(module, clients ++ module.__middleware__ ++ default_middleware ++ [module.__adapter__])
	- env = struct(Tesla.Env, options)
	+ env = struct(Tesla.Env, options ++ [__module__: module])
	run(env, stack)
	end

	def prepare(module, stack) do
	Enum.map stack, fn
	{name, opts} -> prepare_module(module, name, opts)
	name when is_atom(name) -> prepare_module(module, name, nil)
	fun when is_function(fun) -> {:fn, fun}
	end
	end

	defp prepare_module(module, name, opts) do
	case Atom.to_char_list(name) do
	~c"Elixir." ++ _ -> {name, :call, [opts]}
	_ -> {module, name}
	end
	end

	# empty stack case is useful for reusing/testing middlewares (just pass [] as next)
	def run(env, []), do: env

	# last item in stack is adapter - skip passing rest of stack
	def run(env, [{:fn, f}]), do: apply(f, [env])
	def run(env, [{m,f}]), do: apply(m, f, [env])
	def run(env, [{m,f,a}]), do: apply(m, f, [env \| a])

	# for all other elements pass (env, next, opts)
	def run(env, [{:fn, f} \| rest]), do: apply(f, [env, rest])
	def run(env, [{m,f} \| rest]), do: apply(m, f, [env, rest])
	def run(env, [{m,f,a} \| rest]), do: apply(m, f, [env, rest \| a])

	# useful helper fuctions
	def put_opt(env, key, value) do
	Map.update!(env, :opts, &Keyword.put(&1, key, value))
	end


	def default_adapter do
	adapter = Application.get_env(:tesla, :adapter, :httpc) \|> Tesla.alias
	{adapter, []}
	end

	def default_middleware do
	[{Tesla.Middleware.Normalize, nil}]
	end


	@doc """
	Dynamically build client from list of middlewares.

	```ex
	defmodule ExampleAPI do
	use Tesla

	def new(token) do
	Tesla.build_client([
	{Tesla.Middleware.Headers, %{"Authorization" => token}}
	])
	end
	end

	client = ExampleAPI.new(token: "abc")
	client \|> ExampleAPI.get("/me")
	```
	"""
	defmacro build_client(stack) do
	quote do
	fn env, next -> Tesla.run(env, Tesla.prepare(__MODULE__, unquote(stack)) ++ next) end
	end
	end

	def build_url(url, []), do: url
	def build_url(url, query) do
	join = if String.contains?(url, "?"), do: "&", else: "?"
	url <> join <> encode_query(query)
	end

	defp encode_query(query) do
	query
	\|> Enum.flat_map(&encode_pair/1)
	\|> URI.encode_query
	end

	defp encode_pair({key, value}) when is_list(value) do
	if Keyword.keyword?(value) do
	Enum.flat_map(value, fn {k,v} -> encode_pair({"#{key}[#{k}]", v}) end)
	else
	Enum.map(value, fn e -> {"#{key}[]", e} end)
	end
	end
	defp encode_pair({key, value}), do: [{key, value}]
	end
	diff --git a/test/tesla/middleware/retry_test.exs b/test/tesla/middleware/retry_test.exs
	index 5fcf3a4..5328433 100644
	--- a/test/tesla/middleware/retry_test.exs
	+++ b/test/tesla/middleware/retry_test.exs
	@@ -1,49 +1,49 @@
	defmodule RetryTest do
	use ExUnit.Case, async: false

	use Tesla.Middleware.TestCase, middleware: Tesla.Middleware.Retry

	defmodule LaggyAdapter do
	def start_link, do: Agent.start_link(fn -> 0 end, name: __MODULE__)

	def call(env, _opts) do
	Agent.get_and_update __MODULE__, fn retries ->
	response = case env.url do
	"/ok" -> env
	"/maybe" when retries < 5 -> {:error, :econnrefused}
	"/maybe" -> env
	"/nope" -> {:error, :econnrefused}
	end

	{response, retries + 1}
	end
	end
	end


	defmodule Client do
	use Tesla

	plug Tesla.Middleware.Retry, delay: 10, max_retries: 10

	adapter LaggyAdapter
	end

	setup do
	{:ok, _} = LaggyAdapter.start_link
	:ok
	end

	test "pass on successful request" do
	- assert %Tesla.Env{url: "/ok", method: :get} == Client.get("/ok")
	+ assert %Tesla.Env{url: "/ok", method: :get} = Client.get("/ok")
	end

	test "finally pass on laggy request" do
	- assert %Tesla.Env{url: "/maybe", method: :get} == Client.get("/maybe")
	+ assert %Tesla.Env{url: "/maybe", method: :get} = Client.get("/maybe")
	end

	test "raise if max_retries is exceeded" do
	assert_raise Tesla.Error, fn -> Client.get("/nope") end
	end

	end

File Metadata

Mime Type: text/x-diff
Expires: Tue, Jan 21, 7:29 AM (1 d, 1 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 55679
Default Alt Text: (14 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions