Apply mix format

Author: bitwalker

lib/builder.ex

@@ -1,57 +1,59 @@
 defmodule Toml.Document do
   @moduledoc false
-  
+
   # Represents a TOML document, and handles conversion to a plain map
   # See `Toml.Builder` for the actual logic for constructing the document.
 
   defstruct [:keys, :comments, :open_table, :comment_stack, :keyfun, :transforms]
-  
+
   # A key is either binary or atom depending on the decoder option value
   @type key :: binary | atom | term
-  
+
   # A value is the fully decoded value from the TOML
-  @type value :: %{key => value}
-               | {:table_array, [%{key => value}]}
-               | number
-               | binary
-               | NaiveDateTime.t
-               | DateTime.t
-               | Date.t
-               | Time.t
-               | [value]
-               
+  @type value ::
+          %{key => value}
+          | {:table_array, [%{key => value}]}
+          | number
+          | binary
+          | NaiveDateTime.t()
+          | DateTime.t()
+          | Date.t()
+          | Time.t()
+          | [value]
+
   # A keypath is a list of keys, they are all of the same key type
   @type keypath :: list(binary) | list(atom) | list(term)
-  
+
   @type t :: %__MODULE__{
-    keys: %{key => value},
-    comments: %{keypath => binary},
-    open_table: keypath | nil,
-    comment_stack: [binary],
-    keyfun: nil | ((binary) -> term | no_return),
-    transforms: [Toml.Transform.t]
-  }
-  
+          keys: %{key => value},
+          comments: %{keypath => binary},
+          open_table: keypath | nil,
+          comment_stack: [binary],
+          keyfun: nil | (binary -> term | no_return),
+          transforms: [Toml.Transform.t()]
+        }
+
   @doc """
   Create a new empty TOML document
   """
-  @spec new(Toml.opts) :: t
+  @spec new(Toml.opts()) :: t
   def new(opts) when is_list(opts) do
     keyfun = to_key_fun(Keyword.get(opts, :keys, :strings))
     transforms = Keyword.get(opts, :transforms, [])
+
     %__MODULE__{
-      keys: %{}, 
-      comments: %{}, 
+      keys: %{},
+      comments: %{},
       open_table: nil,
       comment_stack: [],
       keyfun: keyfun,
       transforms: transforms
     }
   end
