Merge pull request #15 from imax-iva/code_formatting

[minor] code formatting

.formatter.exs

@@ -0,0 +1,4 @@
+[
+  inputs: ["mix.exs", "{config,lib,test}/**/*.{ex,exs}"],
+  line_length: 120
+]

.gitignore

@@ -34,6 +34,7 @@ GitHub.sublime-settings
 .tags_sorted_by_file
 .vagrant
 .DS_Store
+.elixir_ls/*
 
 # Ignore released binaries
 rel/*/

.travis.yml

@@ -20,5 +20,3 @@ script:
   - "mix coveralls.travis"
   # Run static code analysis
   - "mix credo"
-  # Check code style
-  - "mix dogma"

bin/hooks/pre-commit.sh

@@ -1,4 +1,3 @@
 mix test
 mix coveralls
 mix credo
-mix dogma

lib/eview.ex

@@ -18,20 +18,16 @@ defmodule EView do
 
   def init(options), do: options
 
-  @spec call(Conn.t, any) :: Conn.t
+  @spec call(Conn.t(), any) :: Conn.t()
   def call(conn, _options) do
     conn
     |> register_before_send(&update_reponse_body/1)
   end
 
-  defp update_reponse_body(%{resp_body: []} = conn),
-    do: conn
-  defp update_reponse_body(%{resp_body: ""} = conn),
-    do: conn
-  defp update_reponse_body(%{resp_body: nil} = conn),
-    do: conn
-  defp update_reponse_body(%{resp_body: resp_body} = conn),
-    do: put_response(conn, resp_body)
+  defp update_reponse_body(%{resp_body: []} = conn), do: conn
+  defp update_reponse_body(%{resp_body: ""} = conn), do: conn
+  defp update_reponse_body(%{resp_body: nil} = conn), do: conn
+  defp update_reponse_body(%{resp_body: resp_body} = conn), do: put_response(conn, resp_body)
 
   @doc """
   Update `body` and add all meta objects that is required by API Manifest structure.
@@ -47,9 +43,10 @@ defmodule EView do
         resp =
           result
           |> wrap_body(conn)
-          |> Poison.encode_to_iodata!
+          |> Poison.encode_to_iodata!()
 
         %{conn | resp_body: resp}
+
       {:error, _} ->
         %{conn | resp_body: resp_body}
     end

lib/eview/changeset/validators/card_number.ex

@@ -9,12 +9,16 @@ if Code.ensure_loaded?(Ecto) and Code.ensure_loaded?(CreditCard) do
 
     def validate_card_number(changeset, field, opts \\ []) do
       allowed_card_types = opts[:allowed_card_types] || @allowed_card_types
-      validate_change changeset, field, :credit_card, fn _, value ->
+
+      validate_change(changeset, field, :credit_card, fn _, value ->
         if CreditCard.valid?(value, %{allowed_card_types: allowed_card_types}),
-            do: [],
-          else: [{field, {message(opts, "is not a valid card number"), [validation: :card_number,
-                                                                        allowed_card_types: allowed_card_types]}}]
-      end
+          do: [],
+          else: [
+            {field,
+             {message(opts, "is not a valid card number"),
+              [validation: :card_number, allowed_card_types: allowed_card_types]}}
+          ]
+      end)
     end
 
     defp message(opts, key \\ :message, default) do

lib/eview/changeset/validators/email_validator.ex

@@ -5,17 +5,19 @@ if Code.ensure_loaded?(Ecto) do
     """
     import Ecto.Changeset
 
-    @email_regex Regex.compile!(~S((?:[a-z0-9!#$%&'*+\/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+\/=?^_`{|}~-]+\)*|") <>
-                 ~S((?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f]\)*"\)) <>
-                 ~S(@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9]\)?\.\)+[a-z0-9](?:[a-z0-9-]*[a-z0-9]\)?) <>
-                 ~S(|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?\)\.\){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?) <>
-                 ~S(|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]) <>
-                 ~S(|\\[\x01-\x09\x0b\x0c\x0e-\x7f]\)+\)\]\)))
+    @email_regex Regex.compile!(
+                   ~S((?:[a-z0-9!#$%&'*+\/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+\/=?^_`{|}~-]+\)*|") <>
+                     ~S((?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f]\)*"\)) <>
+                     ~S(@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9]\)?\.\)+[a-z0-9](?:[a-z0-9-]*[a-z0-9]\)?) <>
+                     ~S(|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?\)\.\){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?) <>
+                     ~S(|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]) <>
+                     ~S(|\\[\x01-\x09\x0b\x0c\x0e-\x7f]\)+\)\]\))
+                 )
 
     def validate_email(changeset, field, opts \\ []) do
-      validate_change changeset, field, {:email, @email_regex}, fn _, value ->
+      validate_change(changeset, field, {:email, @email_regex}, fn _, value ->
         if value =~ @email_regex, do: [], else: [{field, {message(opts, "is not a valid email"), [validation: :email]}}]
-      end
+      end)
     end
 
     defp message(opts, key \\ :message, default) do

lib/eview/changeset/validators/metadata_validator.ex

