stannum 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e4e097d69d42e93658309a2d4415742bdbeb66d48981f89a0a8b486c6935582
-  data.tar.gz: 2fdf05503a9fd0e480c30fe45283c1e21dae6701cf79599a0a39ace8717d587f
+  metadata.gz: b13aa2cda5a99f544b2e7c281147f51b4e4fa02e394e4b6d017dcc2b1f03705d
+  data.tar.gz: e84dc0c10ccfd8989dcec729c485136c099257079df57cb44e82befb42ebf9b8
 SHA512:
-  metadata.gz: a650ec61bfc9997fef0ba824670b570c07e57089bde90c81a63fda2a5caaa3a6edfcf2075f2b4060bc25299858715bb8e97eca0548d4d729b9300a864c5cb141
-  data.tar.gz: 50ed1712df35e1ac05d88c0661be728e10d77df2fecfd6b521e5b3a35c1045e54f4a88c0c9a715d14f24ea4ab5e6f9c25c17c5bf526abf3271a0a19bb1df5617
+  metadata.gz: bd159ef522b377cb71e4ebc58d8e46987906a1b3a36a5e905965a5cef9dfcf09b3d3b6818519659a05a19b894b516af8d37ee17a60beb4c72fe4a5df04b2b97d
+  data.tar.gz: 806b0a8e067afee2185ba5164d85127543f4e3e821a2ca5582afa13135e6f1b4469f9c5cfb6461bfe3f376e17ec9d2c4580780f3b89d574764856593a660b763

data/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## 0.3.0
+
+### Constraints
+
+- Implemented `Stannum::Constraints::Properties::MatchProperty`
+- Implemented `Stannum::Constraints::Properties::DoNotMatchProperty`
+
+### Contracts
+
+- Added `#concat` to `Stannum::Contracts::Builder`.
+
+### Entities
+
+Implemented `Stannum::Entity`, a replacement for the existing `Stannum::Struct`.
+
+Entitise are largely identical to structs, except for the constructor signature - entities require properties to be passed as keyword parameters, rather than as an attributes hash. Entities (and now Structs) are defined using composable modules.
+
+- Implemented `Stannum::Entities::Attributes`.
+- Implemented `Stannum::Entities::Constraints`.
+- Implemented `Stannum::Entities::Properties`.
+
+`Stannum::Struct` is now deprecated, and will be removed in a future release.
+
+## 0.2.0
+
+### Constraints
+
+#### Parameter Constraints
+
+- Implemented `Stannum::Constraints::Parameters::ExtraArguments`
+- Implemented `Stannum::Constraints::Parameters::ExtraKeywords`
+
 ## 0.1.0
 
 Initial version.

data/README.md

