Format codebase

Author: halfdan

lib/cereal/association_not_loaded_error.ex

@@ -7,6 +7,7 @@ defmodule Cereal.AssociationNotLoadedError do
       Please pre-fetch the relationship before serialization or override the
       #{opts[:name]}/2 function in your serializer.
     """
+
     %Cereal.AssociationNotLoadedError{message: msg}
   end
 end

lib/cereal/builders/base.ex

@@ -10,14 +10,16 @@ defmodule Cereal.Builders.Base do
 
   Will correctly handle Scrievener pagination.
   """
-  @spec build(Cereal.Context.t) :: __MODULE__.t
+  @spec build(Cereal.Context.t()) :: __MODULE__.t()
   def build(context)
+
   if Code.ensure_loaded?(Scrivener) do
     def build(%{data: %Scrivener.Page{} = page, opts: opts} = context) do
       opts = opts |> Enum.into(%{}) |> Map.put(:page, to_page_options(page))
       build(%{context | data: page.entries, opts: opts})
     end
   end
+
   def build(%{serializer: serializer, data: data, opts: opts} = context) do
     opts = parse_opts(opts)
     data = serializer.preload(data, context.conn, Map.get(opts, :include, []))
@@ -33,16 +35,19 @@ defmodule Cereal.Builders.Base do
   defp build_metadata(%{opts: opts}), do: Map.get(opts, :metadata)
 
   defp parse_opts(opts) when is_list(opts), do: opts |> Map.new() |> parse_opts()
+
   defp parse_opts(opts) when is_map(opts) do
     opts
     |> parse_includes()
     |> parse_fields_list(:fields)
     |> parse_fields_list(:excludes)
   end
+
   defp parse_opts(_), do: %{}
 
   defp parse_includes(%{include: include} = opts) when is_binary(include),
     do: %{opts | include: Utils.normalize_includes(include)}
+
   defp parse_includes(opts), do: opts
 
   defp parse_fields_list(opts, key) do

lib/cereal/builders/entity.ex

@@ -10,7 +10,7 @@ defmodule Cereal.Builders.Entity do
       |> Map.put(:data, entity)
       |> build()
     end)
-    |> Enum.map(fn({:ok, result}) -> result end)
+    |> Enum.map(fn {:ok, result} -> result end)
   end
 
   def build(%{serializer: serializer} = context) do
@@ -23,18 +23,20 @@ defmodule Cereal.Builders.Entity do
       id: serializer.id(context.data, context.conn),
       type: serializer.type(context.data, context.conn),
       attributes: attributes(context),
-      rels: relationships(context),
+      rels: relationships(context)
     }
   end
 
   # if an assigns/2 function was specified in the serializer - we'll add its
   # return value to the conn's assigns
   defp do_assigns(%{serializer: serializer, conn: conn, data: data} = context) do
     conn = Map.put_new(conn, :assigns, %{})
+
     conn =
       data
       |> serializer.assigns(conn)
       |> Enum.reduce(conn, &do_assign/2)
+
     %{context | conn: conn}
   end
 
@@ -58,7 +60,7 @@ defmodule Cereal.Builders.Entity do
     relation =
       should_include_relation?(context.opts, name, rel_opts)
       |> case do
-        true  -> relation(context, name, rel_opts)
+        true -> relation(context, name, rel_opts)
         false -> nil
       end
 
@@ -71,6 +73,7 @@ defmodule Cereal.Builders.Entity do
   end
 
   defp build_relation_entity(nil, _, _, _), do: nil
+
   defp build_relation_entity(relation, context, name, rel_opts) do
     context
     |> Map.put(:serializer, rel_opts.serializer)
@@ -81,30 +84,37 @@ defmodule Cereal.Builders.Entity do
 
   defp with_relationship_includes(%{include: includes} = opts, name) when is_list(includes),
     do: %{opts | include: includes[name]}
+
   defp with_relationship_includes(opts, _), do: opts
 
   # We include the option when the following is true:
   # 1) The relation options have `include: true`
   # 2) The `include` option is passed in and includes the resource
   defp should_include_relation?(_, _, %{include: true}), do: true
+
   defp should_include_relation?(%{include: included}, name, _) when is_list(included),
     do: included[name] |> is_list()
+
   defp should_include_relation?(_, _, %{include: false}), do: false
   defp should_include_relation?(_, _, _), do: true
 
   defp filter_attributes(attrs, %{serializer: serializer, opts: %{fields: fields}} = context) when is_list(fields) do
     type = serializer.type(context.data, context.conn) |> String.to_atom()
     do_filter_attributes(attrs, {:take, fields[type]})
   end
+
   defp filter_attributes(attrs, %{serializer: serializer, opts: %{excludes: fields}} = context) when is_list(fields) do
     type = serializer.type(context.data, context.conn) |> String.to_atom()
     do_filter_attributes(attrs, {:drop, fields[type]})
   end
+
   defp filter_attributes(attrs, _), do: attrs
 
   defp do_filter_attributes(attrs, {:take, fields}) when is_list(fields),
     do: Map.take(attrs, fields)
+
   defp do_filter_attributes(attrs, {:drop, fields}) when is_list(fields),
     do: Map.drop(attrs, fields)
+
   defp do_filter_attributes(attrs, _), do: attrs
 end

lib/cereal/builders/error.ex

@@ -3,32 +3,38 @@ defmodule Cereal.Builders.Error do
   defstruct [:title, :code, :detail, :source, {:meta, %{}}]
 
   def build(%{data: %Ecto.Changeset{}} = context), do: build_errors_from_changeset(context)
+
   def build(%{data: data} = context) when is_list(data) do
