formatting code with elxir 1.6.0 formatter

.formatter.exs

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

lib/fsm.ex

@@ -3,22 +3,24 @@ defmodule Fsm do
     quote do
       import Fsm
 
-      defstruct [state: unquote(opts[:initial_state]),
-                 data:  unquote(opts[:initial_data])]
+      defstruct state: unquote(opts[:initial_state]),
+                data: unquote(opts[:initial_data])
 
       @declaring_state nil
-      @declared_events MapSet.new
+      @declared_events MapSet.new()
 
       def new(params \\ []), do: struct!(__MODULE__, params)
 
       def state(%__MODULE__{state: state}), do: state
       def data(%__MODULE__{data: data}), do: data
 
-      defp change_state(%__MODULE__{} = fsm, {:action_responses, responses}), do: parse_action_responses(fsm, responses)
+      defp change_state(%__MODULE__{} = fsm, {:action_responses, responses}),
+        do: parse_action_responses(fsm, responses)
+
       defp change_state(%__MODULE__{} = fsm, _), do: fsm
 
       defp parse_action_responses(fsm, responses) do
-        Enum.reduce(responses, fsm, fn(response, fsm) ->
+        Enum.reduce(responses, fsm, fn response, fsm ->
           handle_action_response(fsm, response)
         end)
       end
@@ -42,14 +44,17 @@ defmodule Fsm do
 
   def respond(response), do: {:action_responses, [respond: response]}
   def respond(response, state), do: {:action_responses, [next_state: state, respond: response]}
-  def respond(response, state, data), do: {:action_responses, [next_state: state, new_data: data, respond: response]}
+
+  def respond(response, state, data),
+    do: {:action_responses, [next_state: state, new_data: data, respond: response]}
 
   defmacro defstate(state, state_def) do
     quote do
-      state_name = case unquote(Macro.escape(state, unquote: true)) do
-        name when is_atom(name) -> name
-        {name, _, _} -> name
-      end
+      state_name =
+        case unquote(Macro.escape(state, unquote: true)) do
+          name when is_atom(name) -> name
+          {name, _, _} -> name
+        end
 
       @declaring_state state_name
       unquote(state_def)
@@ -67,16 +72,18 @@ defmodule Fsm do
 
   defp decl_event(event, private) do
     quote do
-      {event_name, arity} = case unquote(Macro.escape(event, unquote: nil)) do
-        event_name when is_atom(event_name) -> {event_name, 0}
-        {:/, _, [{event_name, _, _}, arity]} -> {event_name, arity}
-        {event_name, _, _} -> {event_name, 0}
-      end
+      {event_name, arity} =
+        case unquote(Macro.escape(event, unquote: nil)) do
+          event_name when is_atom(event_name) -> {event_name, 0}
+          {:/, _, [{event_name, _, _}, arity]} -> {event_name, arity}
+          {event_name, _, _} -> {event_name, 0}
+        end
 
-      args = case arity do
-        0 -> []
-        n -> Enum.to_list(1..n)
-      end
+      args =
+        case arity do
+          0 -> []
+          n -> Enum.to_list(1..n)
+        end
 
       private = unquote(private)
       unquote(define_interface())
@@ -109,11 +116,12 @@ defmodule Fsm do
 
   defp extract_args(event_decl, opts, event_def) do
     quote do
-      {event_name, args} = case unquote(Macro.escape(event_decl, unquote: true)) do
-        :_ -> {:_, []}
-        name when is_atom(name) -> {name, []}
-        {name, _, args} -> {name, args || []}
-      end
+      {event_name, args} =
+        case unquote(Macro.escape(event_decl, unquote: true)) do
+          :_ -> {:_, []}
+          name when is_atom(name) -> {name, []}
+          {name, _, args} -> {name, args || []}
+        end
 
       private = unquote(opts[:private])
       state_arg = unquote(Macro.escape(opts[:state] || quote(do: _), unquote: true))
@@ -128,18 +136,20 @@ defmodule Fsm do
   defp define_interface do
     quote bind_quoted: [] do
       unless event_name == :_ or MapSet.member?(@declared_events, {event_name, length(args)}) do
-        interface_args = Enum.reduce(args, {0, []}, fn(_, {index, args}) ->
-          {
-            index + 1,
-            [{:"arg#{index}", [], nil} | args]
-          }
-        end)
-        |> elem(1)
-        |> Enum.reverse
-
-        body = quote do
-          transition(fsm, unquote(event_name), [unquote_splicing(interface_args)])
-        end
+        interface_args =
+          Enum.reduce(args, {0, []}, fn _, {index, args} ->
+            {
+              index + 1,
+              [{:"arg#{index}", [], nil} | args]
+            }
+          end)
+          |> elem(1)
+          |> Enum.reverse()
+
+        body =
+          quote do
+            transition(fsm, unquote(event_name), [unquote_splicing(interface_args)])
+          end
 
         interface_args = [quote(do: fsm) | interface_args]
 
@@ -159,24 +169,25 @@ defmodule Fsm do
       transition_args = [
         if @declaring_state do
           quote do
-            %__MODULE__{state: unquote(@declaring_state) = unquote(state_arg), data: unquote(data_arg)} = fsm
+            %__MODULE__{
+              state: unquote(@declaring_state) = unquote(state_arg),
+              data: unquote(data_arg)
+            } = fsm
           end
         else
           quote do
             %__MODULE__{state: unquote(state_arg), data: unquote(data_arg)} = fsm
           end
         end,
-
         quote do
           unquote(if event_name == :_, do: quote(do: _), else: event_name) = unquote(event_arg)
         end,
-
         quote do
           unquote(if event_name == :_, do: quote(do: _), else: args) = unquote(args_arg)
         end
       ]
 
-      body = quote(do: change_state(fsm, (unquote(event_def))))
+      body = quote(do: change_state(fsm, unquote(event_def)))
 
       if guard do
         def transition(unquote_splicing(transition_args)) when unquote(guard), do: unquote(body)

mix.exs

@@ -10,7 +10,7 @@ defmodule Fsm.Mixfile do
       package: [
         maintainers: ["Saša Jurić"],
         licenses: ["MIT"],
-        links: %{"Github": "https://github.com/sasa1977/fsm"}
+        links: %{Github: "https://github.com/sasa1977/fsm"}
       ],
       description: "Finite state machine as a functional data structure."
     ]