easy_params 0.9.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 56cdc3f7e00c381786f025e6aca73baacbb8b8e7cf02aaa6d37c163db2c8463e
-  data.tar.gz: 531ef26595af187e646caa32a448c3c3b37b4d31f028d0202989424ea5761b90
+  metadata.gz: 2bee55f0854b77323d19e97acace58d7de0602aa1bb4500c19a0b9ea79f26013
+  data.tar.gz: 2587c8ae019b986041b712ddf9eb433666ff99efa7dcacbe1b4f6d2ae31ec66a
 SHA512:
-  metadata.gz: 59d619a8301928dc576050eee95959edb97a5dbaac9a7179e0d2d698317236707b7715208e8274db8c0379a15fdb5d5035a6b445eb7bc7543583668dcda0ffcb
-  data.tar.gz: 12a2e968a77f10af3c960bc57c6fc63b66c4dd2d1cbceff371114ac8f1c534e326ddf4b4365ccc4e826f979baa690b9661d54c1c9a3216bbdeac5e54f98248af
+  metadata.gz: b66f092c49e32afc330b5230184edad67af9c7ede2362befd80861978e90a22efe8dc86d9166121432416b9014fed2467654b294aa7c316dcf557ed13e987c1d
+  data.tar.gz: 45aaac0c0cb73909c1d75d9288fb1d3ab357a1a549295bebe160cbadb8cf0355b1bf1a112b14191fc2ca0d540b5a2667dd8b8b24ceedb01523e33086b6d9425d

data/Gemfile.lock

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

data/README.md

@@ -173,6 +173,77 @@ params.comments.first.created_at # => Date.today
 - **Replaces parent**: The new subclass completely replaces the original schema class
 - **Collection support**: Works with both `has` (struct) and `each` (collection) parameters
 