@@ -14,9 +14,9 @@ if Code.ensure_loaded?(Ecto) do
     @jsonpath_joiner "."
 
     def validate_metadata(changeset, field, opts \\ []) do
-      validate_change changeset, field, :metadata, fn _, value ->
+      validate_change(changeset, field, :metadata, fn _, value ->
         get_metadata_errors(field, value, opts)
-      end
+      end)
     end
 
     defp get_metadata_errors(field, metadata, _opts) when is_map(metadata) do
@@ -34,43 +34,58 @@ if Code.ensure_loaded?(Ecto) do
 
     # Check max length of key
     defp field_validation_reducer(parent, {key, _}, acc) when is_binary(key) and byte_size(key) > @max_key_length do
-      [{field_path(parent, key),
-       {"key should be up to %{max} characters", [validation: :length, max: @max_key_length]}}
-      | acc]
+      [
+        {field_path(parent, key),
+         {"key should be up to %{max} characters", [validation: :length, max: @max_key_length]}}
+        | acc
+      ]
     end
 
     # Check binary value max length
     defp field_validation_reducer(parent, {key, val}, acc) when is_binary(val) and byte_size(val) > @max_value_length do
-      [{field_path(parent, key),
-       {"value should be up to %{max} characters", [validation: :length, max: @max_value_length]}}
-      | acc]
+      [
+        {field_path(parent, key),
+         {"value should be up to %{max} characters", [validation: :length, max: @max_value_length]}}
+        | acc
+      ]
     end
 
     # Check list values
     defp field_validation_reducer(parent, {key, list}, acc) when is_list(list) and length(list) > @max_list_length do
-      [{field_path(parent, key),
-       {"lists should be up to %{max} elements", [validation: :length, max: @max_list_length]}}
-      | acc]
+      [
+        {field_path(parent, key),
+         {"lists should be up to %{max} elements", [validation: :length, max: @max_list_length]}}
+        | acc
+      ]
     end
 
     # Check list elements length
     defp field_validation_reducer(parent, {key, list}, acc) when is_list(list) do
-      {errors, _} = Enum.reduce(list, {[], 0}, fn
-        %Decimal{}, {el_acc, i} ->
-          {el_acc, i + 1}
-        elem, {el_acc, i} when is_float(elem) or is_number(elem) ->
-          {el_acc, i + 1}
-        elem, {el_acc, i} when is_binary(elem) and byte_size(elem) <= @max_list_value_length ->
-          {el_acc, i + 1}
-        elem, {el_acc, i} when is_binary(elem) and byte_size(elem) > @max_list_value_length ->
-          {[{join_atoms(field_path(parent, key), "[#{i}]"),
-            {"list keys should be up to %{max} characters", [validation: :length, max: @max_key_length]}}
-          | el_acc], i + 1}
-        _, {el_acc, i} ->
-          {[{field_path(parent, key),
-            {"one of keys is invalid", [validation: :cast, type: [:integer, :float, :decimal, :string]]}}
-          | el_acc], i + 1}
-      end)
+      {errors, _} =
+        Enum.reduce(list, {[], 0}, fn
+          %Decimal{}, {el_acc, i} ->
+            {el_acc, i + 1}
+
+          elem, {el_acc, i} when is_float(elem) or is_number(elem) ->
+            {el_acc, i + 1}
+
+          elem, {el_acc, i} when is_binary(elem) and byte_size(elem) <= @max_list_value_length ->
+            {el_acc, i + 1}
+
+          elem, {el_acc, i} when is_binary(elem) and byte_size(elem) > @max_list_value_length ->
+            {[
+               {join_atoms(field_path(parent, key), "[#{i}]"),
+                {"list keys should be up to %{max} characters", [validation: :length, max: @max_key_length]}}
+               | el_acc
+             ], i + 1}
+
+          _, {el_acc, i} ->
+            {[
+               {field_path(parent, key),
+                {"one of keys is invalid", [validation: :cast, type: [:integer, :float, :decimal, :string]]}}
+               | el_acc
+             ], i + 1}
+        end)
 
       errors ++ acc
     end
@@ -81,16 +96,17 @@ if Code.ensure_loaded?(Ecto) do
 
     # Pass valid binary keys and values
     defp field_validation_reducer(_parent, {key, val}, acc)
-      when is_binary(key) and byte_size(key) <= @max_key_length
-       and is_binary(val) and byte_size(val) <= @max_value_length do
+         when is_binary(key) and byte_size(key) <= @max_key_length and is_binary(val) and
+                byte_size(val) <= @max_value_length do
       acc
     end
 
     # Everything else is an error
     defp field_validation_reducer(parent, {key, _val}, acc) do
-      [{field_path(parent, key),
-       {"is invalid", [validation: :cast, type: [:integer, :float, :decimal, :string]]}}
-      | acc]
+      [
+        {field_path(parent, key), {"is invalid", [validation: :cast, type: [:integer, :float, :decimal, :string]]}}
+        | acc
+      ]
     end
 
     # Join atom in JSON Path style

lib/eview/changeset/validators/phone_number.ex

