Apply format to remaining files (#23)

- closes #12

Signed-off-by: Tallys Martins <tallysmartins@gmail.com>

.formatter.exs

@@ -1,9 +1,6 @@
 # Used by "mix format"
 [
-  inputs: ["mix.exs", "lib/elixir_bench/{benchmarks,github}/**/*.{ex,exs}", "{config,test}/**/*.{ex,exs}"],
-  #inputs: ["mix.exs", "lib/elixir_bench/**/*.{ex,exs}", "{config,test}/**/*.{ex,exs}"],
-  #inputs: ["mix.exs","lib/elixir_bench_web/**/*.{ex,exs}", "lib/elixir_bench/**/*.{ex,exs}", "{config,test}/**/*.{ex,exs}"],
-  #inputs: ["mix.exs","{config,test,lib}/**/*.{ex,exs}"],
+  inputs: ["mix.exs","{config,test,lib}/**/*.{ex,exs}"],
   locals_without_parens: [
     plug: 1,
     plug: 2,

lib/elixir_bench/application.ex

@@ -11,7 +11,7 @@ defmodule ElixirBench.Application do
       # Start the Ecto repository
       supervisor(ElixirBench.Repo, []),
       # Start the endpoint when the application starts
-      supervisor(ElixirBenchWeb.Endpoint, []),
+      supervisor(ElixirBenchWeb.Endpoint, [])
       # Start your own worker by calling: ElixirBench.Worker.start_link(arg1, arg2, arg3)
       # worker(ElixirBench.Worker, [arg1, arg2, arg3]),
     ]

lib/elixir_bench/repos/repo.ex

@@ -3,7 +3,6 @@ defmodule ElixirBench.Repos.Repo do
   import Ecto.Changeset
   alias ElixirBench.Repos.Repo
 
-
   schema "repos" do
     field :name, :string
     field :owner, :string

lib/elixir_bench/repos/repos.ex

@@ -18,7 +18,7 @@ defmodule ElixirBench.Repos do
 
   def fetch_repo_by_slug(slug) do
     parse_slug(slug, fn owner, name ->
-      Repo.fetch(where(Repos.Repo, [owner: ^owner, name: ^name]))
+      Repo.fetch(where(Repos.Repo, owner: ^owner, name: ^name))
     end)
   end
 
@@ -28,7 +28,7 @@ defmodule ElixirBench.Repos do
 
   def fetch_repo_id_by_slug(slug) do
     parse_slug(slug, fn owner, name ->
-      Repo.fetch(from r in Repos.Repo, where: [owner: ^owner, name: ^name], select: r.id)
+      Repo.fetch(from(r in Repos.Repo, where: [owner: ^owner, name: ^name], select: r.id))
     end)
   end
 

lib/elixir_bench_web.ex

@@ -27,8 +27,9 @@ defmodule ElixirBenchWeb do
 
   def view do
     quote do
-      use Phoenix.View, root: "lib/elixir_bench_web/templates",
-                        namespace: ElixirBenchWeb
+      use Phoenix.View,
+        root: "lib/elixir_bench_web/templates",
+        namespace: ElixirBenchWeb
 
       # Import convenience functions from controllers
       import Phoenix.Controller, only: [get_flash: 2, view_module: 1]

lib/elixir_bench_web/controllers/job_controller.ex

@@ -3,7 +3,7 @@ defmodule ElixirBenchWeb.JobController do
 
   alias ElixirBench.{Benchmarks, Repos, Benchmarks.Job}
 
-  action_fallback ElixirBenchWeb.FallbackController
+  action_fallback(ElixirBenchWeb.FallbackController)
 
   def claim(conn, _params) do
     with {:ok, %Job{} = job} <- Benchmarks.claim_job(conn.assigns.runner),

lib/elixir_bench_web/endpoint.ex

@@ -28,7 +28,10 @@ defmodule ElixirBenchWeb.Endpoint do
   plug Plug.MethodOverride
   plug Plug.Head
 
-  plug Corsica, max_age: 600, origins: [~r/localhost:\d+$/, ~r/elixirbench.org$/], allow_headers: ~w(accept content-type origin)
+  plug Corsica,
+    max_age: 600,
+    origins: [~r/localhost:\d+$/, ~r/elixirbench.org$/],
+    allow_headers: ~w(accept content-type origin)
 
   plug ElixirBenchWeb.Router
 

lib/elixir_bench_web/router.ex

@@ -14,8 +14,8 @@ defmodule ElixirBenchWeb.Router do
   scope "/runner-api", ElixirBenchWeb do
     pipe_through [:api, :runner_secure]
 
-    post "/jobs/claim", JobController, :claim
-    put "/jobs/:id", JobController, :update
+    post("/jobs/claim", JobController, :claim)
+    put("/jobs/:id", JobController, :update)
   end
 
   scope "/api" do
@@ -30,6 +30,7 @@ defmodule ElixirBenchWeb.Router do
     case Benchmarks.authenticate_runner(username, password) do
       {:ok, runner} ->
         assign(conn, :runner, runner)
+
       {:error, _reason} ->
         send_resp(conn, :unauthorized, Antidote.encode!(%{error: "unauthorized"}))
     end

lib/elixir_bench_web/schema.ex

@@ -5,71 +5,75 @@ defmodule ElixirBenchWeb.Schema do
 
   alias ElixirBench.{Repos, Benchmarks}
 
-  import_types Absinthe.Type.Custom
-  import_types Schema.ContentTypes
+  import_types(Absinthe.Type.Custom)
+  import_types(Schema.ContentTypes)
 
   query do
     field :repos, list_of(:repo) do
-      resolve fn _, _ ->
+      resolve(fn _, _ ->
         {:ok, Repos.list_repos()}
-      end
+      end)
     end
 
     field :repo, :repo do
-      arg :slug, non_null(:string)
-      resolve fn %{slug: slug}, _ ->
+      arg(:slug, non_null(:string))
+
+      resolve(fn %{slug: slug}, _ ->
         Repos.fetch_repo_by_slug(slug)
-      end
+      end)
     end
 
     field :benchmark, :benchmark do
-      arg :repo_slug, non_null(:string)
-      arg :name, non_null(:string)
-      resolve fn %{repo_slug: slug, name: name}, _ ->
+      arg(:repo_slug, non_null(:string))
+      arg(:name, non_null(:string))
+
+      resolve(fn %{repo_slug: slug, name: name}, _ ->
         with {:ok, repo_id} <- Repos.fetch_repo_id_by_slug(slug) do
           Benchmarks.fetch_benchmark(repo_id, name)
         end
-      end
+      end)
     end
 
     field :measurement, :measurement do
-      arg :id, non_null(:id)
-      resolve fn %{id: id}, _ ->
+      arg(:id, non_null(:id))
+
+      resolve(fn %{id: id}, _ ->
         Benchmarks.fetch_measurement(id)
-      end
+      end)
     end
 
     field :jobs, list_of(:job) do
-      resolve fn _, _ ->
+      resolve(fn _, _ ->
         {:ok, Benchmarks.list_jobs()}
-      end
+      end)
     end
 
     field :job, :job do
-      arg :id, non_null(:id)
-      resolve fn %{id: id}, _ ->
+      arg(:id, non_null(:id))
+
+      resolve(fn %{id: id}, _ ->
         Benchmarks.fetch_job(id)
-      end
+      end)
     end
   end
 
   mutation do
     field :schedule_job, type: :job do
-      arg :branch_name, non_null(:string)
-      arg :commit_sha, non_null(:string)
-      arg :repo_slug, non_null(:string)
+      arg(:branch_name, non_null(:string))
+      arg(:commit_sha, non_null(:string))
+      arg(:repo_slug, non_null(:string))
 
-      resolve fn %{repo_slug: slug} = data, _ ->
+      resolve(fn %{repo_slug: slug} = data, _ ->
         with {:ok, repo} <- Repos.fetch_repo_by_slug(slug) do
           Benchmarks.create_job(repo, data)
         end
-      end
+      end)
     end
   end
 
   def context(ctx) do
     loader =
-      Dataloader.new
+      Dataloader.new()
       |> Dataloader.add_source(Repos, Repos.data())
       |> Dataloader.add_source(Benchmarks, Benchmarks.data())
 

lib/elixir_bench_web/schema/content_types.ex

@@ -8,22 +8,24 @@ defmodule ElixirBenchWeb.Schema.ContentTypes do
   object :repo do
     field :owner, :string
     field :name, :string
-    field :slug, :string, resolve: fn repo, _args, _info -> {:ok, "#{repo.owner}/#{repo.name}"} end
+
+    field :slug, :string,
+      resolve: fn repo, _args, _info -> {:ok, "#{repo.owner}/#{repo.name}"} end
 
     field :benchmarks, list_of(:benchmark) do
-      resolve fn %{id: id}, _, _ ->
+      resolve(fn %{id: id}, _, _ ->
         batch({__MODULE__, :list_benchmarks_by_repo_id}, id, fn batch_results ->
           {:ok, Map.get(batch_results, id, [])}
         end)
-      end
+      end)
     end
 
     field :jobs, list_of(:job) do
-      resolve fn %{id: id}, _, _ ->
+      resolve(fn %{id: id}, _, _ ->
         batch({__MODULE__, :list_jobs_by_repo_id}, id, fn batch_results ->
           {:ok, Map.get(batch_results, id, [])}
         end)
-      end
+      end)
     end
   end
 
@@ -34,15 +36,16 @@ defmodule ElixirBenchWeb.Schema.ContentTypes do
     field :claimed_at, :datetime
     field :completed_at, :datetime
     field :log, :string
+
     field :repo_slug, :string do
-      resolve fn %{repo_id: repo_id}, _, %{context: %{loader: loader}} ->
+      resolve(fn %{repo_id: repo_id}, _, %{context: %{loader: loader}} ->
         loader
         |> Dataloader.load(Repos, Repos.Repo, repo_id)
         |> on_load(fn loader ->
           %{owner: owner, name: name} = Dataloader.get(loader, Repos, Repos.Repo, repo_id)
           {:ok, "#{owner}/#{name}"}
         end)
-      end
+      end)
     end
   end
 
@@ -53,16 +56,18 @@ defmodule ElixirBenchWeb.Schema.ContentTypes do
 
   object :measurement do
     field :id, :id
+
     field :collected_at, :datetime do
-      resolve fn measurement, _, %{context: %{loader: loader}} ->
+      resolve(fn measurement, _, %{context: %{loader: loader}} ->
         loader
         |> Dataloader.load(Benchmarks, :job, measurement)
         |> on_load(fn loader ->
           %{completed_at: value} = Dataloader.get(loader, Benchmarks, :job, measurement)
           {:ok, value}
         end)
-      end
+      end)
     end
+
     field :commit, :commit, resolve: dataloader(Benchmarks, :job)
     field :environment, :environment, resolve: dataloader(Benchmarks, :job)
     field :result, :result, resolve: parent()
@@ -77,8 +82,10 @@ defmodule ElixirBenchWeb.Schema.ContentTypes do
   object :environment do
     field :elixir_version, :string
     field :erlang_version, :string
+
     field :dependency_versions, list_of(:package_version),
       resolve: map_to_list(:dependency_versions, :name, :version)
+
     field :cpu, :string
     field :cpu_count, :integer
     field :memory, :integer, resolve: key(:memory_mb)

lib/elixir_bench_web/views/error_view.ex

@@ -12,6 +12,6 @@ defmodule ElixirBenchWeb.ErrorView do
   # In case no render clause matches or no
   # template is found, let's render it as 500
   def template_not_found(_template, assigns) do
-    render "500.json", assigns
+    render("500.json", assigns)
   end
 end

lib/elixir_bench_web/views/job_view.ex

@@ -30,6 +30,7 @@ defmodule ElixirBenchWeb.JobView do
   defp render_docker(%{docker: docker}) when is_list(docker) do
     Enum.map(docker, &render_each_docker/1)
   end
+
   defp render_docker(nil), do: []
 
   def render_each_docker(docker) do