easy_params 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a23a79fb06b0d9c02b836dc314e420f1339b20473d740f4427a6f1a9e740efe
-  data.tar.gz: e1ddbee8e7b5aa08fb3e9f1f2dc925ecc179a8f95ac3276e2aeb839f7e3cbe9d
+  metadata.gz: 4e5797272eae09e65c24f46558c801f19126e71e4ca940bdfaeecfaab478fe7d
+  data.tar.gz: 95d1a80d4f0635013658713c6dccc45058e707cae9e90ec88036313c673819ee
 SHA512:
-  metadata.gz: 9a9968cc2201493bd774562cc9590d47537b870238ac5b64b33167c9b084feb14c067b6b4ee9a36f54abdff18a198c8d99474b8dc531fab45ebbffd61ae08c11
-  data.tar.gz: 11d7e883cc4a229c14b9323e94f8372e2f38d2c238e883884c2fe733bab4918be6ad62c13da09621fbb0e8b5b85405d7d2d9cb8197abc3cbf0d762b6657c2a7d
+  metadata.gz: 1e76c8c64f7568d0ef3633eb3ca86a1cf1f03f331d528aa7a941c8197a2030dbbeb3fc77149b7dd0416b4776b3a8b547a6e0c451a6e1c3af92835b25e2d6815c
+  data.tar.gz: 82f361cf4ebce4db3ab3bbc9fd7ca196a3dc57a91c3156df1b2e18d443922a900998f58c43b5a12571346de047c1f9e803ad45e109dcb32c028840c44ebf0681

data/Gemfile.lock

@@ -1,17 +1,15 @@
 PATH
   remote: .
   specs:
-    easy_params (0.4.0)
-      activemodel (>= 3.2, < 8)
-      dry-struct (~> 1.4)
-      dry-types (~> 1.5)
+    easy_params (0.5.0)
+      activemodel (>= 3.2)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (7.1.2)
-      activesupport (= 7.1.2)
-    activesupport (7.1.2)
+    activemodel (7.1.3)
+      activesupport (= 7.1.3)
+    activesupport (7.1.3)
       base64
       bigdecimal
       concurrent-ruby (~> 1.0, >= 1.0.2)
@@ -23,40 +21,19 @@ GEM
       tzinfo (~> 2.0)
     ast (2.4.2)
     base64 (0.2.0)
-    bigdecimal (3.1.5)
+    bigdecimal (3.1.6)
     coderay (1.1.3)
-    concurrent-ruby (1.2.2)
+    concurrent-ruby (1.2.3)
     connection_pool (2.4.1)
     diff-lcs (1.4.4)
     docile (1.3.5)
     drb (2.2.0)
       ruby2_keywords
-    dry-core (1.0.1)
-      concurrent-ruby (~> 1.0)
-      zeitwerk (~> 2.6)
-    dry-inflector (1.0.0)
-    dry-logic (1.5.0)
-      concurrent-ruby (~> 1.0)
-      dry-core (~> 1.0, < 2)
-      zeitwerk (~> 2.6)
-    dry-struct (1.6.0)
-      dry-core (~> 1.0, < 2)
-      dry-types (>= 1.7, < 2)
-      ice_nine (~> 0.11)
-      zeitwerk (~> 2.6)
-    dry-types (1.7.2)
-      bigdecimal (~> 3.0)
-      concurrent-ruby (~> 1.0)
-      dry-core (~> 1.0)
-      dry-inflector (~> 1.0)
-      dry-logic (~> 1.4)
-      zeitwerk (~> 2.6)
     i18n (1.14.1)
       concurrent-ruby (~> 1.0)
-    ice_nine (0.11.2)
     json (2.6.3)
     method_source (1.0.0)
-    minitest (5.20.0)
+    minitest (5.21.2)
     mutex_m (0.2.0)
     parallel (1.23.0)
     parser (3.2.2.3)
@@ -108,7 +85,6 @@ GEM
     tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
     unicode-display_width (2.4.2)
