fill-unill

Author: jechol

README.md

@@ -1,76 +1,86 @@
 # AshRandomParams
 
-Shortcut DSL for attributes and relationships in Ash resources.
+A library that generates random parameters for Ash resource actions. It provides a convenient way to create random test data for your Ash resources by automatically generating random values for accepts and arguments.
 
-### For attribute
+## Installation
 
-| DSL | allow_nil? | public? |
-|:---:|:----------:|:-------:|
-| `attribute` (Ash) | true | false |
-| `req` | false | true |
-| `req_prv` | false | false |
-| `opt` | true | true |
-| `opt_prv` | true | false |
+Add `ash_random_params` to your list of dependencies in `mix.exs`:
 
-### For belongs_to
+```elixir
+def deps do
+  [
+    {:ash_random_params, "~> 0.2.0"}
+  ]
+end
+```
 
-| DSL | allow_nil? | public? |
-|:---:|:----------:|:-------:|
-| `belongs_to` (Ash) | true | false |
-| `req_belongs_to` | false | true |
-| `req_prv_belongs_to` | false | false |
-| `opt_belongs_to` | true | true |
-| `opt_prv_belongs_to` | true | false |
+## Usage
 
-## Usage Example
+Add the `random_params` DSL to your Ash resource:
 
 ```elixir
-defmodule MyApp.User do
+defmodule MyApp.Post do
   use Ash.Resource, extensions: [AshRandomParams]
 
   attributes do
     uuid_primary_key :id
+    attribute :title, :string, allow_nil?: false
+    attribute :content, :string, allow_nil?: true
+  end
 
-    # Required attributes
-    req :email, :string    # allow_nil?: false, public?: true
-    req_prv :password_hash, :string    # allow_nil?: false, public?: false
+  random_params do
+    random MyRandom  # Optional: specify your custom random generator
+  end
+end
+```
 
-    # Optional attributes
-    opt :name, :string     # allow_nil?: true, public?: true
-    opt_prv :last_login_at, :utc_datetime  # allow_nil?: true, public?: false
+### Custom Random Generator
 
-    # Original attribute macro still works
-    attribute :nickname, :string, allow_nil?: true
-  end
+You can implement a custom random generator by using the `AshRandomParams.Random` behaviour:
 
-  relationships do
-    # Required relationships
-    req_belongs_to :company, Company    # allow_nil?: false, public?: true
-    req_prv_belongs_to :created_by, User    # allow_nil?: false, public?: false
+```elixir
+defmodule MyRandom do
+  use AshRandomParams.Random
 
-    # Optional relationships
-    opt_belongs_to :manager, User       # allow_nil?: true, public?: true
-    opt_prv_belongs_to :updated_by, User    # allow_nil?: true, public?: false
+  @impl AshRandomParams.Random
+  def random(%{type: Ash.Type.Integer}, _opts, _context) do
+    777  # Custom random integer
+  end
 
-    # Original belongs_to macro still works
-    belongs_to :department, Department, allow_nil?: true
+  @impl AshRandomParams.Random
+  def random(attr_or_arg, opts, context) do
+    # Fallback to DefaultRandom for all other types
+    AshRandomParams.DefaultRandom.random(attr_or_arg, opts, context)
   end
 end
 ```
 
-## Installation
-
-Add `ash_random_params` to your list of dependencies in `mix.exs`:
+### Using Random Params
 
 ```elixir
-def deps do
-  [
-    {:ash_random_params, "~> 0.2.0"}
-  ]
-end
+# Basic usage
+Post.random_params!(:create)
+
+# With initial params
+Post.random_params!(:create, %{key: "value"})
+
+# With options
+Post.random_params!(:create, %{key: "value"}, %{
+  fill: [:optional_field],    # Fill optional fields
+  unfill: [:required_field]   # Leave required fields as nil
+})
 ```
 
+## Features
+
+- Automatically generates random values for action accepts and arguments
+- Supports custom random value generators
+- Useful for testing and development
+
 ## License
 
 MIT
 
