structured_params 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9c06ea969ca1b6ba0b64271bc9b168519fecbb48d754c234489e9b509cd22578
+  data.tar.gz: 9f10004fd987e2e5af527857860d72d6d4ccaf19ec98dec0ac673c9db20ec473
+SHA512:
+  metadata.gz: 6354a4d7f609f46093ed55f8cab4873d2f0f15370f0ad4a1e6719e7e5e02ff12a17ce0bd34f5b82bb1129ed6d933cfa51aa6de353b7fe7cf18882d857f3daa23
+  data.tar.gz: ff1fe2be0beb5024f7afa1e8f41a4b32dc55aeee061d633d40ca0052802129b507962d0a38bcad826d10da98ac7c64bd3b25edb7f6bc4c65a3117449fbc8aef9

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Mizuki Yamamoto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/lib/structured_params/params.rb

@@ -0,0 +1,154 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module StructuredParams
+  # Parameter model that supports nested structures
+  #
+  # Usage example:
+  #   class UserParameter < StructuredParams::Params
+  #     attribute :name, :string
+  #     attribute :address, :nested, value_class: AddressParameter
+  #     attribute :hobbies, :array, value_class: HobbyParameter
+  #     attribute :tags, :array, value_type: :string
+  #   end
+  class Params
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+
+    class << self
+      # 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)
+            { name => type.permit_attribute_names }
+          else
+            name
+          end
+        end
+      end
+
+      # Get names of nested StructuredParams attributes
+      #: () { (String) -> void } -> void
+      def each_nested_attribute_name
+        attribute_types.each do |name, type|
+          yield name if structured_params_type?(type)
+        end
+      end
+
+      private
+
+      # Determine if the specified type is a nested parameter type
+      #: (untyped) -> 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?)
+      end
+    end
+
+    # Integrate validation of nested objects
+    validate :validate_nested_parameters
+
+    #: (untyped) -> void
+    def initialize(params)
+      processed_params = process_input_parameters(params)
+      super(**processed_params)
+    end
+
+    # Convert nested objects to Hash and get attributes
+    #: (symbolize: bool) -> Hash[untyped, untyped]
+    def attributes(symbolize: false)
+      attrs = super()
+
+      self.class.each_nested_attribute_name do |name|
+        value = attrs[name.to_s]
+        attrs[name.to_s] = serialize_nested_value(value)
+      end
+
+      symbolize ? attrs.deep_symbolize_keys : attrs
+    end
+
+    private
+
+    # Process input parameters
+    #: (untyped) -> Hash[untyped, untyped]
+    def process_input_parameters(params)
+      case params
+      when ActionController::Parameters
+        params.permit(self.class.permit_attribute_names).to_h
+      when Hash
+        # ActiveModel::Attributes can handle both symbol and string keys
+        params
+      else
+        raise ArgumentError, "params must be ActionController::Parameters or Hash, got #{params.class}"
+      end
+    end
+
+    # Execute nested parameter validation
+    #: () -> void
+    def validate_nested_parameters
+      self.class.each_nested_attribute_name do |attr_name|
+        value = attribute(attr_name)
+        next if value.blank?
+
+        case value
+        when Array
+          validate_nested_array(attr_name, value)
+        else
+          validate_nested_object(attr_name, value)
+        end
+      end
+    end
+
+    # Validate nested arrays
+    #: (String, Array[untyped]) -> void
+    def validate_nested_array(attr_name, array_value)
+      array_value.each_with_index do |item, index|
+        next if item.valid?(validation_context)
+
+        error_path = format_error_path(attr_name, index)
+        import_nested_errors(item.errors, error_path)
+      end
+    end
+
+    # Validate nested objects
+    #: (String, StructuredParams::Params) -> void
+    def validate_nested_object(attr_name, object_value)
+      return if object_value.valid?(validation_context)
+
+      error_path = format_error_path(attr_name)
+      import_nested_errors(object_value.errors, error_path)
+    end
+
+    # Format error path using dot notation (always consistent)
+    #: (String, 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 nested errors into parent errors
+    #: (untyped, String) -> void
+    def import_nested_errors(nested_errors, prefix)
+      nested_errors.each do |error|
+        errors.import(error, attribute: "#{prefix}.#{error.attribute}")
+      end
+    end
+
+    # Serialize nested values
+    #: (untyped) -> untyped
+    def serialize_nested_value(value)
+      case value
+      when Array
+        value.map(&:attributes)
+      when StructuredParams::Params
+        value.attributes
+      else
+        value
+      end
+    end
+  end
+end