@@ -8,11 +8,11 @@ if Code.ensure_loaded?(Ecto) do
     @phone_regex ~r/^\+[0-9]{9,16}$/
 
     def validate_phone_number(changeset, field, opts \\ []) do
-      validate_change changeset, field, {:phone_number, @phone_regex}, fn _, value ->
+      validate_change(changeset, field, {:phone_number, @phone_regex}, fn _, value ->
         if value =~ @phone_regex,
-            do: [],
+          do: [],
           else: [{field, {message(opts, "is not a valid phone number"), [validation: :phone_number]}}]
-      end
+      end)
     end
 
     defp message(opts, key \\ :message, default) do

lib/eview/helpers/changeset_validations_parser.ex

@@ -15,12 +15,7 @@ if Code.ensure_loaded?(Ecto) do
 
     defp construct_rule(%Ecto.Changeset{validations: validations}, field, {message, opts}) do
       validation_name = opts[:validation]
-      get_rule(
-        field,
-        validation_name,
-        put_validation(validations, validation_name, field, opts),
-        message,
-        opts)
+      get_rule(field, validation_name, put_validation(validations, validation_name, field, opts), message, opts)
     end
 
     # Special case for cast validation that stores type in field that dont match validation name
@@ -35,17 +30,16 @@ if Code.ensure_loaded?(Ecto) do
     end
 
     # Embeds
-    defp put_validation(validations, nil, field, [type: :map]) do
+    defp put_validation(validations, nil, field, type: :map) do
       [{field, {:cast, :map}} | validations]
     end
 
     # Embeds Many
-    defp put_validation(validations, nil, field, [type: {_, _} = type]) do
+    defp put_validation(validations, nil, field, type: {_, _} = type) do
       [{field, {:cast, type}} | validations]
     end
 
-    defp put_validation(validations, _, _field, _opts),
-      do: validations
+    defp put_validation(validations, _, _field, _opts), do: validations
 
     # Embeds
     defp get_rule(field, nil, validations, message, [type: {_, _}] = opts) do
@@ -128,21 +122,21 @@ if Code.ensure_loaded?(Ecto) do
         _, acc ->
           acc
       end)
-      |> Enum.uniq
+      |> Enum.uniq()
     end
 
-    defp cast_rules_type([h | _] = rules) when is_tuple(h),
-      do: rules |> Enum.into(%{})
-    defp cast_rules_type(rules),
-      do: rules
+    defp cast_rules_type([h | _] = rules) when is_tuple(h), do: rules |> Enum.into(%{})
+    defp cast_rules_type(rules), do: rules
 
     # Recursively flatten errors map
-    defp errors_flatener({field, [%{rule: _}|_] = rules}, prefix, entry_type) when is_list(rules) do
-      [%{
-        entry_type: entry_type,
-        entry: prefix <> @jsonpath_joiner <> to_string(field),
-        rules: rules
-      }]
+    defp errors_flatener({field, [%{rule: _} | _] = rules}, prefix, entry_type) when is_list(rules) do
+      [
+        %{
+          entry_type: entry_type,
+          entry: prefix <> @jsonpath_joiner <> to_string(field),
+          rules: rules
+        }
+      ]
     end
 
     defp errors_flatener({field, errors}, prefix, entry_type) when is_map(errors) do
@@ -151,17 +145,21 @@ if Code.ensure_loaded?(Ecto) do
     end
 
     defp errors_flatener({field, errors}, prefix, entry_type) when is_list(errors) do
-      {acc, _} = errors
-      |> Enum.reduce({[], 0}, fn inner_errors, {acc, i} ->
-        inner_rules = inner_errors
-        |> Enum.flat_map(&errors_flatener(
-             &1,
-             "#{prefix}#{@jsonpath_joiner}" <> to_string(field) <> "[#{i}]",
-             entry_type
-           ))
-
-        {acc ++ inner_rules, i + 1}
-      end)
+      {acc, _} =
+        errors
+        |> Enum.reduce({[], 0}, fn inner_errors, {acc, i} ->
+          inner_rules =
+            inner_errors
+            |> Enum.flat_map(
+              &errors_flatener(
+                &1,
+                "#{prefix}#{@jsonpath_joiner}" <> to_string(field) <> "[#{i}]",
+                entry_type
+              )
+            )
+
+          {acc ++ inner_rules, i + 1}
+        end)
 
       acc
     end

lib/eview/helpers/sanitization.ex

@@ -11,7 +11,7 @@ defmodule EView.Helpers.Sanitizer do
 
   def sanitize(term) when is_tuple(term) do
     term
-    |> Tuple.to_list
+    |> Tuple.to_list()
     |> sanitize()
   end
 

lib/eview/plugs/idempotency.ex

@@ -14,12 +14,13 @@ defmodule EView.Plugs.Idempotency do
 
   def init(opts), do: opts
 
-  @spec call(Conn.t, any) :: Conn.t
+  @spec call(Conn.t(), any) :: Conn.t()
   def call(conn, _options) do
     case get_req_header(conn, "x-idempotency-key") do
       [idempotency_key | _] ->
         conn
         |> put_resp_header("x-idempotency-key", idempotency_key)
+
       _ ->
         conn
     end