Add :styler and do mix format

Author: joern-lang-studitemps

.formatter.exs

@@ -1,4 +1,5 @@
 # Used by "mix format"
 [
-  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
+  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"],
+  plugins: [Styler]
 ]

lib/event_store/appendable_event.ex

@@ -22,7 +22,7 @@ defimpl Shared.AppendableEvent, for: Any do
         end
 
         def streams_to_link(event) do
-          fields_to_link = Keyword.get(unquote(options), :streams_to_link, []) |> List.wrap()
+          fields_to_link = unquote(options) |> Keyword.get(:streams_to_link, []) |> List.wrap()
 
           invalid_links =
             Enum.reduce(fields_to_link, %{}, fn field, errors ->
@@ -49,7 +49,7 @@ defimpl Shared.AppendableEvent, for: Any do
                   "Streams ids to link need to be a string, got '#{invalid_links}'."
           end
 
-          Map.take(event, fields_to_link) |> Map.values()
+          event |> Map.take(fields_to_link) |> Map.values()
         end
       end
     end

lib/event_store/appendable_event_test.exs

@@ -1,8 +1,10 @@
 defmodule Shared.AppendableEventTest do
   use ExUnit.Case, async: true
+
   require Protocol
 
   defmodule Event do
+    @moduledoc false
     defstruct [:a, :b, :c, :d]
   end
 

lib/event_store/event_store.ex

@@ -2,26 +2,25 @@ defmodule Shared.EventStore do
   @moduledoc false
   defmacro __using__(opts \\ []) do
     quote location: :keep, generated: true, bind_quoted: [opts: opts] do
+      use EventStore, otp_app: @otp_app
+
+      alias Shared.EventStoreEvent
+
+      require Logger
+
       @event_store_backend __MODULE__
 
       @otp_app Keyword.fetch!(opts, :otp_app)
-      use EventStore, otp_app: @otp_app
-
       @repository Keyword.get(opts, :repo) ||
                     (case(Application.compile_env(@otp_app, :ecto_repos)) do
                        [repo] ->
                          repo
 
                        _ ->
-                         IO.warn(
-                           ":repo option required if you want to wrap append_event in a transaction."
-                         )
+                         IO.warn(":repo option required if you want to wrap append_event in a transaction.")
                      end)
       @use_shared_connection Keyword.get(opts, :use_shared_connection, true)
 
-      alias Shared.EventStoreEvent
-      require Logger
-
       @spec append_event(list(struct()) | struct(), keyword | map) ::
               {:ok, list(EventStore.EventData.t())}
       def append_event(domain_events, metadata) do
@@ -39,12 +38,8 @@ defmodule Shared.EventStore do
 
       @spec append_event(String.t(), list(struct()) | struct(), keyword | map) ::
               {:ok, list(EventStore.EventData.t())}
-      def append_event(
-            stream_uuid,
-            domain_events,
-            metadata
-          ) do
-        persisted_events = domain_events |> EventStoreEvent.wrap_for_persistence(metadata)
+      def append_event(stream_uuid, domain_events, metadata) do
+        persisted_events = EventStoreEvent.wrap_for_persistence(domain_events, metadata)
 
         case @event_store_backend.append_to_stream(stream_uuid, :any_version, persisted_events,
                conn: current_connection(@repository, @use_shared_connection)
@@ -60,8 +55,7 @@ defmodule Shared.EventStore do
 
       @spec append_events(String.t(), list(struct()) | struct(), keyword | map) ::
               {:ok, list(EventStore.EventData.t())}
-      def append_events(stream_uuid, domain_events, metadata),
-        do: append_event(stream_uuid, domain_events, metadata)
+      def append_events(stream_uuid, domain_events, metadata), do: append_event(stream_uuid, domain_events, metadata)
 
       @spec all_events(String.t(), keyword()) ::
               list(Shared.EventStoreEvent.event_with_metadata())
@@ -131,7 +125,7 @@ defmodule Shared.EventStore do
           logged_event = Shared.LoggableEvent.to_log(event)
 
           Logger.info(fn ->
-            "Appended event stream_uuid=#{stream_uuid} event=[#{logged_event}] metadata=#{metadata |> inspect()}"
+            "Appended event stream_uuid=#{stream_uuid} event=[#{logged_event}] metadata=#{inspect(metadata)}"
           end)
         end)
       end

lib/event_store/event_store_event.ex

@@ -5,7 +5,7 @@ defmodule Shared.EventStoreEvent do
   @spec wrap_for_persistence(term | list(term), Enum.t()) :: list(EventStore.EventData.t())
   def wrap_for_persistence(events, metadata) do
     events = List.wrap(events)
-    metadata = Enum.into(metadata, %{})
+    metadata = Map.new(metadata)
 
     Enum.map(events, fn event ->
       %EventStore.EventData{
@@ -17,7 +17,7 @@ defmodule Shared.EventStoreEvent do
 
   @spec unwrap(EventStore.RecordedEvent.t()) :: event_with_metadata
   def unwrap(%EventStore.RecordedEvent{data: domain_event, metadata: metadata} = event) do
-    metadata = Enum.into(metadata, %{})
+    metadata = Map.new(metadata)
 
     recorded_event_metadata =
       Map.take(event, [

lib/event_store/event_store_event_test.exs

@@ -1,8 +1,10 @@
 defmodule Shared.EventStoreEventTest do
   use ExUnit.Case, async: true
+
   alias Shared.EventStoreEvent, as: Event
 
   defmodule TestEvent do
+    @moduledoc false
     defstruct foo: "bar"
   end
 

lib/event_store/event_store_listener.ex

@@ -1,9 +1,11 @@
 defmodule Shared.EventStoreListener do
   @moduledoc false
   use GenServer
-  require Logger
+
   alias EventStore.RecordedEvent
 
+  require Logger
+
   defmodule ErrorContext do
     @moduledoc false
     defstruct [:error_count, :max_retries, :base_delay_in_ms]
@@ -30,11 +32,7 @@ defmodule Shared.EventStoreListener do
       error_count - 1
     end
 
-    def delay(%__MODULE__{
-          error_count: error_count,
-          max_retries: max_retries,
-          base_delay_in_ms: base_delay_in_ms
-        })
+    def delay(%__MODULE__{error_count: error_count, max_retries: max_retries, base_delay_in_ms: base_delay_in_ms})
         when error_count <= max_retries do
       # Exponential backoff
       round(:math.pow(2, error_count) * base_delay_in_ms)
@@ -120,8 +118,7 @@ defmodule Shared.EventStoreListener do
       def handle(event, metadata, _state), do: handle(event, metadata)
       defoverridable handle: 3
 
-      def on_error({:error, reason}, _event, _metadata, error_context),
-        do: {:retry, error_context}
+      def on_error({:error, reason}, _event, _metadata, error_context), do: {:retry, error_context}
 
       defoverridable on_error: 4
 
@@ -176,9 +173,7 @@ defmodule Shared.EventStoreListener do
   end
 
   def handle_info({:events, [event]}, %{name: name, error_context: context} = state) do
-    Logger.warning(
-      "#{name} is retrying (#{context.error_count}/#{context.max_retries}) failed event #{inspect(event)}"
-    )
+    Logger.warning("#{name} is retrying (#{context.error_count}/#{context.max_retries}) failed event #{inspect(event)}")
 
     handle_event(event, state, context)
   end
@@ -196,11 +191,7 @@ defmodule Shared.EventStoreListener do
       do: handler_module.terminate(reason, state)
   end
 
-  defp handle_event(
-         %RecordedEvent{} = event,
-         %{handler_module: handler_module} = state,
-         %ErrorContext{} = error_context
-       ) do
+  defp handle_event(%RecordedEvent{} = event, %{handler_module: handler_module} = state, %ErrorContext{} = error_context) do
     {domain_event, metadata} = Shared.EventStoreEvent.unwrap(event)
     handler_module.handle(domain_event, metadata, state)
   rescue
@@ -327,15 +318,11 @@ defmodule Shared.EventStoreListener do
 
   # Wir verwenden diese Schreibweisen um die Dependency auf Timex optional zu halten.
   defp unify_delay(%{__struct__: Timex.Duration} = delay) do
-    {apply(Timex.Duration, :to_milliseconds, [delay, [truncate: true]]),
-     apply(Timex.Duration, :to_string, [delay])}
+    {apply(Timex.Duration, :to_milliseconds, [delay, [truncate: true]]), apply(Timex.Duration, :to_string, [delay])}
   end
 
   if function_exported?(Kernel, :to_timeout, 1) do
-    defp unify_delay(delay)
-         when is_list(delay)
-         when is_integer(delay)
-         when is_struct(delay, Duration) do
+    defp unify_delay(delay) when is_list(delay) when is_integer(delay) when is_struct(delay, Duration) do
       t = to_timeout(delay)
       {t, "#{t}ms"}
     end

lib/event_store/event_store_listener_test.exs

@@ -1,14 +1,17 @@
 defmodule Shared.EventStoreListenerTest do
   use Support.EventStoreCase, async: false
+
   import ExUnit.CaptureLog
 
   @event %Shared.EventTest.FakeEvent{}
 
   defmodule EventHandlingError do
+    @moduledoc false
     defexception [:message]
   end
 
   defmodule Counter do
+    @moduledoc false
     use Agent
 
     def start_link(initial_value) do
@@ -21,6 +24,7 @@ defmodule Shared.EventStoreListenerTest do
   end
 
   defmodule ExampleConsumer do
+    @moduledoc false
     use Shared.EventStoreListener,
       subscription_key: "example_consumer",
       event_store: JehovakelEx.EventStore
@@ -103,6 +107,7 @@ defmodule Shared.EventStoreListenerTest do
 
     test "allows to configure retry behaviour" do
       defmodule ExampleConsumerWithCustomConfig do
+        @moduledoc false
         use Shared.EventStoreListener,
           subscription_key: "example_consumer_with_custom_config",
           event_store: JehovakelEx.EventStore,
@@ -172,6 +177,7 @@ defmodule Shared.EventStoreListenerTest do
       test_process = self()
 
       defmodule SnoozingConsumer do
+        @moduledoc false
         use Shared.EventStoreListener,
           subscription_key: "snoozing_consumer",
           event_store: JehovakelEx.EventStore
@@ -219,6 +225,7 @@ defmodule Shared.EventStoreListenerTest do
 
   test "does graceful shutdown when GenServer is stopped" do
     defmodule SlowConsumer do
+      @moduledoc false
       use Shared.EventStoreListener,
         subscription_key: "example_consumer",
         event_store: JehovakelEx.EventStore
@@ -243,6 +250,7 @@ defmodule Shared.EventStoreListenerTest do
 
   test "accepts Timex.Duration as :snooze delay" do
     defmodule SnoozingConsumer do
+      @moduledoc false
       use Shared.EventStoreListener,
         subscription_key: "snoozing_consumer",
         event_store: JehovakelEx.EventStore
@@ -306,6 +314,7 @@ defmodule Shared.EventStoreListenerTest do
 
   test "can configure custom restart option for the child spec" do
     defmodule TemporaryRestartConsumer do
+      @moduledoc false
       use Shared.EventStoreListener,
         subscription_key: "example_consumer",
         event_store: JehovakelEx.EventStore,
@@ -323,6 +332,7 @@ defmodule Shared.EventStoreListenerTest do
     test "raises if subscription_key is missing" do
       assert_raise(RuntimeError, "subscription_key is required since v3.0", fn ->
         defmodule MissingSubscriptionKey do
+          @moduledoc false
           use Shared.EventStoreListener,
             event_store: JehovakelEx.EventStore
         end
@@ -335,6 +345,7 @@ defmodule Shared.EventStoreListenerTest do
         "Event Store(event_store: My.EventStore) configuration is missing",
         fn ->
           defmodule MissingEventStore do
+            @moduledoc false
             use Shared.EventStoreListener,
               subscription_key: "example_consumer"
           end

lib/event_store/link_appendable_events.ex

@@ -36,10 +36,7 @@ defmodule Shared.LinkAppendableEvents do
   end
 
   # Event notification
-  def handle_info(
-        {:events, events},
-        %{subscription: subscription, event_store: event_store} = state
-      ) do
+  def handle_info({:events, events}, %{subscription: subscription, event_store: event_store} = state) do
     link_appendable_events(event_store, subscription, events)
 
     {:noreply, state}
@@ -51,11 +48,7 @@ defmodule Shared.LinkAppendableEvents do
     end
   end
 
-  defp link_appendable_event(
-         event_store,
-         subscription,
-         %EventStore.RecordedEvent{} = eventstore_event
-       ) do
+  defp link_appendable_event(event_store, subscription, %EventStore.RecordedEvent{} = eventstore_event) do
     event = eventstore_event.data
 
     if Shared.AppendableEvent.impl_for(event) do

lib/event_store/link_appendable_events_test.exs

@@ -2,6 +2,7 @@ defmodule Shared.LinkAppendableEventsTest do
   use Support.EventStoreCase, async: false
 
   defmodule TestEvent do
+    @moduledoc false
     @derive {Shared.AppendableEvent, stream_id: :a, streams_to_link: :b}
     defstruct [:a, :b, :c, :d]
   end
@@ -39,9 +40,7 @@ defmodule Shared.LinkAppendableEventsTest do
 
     Postgrex.query!(postgrex, "DELETE FROM subscriptions WHERE true", [])
 
-    start_supervised!(
-      {Shared.LinkAppendableEvents, event_store: JehovakelEx.EventStore, subscription_name: "FOO"}
-    )
+    start_supervised!({Shared.LinkAppendableEvents, event_store: JehovakelEx.EventStore, subscription_name: "FOO"})
 
     wait_until(fn ->
       assert %{num_rows: 1, rows: [[1]]} =