structured_params 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0602589143c9592a299fadcdeb5c1464da069e77a0036294ed12e157261efa94'
-  data.tar.gz: 24d9f4bd999c649da78007696e28e0bf4e3ff5da0b9e77dd24da5d2a9b46062e
+  metadata.gz: 6194009fbc5383add9717e12380cea940598248d52e395acf0abaa6045cea93e
+  data.tar.gz: 9d5298274672938c883872ef1595d7609d0a13dc8971b395a90efef2c265dbcb
 SHA512:
-  metadata.gz: c059ae0f0dd7cbee7996368159bf267025c5d0e76f356de50bf82be556075e69270c1dae007bcaa6bd0d793d7ada93245e83da386b5d4b4b6096a93a08f5916b
-  data.tar.gz: cf1511eb456ce037fec5d06f0e8f38a041546a43731d368d68a92629b88343793f82105d6b237c2d216142fedb511a9e278a770313cb69cd75542c94de07df68
+  metadata.gz: 37c7d0ead65ced25e00fb82d34ebd0b8d6a049ae3ec966a9cb296769fb611c95c0381dbaa8ccdb5aca0c2760296b56a57de6dce030d348d4b88a587fc1cb5b1e
+  data.tar.gz: 266f140f0d76a90003223e8bb52a6092fa3ce49ca3a9c3eee32881a0f053baee4150802176f6418e13a4ee84bdd884dbe239bdd413061f6f34e7b2a0788685a0

data/CHANGELOG.md

@@ -5,7 +5,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.1.1] - 2025-09-03
+## [0.1.4] - 2025-09-04
+
+**Full Changelog**: https://github.com/Syati/structured_params/compare/v0.1.3...v0.1.4
+
+
 
 ### Fixed
 - Fixed error key consistency issue where `errors.import` was using string keys instead of symbol keys

data/lib/structured_params/errors.rb

@@ -0,0 +1,68 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+# rubocop:disable Style/OptionalBooleanParameter
+module StructuredParams
+  # Custom errors collection that handles nested attribute names
+  class Errors < ActiveModel::Errors
+    # Override to_hash to maintain compatibility with ActiveModel::Errors by default
+    # Add structured option to get nested structure for dot-notation attributes
+    #: (?bool, ?structured: false) -> Hash[Symbol, String]
+    #: (?bool, structured: bool) -> Hash[Symbol, untyped]
+    def to_hash(full_messages = false, structured: false)
+      if structured
+        attribute_messages_hash = build_attribute_messages_hash(full_messages)
+        build_nested_hash({}, attribute_messages_hash)
+      else
+        # Use default ActiveModel::Errors behavior
+        super(full_messages)
+      end
+    end
+
+    # Override as_json to support structured option
+    # This maintains compatibility with ActiveModel::Errors while adding structured functionality
+    #: (?{ full_messages?: bool, structured?: bool }?) -> Hash[Symbol, untyped]
+    def as_json(options = nil)
+      options ||= {}
+      to_hash(options.fetch(:full_messages, false),
+              structured: options.fetch(:structured, false))
+    end
+
+    # Override messages to support structured option
+    # This maintains compatibility with ActiveModel::Errors while adding structured functionality
+    #: (?structured: bool) -> Hash[Symbol, untyped]
+    def messages(structured: false)
+      hash = to_hash(false, structured: structured)
+      hash.default = [].freeze
+      hash.freeze
+      hash
+    end
+
+    private
+
+    # Build a hash with attribute names as keys and their error messages as values
+    # This is used for to_hash(structured: true)
+    #: (bool) -> Hash[Symbol, Array[String]]
+    def build_attribute_messages_hash(full_messages = false)
+      message_method = full_messages ? :full_message : :message
+
+      group_by_attribute.transform_values do |error_list|
+        error_list.map(&message_method)
+      end
+    end
+
+    # Build a nested hash structure from flat dot-notation keys
+    # Converts "address.postal_code" to {address: {postal_code: value}}
+    #: (Hash[untyped, untyped], Hash[Symbol, Array[String]], ?String) -> Hash[Symbol, untyped]
+    def build_nested_hash(target_hash, flat_hash, separator = '.')
+      flat_hash.each_with_object(target_hash) do |(key, value), result|
+        *prefix, last = key.to_s.split(separator)
+        # Navigate/create nested structure and use symbols for keys
+        prefix.reduce(result) do |hash, k|
+          hash[k.to_sym] ||= {}
+        end[last.to_sym] = value
+      end
+    end
+  end
+end
+# rubocop:enable Style/OptionalBooleanParameter

data/lib/structured_params/params.rb

@@ -15,14 +15,18 @@ module StructuredParams
     include ActiveModel::Model
     include ActiveModel::Attributes
 