data/lib/structured_params/type/array.rb

@@ -0,0 +1,102 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module StructuredParams
+  module Type
+    # Custom type for arrays of both StructuredParams::Params objects and primitive types
+    #
+    # Usage examples:
+    #   # Array of nested objects
+    #   attribute :hobbies, :array, value_class: HobbyParameter
+    #
+    #   # Array of primitive types
+    #   attribute :tags, :array, value_type: :string
+    class Array < ActiveModel::Type::Value
+      attr_reader :item_type #: ActiveModel::Type::Value
+
+      # value_class or value_type is required
+      #: (?value_class: singleton(StructuredParams::Params)?, ?value_type: Symbol?, **untyped) -> void
+      def initialize(value_class: nil, value_type: nil, **options)
+        super()
+        validate_parameters!(value_class, value_type)
+        @item_type = build_item_type(value_class, value_type, options)
+      end
+
+      #: () -> Symbol
+      def type
+        :array
+      end
+
+      # Cast value to array and convert each element to appropriate type
+      #: (untyped) -> ::Array[untyped]?
+      def cast(value)
+        return nil if value.nil?
+
+        ensure_array(value).map { |item| cast_item(item) }
+      end
+
+      # Serialize array (convert each element to Hash)
+      #: (::Array[untyped]?) -> ::Array[untyped]?
+      def serialize(value)
+        return nil if value.nil?
+        return [] unless value.is_a?(::Array)
+
+        value.map { |item| @item_type.serialize(item) }
+      end
+
+      # Get permitted parameter names for use with Strong Parameters
+      #: () -> ::Array[untyped]
+      def permit_attribute_names
+        return [] unless item_type_is_structured_params_object?
+
+        @item_type.permit_attribute_names
+      end
+
+      # Determine if item type is StructuredParams::Object
+      #: () -> bool
+      def item_type_is_structured_params_object?
+        @item_type.is_a?(StructuredParams::Type::Object)
+      end
+
+      private
+
+      # Cast single item (delegate to new method)
+      #: (untyped) -> untyped
+      def cast_item(item)
+        if item_type_is_structured_params_object?
+          @item_type.value_class.new(item)
+        else
+          @item_type.cast(item)
+        end
+      end
+
+      # Parameter validation
+      #: (singleton(StructuredParams::Params)?, Symbol?) -> void
+      def validate_parameters!(value_class, value_type)
+        if value_class && value_type
+          raise ArgumentError, 'Specify either value_class or value_type, not both'
+        elsif !value_class && !value_type
+          raise ArgumentError, 'Either value_class or value_type must be specified'
+        elsif value_class && !(value_class <= StructuredParams::Params)
+          raise ArgumentError, "value_class must inherit from StructuredParams::Params, got #{value_class}"
+        end
+      end
+
+      # Build item type
+      #: (singleton(StructuredParams::Params)?, Symbol?, Hash[untyped, untyped]) -> ActiveModel::Type::Value
+      def build_item_type(value_class, value_type, options)
+        if value_class
+          StructuredParams::Type::Object.new(value_class: value_class)
+        else
+          ActiveModel::Type.lookup(value_type, **options)
+        end
+      end
+
+      # Convert value to array
+      #: (untyped) -> ::Array[untyped]
+      def ensure_array(value)
+        value.is_a?(::Array) ? value : [value]
+      end
+    end
+  end
+end

data/lib/structured_params/type/object.rb

