easy_params 0.8.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 520468dff4cbd537cef3eec5d4d0c15607e0616143812746c559a7697294bc1c
-  data.tar.gz: 338dc40010d0a02ab8819289ad64e9355fa2ee302fbb93ae82723b15a9b8d94c
+  metadata.gz: 2bee55f0854b77323d19e97acace58d7de0602aa1bb4500c19a0b9ea79f26013
+  data.tar.gz: 2587c8ae019b986041b712ddf9eb433666ff99efa7dcacbe1b4f6d2ae31ec66a
 SHA512:
-  metadata.gz: b0f00c2a25862648b027d96b0491ddfdc6f838cf5fef010c8fa263436afb2ea463f85a3ea8b46ca3839e4036d8a8a73fd98a577fb78f2f8a204a1515b130022f
-  data.tar.gz: 86a0f9d29e30d44d40d3af84604d458b8b8cffc190d9e960de3a3858d550161b33970520ea3d3e03d3ad3e221532f0fc28a48abd3882eb0c760a186465328d21
+  metadata.gz: b66f092c49e32afc330b5230184edad67af9c7ede2362befd80861978e90a22efe8dc86d9166121432416b9014fed2467654b294aa7c316dcf557ed13e987c1d
+  data.tar.gz: 45aaac0c0cb73909c1d75d9288fb1d3ab357a1a549295bebe160cbadb8cf0355b1bf1a112b14191fc2ca0d540b5a2667dd8b8b24ceedb01523e33086b6d9425d

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    easy_params (0.8.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

@@ -6,12 +6,18 @@ module EasyParams
     include ActiveModel::Model
     include EasyParams::Types::Struct
     include EasyParams::Validation
+    include EasyParams::Composition
 
     attr_writer :default
 
     def initialize(params = {})
       self.class.schema.each do |attr, type|
-        public_send("#{attr}=", type.coerce(params.to_h[attr]))
+        coerced_type = type.coerce(params.to_h[attr])
+        if coerced_type && (type.is_a?(EasyParams::Base) || type.is_a?(EasyParams::Types::StructsCollection))
+          coerced_type.owner = self
+        end
+        coerced_type.each { |v| v.owner = coerced_type } if coerced_type.is_a?(EasyParams::Types::StructsCollection)
+        public_send("#{attr}=", coerced_type)
       end
     end
 
@@ -46,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)
@@ -95,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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module EasyParams
+  # Provides composition helpers for EasyParams components.
+  module Composition
+    def self.included(base)
+      base.attr_accessor :owner
+      base.include(InstanceMethods)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods # rubocop:disable Style/Documentation
+      def part_of(owner_name)
+        @owner_name = owner_name
+        alias_method owner_name, :owner
+      end
+    end
+
+    module InstanceMethods # rubocop:disable Style/Documentation
+      def method_missing(name, *attrs, **kwargs, &block)
+        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.respond_to?(owner_method) })
+
+        handler.public_send(owner_method, *attrs, **kwargs, &block)
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        return super unless method_name.to_s.start_with?('owner_')
+
+        owners_chain.lazy.any? { |o| o.respond_to?(method_name.to_s.sub('owner_', '').to_sym, include_private) }
+      end
+
+      private
+
+      def owners_chain
+        @owners_chain ||= Enumerator.new do |y|
+          obj = self
+          y << obj = obj.owner while obj.respond_to?(:owner)
+        end
+      end
+    end
+  end
+end

data/lib/easy_params/types/collection.rb

@@ -41,6 +41,8 @@ module EasyParams
 
     # base interface for array of structs type
     class StructsCollection < Collection
+      include EasyParams::Composition
+
       def read_default
         @default
       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.8.0'
+  VERSION = '0.9.1'
 end

data/lib/easy_params.rb

@@ -2,6 +2,7 @@
 
 require 'active_model'
 require 'bigdecimal/util'
+require 'easy_params/composition'
 require 'easy_params/types/generic'
 require 'easy_params/types/collection'
 require 'easy_params/types/struct'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: easy_params
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.1
 platform: ruby
 authors:
 - Andrii Baran
@@ -48,6 +48,7 @@ files:
 - easy_params.gemspec
 - lib/easy_params.rb
 - lib/easy_params/base.rb
+- lib/easy_params/composition.rb
 - lib/easy_params/types.rb
 - lib/easy_params/types/collection.rb
 - lib/easy_params/types/generic.rb