chore: improved readability

lib/factory_ex/schema_associations_builder.ex

@@ -39,111 +39,114 @@ defmodule FactoryEx.SchemaAssociationsBuilder do
  """
  @spec build_params(module, map, keyword) :: map
  def build_params(ecto_schema, params \\ %{}, options \\ []) do
- related_fields = options[:relational] || []
- build_reflected_associations(ecto_schema, params, related_fields)
+ assoc_keys = options[:relational] || []
+ create_ecto_schema_reflections(ecto_schema, params, assoc_keys)
  end
 
- defp build_reflected_associations(
+ defp create_ecto_schema_reflections(
  ecto_schema,
  params,
- related_fields
+ assoc_keys
  )
  when is_map(params) do
  ecto_assocs = Reflection.associations_reflections(ecto_schema)
 
  Enum.reduce(
- related_fields,
+ assoc_keys,
  params,
- &build_assoc_params(&1, &2, ecto_assocs, ecto_schema)
+ &convert_to_ecto_schema_assoc_params(&1, &2, ecto_assocs, ecto_schema)
  )
  end
 
- defp build_assoc_params({field, rel}, params, ecto_assocs, ecto_schema) do
+ defp convert_to_ecto_schema_assoc_params({field, assoc_keys}, params, ecto_assocs, ecto_schema) do
  ecto_assoc = fetch_association!(ecto_assocs, field, ecto_schema)
  result =
  cond do
  ecto_assoc.cardinality === :many ->
- maybe_create_many_related_params(
+ maybe_create_many_new_assocs(
+ ecto_assoc.queryable,
  params,
  field,
- rel,
- ecto_assoc.owner_key,
- ecto_assoc.queryable
+ assoc_keys,
+ ecto_assoc.owner_key
  )
 
  ecto_assoc.cardinality === :one ->
- maybe_create_related_params(
+ maybe_create_new_assoc(
+ ecto_assoc.queryable,
  params,
  field,
- rel,
- ecto_assoc.owner_key,
- ecto_assoc.queryable
+ assoc_keys,
+ ecto_assoc.owner_key
  )
+
  end
 
  Map.put(params, field, result)
  end
 
- defp build_assoc_params(field, params, ecto_assocs, ecto_schema) do
- build_assoc_params({field, []}, params, ecto_assocs, ecto_schema)
+ defp convert_to_ecto_schema_assoc_params(field, params, ecto_assocs, ecto_schema) do
+ convert_to_ecto_schema_assoc_params({field, []}, params, ecto_assocs, ecto_schema)
  end
 
- defp maybe_create_many_related_params(params, field, rel, owner_key, queryable) do
+ defp maybe_create_many_new_assocs(queryable, params, field, assoc_keys, owner_key) do
  case Map.get(params, owner_key) do
  nil ->
  params = Map.get(params, field, %{})
- convert_count_or_list_to_params(params, queryable, rel)
+ factory_reflections_build_many(queryable, params, assoc_keys)
+
+ _owner_key -> params
+ end
+ end
 
- _ ->
- params
+ defp maybe_create_new_assoc(queryable, params, field, assoc_keys, owner_key) do
+ case Map.get(params, owner_key) do
+ nil -> factory_reflections_build(queryable, params, field, assoc_keys)
+ _owner_key -> params
  end
  end
 
- defp convert_count_or_list_to_params(params, queryable, rel) when is_list(params) do
+ defp factory_reflections_build_many(queryable, params, assoc_keys) when is_list(params) do
  Enum.map(params, fn param ->
- assoc_params = build_reflected_associations(queryable, param, rel)
+ assoc_params = create_ecto_schema_reflections(queryable, param, assoc_keys)
  build_params = QueryableEtsFactory.build_params(queryable, param)
 
  Map.merge(build_params, assoc_params)
  end)
  end
 
- defp convert_count_or_list_to_params({count, params}, queryable, rel) do
- assoc_params = build_reflected_associations(queryable, params, rel)
+ defp factory_reflections_build_many(queryable, {count, params}, assoc_keys) do
+ assoc_params = create_ecto_schema_reflections(queryable, params, assoc_keys)
 
  count
- |> obj_count()
+ |> count_input()
  |> QueryableEtsFactory.build_many_params(queryable, params)
  |> Enum.map(&Map.merge(&1, assoc_params))
  end
 
- defp obj_count(x..y), do: Enum.random(x..y)
- defp obj_count(count) when is_integer(count), do: count
+ defp factory_reflections_build(queryable, params, field, assoc_keys) do
+  params = Map.get(params, field, %{})
 
- defp maybe_create_related_params(params, field, related_fields, owner_key, queryable) do
- case Map.get(params, owner_key) do
- nil ->
- params = Map.get(params, field, %{})
+ assoc_params = create_ecto_schema_reflections(queryable, params, assoc_keys)
+ params = QueryableEtsFactory.build_params(queryable, params)
 
- assoc_params = build_reflected_associations(queryable, params, related_fields)
- params = QueryableEtsFactory.build_params(queryable, params)
-
- Map.merge(params, assoc_params)
-
- _ ->
- params
- end
+ Map.merge(params, assoc_params)
  end
 
+ defp count_input(x..y), do: Enum.random(x..y)
+ defp count_input(count) when is_integer(count), do: count
+
  defp fetch_association!(ecto_assocs, field, ecto_schema) do
  case Keyword.get(ecto_assocs, field) do
  nil ->
- keys = ecto_assocs |> Keyword.keys()
-
  raise ArgumentError,
  message: """
  `#{field}` is not a valid field for the Ecto Schema `#{inspect(ecto_schema)}`!
- Expected one of the following keys: #{inspect(keys)}.
+
+ Expected one of the following keys: #{ecto_assocs |> Keyword.keys() |> inspect()}.
+
+ Ensure your factory `schema/0` callback returns the correct Ecto.Schema for
+ the specified field.
  """
 
  ecto_assoc ->

lib/factory_ex/schema_builder.ex

@@ -67,11 +67,7 @@ defmodule FactoryEx.SchemaBuilder do
  case Keyword.get(ecto_assocs, field) do
  nil -> params
  ecto_assoc ->
- if is_list(params) do
- Enum.map(params, &deep_map_to_schema_struct(ecto_assoc.queryable, &1))
- else
- deep_map_to_schema_struct(ecto_assoc.queryable, params)
- end
+ deep_map_to_schema_struct(ecto_assoc.queryable, params)
 
  end