@@ -0,0 +1,58 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module StructuredParams
+  module Type
+    # Custom type for single StructuredParams::Params objects
+    class Object < ActiveModel::Type::Value
+      attr_reader :value_class #: singleton(StructuredParams::Params)
+
+      # Get permitted parameter names for use with Strong Parameters
+      # @rbs!
+      #  def permit_attribute_names: () -> ::Array[untyped]
+      delegate :permit_attribute_names, to: :value_class
+
+      #: (value_class: singleton(StructuredParams::Params), **untyped) -> void
+      def initialize(value_class:, **_options)
+        super()
+        validate_value_class!(value_class)
+        @value_class = value_class
+      end
+
+      #: () -> Symbol
+      def type
+        :object
+      end
+
+      # Cast value to StructuredParams::Params instance
+      #: (untyped) -> StructuredParams::Params?
+      def cast(value)
+        return nil if value.nil?
+        return value if value.is_a?(@value_class)
+
+        @value_class.new(value) # call new directly instead of cast_value method
+      end
+
+      # Serialize (convert to Hash) the object
+      #: (untyped) -> untyped
+      def serialize(value)
+        return nil if value.nil?
+
+        value.is_a?(@value_class) ? value.attributes : value
+      end
+
+      private
+
+      # Validate the class
+      #: (untyped) -> void
+      def validate_value_class!(value_class)
+        raise ArgumentError, 'value_class must inherit from StructuredParams::Params, got NilClass' if value_class.nil?
+        raise ArgumentError, "value_class must be a Class, got #{value_class.class}" unless value_class.is_a?(Class)
+
+        return if value_class < StructuredParams::Params
+
+        raise ArgumentError, "value_class must inherit from StructuredParams::Params, got #{value_class}"
+      end
+    end
+  end
+end

data/lib/structured_params/version.rb

@@ -0,0 +1,6 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module StructuredParams
+  VERSION = '0.1.0' #: string
+end

data/lib/structured_params.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'active_model'
+require 'active_model/type'
+require 'action_controller/metal/strong_parameters'
+
+# version
+require_relative 'structured_params/version'
+
+# types (load first for module definition)
+require_relative 'structured_params/type/object'
+require_relative 'structured_params/type/array'
+
+# params (load after type definitions)
+require_relative 'structured_params/params'
+
+# Main module
+module StructuredParams
+  # Helper method to register types
+  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)
+    ActiveModel::Type.register(object_name, StructuredParams::Type::Object)
+    ActiveModel::Type.register(array_name, StructuredParams::Type::Array)
+  end
+end

data/sig/structured_params/params.rbs

@@ -0,0 +1,67 @@
+# Generated from lib/structured_params/params.rb with RBS::Inline
+
+module StructuredParams
+  # Parameter model that supports nested structures
+  #
+  # Usage example:
+  #   class UserParameter < StructuredParams::Params
+  #     attribute :name, :string
+  #     attribute :address, :nested, value_class: AddressParameter
+  #     attribute :hobbies, :array, value_class: HobbyParameter
+  #     attribute :tags, :array, value_type: :string
+  #   end
+  class Params
+    include ActiveModel::Model
+
+    include ActiveModel::Attributes
+
+    # 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
+
+    # Determine if the specified type is a nested parameter type
+    # : (untyped) -> bool
+    private def self.structured_params_type?: (untyped) -> bool
+
+    # : (untyped) -> void
+    def initialize: (untyped) -> void
+
+    # Convert nested objects to Hash and get attributes
+    # : (symbolize: bool) -> Hash[untyped, untyped]
+    def attributes: (symbolize: bool) -> Hash[untyped, untyped]
+
+    private
+
+    # Process input parameters
+    # : (untyped) -> Hash[untyped, untyped]
+    def process_input_parameters: (untyped) -> Hash[untyped, untyped]
+
+    # Execute nested parameter validation
+    # : () -> void
+    def validate_nested_parameters: () -> void
+
+    # Validate nested arrays
+    # : (String, Array[untyped]) -> void
+    def validate_nested_array: (String, Array[untyped]) -> void
+
+    # Validate nested objects
+    # : (String, StructuredParams::Params) -> void
+    def validate_nested_object: (String, StructuredParams::Params) -> void
+
+    # Format error path using dot notation (always consistent)
+    # : (String, Integer?) -> String
+    def format_error_path: (String, Integer?) -> String
+
+    # Integrate nested errors into parent errors
+    # : (untyped, String) -> void
+    def import_nested_errors: (untyped, String) -> void
+
+    # Serialize nested values
+    # : (untyped) -> untyped
+    def serialize_nested_value: (untyped) -> untyped
+  end
+end

data/sig/structured_params/type/array.rbs