- 
+
   @doc """
   Convert the given TOML document to a plain map.
-  
+
   During conversion to a plain map, keys are converted according 
   to the key type defined when the document was created.
 
@@ -68,9 +70,11 @@ defmodule Toml.Document do
       case ts do
         [] ->
           nil
+
         ts when is_list(ts) ->
           Toml.Transform.compose(ts)
       end
+
     {:ok, to_map2(keys, keyfun, transform)}
   catch
     _, {:error, {:keys, {:non_existing_atom, _}}} = err ->
@@ -81,19 +85,23 @@ defmodule Toml.Document do
   defp to_map2(m, nil, nil) when is_map(m) do
     for {k, v} <- m, into: %{}, do: {k, to_map3(k, v, nil, nil)}
   end
+
   defp to_map2(m, keyfun, nil) when is_map(m) and is_function(keyfun, 1) do
-    for {k, v} <- m, into: %{} do 
+    for {k, v} <- m, into: %{} do
       k2 = keyfun.(k)
       {k2, to_map3(k2, v, keyfun, nil)}
     end
   end
+
   defp to_map2(m, nil, transform) when is_map(m) and is_function(transform, 2) do
     for {k, v} <- m, into: %{} do
       v2 = to_map3(k, v, nil, transform)
       {k, v2}
     end
   end
-  defp to_map2(m, keyfun, transform) when is_map(m) and is_function(keyfun, 1) and is_function(transform, 2) do
+
+  defp to_map2(m, keyfun, transform)
+       when is_map(m) and is_function(keyfun, 1) and is_function(transform, 2) do
     for {k, v} <- m, into: %{} do
       k2 = keyfun.(k)
       v2 = to_map3(k2, v, keyfun, transform)
@@ -104,39 +112,46 @@ defmodule Toml.Document do
   # Called when a table value is being converted
   defp to_map3(_key, %_{} = s, _keyfun, nil), do: s
   defp to_map3(key, %_{} = s, _keyfun, transform), do: transform.(key, s)
+
   defp to_map3(key, list, keyfun, nil) when is_list(list) do
     for v <- list, do: to_map3(key, v, keyfun, nil)
   end
+
   defp to_map3(key, list, _keyfun, transform) when is_list(list) do
     transform.(key, list)
   end
-  defp to_map3(_key, {:table_array, list}, keyfun, transform) do 
+
+  defp to_map3(_key, {:table_array, list}, keyfun, transform) do
     for v <- Enum.reverse(list) do
       to_map2(v, keyfun, transform)
     end
   end
+
   defp to_map3(_key, v, keyfun, nil) when is_map(v) do
     to_map2(v, keyfun, nil)
   end
+
   defp to_map3(key, v, keyfun, transform) when is_map(v) and is_function(transform) do
     transform.(key, to_map2(v, keyfun, transform))
   end
+
   defp to_map3(_key, v, _keyfun, nil), do: v
   defp to_map3(key, v, _keyfun, transform), do: transform.(key, v)
-  
+
   # Convert the value of `:keys` to a key conversion function (if not already one)
   defp to_key_fun(:atoms), do: &to_atom/1
   defp to_key_fun(:atoms!), do: &to_existing_atom/1
   defp to_key_fun(:strings), do: nil
   defp to_key_fun(fun) when is_function(fun, 1), do: fun
-  
+
   # Convert the given key (as binary) to an atom
   # Handle converting uppercase keys to module names rather than plain atoms
   defp to_atom(<<c::utf8, _::binary>> = key) when c >= ?A and c <= ?Z do
     Module.concat([key])
   end
+
   defp to_atom(key), do: String.to_atom(key)
-  
+
   # Convert the given key (as binary) to an existing atom
   # Handle converting uppercase keys to module names rather than plain atoms
   #
@@ -146,12 +161,13 @@ defmodule Toml.Document do
     Module.concat([String.to_existing_atom(key)])
   rescue
     _ ->
-      throw {:error, {:keys, {:non_existing_atom, key}}}
+      throw({:error, {:keys, {:non_existing_atom, key}}})
   end
+
   defp to_existing_atom(key) do
     String.to_existing_atom(key)
   rescue
     _ ->
-      throw {:error, {:keys, {:non_existing_atom, key}}}
+      throw({:error, {:keys, {:non_existing_atom, key}}})
   end
 end

lib/decoder.ex

@@ -1,97 +1,125 @@
 defmodule Toml.Error do
   @moduledoc false
-  
+
   defexception [:message, :reason]
-  
+
   def exception(msg) when is_binary(msg) do
     %__MODULE__{message: msg, reason: nil}
   end
+
   def exception({:error, reason}) do
     %__MODULE__{message: format_reason(reason), reason: reason}
   end
+
   def exception(reason) when is_tuple(reason) do
     %__MODULE__{message: format_reason(reason), reason: reason}
   end
 
   def message(%__MODULE__{message: message}) do
     message
   end
-  
+
   @doc """
   Convert internal error reasons into friendly, printable form
   """
   def format_reason({:keys, {:non_existing_atom, key}}),
     do: "unable to convert '#{key}' to an existing atom"
+
   def format_reason({:expected, token, other}),
     do: "expected #{format_token(token)}, but got #{format_token(other)}"
+
   def format_reason({:invalid_token, token}),
     do: "invalid token #{format_token(token)}"
+
   def format_reason({:invalid_integer, :leading_zero}),
     do: "invalid integer syntax, leading zeros are not allowed"
+
   def format_reason({:invalid_float, :leading_zero}),
     do: "invalid float syntax, leading zeros are not allowed"
+
   def format_reason({:invalid_float, token}),
     do: "invalid float syntax, unexpected token #{format_token(token)}"
+
   def format_reason({:invalid_datetime, reason}),
-    do: "invalid datetime syntax, #{inspect reason}"
+    do: "invalid datetime syntax, #{inspect(reason)}"
+
   def format_reason({:invalid_datetime_offset, reason}),
-    do: "invalid datetime offset syntax, #{inspect reason}"
+    do: "invalid datetime offset syntax, #{inspect(reason)}"
+
   def format_reason({:invalid_date, reason}),
-    do: "invalid date syntax, #{inspect reason}"
+    do: "invalid date syntax, #{inspect(reason)}"
+
   def format_reason({:invalid_time, reason}),
-    do: "invalid time syntax, #{inspect reason}"
+    do: "invalid time syntax, #{inspect(reason)}"
+
   def format_reason({:invalid_key_value, token}),
     do: "invalid key/value syntax, unexpected token #{format_token(token)}"
+
   def format_reason({:unclosed_table_array_name, token}),
     do: "unclosed table array name at #{format_token(token)}"
+
   def format_reason({:unclosed_array, {oline, ocol}}),
     do: "unclosed array started on line #{oline}, column #{ocol}"
+
   def format_reason({:unclosed_inline_table, {oline, ocol}}),
     do: "unclosed inline table started on line #{oline}, column #{ocol}"
+
   def format_reason(:unclosed_quote),
     do: "unclosed quoted string"
+
   def format_reason(:unexpected_newline),
     do: "unexpected newline in single-quoted string"
+
   def format_reason(:unexpected_eof),
     do: "unexpected end of file"
+
   def format_reason({:invalid_escape, char}),
     do: "illegal escape sequence #{char}"
+
   def format_reason({:invalid_control_char, char}) do
     if String.printable?(char) do
-      "illegal control character #{inspect char, base: :hex} ('#{char}')"
+      "illegal control character #{inspect(char, base: :hex)} ('#{char}')"
     else
-      "illegal control character #{inspect char, base: :hex}"
+      "illegal control character #{inspect(char, base: :hex)}"
     end
   end
+
   def format_reason({:invalid_char, char}) do
     if String.printable?(char) do
-      "illegal character #{inspect char, base: :hex} ('#{char}')"
+      "illegal character #{inspect(char, base: :hex)} ('#{char}')"
     else
-      "illegal character #{inspect char, base: :hex}"
+      "illegal character #{inspect(char, base: :hex)}"
     end
   end
+
   def format_reason({:invalid_unicode, char}) do
     if String.printable?(char) do
-      "illegal unicode escape, #{inspect char, base: :hex} ('#{char}')"
+      "illegal unicode escape, #{inspect(char, base: :hex)} ('#{char}')"
     else
-      "illegal unicode escape, #{inspect char, base: :hex}"
+      "illegal unicode escape, #{inspect(char, base: :hex)}"
     end
   end
+
   def format_reason({:key_exists, key}) do
     "cannot redefine key in path '#{key}'"
   end
-  def format_reason(reason), do: "#{inspect reason}"
-  
+
+  def format_reason(reason), do: "#{inspect(reason)}"
+
   # Format a token in `{type, data}`, or `type` form into printable representation
   defp format_token({true, _}), do: "'true'"
   defp format_token({false, _}), do: "'false'"
   defp format_token(:newline), do: "'\\n'"
+
   defp format_token({_, data}) when is_binary(data),
     do: "'#{data}'"
+
   defp format_token({token, data}) when is_atom(token),
     do: "'#{data}' (#{token})"
+
   defp format_token({token, _}),
     do: "'#{<<token>>}'"
+
   defp format_token(token),
     do: "'#{<<token>>}'"
 end