+### Composition and Owner Context
+
+EasyParams supports composition through an owner relationship, allowing nested objects to access methods from their parent objects or an external owner object. This is particularly useful for conditional validations and accessing context from nested structures.
+
+Every `EasyParams::Base` instance has an `owner` attribute that is automatically set for nested objects:
+- Objects created with `has` get their parent as the owner
+- Objects in collections created with `each` get the collection as their owner, and the collection gets the parent as its owner
+
+You can access methods on the owner chain using the `owner_` prefix:
+
+```ruby
+class Owner
+  def check_name?
+    true
+  end
+
+  def check_address_city?
+    true
+  end
+
+  def check_phone_number?
+    true
+  end
+end
+
+class UserParams < EasyParams::Base
+  integer :id
+  string :name, presence: { if: :owner_check_name? }
+
+  has :address do
+    string :street
+    string :city, presence: { if: :owner_check_address_city? }
+    string :state
+    string :zip
+  end
+
+  each :phones do
+    string :number, presence: { if: :owner_check_phone_number? }
+    string :type
+  end
+end
+
+# Use with an external owner object
+owner = Owner.new
+params = UserParams.new(
+  id: 1,
+  address: { street: '123 Main St', city: nil },
+  phones: [{ number: nil, type: 'home' }]
+)
+params.owner = owner
+
+# Validations will use the owner's methods
+params.valid? # => false
+params.errors[:name] # => ["can't be blank"]
+params.address.errors[:city] # => ["can't be blank"]
+params.phones[0].errors[:number] # => ["can't be blank"]
+
+# Owner relationships are automatically established
+params.owner # => owner
+params.address.owner # => params (parent)
+params.phones.owner # => params (parent)
+params.phones[0].owner # => params.phones (collection)
+```
+
+**Key Features:**
+- **Automatic owner setup**: Nested objects automatically get their parent as owner
+- **Owner chain**: The `owner_` prefix searches up the owner chain to find methods
+- **External owners**: Set an external object as owner to provide additional context
+- **Conditional validations**: Use owner methods in validation conditions (`if:`, `unless:`)
+- **Nested access**: Works at any nesting level - nested objects can access parent methods
+
 ### Validation errors
 
 ```ruby

data/lib/easy_params/base.rb

@@ -52,7 +52,7 @@ module EasyParams
           raise ArgumentError, "definition for attribute #{param_name.inspect} must be a subclass of EasyParams::Base"
         end
 
-        handle_schema_definition(param_name, definition, collection: true, &block)
+        handle_schema_definition(param_name, definition, &block)
         type = EasyParams::Types::Each.of(schemas[param_name].new)
         type = customize_type(type, default, &normalize)
         attribute(param_name, type)
@@ -101,24 +101,23 @@ module EasyParams
         type
       end
 
-      def handle_schema_definition(param_name, definition = nil, collection: false, &block)
+      def handle_schema_definition(param_name, definition = nil, &block)
         schemas[param_name] = definition || Class.new(EasyParams::Base).tap { |c| c.class_eval(&block) }
-        define_schema_method(param_name, collection: collection)
+        define_schema_method(param_name)
       end
 
-      def define_schema_method(param_name, collection: false)
+      def define_schema_method(param_name)
         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)
+          type = create_schema_type(param_name, schema[param_name])
           attribute(param_name, type)
         end
       end
 
-      def create_schema_type(param_name, collection, default)
+      def create_schema_type(param_name, custom_type)
         type = schemas[param_name].new
-        type = EasyParams::Types::Each.of(type) if collection
-        customize_type(type, default)
+        type = EasyParams::Types::Each.of(type) if custom_type.is_a?(Types::StructsCollection)
+        customize_type(type, custom_type.read_default, &custom_type.normalize_proc)
       end
     end
 

data/lib/easy_params/composition.rb

@@ -21,7 +21,7 @@ module EasyParams
         return super unless name.to_s.start_with?('owner_')
 
         owner_method = name.to_s.sub('owner_', '').to_sym
-        return super unless (handler = owners_chain.lazy.detect { |o| o.public_methods.include?(owner_method) })
+        return super unless (handler = owners_chain.lazy.detect { |o| o.respond_to?(owner_method) })
 
         handler.public_send(owner_method, *attrs, **kwargs, &block)
       end
@@ -37,7 +37,7 @@ module EasyParams
       def owners_chain
         @owners_chain ||= Enumerator.new do |y|
           obj = self
-          y << obj = obj.owner while obj.public_methods.include?(:owner)
+          y << obj = obj.owner while obj.respond_to?(:owner)
         end
       end
     end

data/lib/easy_params/types/generic.rb

@@ -4,9 +4,7 @@ module EasyParams
   module Types
     # base interface for simple types
     class Generic
-      def array?
-        @title == :array
-      end
+      attr_reader :normalize_proc
 
       def initialize(title, default = nil, normalize_proc = nil, &coerce_proc)
         @title = title
@@ -15,6 +13,10 @@ module EasyParams
         @normalize_proc = normalize_proc
       end
 
+      def array?
+        @title == :array
+      end
+
       def default(value)
         self.class.new(@title, value, @normalize_proc, &@coerce_proc)
       end

data/lib/easy_params/types/struct.rb

@@ -12,14 +12,26 @@ module EasyParams
         @default
       end
 
+      def normalize_proc
+        @normalize_proc
+      end
+
       def default(value)
         self.default = value
         self
       end
 
-      def coerce(input)
-        return if input.nil? && @default.nil?
-        return self.class.new(@default) if input.nil? && @default.is_a?(Hash)
+      def normalize(&block)
+        @normalize_proc = block
+        self
+      end
+
+      def coerce(value)
+        return if value.nil? && @default.nil?
+
+        input = value || @default
+        input = @normalize_proc.call(input) if @normalize_proc
+        return self.class.new(input) if input.is_a?(Hash)
 
         self.class.new(input)
       end

data/lib/easy_params/version.rb

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

metadata

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