@@ -0,0 +1,58 @@
+# Generated from lib/structured_params/type/array.rb with RBS::Inline
+
+module StructuredParams
+  module Type
+    # Custom type for arrays of both StructuredParams::Params objects and primitive types
+    #
+    # Usage examples:
+    #   # Array of nested objects
+    #   attribute :hobbies, :array, value_class: HobbyParameter
+    #
+    #   # Array of primitive types
+    #   attribute :tags, :array, value_type: :string
+    class Array < ActiveModel::Type::Value
+      attr_reader item_type: ActiveModel::Type::Value
+
+      # value_class or value_type is required
+      # : (?value_class: singleton(StructuredParams::Params)?, ?value_type: Symbol?, **untyped) -> void
+      def initialize: (?value_class: singleton(StructuredParams::Params)?, ?value_type: Symbol?, **untyped) -> void
+
+      # : () -> Symbol
+      def type: () -> Symbol
+
+      # Cast value to array and convert each element to appropriate type
+      # : (untyped) -> ::Array[untyped]?
+      def cast: (untyped) -> ::Array[untyped]?
+
+      # Serialize array (convert each element to Hash)
+      # : (::Array[untyped]?) -> ::Array[untyped]?
+      def serialize: (::Array[untyped]?) -> ::Array[untyped]?
+
+      # Get permitted parameter names for use with Strong Parameters
+      # : () -> ::Array[untyped]
+      def permit_attribute_names: () -> ::Array[untyped]
+
+      # Determine if item type is StructuredParams::Object
+      # : () -> bool
+      def item_type_is_structured_params_object?: () -> bool
+
+      private
+
+      # Cast single item (delegate to new method)
+      # : (untyped) -> untyped
+      def cast_item: (untyped) -> untyped
+
+      # Parameter validation
+      # : (singleton(StructuredParams::Params)?, Symbol?) -> void
+      def validate_parameters!: (singleton(StructuredParams::Params)?, Symbol?) -> void
+
+      # Build item type
+      # : (singleton(StructuredParams::Params)?, Symbol?, Hash[untyped, untyped]) -> ActiveModel::Type::Value
+      def build_item_type: (singleton(StructuredParams::Params)?, Symbol?, Hash[untyped, untyped]) -> ActiveModel::Type::Value
+
+      # Convert value to array
+      # : (untyped) -> ::Array[untyped]
+      def ensure_array: (untyped) -> ::Array[untyped]
+    end
+  end
+end

data/sig/structured_params/type/object.rbs

@@ -0,0 +1,32 @@
+# Generated from lib/structured_params/type/object.rb with RBS::Inline
+
+module StructuredParams
+  module Type
+    # Custom type for single StructuredParams::Params objects
+    class Object < ActiveModel::Type::Value
+      attr_reader value_class: singleton(StructuredParams::Params)
+
+      def permit_attribute_names: () -> ::Array[untyped]
+
+      # : (value_class: singleton(StructuredParams::Params), **untyped) -> void
+      def initialize: (value_class: singleton(StructuredParams::Params), **untyped) -> void
+
+      # : () -> Symbol
+      def type: () -> Symbol
+
+      # Cast value to StructuredParams::Params instance
+      # : (untyped) -> StructuredParams::Params?
+      def cast: (untyped) -> StructuredParams::Params?
+
+      # Serialize (convert to Hash) the object
+      # : (untyped) -> untyped
+      def serialize: (untyped) -> untyped
+
+      private
+
+      # Validate the class
+      # : (untyped) -> void
+      def validate_value_class!: (untyped) -> void
+    end
+  end
+end

data/sig/structured_params/version.rbs

@@ -0,0 +1,5 @@
+# Generated from lib/structured_params/version.rb with RBS::Inline
+
+module StructuredParams
+  VERSION: string
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: structured_params
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mizuki Yamamoto
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 8.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 8.0.0
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 8.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 8.0.0
+description: ''
+email:
+- mizuki-y@syati.info
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- lib/structured_params.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/params.rbs
+- sig/structured_params/type/array.rbs
+- sig/structured_params/type/object.rbs
+- sig/structured_params/version.rbs
+homepage: https://github.com/Syati/structured_params
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/Syati/structured_params#readme
+  changelog_uri: https://github.com/Syati/structured_params/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/Syati/structured_params/issues
+  source_code_uri: https://github.com/Syati/structured_params
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: StructuredParams allows you to validate pass parameter.
+test_files: []