@@ -7,7 +7,7 @@ Stannum defines the following objects:
 - [Constraints](#constraints): A validator object that responds to `#match`, `#matches?` and `#errors_for` for a given object.
 - [Contracts](#contracts): A collection of constraints about an object or its properties. Obeys the `Constraint` interface.
 - [Errors](#errors): Data object for storing validation errors. Supports arbitrary nesting of errors.
-- [Structs](#structs): Defines a mutable data object with a specified set of typed attributes.
+- [Entities](#entities): Defines a mutable data object with a specified set of typed attributes.
 
 ## About
 
@@ -17,11 +17,11 @@ First and foremost, Stannum provides you with the tools to validate your data. U
 
 Finally, you can combine your constraints into a `Stannum::Contract` to combine multiple validations of your object and its properties. Stannum provides pre-defined contracts for asserting on objects, `Array`s, `Hash`es, and even method parameters.
 
-Stannum also defines the `Stannum::Struct` module for defining structured data entities that are not tied to any framework or datastore. Stannum structs have more functionality and a friendlier interface than a core library `Struct`, provide more structure than a `Hash` or hash-like object (such as an `OpenStruct` or `Hashie::Mash`), and are completely independent from the source of the data. Need to load seed data from a YAML configuration file, perform operations in a SQL database, cross-reference with a MongoDB data store, and use an in-memory data array for lightning-fast tests? A `Stannum::Struct` won't fight you every step of the way.
+Stannum also defines the `Stannum::Entity` module for defining structured data entities that are not tied to any framework or datastore. Stannum entities have more functionality and a friendlier interface than a core library `Struct`, provide more structure than a `Hash` or hash-like object (such as an `OpenStruct` or `Hashie::Mash`), and are completely independent from the source of the data. Need to load seed data from a YAML configuration file, perform operations in a SQL database, cross-reference with a MongoDB data store, and use an in-memory data array for lightning-fast tests? A `Stannum::Entity` won't fight you every step of the way.
 
 ### Why Stannum?
 
-Stannum is not tied to any framework. You can create constraints and contracts to validate Ruby objects and Structs, data structures such as Arrays, Hashes, and Sets, and even framework objects such as `ActiveRecord::Model`s and `Mongoid::Document`s.
+Stannum is not tied to any framework. You can create constraints and contracts to validate Ruby objects and Entities, data structures such as Arrays, Hashes, and Sets, and even framework objects such as `ActiveRecord::Model`s and `Mongoid::Document`s.
 
 Still, most projects and applications use one framework to handle their data. Why use Stannum constraints?
 
@@ -33,7 +33,7 @@ Still, most projects and applications use one framework to handle their data. Wh
 
 ### Compatibility
 
-Stannum is tested against Ruby (MRI) 2.6 through 3.0.
+Stannum is tested against Ruby (MRI) 2.7 through 3.2.
 
 ### Documentation
 
@@ -331,7 +331,7 @@ contract.does_not_match?({ color: 'blue', shape: 'square'})
 
 Note that for an object that partially matches the contract, both `#matches?` and `#does_not_match?` methods will return false. If you want to check whether **any** of the constraints do not match the object, use the `#matches?` method and apply the `!` boolean negation operator (or switch from an `if` to an `unless`).
 
-#### Property Constraints
+#### Constraining Properties
 
 Constraints can also define constraints on the *properties* of the matched object. This is a powerful feature for defining validations on objects and nested data structures. To define a property constraint, use the `property` macro in a contract constructor block, or use the `#add_property_constraint` method on an existing contract.
 
@@ -725,16 +725,20 @@ errors.first.message
 
 Stannum uses the strategy pattern to determine how error messages are generated. You can pass the `strategy:` keyword to `#with_messages` to force Stannum to use the specified strategy, or set the `Stannum::Messages.strategy` property to define the default for your application. The default strategy for Stannum uses an I18n-like configuration file to define messages based on the type and optionally the data for each error.
 
-<a id="structs"></a>
+<a id="entities"></a>
 
-### Structs
+### Entities
 
-While constraints and contracts are used to validate data, structs are used to define and structure that data. Each `Stannum::Struct` contains a specific set of attributes, and each attribute has a type definition that is a `Class` or `Module` or the name of a Class or Module.
+While constraints and contracts are used to validate data, entities are used to define and structure that data. Each `Stannum::Entity` contains a specific set of attributes, and each attribute has a type definition that is a `Class` or `Module` or the name of a Class or Module.
 
-Structs are defined by creating a new class and including `Stannum::Struct`:
+Entities are defined by creating a new class and including `Stannum::Entity`:
 
 ```ruby
+require 'stannum'
+
 class Gadget
+  include Stannum::Entity
+
   attribute :name,        String
   attribute :description, String,  optional: true
   attribute :quantity,    Integer, default:  0
@@ -763,21 +767,21 @@ gadget[:description]
 
 Our `Gadget` class has three attributes: `#name`, `#description`, and `#quantity`, which we are defining using the `.attribute` class method.
 
-We can initialize a gadget with values by passing the desired attributes to `.new`. We can read or write the attributes using either dot `.` notation or `#[]` notation. Finally, we can access all of a struct's attributes and values using the `#attributes` method.
+We can initialize a gadget with values by passing the desired attributes to `.new`. We can read or write the attributes using either dot `.` notation or `#[]` notation. Finally, we can access all of a entity's attributes and values using the `#attributes` method.
 
-`Stannum::Struct` defines a number of helper methods for interacting with a struct's attributes:
+`Stannum::Entity` defines a number of helper methods for interacting with a entity's attributes:
 
 - `#[](attribute)`: Returns the value of the given attribute.
 - `#[]=(attribute, value)`: Writes the given value to the given attribute.
-- `#assign_attributes(values)`: Updates the struct's attributes using the given values. If an attribute is not given, that value is unchanged.
+- `#assign_attributes(values)`: Updates the entity's attributes using the given values. If an attribute is not given, that value is unchanged.
 - `#attributes`: Returns a hash containing the attribute keys and values.
-- `#attributes=(values)`: Sets the struct's attributes to the given values. If an attribute is not given, that attribute is set to `nil`.
+- `#attributes=(values)`: Sets the entity's attributes to the given values. If an attribute is not given, that attribute is set to `nil`.
 
-For all of the above methods, if a given attribute is invalid or the attribute is not defined on the struct, an `ArgumentError` will be raised.
+For all of the above methods, if a given attribute is invalid or the attribute is not defined on the entity, an `ArgumentError` will be raised.
 
 #### Attributes
 
-A struct's attributes are defined using the `.attribute` class method, and can be accessed and enumerated using the `.attributes` class method on the struct class or via the `::Attributes` constant. Internally, each attribute is represented by a `Stannum::Attribute` instance, which stores the attribute's `:name`, `:type`, and `:attributes`.
+A entity's attributes are defined using the `.attribute` class method, and can be accessed and enumerated using the `.attributes` class method on the entity class or via the `::Attributes` constant. Internally, each attribute is represented by a `Stannum::Attribute` instance, which stores the attribute's `:name`, `:type`, and `:attributes`.
 
 ```ruby
 Gadget::Attributes
@@ -796,11 +800,11 @@ Gadget.attributes[:quantity].options
 
 ##### Default Values
 
-Structs can define default values for attributes by passing a `:default` value to the `.attribute` call.
+Entities can define default values for attributes by passing a `:default` value to the `.attribute` call.
 
 ```ruby
 class LightsCounter
-  include Stannum::Struct
+  include Stannum::Entity
 
   attribute :count, Integer, default: 4
 end
@@ -811,11 +815,11 @@ LightsCounter.new.count
 
 ##### Optional Attributes
 
-Struct classes can also mark attributes as `optional`. When a struct is validated (see [Validation](#structs-validation), below), optional attributes will pass with a value of `nil`.
+Entity classes can also mark attributes as `optional`. When an entity is validated (see [Validation](#entities-validation), below), optional attributes will pass with a value of `nil`.
 
 ```ruby
 class WhereWeAreGoing
-  include Stannum::Struct
+  include Stannum::Entity
 
   attribute :roads, Object, optional: true
 end
@@ -823,11 +827,11 @@ end
 
 `Stannum` supports both `:optional` and `:required` as keys. Passing either `optional: true` or `required: false` will mark the attribute as optional. Attributes are required by default.
 
-<a id="structs-validation"></a>
+<a id="entities-validation"></a>
 
 #### Validation
 
-Each `Stannum::Struct` automatically generates a contract that can be used to validate instances of the struct class. The contract can be accessed using the `.contract` class method or via the `::Contract` constant.
+Each `Stannum::Entity` automatically generates a contract that can be used to validate instances of the entity class. The contract can be accessed using the `.contract` class method or via the `::Contract` constant.
 
 ```ruby
 class Gadget
@@ -1091,6 +1095,66 @@ constraint.matches?(:a_symbol)
 #=> true
 ```
 
+#### Property Constraints
+
+Property constraints match against the properties of the object.
+
+**Do Not Match Property Constraint**
+
+Matches if none of the values of the given properties are equal to the value of the expected property.
+
+```ruby
+UpdatePassword = Struct.new(:old_password, :new_password)
+constraint    = Stannum::Constraints::Properties::DoNotMatchProperty.new(
+  :old_password,
+  :new_password
+)
+
+params = UpdatePassword.new('tronlives', 'ifightfortheusers')
+constraint.matches?(params)
+#=> true
+
+params = UpdatePassword.new('tronlives', 'tronlives')
+constraint.matches?(params)
+#=> false
+constraint.errors_for(params)
+#=> [
+  {
+    path: [:confirmation],
+    type: 'stannum.constraints.is_equal_to',
+    data: { expected: '[FILTERED]', actual: '[FILTERED]' }
+  }
+]
+```
+
+**Match Property Constraint**
+
+Matches if all the values of the given properties are equal to the value of the expected property.
+
+```ruby
+ConfirmPassword = Struct.new(:password, :confirmation)
+constraint    = Stannum::Constraints::Properties::MatchProperty.new(
+  :password,
+  :confirmation
+)
+
+params = ConfirmPassword.new('tronlives', 'ifightfortheusers')
+constraint.matches?(params)
+#=> false
+constraint.errors_for(params)
+#=> [
+  {
+    path: [:confirmation],
+    type: 'stannum.constraints.is_not_equal_to',
+    data: { expected: '[FILTERED]', actual: '[FILTERED]' }
+  }
+]
+
+params = ConfirmPassword.new('tronlives', 'tronlives')
+constraint.matches?(params)
+#=> true
+```
+
 #### Type Constraints
 
 Stannum also defines a set of built-in type constraints. Unless otherwise noted, these are identical to a [Type Constraint](#builtin-constraints-type) with the given Class.

data/config/locales/en.rb

@@ -23,13 +23,27 @@
         is_not_equal_to: 'is not equal to',
         is_not_in_list: 'is not in the list',
         is_not_in_union: 'does not match any of the constraints',
-        is_not_type: ->(_type, data) { "is not a #{data[:type]}" },
+        is_not_type: lambda do |_type, data|
+          if data[:required]
+            "is not a #{data[:type]}"
+          else
+            "is not a #{data[:type]} or nil"
+          end
+        end,
         is_not_value: 'is not the expected value',
-        is_type: ->(_type, data) { "is a #{data[:type]}" },
+        is_type: lambda do |_type, data|
+          if data[:required]
+            "is a #{data[:type]}"
+          else
+            "is a #{data[:type]} or nil"
+          end
+        end,
         is_value: 'is the expected value',
         parameters: {
           extra_arguments: 'has extra arguments',
-          extra_keywords: 'has extra keywords'
+          extra_keywords: 'has extra keywords',
+          no_extra_arguments: 'does not have extra arguments',
+          no_extra_keywords: 'does not have extra keywords'
         },
         tuples: {
           extra_items: 'has extra items',

data/lib/stannum/constraints/base.rb

@@ -74,6 +74,8 @@ module Stannum::Constraints
     #
     #   constraint.does_not_match?(object) #=> true
     #
+    # @param actual [Object] The object to match.
+    #
     # @return [true, false] false if the object matches the expected properties
     #   or behavior, otherwise true.
     #
@@ -143,6 +145,8 @@ module Stannum::Constraints
     #   errors.class #=> Stannum::Errors
     #   errors.to_a  #=> [{ type: 'some_error', message: 'some error message' }]
     #
+    # @param actual [Object] The object to match.
+    #
     # @see #errors_for
     # @see #matches?
     def match(actual)
@@ -152,8 +156,12 @@ module Stannum::Constraints
     end
 
     # @overload matches?(actual)
+    #   Checks that the given object matches the constraint.
+    #
+    #   @param actual [Object] The object to match.
     #
-    # Checks that the given object matches the constraint.
+    #   @return [true, false] true if the object matches the expected properties
+    #     or behavior, otherwise false.
     #
     # @example Checking a matching object.
     #   constraint = CustomConstraint.new
@@ -167,9 +175,6 @@ module Stannum::Constraints
     #
     #   constraint.matches?(object) #=> false
     #
-    # @return [true, false] true if the object matches the expected properties
-    #   or behavior, otherwise false.
-    #
     # @see #does_not_match?
     def matches?(_actual)
       false
@@ -221,6 +226,8 @@ module Stannum::Constraints
     # false and the generated errors for that object. If the object does not
     # match the constraint, #negated_match will return true.
     #
+    # @param actual [Object] The object to match.
+    #
     # @example Checking a matching object.
     #   constraint = CustomConstraint.new
     #   object     = MatchingObject.new

data/lib/stannum/constraints/hashes/extra_keys.rb

@@ -1,16 +1,22 @@
 # frozen_string_literal: true
 
 require 'stannum/constraints/hashes'
+require 'stannum/support/coercion'
 
 module Stannum::Constraints::Hashes
   # Constraint for validating the keys of a hash-like object.
   #
+  # When using this constraint, the keys must be strings or symbols, and the
+  # hash keys must be of the same type. A constraint configured with string keys
+  # will not match a hash with symbol keys, and vice versa.
+  #
   # @example
-  #   keys       = %[fuel mass size]
+  #   keys       = %i[fuel mass size]
   #   constraint = Stannum::Constraints::Hashes::ExpectedKeys.new(keys)
   #
   #   constraint.matches?({})                                #=> true
   #   constraint.matches?({ fuel: 'Monopropellant' })        #=> true
+  #   constraint.matches?({ 'fuel' => 'Monopropellant' })    #=> false
   #   constraint.matches?({ electric: true, fuel: 'Xenon' }) #=> false
   #   constraint.matches?({ fuel: 'LF/O', mass: '1 ton', size: 'Medium' })
   #   #=> true
@@ -59,13 +65,15 @@ module Stannum::Constraints::Hashes
       end
 
       each_extra_key(actual) do |key, value|
+        key = Stannum::Support::Coercion.error_key(key)
+
         errors[key].add(type, value: value)
       end
 
       errors
     end
 
-    # @return [Array] the expected keys.
+    # @return [Set] the expected keys.
     def expected_keys
       keys = options[:expected_keys]
 

data/lib/stannum/constraints/hashes/indifferent_extra_keys.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'stannum/constraints/hashes'
+require 'stannum/constraints/hashes/extra_keys'
+
+module Stannum::Constraints::Hashes
+  # Constraint for validating the keys of an indifferent hash-like object.
+  #
+  # When using this constraint, the keys must be strings or symbols, but it does
+  # not matter which - a constraint configured with string keys will match a
+  # hash with symbol keys, and vice versa.
+  #
+  # @example
+  #   keys       = %i[fuel mass size]
+  #   constraint = Stannum::Constraints::Hashes::ExpectedKeys.new(keys)
+  #
+  #   constraint.matches?({})                                #=> true
+  #   constraint.matches?({ fuel: 'Monopropellant' })        #=> true
+  #   constraint.matches?({ 'fuel' => 'Monopropellant' })    #=> true
+  #   constraint.matches?({ electric: true, fuel: 'Xenon' }) #=> false
+  #   constraint.matches?({ fuel: 'LF/O', mass: '1 ton', size: 'Medium' })
+  #   #=> true
+  #   constraint.matches?(
+  #     { fuel: 'LF', mass: '2 tons', nuclear: true, size: 'Medium' }
+  #   )
+  #   #=> false
+  class IndifferentExtraKeys < Stannum::Constraints::Hashes::ExtraKeys
+    # @return [Set] the expected keys.
+    def expected_keys
+      keys = options[:expected_keys]
+
+      return indifferent_keys_for(keys) unless keys.is_a?(Proc)
+
+      indifferent_keys_for(keys.call)
+    end
+
+    private
+
+    def indifferent_keys_for(keys)
+      Set.new(
+        keys.reduce([]) do |ary, key|
+          ary << key.to_s << key.intern
+        end
+      )
+    end
+  end
+end

data/lib/stannum/constraints/hashes.rb

@@ -5,7 +5,11 @@ require 'stannum/constraints'
 module Stannum::Constraints
   # Namespace for Hash-specific constraints.
   module Hashes
-    autoload :ExtraKeys,      'stannum/constraints/hashes/extra_keys'
-    autoload :IndifferentKey, 'stannum/constraints/hashes/indifferent_key'
+    autoload :ExtraKeys,
+      'stannum/constraints/hashes/extra_keys'
+    autoload :IndifferentExtraKeys,
+      'stannum/constraints/hashes/indifferent_extra_keys'
+    autoload :IndifferentKey,
+      'stannum/constraints/hashes/indifferent_key'
   end
 end

data/lib/stannum/constraints/parameters/extra_arguments.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'stannum/constraints/parameters'
+require 'stannum/constraints/tuples/extra_items'
+
+module Stannum::Constraints::Parameters
+  # Validates that the arguments passed to a method have no extra items.
+  #
+  # @example
+  #   constraint = Stannum::Constraints::Parameters::ExtraArguments.new(3)
+  #
+  #   constraint.matches?([])           #=> true
+  #   constraint.matches?([1])          #=> true
+  #   constraint.matches?([1, 2, 3])    #=> true
+  #   constraint.matches?([1, 2, 3, 4]) #=> false
+  class ExtraArguments < Stannum::Constraints::Tuples::ExtraItems
+    # The :type of the error generated for a matching object.
+    NEGATED_TYPE = 'stannum.constraints.parameters.no_extra_arguments'
+
+    # The :type of the error generated for a non-matching object.
+    TYPE = 'stannum.constraints.parameters.extra_arguments'
+  end
+end

data/lib/stannum/constraints/parameters/extra_keywords.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'stannum/constraints/hashes/extra_keys'
+require 'stannum/constraints/parameters'
+
+module Stannum::Constraints::Parameters
+  # Validates that the keywords passed to a method have no extra keys.
+  #
+  # @example
+  #   keys       = %[fuel mass size]
+  #   constraint = Stannum::Constraints::Parameters::ExpectedKeywords.new(keys)
+  #
+  #   constraint.matches?({})                                #=> true
+  #   constraint.matches?({ fuel: 'Monopropellant' })        #=> true
+  #   constraint.matches?({ electric: true, fuel: 'Xenon' }) #=> false
+  #   constraint.matches?({ fuel: 'LF/O', mass: '1 ton', size: 'Medium' })
+  #   #=> true
+  #   constraint.matches?(
+  #     { fuel: 'LF', mass: '2 tons', nuclear: true, size: 'Medium' }
+  #   )
+  #   #=> false
+  class ExtraKeywords < Stannum::Constraints::Hashes::ExtraKeys
+    # The :type of the error generated for a matching object.
+    NEGATED_TYPE = 'stannum.constraints.parameters.no_extra_keywords'
+
+    # The :type of the error generated for a non-matching object.
+    TYPE = 'stannum.constraints.parameters.extra_keywords'
+  end
+end

data/lib/stannum/constraints/parameters.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'stannum/constraints'
+
+module Stannum::Constraints
+  # Namespace for constraints that match method parameters.
+  module Parameters
+    autoload :ExtraArguments, 'stannum/constraints/parameters/extra_arguments'
+    autoload :ExtraKeywords,  'stannum/constraints/parameters/extra_keywords'
+  end
+end

data/lib/stannum/constraints/properties/base.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'sleeping_king_studios/tools/toolbelt'
+
+require 'stannum/constraints/properties'
+
+module Stannum::Constraints::Properties
+  # Abstract base class for property constraints.
+  class Base < Stannum::Constraints::Base
+    # Default parameter names to filter out of errors.
+    FILTERED_PARAMETERS = %i[
+      passw
+      secret
+      token
+      _key
+      crypt
+      salt
+      certificate
+      otp
+      ssn
+    ].freeze
+
+    # @param property_names [Array<String, Symbol>] the name or names of the
+    #   properties to match.
+    # @param options [Hash<Symbol, Object>] configuration options for the
+    #   constraint. Defaults to an empty Hash.
+    #
+    # @option options allow_empty [true, false] if true, will match against an
+    #   object with empty property values, such as an empty string.
+    # @option options allow_nil [true, false] if true, will match against an
+    #   object with nil property values.
+    def initialize(*property_names, **options)
+      @property_names = property_names
+
+      validate_property_names
+
+      super(
+        allow_empty:    !!options[:allow_empty],
+        allow_nil:      !!options[:allow_nil],
+        property_names: property_names,
+        **options
+      )
+    end
+
+    # @return [Array<String, Symbol>] the name or names of the properties to
+    #   match.
+    attr_reader :property_names
+
+    # @return [true, false] if true, will match against an object with empty
+    #   property values, such as an empty string.
+    def allow_empty?
+      options[:allow_empty]
+    end
+
+    # @return [true, false] if true, will match against an object with nil
+    #   property values.
+    def allow_nil?
+      options[:allow_nil]
+    end
+
+    private
+
+    def can_match_properties?(actual)
+      actual.respond_to?(:[])
+    end
+
+    def each_property(actual)
+      return to_enum(__method__, actual) unless block_given?
+
+      property_names.each do |property_name|
+        yield property_name, actual[property_name]
+      end
+    end
+
+    def empty?(value)
+      value.respond_to?(:empty?) && value.empty?
+    end
+
+    def filter_parameters?
+      return @filter_parameters unless @filter_parameters.nil?
+
+      filters = filtered_parameters.map { |param| Regexp.new(param.to_s) }
+
+      @filter_parameters =
+        property_names.any? do |property_name|
+          filters.any? { |filter| filter.match?(property_name.to_s) }
+        end
+    end
+
+    def filtered_parameters
+      return Rails.configuration.filter_parameters if defined?(Rails)
+
+      FILTERED_PARAMETERS
+    end
+
+    def invalid_object_errors(errors)
+      errors.add(
+        Stannum::Constraints::Signature::TYPE,
+        methods: %i[[]],
+        missing: %i[[]]
+      )
+    end
+
+    def skip_property?(value)
+      (allow_empty? && empty?(value)) || (allow_nil? && value.nil?)
+    end
+
+    def tools
+      SleepingKingStudios::Tools::Toolbelt.instance
+    end
+
+    def validate_property_names
+      if property_names.empty?
+        raise ArgumentError, "property names can't be empty"
+      end
+
+      property_names.each.with_index do |property_name, index|
+        tools
+          .assertions
+          .validate_name(property_name, as: "property name at #{index}")
+      end
+    end
+  end
+end