Format code and ensure formatting in CI (#234)

* Format code and ensure formatting in CI

closes #233

* Format tests too

* Only lint on latest version

Author: halfdan

.formatter.exs

@@ -0,0 +1,10 @@
+[
+  inputs: [
+    "mix.exs",
+    ".formatter.exs",
+    "config/*.exs",
+    "lib/**/*.ex",
+    "test/**/*_test.exs"
+  ],
+  line_length: 120
+]

.github/workflows/tests.yml

@@ -11,12 +11,12 @@ jobs:
       fail-fast: true
       matrix:
         include:
-          - otp: '25'
-            elixir: '1.14'
+          - otp: "25"
+            elixir: "1.14"
             global-mock: true
             experimental: false
-          - otp: '25'
-            elixir: '1.14'
+          - otp: "25"
+            elixir: "1.14"
             global-mock: false
             experimental: false
           - otp: "27"
@@ -35,6 +35,7 @@ jobs:
             elixir: "1.18.0"
             global-mock: false
             experimental: true
+            lint: true
     env:
       MIX_ENV: test
       GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -43,8 +44,8 @@ jobs:
       - uses: actions/checkout@v4
       - uses: erlef/setup-beam@v1
         with:
-         otp-version: ${{ matrix.otp }}
-         elixir-version: ${{ matrix.elixir }}
+          otp-version: ${{ matrix.otp }}
+          elixir-version: ${{ matrix.elixir }}
       - uses: actions/cache@v4
         with:
           path: |
@@ -53,12 +54,19 @@ jobs:
           key: ${{ runner.os }}-${{ matrix.otp }}-${{ matrix.elixir }}-mix-${{ hashFiles('**/mix.lock') }}
           restore-keys: |
             ${{ runner.os }}-${{ matrix.otp }}-${{ matrix.elixir }}-mix-
-      - run: mix deps.get
-      - run: mix test
+      - name: Install dependencies
+        run: mix deps.get
+      - name: Compile project
+        run: mix compile
+      - name: Check formatting
+        run: mix format --check-formatted
+        if: ${{ matrix.lint }}
+      - name: Run tests
+        run: mix test
       - uses: nick-invision/retry@v3
         with:
           timeout_minutes: 3
           max_attempts: 3
           shell: bash
           command: mix coveralls.github
-        continue-on-error: true
+        continue-on-error: true

config/config.exs

@@ -1,6 +1,6 @@
 import Config
 
-config :exvcr, [
+config :exvcr,
   global_mock: false,
   vcr_cassette_library_dir: "fixture/vcr_cassettes",
   custom_cassette_library_dir: "fixture/custom_cassettes",
@@ -13,6 +13,5 @@ config :exvcr, [
   ignore_localhost: false,
   enable_global_settings: false,
   strict_mode: false
-]
 
-if Mix.env() == :test, do: import_config "test.exs"
+if Mix.env() == :test, do: import_config("test.exs")

config/test.exs

@@ -1,5 +1,4 @@
 import Config
 
-config :exvcr, [
+config :exvcr,
   global_mock: System.get_env("GLOBAL_MOCK") == "true"
-]

lib/exvcr.ex

@@ -4,4 +4,3 @@ defmodule ExVCR do
   It's inspired by Ruby's VCR, and trying to provide similar functionalities.
   """
 end
-

lib/exvcr/actor.ex

@@ -43,7 +43,7 @@ defmodule ExVCR.Actor do
 
     @impl true
     def handle_cast({:append, x}, state) do
-      {:noreply, [x|state]}
+      {:noreply, [x | state]}
     end
 
     @impl true
@@ -58,13 +58,15 @@ defmodule ExVCR.Actor do
 
     @impl true
     def handle_call({:update, finder, updater}, _from, state) do
-      new_state = Enum.map(state, fn(record) ->
-        if finder.(record) do
-          updater.(record)
-        else
-          record
-        end
-      end)
+      new_state =
+        Enum.map(state, fn record ->
+          if finder.(record) do
+            updater.(record)
+          else
+            record
+          end
+        end)
+
       {:reply, new_state, new_state}
     end
 

lib/exvcr/adapter.ex

@@ -8,40 +8,40 @@ defmodule ExVCR.Adapter do
       @doc """
       Returns the name of the mock target module.
       """
-      def module_name, do: raise ExVCR.ImplementationMissingError
-      defoverridable [module_name: 0]
+      def module_name, do: raise(ExVCR.ImplementationMissingError)
+      defoverridable module_name: 0
 
       @doc """
       Returns list of the mock target methods with function name and callback.
       Implementation for global mock.
       """
-      def target_methods(), do: raise ExVCR.ImplementationMissingError
-      defoverridable [target_methods: 0]
+      def target_methods(), do: raise(ExVCR.ImplementationMissingError)
+      defoverridable target_methods: 0
 
       @doc """
       Returns list of the mock target methods with function name and callback.
       """
-      def target_methods(recorder), do: raise ExVCR.ImplementationMissingError
-      defoverridable [target_methods: 1]
+      def target_methods(recorder), do: raise(ExVCR.ImplementationMissingError)
+      defoverridable target_methods: 1
 
       @doc """
       Generate key for searching response.
       [url: url, method: method] needs to be returned.
       """
-      def generate_keys_for_request(request), do: raise ExVCR.ImplementationMissingError
-      defoverridable [generate_keys_for_request: 1]
+      def generate_keys_for_request(request), do: raise(ExVCR.ImplementationMissingError)
+      defoverridable generate_keys_for_request: 1
 
       @doc """
       Callback from ExVCR.Handler when response is retrieved from the HTTP server.
       """
       def hook_response_from_server(response), do: response
-      defoverridable [hook_response_from_server: 1]
+      defoverridable hook_response_from_server: 1
 
       @doc """
       Callback from ExVCR.Handler when response is retrieved from the json file cache.
       """
       def hook_response_from_cache(_request, response), do: response
-      defoverridable [hook_response_from_cache: 2]
+      defoverridable hook_response_from_cache: 2
 
       @doc """
       Callback from ExVCR.Handler to get the response content tuple from the ExVCR.Response record.
@@ -53,7 +53,8 @@ defmodule ExVCR.Adapter do
           {:ok, response.status_code, response.headers, response.body}
         end
       end
-      defoverridable [get_response_value_from_cache: 1]
+
+      defoverridable get_response_value_from_cache: 1
     end
   end
 end

lib/exvcr/adapter/finch.ex

@@ -29,10 +29,10 @@ if Code.ensure_loaded?(Finch) do
     """
     def target_methods() do
       [
-        {:request, &ExVCR.Recorder.request([&1,&2])},
-        {:request, &ExVCR.Recorder.request([&1,&2,&3])},
-        {:request!, &(ExVCR.Recorder.request([&1,&2]) |> handle_response_for_request!())},
-        {:request!, &(ExVCR.Recorder.request([&1,&2,&3]) |> handle_response_for_request!())}
+        {:request, &ExVCR.Recorder.request([&1, &2])},
+        {:request, &ExVCR.Recorder.request([&1, &2, &3])},
+        {:request!, &(ExVCR.Recorder.request([&1, &2]) |> handle_response_for_request!())},
+        {:request!, &(ExVCR.Recorder.request([&1, &2, &3]) |> handle_response_for_request!())}
       ]
     end
 
@@ -41,10 +41,10 @@ if Code.ensure_loaded?(Finch) do
     """
     def target_methods(recorder) do
       [
-        {:request, &ExVCR.Recorder.request(recorder, [&1,&2])},
-        {:request, &ExVCR.Recorder.request(recorder, [&1,&2,&3])},
-        {:request!, &(ExVCR.Recorder.request(recorder, [&1,&2]) |> handle_response_for_request!())},
-        {:request!, &(ExVCR.Recorder.request(recorder, [&1,&2,&3]) |> handle_response_for_request!())}
+        {:request, &ExVCR.Recorder.request(recorder, [&1, &2])},
+        {:request, &ExVCR.Recorder.request(recorder, [&1, &2, &3])},
+        {:request!, &(ExVCR.Recorder.request(recorder, [&1, &2]) |> handle_response_for_request!())},
+        {:request!, &(ExVCR.Recorder.request(recorder, [&1, &2, &3]) |> handle_response_for_request!())}
       ]
     end
 
@@ -88,8 +88,9 @@ if Code.ensure_loaded?(Finch) do
     end
 
     defp apply_filters(%Finch.Response{} = response) do
-      replaced_body = to_string(response.body) |> ExVCR.Filter.filter_sensitive_data
+      replaced_body = to_string(response.body) |> ExVCR.Filter.filter_sensitive_data()
       filtered_headers = ExVCR.Filter.remove_blacklisted_headers(response.headers)
+
       response
       |> Map.put(:body, replaced_body)
       |> Map.put(:headers, filtered_headers)
@@ -98,7 +99,7 @@ if Code.ensure_loaded?(Finch) do
     defp apply_filters({:error, reason}), do: {:error, reason}
 
     defp handle_response_for_request!({:ok, resp}), do: resp
-    defp handle_response_for_request!({:error, error}), do: raise error
+    defp handle_response_for_request!({:error, error}), do: raise(error)
     defp handle_response_for_request!(resp), do: resp
 
     @doc """
@@ -107,10 +108,9 @@ if Code.ensure_loaded?(Finch) do
     def default_stub_params(:headers), do: %{"content-type" => "text/html"}
     def default_stub_params(:status_code), do: 200
   end
-
 else
   defmodule ExVCR.Adapter.Finch do
-    def module_name, do: raise "Missing dependency: Finch"
-    def target_methods, do: raise "Missing dependency: Finch"
+    def module_name, do: raise("Missing dependency: Finch")
+    def target_methods, do: raise("Missing dependency: Finch")
   end
 end

lib/exvcr/adapter/hackney.ex

@@ -59,10 +59,10 @@ defmodule ExVCR.Adapter.Hackney do
   Generate key for searching response.
   """
   def generate_keys_for_request(request) do
-    url          = Enum.fetch!(request, 1)
-    method       = Enum.fetch!(request, 0)
-    request_body = Enum.fetch(request, 3) |> parse_request_body
-    headers      = Enum.at(request, 2, []) |> Util.stringify_keys()
+    url = Enum.fetch!(request, 1)
+    method = Enum.fetch!(request, 0)
+    request_body = Enum.fetch(request, 3) |> parse_request_body()
+    headers = Enum.at(request, 2, []) |> Util.stringify_keys()
 
     [url: url, method: method, request_body: request_body, headers: headers]
   end
@@ -94,12 +94,13 @@ defmodule ExVCR.Adapter.Hackney do
   def hook_response_from_cache(_request, nil), do: nil
   def hook_response_from_cache(_request, %ExVCR.Response{type: "error"} = response), do: response
   def hook_response_from_cache(_request, %ExVCR.Response{body: nil} = response), do: response
+
   def hook_response_from_cache([_, _, _, _, opts], %ExVCR.Response{body: body} = response) do
     if :with_body in opts || {:with_body, true} in opts do
       response
     else
-      client          = make_ref()
-      client_key_atom = client |> inspect |> String.to_atom
+      client = make_ref()
+      client_key_atom = client |> inspect() |> String.to_atom()
       Store.set(client_key_atom, body)
       %{response | body: client}
     end
@@ -119,7 +120,8 @@ defmodule ExVCR.Adapter.Hackney do
   end
 
   defp handle_body_request(recorder, [client, max_length]) do
-    client_key_atom = client |> inspect |> String.to_atom
+    client_key_atom = client |> inspect() |> String.to_atom()
+
     if body = Store.get(client_key_atom) do
       Store.delete(client_key_atom)
       {:ok, body}
@@ -129,15 +131,19 @@ defmodule ExVCR.Adapter.Hackney do
           body = ExVCR.Filter.filter_sensitive_data(body)
 
           client_key_string = inspect(client)
-          ExVCR.Recorder.update(recorder,
-            fn(%{request: _request, response: response}) ->
+
+          ExVCR.Recorder.update(
+            recorder,
+            fn %{request: _request, response: response} ->
               response.body == client_key_string
             end,
-            fn(%{request: request, response: response}) ->
+            fn %{request: request, response: response} ->
               %{request: request, response: %{response | body: body}}
             end
           )
+
           {:ok, body}
+
         {ret, body} ->
           {ret, body}
       end
@@ -153,7 +159,7 @@ defmodule ExVCR.Adapter.Hackney do
     else
       case response.body do
         nil -> {:ok, response.status_code, response.headers}
-        _   -> {:ok, response.status_code, response.headers, response.body}
+        _ -> {:ok, response.status_code, response.headers, response.body}
       end
     end
   end

lib/exvcr/adapter/hackney/converter.ex

@@ -103,7 +103,7 @@ defmodule ExVCR.Adapter.Hackney.Converter do
   def parse_request_body({:form, body}) do
     hackney_request_module().encode_form(body)
     |> elem(2)
-    |> to_string
+    |> to_string()
     |> ExVCR.Filter.filter_sensitive_data()
   end
 

lib/exvcr/adapter/hackney/store.ex

@@ -10,6 +10,7 @@ defmodule ExVCR.Adapter.Hackney.Store do
     if :ets.info(table()) == :undefined do
       :ets.new(table(), [:set, :public, :named_table])
     end
+
     :ok
   end
 
@@ -39,6 +40,6 @@ defmodule ExVCR.Adapter.Hackney.Store do
   end
 
   defp table do
-    "exvcr_hackney#{inspect self()}" |> String.to_atom
+    "exvcr_hackney#{inspect(self())}" |> String.to_atom()
   end
 end

lib/exvcr/adapter/httpc.ex

@@ -29,8 +29,7 @@ defmodule ExVCR.Adapter.Httpc do
       {:request, &ExVCR.Recorder.request(recorder, [&1,&2,&3,&4,&5])}
   """
   def target_methods() do
-    [ {:request, &ExVCR.Recorder.request([&1])},
-      {:request, &ExVCR.Recorder.request([&1,&2,&3,&4])} ]
+    [{:request, &ExVCR.Recorder.request([&1])}, {:request, &ExVCR.Recorder.request([&1, &2, &3, &4])}]
   end
 
   @doc """
@@ -40,20 +39,23 @@ defmodule ExVCR.Adapter.Httpc do
       {:request, &ExVCR.Recorder.request(recorder, [&1,&2,&3,&4,&5])}
   """
   def target_methods(recorder) do
-    [ {:request, &ExVCR.Recorder.request(recorder, [&1])},
-      {:request, &ExVCR.Recorder.request(recorder, [&1,&2,&3,&4])} ]
+    [
+      {:request, &ExVCR.Recorder.request(recorder, [&1])},
+      {:request, &ExVCR.Recorder.request(recorder, [&1, &2, &3, &4])}
+    ]
   end
 
-
   @doc """
   Generate key for searching response.
   """
   def generate_keys_for_request(request) do
     case request do
       [method, {url, headers} | _] ->
         [url: url, method: method, request_body: nil, headers: Util.stringify_keys(headers)]
+
       [method, {url, headers, _, body} | _] ->
         [url: url, method: method, request_body: body, headers: Util.stringify_keys(headers)]
+
       [url | _] ->
         [url: url, method: :get, request_body: nil, headers: []]
     end
@@ -67,7 +69,7 @@ defmodule ExVCR.Adapter.Httpc do
   end
 
   defp apply_filters({:ok, {status_code, headers, body}}) do
-    replaced_body = to_string(body) |> ExVCR.Filter.filter_sensitive_data
+    replaced_body = to_string(body) |> ExVCR.Filter.filter_sensitive_data()
     filtered_headers = ExVCR.Filter.remove_blacklisted_headers(headers)
     {:ok, {status_code, filtered_headers, replaced_body}}
   end