-    zeitwerk (2.6.12)
 
 PLATFORMS
   ruby

data/README.md

@@ -4,11 +4,11 @@
 [![Maintainability](https://api.codeclimate.com/v1/badges/17872804ce576b8b0df2/maintainability)](https://codeclimate.com/github/andriy-baran/easy_params/maintainability)
 [![Test Coverage](https://api.codeclimate.com/v1/badges/17872804ce576b8b0df2/test_coverage)](https://codeclimate.com/github/andriy-baran/easy_params/test_coverage)
 
-Provides an easy way define structure, validation rules, type coercion and set default values for any hash-like structure. It's built on top of `dry-types`, `dry-structure` and `active_model/validations`.
+Provides an easy way define structure, validation rules, type coercion and set default values for any hash-like structure. It's built on top of `active_model`.
 
 ## Types
 
-Dry types are wrapped by class methods. Avaliable types: `integer`, `decimal`, `float`, `bool`, `string`, `array`, `date`, `datetime`, `time`, `struct`
+Dry types are wrapped by class methods. Avaliable types: `integer`, `decimal`, `float`, `bool`, `string`, `array`, `date`, `datetime`, `time`
 
 ## Installation
 
@@ -28,24 +28,39 @@ Or install it yourself as:
 
 ## Usage
 
+To define attribute we have a set of methods which match types list. Ex.
+```ruby
+integer(param_name, default: nil, normalize: nil, **validations)
+```
+* `:default` provides a value to return if got `nil` as input or there were errors during coersion.
+* `normalize` a proc or lambda that accepts single argument and changes it in some way. It's get called before coercion.
+* `validations` mimics `activemodel/validation` can be any supported validation `presence: true, numericality: { only_integer: true, greater_than: 0 }`
+
+In addition we have special option for an `array` type
+* `:of` accepts `:integer`, `:decimal`, `:float`, `:bool`, `:string`, `:date`, `:datetime`, `:time` (`:array` is not supported)
+
+There are two special types:
+
+| type              | method to define | default |
+|-------------------|------------------|---------|
+| :struct           | has              | {}      |
+| :array_of_structs | each             | []      |
+
 ```ruby
 # app/params/api/v2/icqa/move_params.rb
 class Api::V1::Carts::MoveParams < EasyParams::Base
-  attribute :receive_cart_id, integer
-  attribute :i_am_sure, bool
-  attribute :location_code, string.default('')
-  attribute :sections, struct do
-    attribute :from, string
-    attribute :to, string
+  integer :receive_cart_id, presence: { message: "can't be blank" }
+  bool :i_am_sure
+  string :location_code, default: '', presence: { message: "can't be blank" }
+  has :section do
+    string :from
+    string :to
   end
-  attribute :options, array.of(struct) do
-    attribute :option_type_count, integer
-    attribute :option_type_value, integer
-
-    validates :option_type_count, :option_type_value, presence: { message: "can't be blank" }
+  array :variant_ids, of: :integer
+  each :options do
+    integer :option_type_count, presence: { message: "can't be blank" }
+    integer :option_type_value, presence: { message: "can't be blank" }
   end
-
-  validates :receive_cart_id, :location_code, presence: { message: "can't be blank" }
 end
 ```
 Validation messages for nested attributes will look like this.
@@ -57,21 +72,6 @@ Validation messages for nested attributes will look like this.
   :"post.sections[0].id"=>an_instance_of(Array)
  }
 ```
-Optionally you can use more compact form
-```ruby
-class MyParams < EasyParams::Base
-  extend EasyParams::DSL
-
-  quantity integer.default(1)
-  posts each do
-    content string.default('')
-  end
-  user has do
-    role string
-  end
-end
-```
-This hovewer has some limitations: for attributes have name like `integer`, `decimal`, `float`, `bool`, `string`, `array`, `date`, `datetime`, `time`, `struct` it won't work as expected.
 
 More examples here [params_spec.rb](https://github.com/andriy-baran/easy_params/blob/master/spec/easy_params_spec.rb)
 

data/easy_params.gemspec

@@ -29,11 +29,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  version_string = ['>= 3.2', '< 8']
+  version_string = ['>= 3.2']
 
   spec.add_runtime_dependency 'activemodel', version_string
-
-  # spec.add_dependency 'dry-logic', '~> 0.4.2'
-  spec.add_dependency 'dry-struct', '~> 1.4'
-  spec.add_dependency 'dry-types', '~> 1.5'
 end

data/lib/easy_params/base.rb

@@ -2,102 +2,90 @@
 
 module EasyParams
   # Implements validations logic and nesting structures
-  class Base < Dry::Struct
-    include ActiveModel::Validations
+  class Base
+    include ActiveModel::Model
+    include EasyParams::Types::Struct
+    include EasyParams::Validation
 
-    transform_keys(&:to_sym)
-
-    def self.name
-      'EasyParams::Base'
+    def initialize(params = {})
+      self.class.schema.each do |attr, type|
+        public_send("#{attr}=", type.coerce(params[attr])) if params
+      end
     end
 
-    validate do
-      validate_nested
-    end
+    class << self
+      def name
+        'EasyParams::Base'
+      end
 
-    # %w[Integer Decimal Float Bool String Date DateTime Time Array Struct StructDSL].each do |type|
-    %w[Integer Decimal Float Bool String Date DateTime Time].each do |type_name|
-      send(:define_singleton_method, type_name.underscore) do |param_name, default: nil, normalize: nil, **validations|
-        type = EasyParams::Types.const_get(type_name)
-        type = type.default(default) if default
-        type = type.constructor { |value| value == Dry::Types::Undefined ? value : normalize.call(value) } if normalize
-        validates param_name, **validations if validations.any?
-        public_send(:attribute, param_name, type)
+      def attribute(param_name, type)
+        attr_accessor param_name
+
+        schema[param_name] = type
       end
-    end
 
-    def self.each(param_name, normalize: nil, **validations, &block)
-      validates param_name, **validations if validations.any?
-      type = EasyParams::Types::Each
-      type = type.constructor { |value| value == Dry::Types::Undefined ? value : normalize.call(value) } if normalize
-      public_send(:attribute, param_name, type, &block)
-    end
+      def schema
+        @schema ||= {}
+      end
 
-    def self.has(param_name, normalize: nil, **validations, &block)
-      validates param_name, **validations if validations.any?
-      type = EasyParams::Types::Struct
-      type = type.constructor { |value| value == Dry::Types::Undefined ? value : normalize.call(value) } if normalize
-      public_send(:attribute, param_name, type, &block)
-    end
+      def each(param_name, normalize: nil, **validations, &block)
+        validates param_name, **validations if validations.any?
+        type = EasyParams::Types::Each.with_type(&block)
+        type = customize_type(type, nil, &normalize)
+        public_send(:attribute, param_name, type)
+      end
 
-    def self.array(param_name, of:, normalize: nil, **validations, &block)
-      validates param_name, **validations if validations.any?
-      of_type = EasyParams::Types.const_get(of.to_s.camelcase)
-      type = EasyParams::Types::Array
-      type = type.constructor { |value| value == Dry::Types::Undefined ? value : normalize.call(value) } if normalize
-      public_send(:attribute, param_name, type.of(of_type), &block)
-    end
+      def has(param_name, normalize: nil, **validations, &block)
+        validates param_name, **validations if validations.any?
+        type = Class.new(EasyParams::Types::Struct.class).tap { |c| c.class_eval(&block) }.new
+        type = customize_type(type, nil, &normalize)
+        public_send(:attribute, param_name, type)
+      end
 
-    def self.param(method_name, type_name, of: nil, default: nil, **validations, &block)
-      type = EasyParams::Types.const_get(type_name.to_s.camelcase)
-      type = type.default(default) if default
-      type = type.of(EasyParams::Types.const_get(of.to_s.camelcase)) if of && type_name != :each
-      validates method_name, **validations if validations.any?
-      public_send(:attribute, method_name, type, &block)
-    end
+      def array(param_name, of:, normalize: nil, **validations)
+        validates param_name, **validations if validations.any?
+        type = EasyParams::Types::Array.of(EasyParams::Types.const_get(of.to_s.camelcase))
+        type = customize_type(type, nil, &normalize)
+        public_send(:attribute, param_name, type)
+      end
 
-    private
+      private
 
-    def validate_nested
-      attributes.each do |_, value|
-        case value
-        when *EasyParams::Types::ARRAY_OF_STRUCTS_TYPES_LIST
-          value.each(&:valid?)
-        when *EasyParams::Types::STRUCT_TYPES_LIST
-          value.valid?
-        end
+      def customize_type(type, default, &normalize)
+        type = type.default(default) if default
+        type = type.normalize(&normalize) if normalize
+        type
       end
-      attributes.each(&aggregate_nested_errors)
     end
 
-    def aggregate_nested_errors
-      proc do |attr_name, value, array_index, error_key_prefix|
-        case value
-        when *EasyParams::Types::ARRAY_OF_STRUCTS_TYPES_LIST
-          value.each.with_index do |element, i|
-            aggregate_nested_errors[attr_name, element, "[#{i}]", error_key_prefix]
-          end
-        when *EasyParams::Types::STRUCT_TYPES_LIST
-          handle_nested_errors(value, error_key_prefix, attr_name, array_index)
-        end
+    %w[Integer Decimal Float Bool String Date DateTime Time].each do |type_name|
+      send(:define_singleton_method,
+           type_name.underscore) do |param_name, default: nil, normalize: nil, **validations|
+        validates param_name, **validations if validations.any?
+        type = EasyParams::Types.const_get(type_name)
+        type = customize_type(type, default, &normalize)
+        public_send(:attribute, param_name, type)
       end
     end
 
-    def handle_nested_errors(value, error_key_prefix, attr_name, array_index)
-      return if value.errors.blank?
+    def attributes
+      self.class.schema.to_h { |k, type| [k, type.array? ? send(k).to_a : send(k)] }
+    end
 
-      error_key_components = [error_key_prefix, attr_name, array_index]
-      attr_error_key_prefix = error_key_components.compact.join('.').gsub(/\.\[(\d+)\]/, '[\1]')
-      add_errors_on_top_level(value, attr_error_key_prefix)
+    validate do
+      validate_nested
     end
 
-    if defined? ActiveModel::Error
-      def add_errors_on_top_level(value, attr_error_key_prefix)
-        value.errors.each { |error| errors.add("#{attr_error_key_prefix}.#{error.attribute}", error.message) }
-      end
-    else
-      def add_errors_on_top_level(value, attr_error_key_prefix)
-        value.errors.each { |key, message| errors.add("#{attr_error_key_prefix}.#{key}", message) }
+    def to_h
+      attributes.each.with_object({}) do |(key, value), result|
+        result[key] = case value
+                      when EasyParams::Types::StructsCollection
+                        value.map(&:to_h)
+                      when EasyParams::Types::Struct.class
+                        value.to_h
+                      else
+                        value
+                      end
       end
     end
   end

data/lib/easy_params/types/collection.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module EasyParams
+  module Types
+    # base interface for array type
+    class Collection < Generic
+      include Enumerable
+
+      def initialize(*attrs, of: nil)
+        super(*attrs)
+        @of_type = of
+      end
+
+      def of(of_type)
+        self.class.new(@title, @default, @normalize_proc, of: of_type, &@coerce_proc)
+      end
+
+      def coerce(value)
+        value = @normalize_proc.call(Array(value)) if @normalize_proc
+        self.class.new(@title, Array(value).map do |v|
+                                 @of_type.coerce(v)
+                               end, @normalize_proc, of: @of_type, &@coerce_proc)
+      end
+
+      def normalize(&block)
+        self.class.new(@title, @default, block, of: @of_type, &@coerce_proc)
+      end
+
+      def self.optional
+        self.class.new(@title, @default, @normalize_proc, of: @of_type, &@coerce_proc)
+      end
+
+      def default(value)
+        self.class.new(@title, value, @normalize_proc, of: @of_type, &@coerce_proc)
+      end
+
+      def each(&block)
+        @default.each(&block)
+      end
+    end
+
+    # base interface for array of structs type
+    class StructsCollection < Collection
+      def with_type(&block)
+        of_type = Class.new(EasyParams::Types::Struct.class).tap { |c| c.class_eval(&block) }.new
+        self.class.new(@title, @default, @normalize_proc, of: of_type)
+      end
+    end
+  end
+end

data/lib/easy_params/types/generic.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module EasyParams
+  module Types
+    # base interface for simple types
+    class Generic
+      def array?
+        @title == :array
+      end
+
+      def initialize(title, default = nil, normalize_proc = nil, &coerce_proc)
+        @title = title
+        @default = default
+        @coerce_proc = coerce_proc
+        @normalize_proc = normalize_proc
+      end
+
+      def default(value)
+        self.class.new(@title, value, @normalize_proc, &@coerce_proc)
+      end
+
+      def optional
+        self.class.new(@title, @default, @normalize_proc, &@coerce_proc)
+      end
+
+      def optional?
+        @optional
+      end
+
+      def normalize(&block)
+        self.class.new(@title, @default, block, &@coerce_proc)
+      end
+
+      def coerce(value)
+        value = @normalize_proc.call(value) if @normalize_proc
+        return @default if value.nil?
+
+        @coerce_proc.call(value)
+      rescue StandardError
+        @default
+      end
+    end
+  end
+end

data/lib/easy_params/types/struct.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module EasyParams
+  module Types
+    # base interface for struct type
+    module Struct
+      def array?
+        false
+      end
+
+      def coerce(input)
+        return if input.blank?
+
+        self.class.new(input)
+      end
+    end
+  end
+end

data/lib/easy_params/types.rb

@@ -2,20 +2,37 @@
 
 module EasyParams
   module Types
-    Struct    = EasyParams::Base.meta(omittable: true)
-    Has       = EasyParams::Base.meta(omittable: true)
-    Integer   = Dry::Types['params.integer'].optional.meta(omittable: true).default(nil)
-    Decimal   = Dry::Types['params.decimal'].optional.meta(omittable: true).default(nil)
-    Float     = Dry::Types['params.float'].optional.meta(omittable: true).default(nil)
-    Bool      = Dry::Types['params.bool'].optional.meta(omittable: true).default(nil)
-    String    = Dry::Types['string'].optional.meta(omittable: true).default(nil)
-    Array     = Dry::Types['array'].meta(omittable: true).default([])
-    Each      = Dry::Types['array'].of(Struct).meta(omittable: true).default([])
-    Date      = Dry::Types['params.date'].optional.meta(omittable: true).default(nil)
-    DateTime  = Dry::Types['params.date_time'].optional.meta(omittable: true).default(nil)
-    Time      = Dry::Types['params.time'].optional.meta(omittable: true).default(nil)
+    class CoercionError < StandardError; end
 
-    STRUCT_TYPES_LIST = [Struct, Has].freeze
-    ARRAY_OF_STRUCTS_TYPES_LIST = [Array.of(Struct), Each].freeze
+    BOOLEAN_MAP =
+      { '1' => true, 't' => true, 'true' => true, 'True' => true, 'TRUE' => true, 'T' => true }.merge(
+        { '0' => false, 'f' => false, 'false' => false, 'False' => false, 'FALSE' => false, 'F' => false }
+      ).freeze
+
+    Struct    = Class.new(EasyParams::Base).new
+    Array     = Collection.new(:array)
+    Each      = StructsCollection.new(:array_of_structs)
+    Integer   = Generic.new(:integer, &:to_i)
+    Float     = Generic.new(:float, &:to_f)
+    String    = Generic.new(:string, &:to_s)
+    Decimal   = Generic.new(:decimal) { |v| v.to_f.to_d }
+    Bool      = Generic.new(:bool) do |v|
+      BOOLEAN_MAP.fetch(v.to_s) { raise CoercionError }
+    end
+    Date = Generic.new(:date) do |v|
+      ::Date.parse(v)
+    rescue ArgumentError, RangeError
+      raise CoercionError, 'cannot be coerced'
+    end
+    DateTime = Generic.new(:datetime) do |v|
+      ::DateTime.parse(v)
+    rescue ArgumentError
+      raise CoercionError, 'cannot be coerced'
+    end
+    Time = Generic.new(:time) do |v|
+      ::Time.parse(v)
+    rescue ArgumentError
+      raise CoercionError, 'cannot be coerced'
+    end
   end
 end

data/lib/easy_params/validation.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module EasyParams
+  # helpers for recursive validation
+  module Validation
+    private
+
+    def validate_nested
+      attributes.each_value do |value|
+        case value
+        when EasyParams::Types::StructsCollection
+          value.each(&:valid?)
+        when EasyParams::Types::Struct.class
+          value.valid?
+        end
+      end
+      attributes.each(&aggregate_nested_errors)
+    end
+
+    def aggregate_nested_errors
+      proc do |attr_name, value, array_index, error_key_prefix|
+        case value
+        when EasyParams::Types::StructsCollection
+          value.each.with_index do |element, i|
+            aggregate_nested_errors[attr_name, element, "[#{i}]", error_key_prefix]
+          end
+        when EasyParams::Types::Struct.class
+          handle_nested_errors(value, error_key_prefix, attr_name, array_index)
+        end
+      end
+    end
+
+    def handle_nested_errors(value, error_key_prefix, attr_name, array_index)
+      return if value.errors.blank?
+
+      error_key_components = [error_key_prefix, attr_name, array_index]
+      attr_error_key_prefix = error_key_components.compact.join('.').gsub(/\.\[(\d+)\]/, '[\1]')
+      add_errors_on_top_level(value, attr_error_key_prefix)
+    end
+
+    if defined? ActiveModel::Error
+      def add_errors_on_top_level(value, attr_error_key_prefix)
+        value.errors.each { |error| errors.add("#{attr_error_key_prefix}.#{error.attribute}", error.message) }
+      end
+    else
+      def add_errors_on_top_level(value, attr_error_key_prefix)
+        value.errors.each { |key, message| errors.add("#{attr_error_key_prefix}.#{key}", message) }
+      end
+    end
+  end
+end

data/lib/easy_params/version.rb

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

data/lib/easy_params.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
-require 'dry-struct'
-require 'dry-types'
 require 'active_model'
+require 'bigdecimal/util'
+require 'easy_params/types/generic'
+require 'easy_params/types/collection'
+require 'easy_params/types/struct'
+require 'easy_params/validation'
 require 'easy_params/base'
 require 'easy_params/types'
 require 'easy_params/version'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: easy_params
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Andrii Baran
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-01-08 00:00:00.000000000 Z
+date: 2024-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -17,9 +17,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.2'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -27,37 +24,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.2'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '8'
-- !ruby/object:Gem::Dependency
-  name: dry-struct
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.4'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.4'
-- !ruby/object:Gem::Dependency
-  name: dry-types
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.5'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.5'
 description: Dessribe structure, validate and coerce values. Powered by dry-types
   and dry-struct
 email:
@@ -83,6 +49,10 @@ files:
 - lib/easy_params.rb
 - lib/easy_params/base.rb
 - lib/easy_params/types.rb
+- lib/easy_params/types/collection.rb
+- lib/easy_params/types/generic.rb
+- lib/easy_params/types/struct.rb
+- lib/easy_params/validation.rb
 - lib/easy_params/version.rb
 homepage: https://github.com/andriy-baran/easy_params
 licenses: