Merge pull request #22 from Frameio/fb/update-deps-gha

Add Github Actions workflow

Author: halfdan

.formatter.exs

@@ -0,0 +1,5 @@
+# Used by "mix format"
+[
+  inputs: ["mix.exs", "{config,lib,test}/**/*.{ex,exs}"],
+  line_length: 120
+]

.github/workflows/ci.yml

@@ -0,0 +1,56 @@
+name: Elixir CI
+
+on:
+  push:
+    branches: ["master"]
+  pull_request:
+    branches: ["master"]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    name: Build and test
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        include:
+          - elixir: "1.15"
+            otp: "25"
+          - elixir: "1.18"
+            otp: "27"
+            lint: true
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Elixir
+        uses: erlef/setup-beam@v1
+        with:
+          otp-version: ${{matrix.otp}}
+          elixir-version: ${{matrix.elixir}}
+
+      - name: Restore dependencies cache
+        uses: actions/cache@v3
+        with:
+          path: deps
+          key: ${{ runner.os }}-mix-${{ hashFiles('**/mix.lock') }}
+          restore-keys: ${{ runner.os }}-mix-
+
+      - name: Install dependencies
+        run: mix deps.get
+        
+      - name: Compile
+        run: mix compile --warnings-as-errors
+        
+      - name: Run tests
+        run: mix test
+        
+      - name: checks that the mix.lock file has no unused deps 
+        run: mix deps.unlock --check-unused
+        if: ${{ matrix.lint }}
+
+      - name: check if files are already formatted
+        run: mix format --check-formatted
+        if: ${{ matrix.lint }}

.tool-versions

@@ -1,2 +1,3 @@
-erlang 25.3.2.8
-elixir 1.16.1-otp-25
+elixir 1.18.2-otp-27
+erlang 27.2.3
+nodejs 16.11.1

cereal-1.0.0.tar

@@ -7,6 +7,7 @@ defmodule Cereal.AssociationNotLoadedError do
       Please pre-fetch the relationship before serialization or override the
       #{opts[:name]}/2 function in your serializer.
     """
+
     %Cereal.AssociationNotLoadedError{message: msg}
   end
 end

cereal_ex.iml

@@ -10,14 +10,16 @@ defmodule Cereal.Builders.Base do
 
   Will correctly handle Scrievener pagination.
   """
-  @spec build(Cereal.Context.t) :: __MODULE__.t
+  @spec build(Cereal.Context.t()) :: __MODULE__.t()
   def build(context)
+
   if Code.ensure_loaded?(Scrivener) do
     def build(%{data: %Scrivener.Page{} = page, opts: opts} = context) do
       opts = opts |> Enum.into(%{}) |> Map.put(:page, to_page_options(page))
       build(%{context | data: page.entries, opts: opts})
     end
   end
+
   def build(%{serializer: serializer, data: data, opts: opts} = context) do
     opts = parse_opts(opts)
     data = serializer.preload(data, context.conn, Map.get(opts, :include, []))
@@ -33,16 +35,19 @@ defmodule Cereal.Builders.Base do
   defp build_metadata(%{opts: opts}), do: Map.get(opts, :metadata)
 
   defp parse_opts(opts) when is_list(opts), do: opts |> Map.new() |> parse_opts()
+
   defp parse_opts(opts) when is_map(opts) do
     opts
     |> parse_includes()
     |> parse_fields_list(:fields)
     |> parse_fields_list(:excludes)
   end
+
   defp parse_opts(_), do: %{}
 
   defp parse_includes(%{include: include} = opts) when is_binary(include),
     do: %{opts | include: Utils.normalize_includes(include)}
+
   defp parse_includes(opts), do: opts
 
   defp parse_fields_list(opts, key) do

lib/cereal/association_not_loaded_error.ex

@@ -10,7 +10,7 @@ defmodule Cereal.Builders.Entity do
       |> Map.put(:data, entity)
       |> build()
     end)
-    |> Enum.map(fn({:ok, result}) -> result end)
+    |> Enum.map(fn {:ok, result} -> result end)
   end
 
   def build(%{serializer: serializer} = context) do
@@ -23,18 +23,20 @@ defmodule Cereal.Builders.Entity do
       id: serializer.id(context.data, context.conn),
       type: serializer.type(context.data, context.conn),
       attributes: attributes(context),
-      rels: relationships(context),
+      rels: relationships(context)
     }
   end
 
   # if an assigns/2 function was specified in the serializer - we'll add its
   # return value to the conn's assigns
   defp do_assigns(%{serializer: serializer, conn: conn, data: data} = context) do
     conn = Map.put_new(conn, :assigns, %{})