+    # @rbs @errors: ::StructuredParams::Errors?
+
     class << self
+      # @rbs self.@structured_attributes: Hash[Symbol, singleton(::StructuredParams::Params)]?
+
       # Generate permitted parameter structure for Strong Parameters
       #: () -> Array[untyped]
       def permit_attribute_names
         attribute_types.map do |name, type|
           name = name.to_sym
 
-          if type.is_a?(StructuredParams::Type::Object) || type.is_a?(StructuredParams::Type::Array)
+          if type.is_a?(Type::Object) || type.is_a?(Type::Array)
             { name => type.permit_attribute_names }
           else
             name
@@ -30,39 +34,51 @@ module StructuredParams
         end
       end
 
-      # Get names of StructuredParams attributes (object and array types)
-      #: () { (String) -> void } -> void
-      def each_structured_attribute_name
-        attribute_types.each do |name, type|
-          yield name if structured_params_type?(type)
+      # Get structured attributes and their classes
+      #: () -> Hash[Symbol, singleton(::StructuredParams::Params)]
+      def structured_attributes
+        @structured_attributes ||= attribute_types.each_with_object({}) do |(name, type), hash|
+          next unless structured_params_type?(type)
+
+          hash[name] = if type.is_a?(Type::Array)
+                         type.item_type.value_class
+                       else
+                         type.value_class
+                       end
         end
       end
 
       private
 
       # Determine if the specified type is a StructuredParams type
-      #: (untyped) -> bool
+      #: (ActiveModel::Type::Value) -> bool
       def structured_params_type?(type)
-        type.is_a?(StructuredParams::Type::Object) ||
-          (type.is_a?(StructuredParams::Type::Array) && type.item_type_is_structured_params_object?)
+        type.is_a?(Type::Object) ||
+          (type.is_a?(Type::Array) && type.item_type_is_structured_params_object?)
       end
     end
 
     # Integrate validation of structured objects
     validate :validate_structured_parameters
 
-    #: (untyped) -> void
+    #: (Hash[untyped, untyped]|::ActionController::Parameters) -> void
     def initialize(params)
       processed_params = process_input_parameters(params)
       super(**processed_params)
     end
 
+    #: () -> ::StructuredParams::Errors
+    def errors
+      @errors ||= Errors.new(self)
+    end
+
     # Convert structured objects to Hash and get attributes
-    #: (symbolize: bool) -> Hash[untyped, untyped]
+    #: (symbolize: true) -> Hash[Symbol, untyped]
+    #: (symbolize: false) -> Hash[String, untyped]
     def attributes(symbolize: false)
       attrs = super()
 
-      self.class.each_structured_attribute_name do |name|
+      self.class.structured_attributes.each_key do |name|
         value = attrs[name.to_s]
         attrs[name.to_s] = serialize_structured_value(value)
       end
@@ -89,21 +105,23 @@ module StructuredParams
     # Execute structured parameter validation
     #: () -> void
     def validate_structured_parameters
-      self.class.each_structured_attribute_name do |attr_name|
-        value = attribute(attr_name)
+      self.class.structured_attributes.each_key do |name|
+        value = attribute(name)
         next if value.blank?
 
         case value
         when Array
-          validate_structured_array(attr_name, value)
+          validate_structured_array(name, value)
         else
-          validate_structured_object(attr_name, value)
+          validate_structured_object(name, value)
         end
       end
     end
 
     # Validate structured arrays
-    #: (String, Array[untyped]) -> void
+    # @rbs attr_name: Symbol
+    # @rbs array_value: Array[untyped]
+    # @rbs return: void
     def validate_structured_array(attr_name, array_value)
       array_value.each_with_index do |item, index|
         next if item.valid?(validation_context)
@@ -114,7 +132,9 @@ module StructuredParams
     end
 
     # Validate structured objects
-    #: (String, StructuredParams::Params) -> void
+    # @rbs attr_name: Symbol
+    # @rbs object_value: ::StructuredParams::Params
+    # @rbs return: void
     def validate_structured_object(attr_name, object_value)
       return if object_value.valid?(validation_context)
 
@@ -123,21 +143,13 @@ module StructuredParams
     end
 
     # Format error path using dot notation (always consistent)
-    #: (String, Integer?) -> String
+    #: (Symbol, Integer?) -> String
     def format_error_path(attr_name, index = nil)
       path_parts = [attr_name]
       path_parts << index.to_s if index
       path_parts.join('.')
     end
 
-    # Integrate structured parameter errors into parent errors
-    #: (untyped, String) -> void
-    def import_structured_errors(structured_errors, prefix)
-      structured_errors.each do |error|
-        errors.import(error, attribute: :"#{prefix}.#{error.attribute}")
-      end
-    end
-
     # Serialize structured values
     #: (untyped) -> untyped
     def serialize_structured_value(value)