+## Links
+
+- [GitHub Repository](https://github.com/devall-org/ash_random_params)

lib/ash_random_params.ex

@@ -2,7 +2,7 @@ defmodule AshRandomParams do
   @random_params %Spark.Dsl.Section{
     name: :random_params,
     describe: """
-    random_params 설정
+    random_params configuration
     """,
     schema: [
       random: [
@@ -11,7 +11,7 @@ defmodule AshRandomParams do
         required: false,
         default: {AshRandomParams.DefaultRandom, []},
         doc: """
-        random attribute, argument 생성 함수
+        random attribute, argument generation function
         """
       ]
     ],

lib/transformer.ex

@@ -4,7 +4,6 @@ defmodule AshRandomParams.Transformer do
   alias Ash.Resource.Relationships.BelongsTo
   alias Ash.Resource.Builder
 
-  # def before?(AshCloak.Transformers.SetupEncryption), do: true
   def before?(Ash.Resource.Transformers.BelongsToAttribute), do: false
   def before?(_), do: true
 
@@ -20,17 +19,17 @@ defmodule AshRandomParams.Transformer do
   def add_random_params(dsl_state) do
     action = Builder.build_action_argument(:action, :atom, default: :create)
     init_params = Builder.build_action_argument(:init_params, :map, default: %{})
-    exclude = Builder.build_action_argument(:exclude, {:array, :atom}, default: [])
-    include = Builder.build_action_argument(:include, {:array, :atom}, default: [])
+    fill = Builder.build_action_argument(:fill, {:array, :atom}, default: [])
+    unfill = Builder.build_action_argument(:unfill, {:array, :atom}, default: [])
     tagged_unions = Builder.build_action_argument(:tagged_unions, :map, default: %{})
 
     dsl_state
     |> Builder.add_action(:action, :random_params,
       returns: :map,
-      arguments: [action, init_params, exclude, include, tagged_unions],
+      arguments: [action, init_params, unfill, fill, tagged_unions],
       run: &__MODULE__.do_random_params/2
     )
-    |> Builder.add_interface(:random_params, args: [:action, :init_params])
+    |> Builder.add_interface(:random_params, args: [:action, {:optional, :init_params}])
   end
 
   def add_random_attr(dsl_state) do
@@ -51,8 +50,8 @@ defmodule AshRandomParams.Transformer do
           arguments: %{
             action: action,
             init_params: init_params,
-            exclude: exclude,
-            include: include,
+            unfill: unfill,
+            fill: fill,
             tagged_unions: tagged_unions
           }
         } =
@@ -105,10 +104,10 @@ defmodule AshRandomParams.Transformer do
           |> Enum.reject(&(&1.name in rel_names))
           |> Enum.reject(&(&1.name in belongs_to_attrs))
           |> Enum.reject(&(&1.name in union_keys))
-          |> Enum.reject(&(&1.name in exclude))
+          |> Enum.reject(&(&1.name in unfill))
           |> Enum.reject(& &1.allow_nil?)
 
-        fields_by_fill = candidates |> Enum.filter(&(&1.name in include))
+        fields_by_fill = candidates |> Enum.filter(&(&1.name in fill))
 
         (fields_by_unfill ++ fields_by_fill)
         |> Enum.reject(&(&1.name in init_keys))

test/ash_random_params_test.exs

@@ -119,7 +119,7 @@ defmodule AshRandomParamsTest do
                |> Ash.run_action!()
     end
 
-    test "with include" do
+    test "with fill" do
       assert %{
                author_id: nil,
                req_str: "req_str-" <> _,
@@ -132,13 +132,13 @@ defmodule AshRandomParamsTest do
                  :random_params,
                  %{
                    action: :create,
-                   include: [:opt_str]
+                   fill: [:opt_str]
                  }
                )
                |> Ash.run_action!()
     end
 
-    test "with exclude" do
+    test "with unfill" do
       assert %{
                author_id: nil,
                req_str: nil,
@@ -151,7 +151,7 @@ defmodule AshRandomParamsTest do
                  :random_params,
                  %{
                    action: :create,
-                   exclude: [:req_str]
+                   unfill: [:req_str]
                  }
                )
                |> Ash.run_action!()
@@ -162,14 +162,32 @@ defmodule AshRandomParamsTest do
     assert %{
              author_id: nil,
              req_str: "req_str-" <> _,
-             opt_str: "opt_str-" <> _,
+             opt_str: nil,
              req_int: 777,
              opt_int: nil
+           } =
+             Post.random_params!(:create)
+
+    assert %{
+             author_id: nil,
+             req_str: "req_str-" <> _,
+             opt_str: nil,
+             req_int: 123,
+             opt_int: 456
+           } =
+             Post.random_params!(:create, %{req_int: 123, opt_int: 456})
+
+    assert %{
+             author_id: nil,
+             req_str: "req_str-" <> _,
+             opt_str: nil,
+             req_int: 777,
+             opt_int: 456
            } =
              Post.random_params!(
                :create,
-               %{},
-               %{include: [:opt_str]}
+               %{opt_int: 456},
+               %{fill: [:opt_int]}
              )
   end
 end