easy_params 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f63905ee9e223d63e2f3855f7e67ace0f3d2abd14ed97fb1f706f73082f73c90
-  data.tar.gz: 1ce09ad5d8a018e97c9c46eb21b32f5dd537d448830578c8b760ee2c99d903ca
+  metadata.gz: 520468dff4cbd537cef3eec5d4d0c15607e0616143812746c559a7697294bc1c
+  data.tar.gz: 338dc40010d0a02ab8819289ad64e9355fa2ee302fbb93ae82723b15a9b8d94c
 SHA512:
-  metadata.gz: 935a110dbedbace4f05a9df987aec2932fec9ccec5cbc9dbb3b4a3460b42971cd7cdafa60c391b24ad334f74e39086c7d81df191e9622844ebda0f4ed9ca952f
-  data.tar.gz: 9ebe7ebeae1961a820e396361e020b5b8cfe712ad81480dcf14b64784d7de6cf16e66e8c8b9eaf44272c0aaed20805ab255bfe1effc073c4f2aebb355f21339a
+  metadata.gz: b0f00c2a25862648b027d96b0491ddfdc6f838cf5fef010c8fa263436afb2ea463f85a3ea8b46ca3839e4036d8a8a73fd98a577fb78f2f8a204a1515b130022f
+  data.tar.gz: 86a0f9d29e30d44d40d3af84604d458b8b8cffc190d9e960de3a3858d550161b33970520ea3d3e03d3ad3e221532f0fc28a48abd3882eb0c760a186465328d21

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    easy_params (0.7.0)
+    easy_params (0.8.0)
       activemodel (>= 3.2)
 
 GEM

data/README.md

@@ -10,6 +10,40 @@ Provides an easy way to define structure, validation rules, type coercion, and d
 
 Available types: `integer`, `decimal`, `float`, `bool`, `string`, `array`, `date`, `datetime`, `time`
 
+### Registering Custom Types
+
+You can register custom types using `EasyParams.register_type`:
+
+```ruby
+# Register a weight type that converts between units
+EasyParams.register_type :weight do |value|
+  case value.to_s.downcase
+  when /^(\d+(?:\.\d+)?)\s*kg$/i
+    $1.to_f
+  when /^(\d+(?:\.\d+)?)\s*lbs?$/i
+    $1.to_f * 0.453592  # Convert pounds to kg
+  when /^(\d+(?:\.\d+)?)\s*g$/i
+    $1.to_f / 1000.0  # Convert grams to kg
+  else
+    value.to_f
+  end
+end
+
+# Now you can use the weight type in your params classes
+class PersonParams < EasyParams::Base
+  weight :mass, presence: true
+  weight :target_weight, default: 70.0
+  array :weights, of: :weight, default: [65.0, 70.0]
+end
+
+# Usage
+person = PersonParams.new(mass: '75.5 kg', target_weight: '165 lbs')
+# person.mass = 75.5
+# person.target_weight ≈ 74.84 (converted from lbs to kg)
+```
+
+Custom types work with all EasyParams features including validation, arrays, nested structures, and inheritance.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -80,6 +114,67 @@ There are two special types:
   # input: nil => items.map(&:qty) == [2, 1]
   ```
 
+### Schema Extension
+
+You can dynamically extend nested schema definitions using the `#{param_name}_schema` method. This creates a subclass of the original schema that replaces the parent class in the schema, allowing you to add validations, methods, or modify attributes at runtime.
+
+```ruby
+class PostParams < EasyParams::Base
+  has :post, default: {} do
+    integer :id
+    string :title
+    string :content
+    date :published_at, default: Date.today
+  end
+end
+
+# Extend with additional validations and methods
+PostParams.post_schema do
+  validates :title, :content, presence: true, if: :published?
+
+  def published?
+    published_at.present?
+  end
+end
+
+# Now the validation will run conditionally
+params = PostParams.new(id: 1)
+params.valid? # => false (because published_at has default value, so published? returns true)
+```
+
+You can also extend collection schemas:
+
+```ruby
+class CommentParams < EasyParams::Base
+  each :comments, default: [{}, {}] do
+    integer :post_id
+    string :author
+    string :text
+  end
+end
+
+# Extend with additional attributes and validations
+CommentParams.comments_schema do
+  string :author, default: 'Anonymous'
+  date :created_at, default: Date.today
+  validates :post_id, presence: true
+end
+
+# Default values are preserved and merged with input
+params = CommentParams.new({})
+params.comments.size # => 2
+params.comments.first.author # => 'Anonymous'
+params.comments.first.created_at # => Date.today
+```
+
+**Key Features:**
+- **Preserves defaults**: Original default values are maintained when extending schemas
+- **Runtime flexibility**: Add validations and methods by creating subclasses dynamically
+- **Replaces parent**: The new subclass completely replaces the original schema class
+- **Collection support**: Works with both `has` (struct) and `each` (collection) parameters
+
+### Validation errors
+
 ```ruby
 # app/params/api/v2/icqa/move_params.rb
 class Api::V1::Carts::MoveParams < EasyParams::Base
@@ -97,7 +192,9 @@ class Api::V1::Carts::MoveParams < EasyParams::Base
   end
 end
 ```