@@ -150,5 +162,15 @@ module StructuredParams
         value
       end
     end
+
+    # Integrate structured parameter errors into parent errors
+    #: (untyped, String) -> void
+    def import_structured_errors(structured_errors, prefix)
+      structured_errors.each do |error|
+        # Create dotted attribute path and import normally
+        error_attribute = "#{prefix}.#{error.attribute}"
+        errors.import(error, attribute: error_attribute.to_sym)
+      end
+    end
   end
 end

data/lib/structured_params/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module StructuredParams
-  VERSION = '0.1.4' #: string
+  VERSION = '0.2.0' #: string
 end

data/lib/structured_params.rb

@@ -1,3 +1,4 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 require 'active_model'
@@ -7,6 +8,9 @@ require 'action_controller/metal/strong_parameters'
 # version
 require_relative 'structured_params/version'
 
+# errors
+require_relative 'structured_params/errors'
+
 # types (load first for module definition)
 require_relative 'structured_params/type/object'
 require_relative 'structured_params/type/array'
@@ -17,13 +21,15 @@ require_relative 'structured_params/params'
 # Main module
 module StructuredParams
   # Helper method to register types
+  #: () -> void
   def self.register_types
     ActiveModel::Type.register(:object, StructuredParams::Type::Object)
     ActiveModel::Type.register(:array, StructuredParams::Type::Array)
   end
 
   # Helper method to register types with custom names
-  def self.register_types_as(object_name: :object, array_name: :array)
+  #: (object_name: Symbol, array_name: Symbol) -> void
+  def self.register_types_as(object_name:, array_name:)
     ActiveModel::Type.register(object_name, StructuredParams::Type::Object)
     ActiveModel::Type.register(array_name, StructuredParams::Type::Array)
   end

data/sig/structured_params/errors.rbs

@@ -0,0 +1,36 @@
+# Generated from lib/structured_params/errors.rb with RBS::Inline
+
+# rubocop:disable Style/OptionalBooleanParameter
+module StructuredParams
+  # Custom errors collection that handles nested attribute names
+  class Errors < ActiveModel::Errors
+    # Override to_hash to maintain compatibility with ActiveModel::Errors by default
+    # Add structured option to get nested structure for dot-notation attributes
+    # : (?bool, ?structured: false) -> Hash[Symbol, String]
+    # : (?bool, structured: bool) -> Hash[Symbol, untyped]
+    def to_hash: (?bool, ?structured: false) -> Hash[Symbol, String]
+               | (?bool, structured: bool) -> Hash[Symbol, untyped]
+
+    # Override as_json to support structured option
+    # This maintains compatibility with ActiveModel::Errors while adding structured functionality
+    # : (?{ full_messages?: bool, structured?: bool }?) -> Hash[Symbol, untyped]
+    def as_json: (?{ :full_messages? => bool, :structured? => bool }?) -> Hash[Symbol, untyped]
+
+    # Override messages to support structured option
+    # This maintains compatibility with ActiveModel::Errors while adding structured functionality
+    # : (?structured: bool) -> Hash[Symbol, untyped]
+    def messages: (?structured: bool) -> Hash[Symbol, untyped]
+
+    private
+
+    # Build a hash with attribute names as keys and their error messages as values
+    # This is used for to_hash(structured: true)
+    # : (bool) -> Hash[Symbol, Array[String]]
+    def build_attribute_messages_hash: (bool) -> Hash[Symbol, Array[String]]
+
+    # Build a nested hash structure from flat dot-notation keys
+    # Converts "address.postal_code" to {address: {postal_code: value}}
+    # : (Hash[untyped, untyped], Hash[Symbol, Array[String]], ?String) -> Hash[Symbol, untyped]
+    def build_nested_hash: (Hash[untyped, untyped], Hash[Symbol, Array[String]], ?String) -> Hash[Symbol, untyped]
+  end
+end

data/sig/structured_params/params.rbs

@@ -1,12 +1,12 @@
 # Generated from lib/structured_params/params.rb with RBS::Inline
 
 module StructuredParams
-  # Parameter model that supports nested structures
+  # Parameter model that supports structured objects and arrays
   #
   # Usage example:
   #   class UserParameter < StructuredParams::Params
   #     attribute :name, :string
-  #     attribute :address, :nested, value_class: AddressParameter
+  #     attribute :address, :object, value_class: AddressParameter
   #     attribute :hobbies, :array, value_class: HobbyParameter
   #     attribute :tags, :array, value_type: :string
   #   end
@@ -15,24 +15,33 @@ module StructuredParams
 
     include ActiveModel::Attributes
 
