elixir format incompatibilities among versions

lib/deep_merge.ex

@@ -57,8 +57,7 @@ defmodule DeepMerge do
   """
   @spec deep_merge(map() | keyword(), map | keyword()) :: map() | keyword()
   def deep_merge(original, override)
-      when (is_map(original) or is_list(original)) and
-             (is_map(override) or is_list(override)) do
+      when (is_map(original) or is_list(original)) and (is_map(override) or is_list(override)) do
     standard_resolve(nil, original, override)
   end
 
@@ -95,8 +94,7 @@ defmodule DeepMerge do
   @spec deep_merge(map() | keyword(), map() | keyword(), (any(), any() -> any())) ::
           map() | keyword()
   def deep_merge(original, override, resolve_function)
-      when (is_map(original) or is_list(original)) and
-             (is_map(override) or is_list(override)) do
+      when (is_map(original) or is_list(original)) and (is_map(override) or is_list(override)) do
     resolver = build_resolver(resolve_function)
     resolver.(nil, original, override)
   end

test/deep_merge_test.exs

@@ -4,20 +4,15 @@ defmodule DeepMergeTest do
   import DeepMerge
 
   test "deep_merge/2 with different keyword list & list combinations" do
-    assert deep_merge([a: [b: []], f: 5], a: [b: [c: 2]]) ==
-             [f: 5, a: [b: [c: 2]]]
+    assert deep_merge([a: [b: []], f: 5], a: [b: [c: 2]]) == [f: 5, a: [b: [c: 2]]]
 
-    assert deep_merge([a: [b: [c: 2]], f: 5], a: [b: []]) ==
-             [f: 5, a: [b: [c: 2]]]
+    assert deep_merge([a: [b: [c: 2]], f: 5], a: [b: []]) == [f: 5, a: [b: [c: 2]]]
 
-    assert deep_merge([a: [b: [c: 2]], f: 5], a: [b: [1, 2, 3]]) ==
-             [f: 5, a: [b: [1, 2, 3]]]
+    assert deep_merge([a: [b: [c: 2]], f: 5], a: [b: [1, 2, 3]]) == [f: 5, a: [b: [1, 2, 3]]]
 
-    assert deep_merge([a: [b: [1, 2, 3]], f: 5], a: [b: [c: 2]]) ==
-             [f: 5, a: [b: [c: 2]]]
+    assert deep_merge([a: [b: [1, 2, 3]], f: 5], a: [b: [c: 2]]) == [f: 5, a: [b: [c: 2]]]
 
-    assert deep_merge([a: [b: []], f: 5], a: [b: []]) ==
-             [f: 5, a: [b: []]]
+    assert deep_merge([a: [b: []], f: 5], a: [b: []]) == [f: 5, a: [b: []]]
   end
 
   defmodule User do
@@ -34,16 +29,14 @@ defmodule DeepMergeTest do
     original = %{a: %MyStruct{attrs: %{b: 1}}}
     override = %{a: %MyStruct{attrs: %{c: 2}}}
 
-    assert deep_merge(original, override) ==
-             %{a: %MyStruct{attrs: %{b: 1, c: 2}}}
+    assert deep_merge(original, override) == %{a: %MyStruct{attrs: %{b: 1, c: 2}}}
   end
 
   test "deep_merge/2 merges Structs with protocol implemented top level" do
     original = %MyStruct{attrs: %{b: 1, c: 0}}
     override = %MyStruct{attrs: %{c: 2, e: 4}}
 
-    assert deep_merge(original, override) ==
-             %MyStruct{attrs: %{b: 1, c: 2, e: 4}}
+    assert deep_merge(original, override) == %MyStruct{attrs: %{b: 1, c: 2, e: 4}}
   end
 
   test "deep_merge/2 doesn't merge structs without the protocol implemented" do