-Validation messages for nested attributes will look like this.
+
+Validation messages for nested attributes a set on top level and each nested object has `errors` set.
+Errors will look like this.
 ```ruby
 {
   :"sections[0].id"=>an_instance_of(Array),

data/lib/easy_params/base.rb

@@ -2,7 +2,7 @@
 
 module EasyParams
   # Implements validations logic and nesting structures
-  class Base
+  class Base # rubocop:disable Metrics/ClassLength
     include ActiveModel::Model
     include EasyParams::Types::Struct
     include EasyParams::Validation
@@ -19,6 +19,11 @@ module EasyParams
       def inherited(subclass)
         super
         subclass.clone_schema(self)
+        subclass.clone_schemas(self)
+      end
+
+      def schemas
+        @schemas ||= {}
       end
 
       def name
@@ -41,7 +46,8 @@ module EasyParams
           raise ArgumentError, "definition for attribute #{param_name.inspect} must be a subclass of EasyParams::Base"
         end
 
-        type = EasyParams::Types::Each.with_type(definition, &block)
+        handle_schema_definition(param_name, definition, collection: true, &block)
+        type = EasyParams::Types::Each.of(schemas[param_name].new)
         type = customize_type(type, default, &normalize)
         attribute(param_name, type)
       end
@@ -52,7 +58,8 @@ module EasyParams
           raise ArgumentError, "definition for attribute #{param_name.inspect} must be a subclass of EasyParams::Base"
         end
 
-        type = (definition || Class.new(EasyParams::Base).tap { |c| c.class_eval(&block) }).new
+        handle_schema_definition(param_name, definition, &block)
+        type = schemas[param_name].new
         type = customize_type(type, default, &normalize)
         attribute(param_name, type)
       end
@@ -68,6 +75,10 @@ module EasyParams
         @schema = parent.schema.dup
       end
 
+      def clone_schemas(parent)
+        @schemas = parent.schemas.dup
+      end
+
       def define_type_method(type_name)
         define_singleton_method(type_name) do |param_name, default: nil, normalize: nil, **validations|
           validates param_name, **validations if validations.any?
@@ -83,6 +94,26 @@ module EasyParams
         type = type.normalize(&normalize) if normalize
         type
       end
+
+      def handle_schema_definition(param_name, definition = nil, collection: false, &block)
+        schemas[param_name] = definition || Class.new(EasyParams::Base).tap { |c| c.class_eval(&block) }
+        define_schema_method(param_name, collection: collection)
+      end
+
+      def define_schema_method(param_name, collection: false)
+        define_singleton_method("#{param_name}_schema") do |&block|
+          default = schema[param_name].read_default
+          schemas[param_name] = Class.new(schemas[param_name]).tap { |c| c.class_eval(&block) }
+          type = create_schema_type(param_name, collection, default)
+          attribute(param_name, type)
+        end
+      end
+
+      def create_schema_type(param_name, collection, default)
+        type = schemas[param_name].new
+        type = EasyParams::Types::Each.of(type) if collection
+        customize_type(type, default)
+      end
     end
 
     def attributes

data/lib/easy_params/types/collection.rb

@@ -41,9 +41,8 @@ module EasyParams
 
     # base interface for array of structs type
     class StructsCollection < Collection
-      def with_type(definition = nil, &block)
-        of_type = (definition || Class.new(EasyParams::Base).tap { |c| c.class_eval(&block) }).new
-        self.class.new(@title, @default, @normalize_proc, of: of_type)
+      def read_default
+        @default
       end
     end
   end

data/lib/easy_params/types/struct.rb

@@ -8,6 +8,10 @@ module EasyParams
         false
       end
 
+      def read_default
+        @default
+      end
+
       def default(value)
         self.default = value
         self

data/lib/easy_params/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EasyParams
-  VERSION = '0.7.0'
+  VERSION = '0.8.0'
 end

data/lib/easy_params.rb

@@ -39,20 +39,20 @@ module EasyParams
   register_type :string, &:to_s
   register_type(:decimal) { |v| v.to_f.to_d }
   register_type(:bool) do |v|
-    BOOLEAN_MAP.fetch(v.to_s) { raise CoercionError }
+    v.is_a?(TrueClass) || v.is_a?(FalseClass) ? v : BOOLEAN_MAP.fetch(v.to_s) { raise CoercionError }
   end
   register_type(:date) do |v|
-    ::Date.parse(v)
+    v.is_a?(Date) ? v : Date.parse(v)
   rescue ArgumentError, RangeError
     raise CoercionError, 'cannot be coerced'
   end
   register_type(:datetime) do |v|
-    ::DateTime.parse(v)
+    v.is_a?(DateTime) ? v : DateTime.parse(v)
   rescue ArgumentError
     raise CoercionError, 'cannot be coerced'
   end
   register_type(:time) do |v|
-    ::Time.parse(v)
+    v.is_a?(Time) ? v : Time.parse(v)
   rescue ArgumentError
     raise CoercionError, 'cannot be coerced'
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: easy_params
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Andrii Baran