+    @errors: ::StructuredParams::Errors?
+
+    self.@structured_attributes: Hash[Symbol, singleton(::StructuredParams::Params)]?
+
     # Generate permitted parameter structure for Strong Parameters
     # : () -> Array[untyped]
     def self.permit_attribute_names: () -> Array[untyped]
 
-    # Get names of nested StructuredParams attributes
-    # : () { (String) -> void } -> void
-    def self.each_nested_attribute_name: () { (String) -> void } -> void
+    # Get structured attributes and their classes
+    # : () -> Hash[Symbol, singleton(::StructuredParams::Params)]
+    def self.structured_attributes: () -> Hash[Symbol, singleton(::StructuredParams::Params)]
 
-    # Determine if the specified type is a nested parameter type
-    # : (untyped) -> bool
-    private def self.structured_params_type?: (untyped) -> bool
+    # Determine if the specified type is a StructuredParams type
+    # : (ActiveModel::Type::Value) -> bool
+    private def self.structured_params_type?: (ActiveModel::Type::Value) -> bool
 
-    # : (untyped) -> void
-    def initialize: (untyped) -> void
+    # : (Hash[untyped, untyped]|::ActionController::Parameters) -> void
+    def initialize: (Hash[untyped, untyped] | ::ActionController::Parameters) -> void
 
-    # Convert nested objects to Hash and get attributes
-    # : (symbolize: bool) -> Hash[untyped, untyped]
-    def attributes: (symbolize: bool) -> Hash[untyped, untyped]
+    # : () -> ::StructuredParams::Errors
+    def errors: () -> ::StructuredParams::Errors
+
+    # Convert structured objects to Hash and get attributes
+    # : (symbolize: true) -> Hash[Symbol, untyped]
+    # : (symbolize: false) -> Hash[String, untyped]
+    def attributes: (symbolize: true) -> Hash[Symbol, untyped]
+                  | (symbolize: false) -> Hash[String, untyped]
 
     private
 
@@ -40,28 +49,32 @@ module StructuredParams
     # : (untyped) -> Hash[untyped, untyped]
     def process_input_parameters: (untyped) -> Hash[untyped, untyped]
 
-    # Execute nested parameter validation
+    # Execute structured parameter validation
     # : () -> void
-    def validate_nested_parameters: () -> void
+    def validate_structured_parameters: () -> void
 
-    # Validate nested arrays
-    # : (String, Array[untyped]) -> void
-    def validate_nested_array: (String, Array[untyped]) -> void
+    # Validate structured arrays
+    # @rbs attr_name: Symbol
+    # @rbs array_value: Array[untyped]
+    # @rbs return: void
+    def validate_structured_array: (Symbol attr_name, Array[untyped] array_value) -> void
 
-    # Validate nested objects
-    # : (String, StructuredParams::Params) -> void
-    def validate_nested_object: (String, StructuredParams::Params) -> void
+    # Validate structured objects
+    # @rbs attr_name: Symbol
+    # @rbs object_value: ::StructuredParams::Params
+    # @rbs return: void
+    def validate_structured_object: (Symbol attr_name, ::StructuredParams::Params object_value) -> void
 
     # Format error path using dot notation (always consistent)
-    # : (String, Integer?) -> String
-    def format_error_path: (String, Integer?) -> String
+    # : (Symbol, Integer?) -> String
+    def format_error_path: (Symbol, Integer?) -> String
 
-    # Integrate nested errors into parent errors
-    # : (untyped, String) -> void
-    def import_nested_errors: (untyped, String) -> void
-
-    # Serialize nested values
+    # Serialize structured values
     # : (untyped) -> untyped
-    def serialize_nested_value: (untyped) -> untyped
+    def serialize_structured_value: (untyped) -> untyped
+
+    # Integrate structured parameter errors into parent errors
+    # : (untyped, String) -> void
+    def import_structured_errors: (untyped, String) -> void
   end
 end

data/sig/structured_params.rbs

@@ -0,0 +1,12 @@
+# Generated from lib/structured_params.rb with RBS::Inline
+
+# Main module
+module StructuredParams
+  # Helper method to register types
+  # : () -> void
+  def self.register_types: () -> void
+
+  # Helper method to register types with custom names
+  # : (object_name: Symbol, array_name: Symbol) -> void
+  def self.register_types_as: (object_name: Symbol, array_name: Symbol) -> void
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: structured_params
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Mizuki Yamamoto
@@ -47,10 +47,13 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - lib/structured_params.rb
+- lib/structured_params/errors.rb
 - lib/structured_params/params.rb
 - lib/structured_params/type/array.rb
 - lib/structured_params/type/object.rb
 - lib/structured_params/version.rb
+- sig/structured_params.rbs
+- sig/structured_params/errors.rbs
 - sig/structured_params/params.rbs
 - sig/structured_params/type/array.rbs
 - sig/structured_params/type/object.rbs