-    data |> Enum.map(fn error ->
+    data
+    |> Enum.map(fn error ->
       context |> Map.put(:data, error) |> build()
     end)
   end
+
   def build(context) do
     attrs = with_serializer_context(context)
     struct(__MODULE__, attrs)
   end
 
   defp build_errors_from_changeset(%{data: cs} = context) do
-    cs.errors |> Enum.map(fn field ->
+    cs.errors
+    |> Enum.map(fn field ->
       context |> Map.put(:data, field) |> format_ecto_error()
     end)
   end
 
   defp format_ecto_error(%{data: {field, {message, vals}}} = context) do
-    message = Enum.reduce(vals, message, fn {key, value}, acc ->
-      case key do
-        :type -> acc
-        _     -> String.replace(acc, "%{#{key}}", to_string(value))
-      end
-    end)
+    message =
+      Enum.reduce(vals, message, fn {key, value}, acc ->
+        case key do
+          :type -> acc
+          _ -> String.replace(acc, "%{#{key}}", to_string(value))
+        end
+      end)
 
     %{context | data: {field, message}} |> format_ecto_error()
   end
+
   defp format_ecto_error(%{data: {field, message}, serializer: serializer} = context) do
     %__MODULE__{
       title: message,

lib/cereal/builders/errors.ex

@@ -4,7 +4,7 @@ defmodule Cereal.Builders.Errors do
 
   alias Cereal.Builders.Error
 
-  @spec build(Cereal.Context.t) :: __MODULE__.t
+  @spec build(Cereal.Context.t()) :: __MODULE__.t()
   def build(%{serializer: serializer} = context) do
     struct(__MODULE__, %{})
     |> Map.put(:title, serializer.title(context.conn))

lib/cereal/error_serializer.ex

@@ -13,14 +13,14 @@ defmodule Cereal.ErrorSerializer do
   defp define_default_title do
     quote do
       def title(conn), do: Cereal.ErrorSerializer.title(conn)
-      defoverridable [title: 1]
+      defoverridable title: 1
     end
   end
 
   defp define_default_status do
     quote do
       def status(conn), do: Cereal.ErrorSerializer.status(conn)
-      defoverridable [status: 1]
+      defoverridable status: 1
     end
   end
 
@@ -29,7 +29,7 @@ defmodule Cereal.ErrorSerializer do
       def error_detail(data), do: Cereal.ErrorSerializer.error_detail(data)
       def error_code(message), do: Cereal.ErrorSerializer.error_code(message)
       def error_metadata(message, conn), do: Cereal.ErrorSerializer.error_metadata(message, conn)
-      defoverridable [error_detail: 1, error_code: 1, error_metadata: 2]
+      defoverridable error_detail: 1, error_code: 1, error_metadata: 2
     end
   end
 

lib/cereal/formatter.ex

@@ -7,13 +7,14 @@ defmodule Cereal.Formatter do
   @doc """
   Given a base entity, format and returns a map or a list
   """
-  @callback format(Cereal.Builder.Base.t | Cereal.Builder.Errors.t) :: Map.t | List.t
+  @callback format(Cereal.Builder.Base.t() | Cereal.Builder.Errors.t()) :: Map.t() | List.t()
 
-  @spec format(Cereal.Builder.Base.t | Cereal.Builders.Errors.t) :: map | list
+  @spec format(Cereal.Builder.Base.t() | Cereal.Builders.Errors.t()) :: map | list
   def format(base), do: apply(formatter(base), :format, [base])
 
   defp formatter(%Cereal.Builders.Base{}),
     do: Application.get_env(:cereal, :formatter, Cereal.Formatters.Attributes)
+
   defp formatter(%Cereal.Builders.Errors{}),
     do: Application.get_env(:cereal, :error_formatter, Cereal.Formatters.Errors)
 end

lib/cereal/formatters/attributes.ex

@@ -6,9 +6,9 @@ defmodule Cereal.Formatters.Attributes do
   defp format_data(data) when is_list(data) do
     data
     |> Task.async_stream(&format_data(&1))
-    |> Enum.map(fn({:ok, result}) -> result end)
+    |> Enum.map(fn {:ok, result} -> result end)
   end
-  
+
   defp format_data(%Cereal.Builders.Entity{} = entity) do
     entity.attributes
     |> Map.put(:id, entity.id)

lib/cereal/formatters/errors.ex

@@ -2,22 +2,18 @@ defmodule Cereal.Formatters.Errors do
   @behaviour Cereal.Formatter
 
   def format(%Cereal.Builders.Errors{} = base) do
-    %{message: base.title,
-      code: base.status,
-      errors: format_errors(base.errors)}
+    %{message: base.title, code: base.status, errors: format_errors(base.errors)}
   end
 
   defp format_errors(errors) when is_list(errors), do: errors |> Enum.map(&format_error/1)
   defp format_errors(error), do: [format_error(error)]
 
   defp format_error(%Cereal.Builders.Error{} = error) do
-    %{field: error.source,
-      detail: error.detail,
-      title: error.title,
-      code: error.code} |> maybe_attach_metadata(error)
+    %{field: error.source, detail: error.detail, title: error.title, code: error.code} |> maybe_attach_metadata(error)
   end
 
   defp maybe_attach_metadata(attrs, %{meta: %{}}), do: attrs
+
   defp maybe_attach_metadata(attrs, %{meta: meta}) do
     attrs |> Map.put(:meta, meta)
   end

lib/cereal/phoenix_view.ex

@@ -1,6 +1,7 @@
 defmodule Cereal.PhoenixView do
   defmacro __using__(_) do
     module = __CALLER__.module
+
     quote do
       use Cereal.Serializer