+
     conn =
       data
       |> serializer.assigns(conn)
       |> Enum.reduce(conn, &do_assign/2)
+
     %{context | conn: conn}
   end
 
@@ -58,7 +60,7 @@ defmodule Cereal.Builders.Entity do
     relation =
       should_include_relation?(context.opts, name, rel_opts)
       |> case do
-        true  -> relation(context, name, rel_opts)
+        true -> relation(context, name, rel_opts)
         false -> nil
       end
 
@@ -71,6 +73,7 @@ defmodule Cereal.Builders.Entity do
   end
 
   defp build_relation_entity(nil, _, _, _), do: nil
+
   defp build_relation_entity(relation, context, name, rel_opts) do
     context
     |> Map.put(:serializer, rel_opts.serializer)
@@ -81,30 +84,37 @@ defmodule Cereal.Builders.Entity do
 
   defp with_relationship_includes(%{include: includes} = opts, name) when is_list(includes),
     do: %{opts | include: includes[name]}
+
   defp with_relationship_includes(opts, _), do: opts
 
   # We include the option when the following is true:
   # 1) The relation options have `include: true`
   # 2) The `include` option is passed in and includes the resource
   defp should_include_relation?(_, _, %{include: true}), do: true
+
   defp should_include_relation?(%{include: included}, name, _) when is_list(included),
     do: included[name] |> is_list()
+
   defp should_include_relation?(_, _, %{include: false}), do: false
   defp should_include_relation?(_, _, _), do: true
 
   defp filter_attributes(attrs, %{serializer: serializer, opts: %{fields: fields}} = context) when is_list(fields) do
     type = serializer.type(context.data, context.conn) |> String.to_atom()
     do_filter_attributes(attrs, {:take, fields[type]})
   end
+
   defp filter_attributes(attrs, %{serializer: serializer, opts: %{excludes: fields}} = context) when is_list(fields) do
     type = serializer.type(context.data, context.conn) |> String.to_atom()
     do_filter_attributes(attrs, {:drop, fields[type]})
   end
+
   defp filter_attributes(attrs, _), do: attrs
 
   defp do_filter_attributes(attrs, {:take, fields}) when is_list(fields),
     do: Map.take(attrs, fields)
+
   defp do_filter_attributes(attrs, {:drop, fields}) when is_list(fields),
     do: Map.drop(attrs, fields)
+
   defp do_filter_attributes(attrs, _), do: attrs
 end

lib/cereal/builders/base.ex

@@ -3,32 +3,38 @@ defmodule Cereal.Builders.Error do
   defstruct [:title, :code, :detail, :source, {:meta, %{}}]
 
   def build(%{data: %Ecto.Changeset{}} = context), do: build_errors_from_changeset(context)
+
   def build(%{data: data} = context) when is_list(data) do
-    data |> Enum.map(fn error ->
+    data
+    |> Enum.map(fn error ->
       context |> Map.put(:data, error) |> build()
     end)
   end
+
   def build(context) do
     attrs = with_serializer_context(context)
     struct(__MODULE__, attrs)
   end
 
   defp build_errors_from_changeset(%{data: cs} = context) do
-    cs.errors |> Enum.map(fn field ->
+    cs.errors
+    |> Enum.map(fn field ->
       context |> Map.put(:data, field) |> format_ecto_error()
     end)
   end
 
   defp format_ecto_error(%{data: {field, {message, vals}}} = context) do
-    message = Enum.reduce(vals, message, fn {key, value}, acc ->
-      case key do
-        :type -> acc
-        _     -> String.replace(acc, "%{#{key}}", to_string(value))
-      end
-    end)
+    message =
+      Enum.reduce(vals, message, fn {key, value}, acc ->
+        case key do
+          :type -> acc
+          _ -> String.replace(acc, "%{#{key}}", to_string(value))
+        end
+      end)
 
     %{context | data: {field, message}} |> format_ecto_error()
   end
+
   defp format_ecto_error(%{data: {field, message}, serializer: serializer} = context) do
     %__MODULE__{
       title: message,

lib/cereal/builders/entity.ex

@@ -4,7 +4,7 @@ defmodule Cereal.Builders.Errors do
 
   alias Cereal.Builders.Error
 
-  @spec build(Cereal.Context.t) :: __MODULE__.t
+  @spec build(Cereal.Context.t()) :: __MODULE__.t()
   def build(%{serializer: serializer} = context) do
     struct(__MODULE__, %{})
     |> Map.put(:title, serializer.title(context.conn))