stannum 0.1.0 → 0.3.0

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'stannum/constraints/properties'
+require 'stannum/constraints/properties/matching'
+
+module Stannum::Constraints::Properties
+  # Compares the properties of the given object with the specified property.
+  #
+  # If none of the property values equal the expected value, the constraint will
+  # match the object; otherwise, if there are any matching values, the
+  # constraint will not match.
+  #
+  # @example Using an Properties::Match constraint
+  #   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]' }
+  #     }
+  #   ]
+  class DoNotMatchProperty < Stannum::Constraints::Properties::Matching
+    # The :type of the error generated for a matching object.
+    NEGATED_TYPE = Stannum::Constraints::Equality::TYPE
+
+    # The :type of the error generated for a non-matching object.
+    TYPE = Stannum::Constraints::Equality::NEGATED_TYPE
+
+    # @return [true, false] true if the property values match the reference
+    #   property value; otherwise false.
+    def does_not_match?(actual)
+      return false unless can_match_properties?(actual)
+
+      expected = expected_value(actual)
+
+      return false if skip_property?(expected)
+
+      each_non_matching_property(
+        actual:      actual,
+        expected:    expected,
+        include_all: true
+      )
+        .none?
+    end
+
+    # (see Stannum::Constraints::Base#errors_for)
+    def errors_for(actual, errors: nil)
+      errors ||= Stannum::Errors.new
+
+      return invalid_object_errors(errors) unless can_match_properties?(actual)
+
+      expected = expected_value(actual)
+      matching = each_matching_property(actual: actual, expected: expected)
+
+      return generic_errors(errors) if matching.count.zero?
+
+      matching.each do |property_name, _|
+        errors[property_name].add(type, message: message)
+      end
+
+      errors
+    end
+
+    # @return [true, false] false if any of the property values match the
+    #   reference property value; otherwise true.
+    def matches?(actual)
+      return false unless can_match_properties?(actual)
+
+      expected = expected_value(actual)
+
+      return true if skip_property?(expected)
+
+      each_matching_property(actual: actual, expected: expected).none?
+    end
+    alias match? matches?
+
+    # (see Stannum::Constraints::Base#negated_errors_for)
+    def negated_errors_for(actual, errors: nil) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      errors ||= Stannum::Errors.new
+
+      return invalid_object_errors(errors) unless can_match_properties?(actual)
+
+      expected = expected_value(actual)
+      matching = each_non_matching_property(
+        actual:      actual,
+        expected:    expected,
+        include_all: true
+      )
+
+      return generic_errors(errors) if matching.count.zero?
+
+      matching.each do |property_name, value|
+        errors[property_name].add(
+          negated_type,
+          message:  negated_message,
+          expected: filter_parameters? ? '[FILTERED]' : expected_value(actual),
+          actual:   filter_parameters? ? '[FILTERED]' : value
+        )
+      end
+
+      errors
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'stannum/constraints/properties'
+require 'stannum/constraints/properties/matching'
+
+module Stannum::Constraints::Properties
+  # Compares the properties of the given object with the specified property.
+  #
+  # If all of the property values equal the expected value, the constraint will
+  # match the object; otherwise, if there are any non-matching values, the
+  # constraint will not match.
+  #
+  # @example Using an Properties::Match constraint
+  #   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
+  class MatchProperty < Stannum::Constraints::Properties::Matching
+    # The :type of the error generated for a matching object.
+    NEGATED_TYPE = Stannum::Constraints::Equality::NEGATED_TYPE
+
+    # The :type of the error generated for a non-matching object.
+    TYPE = Stannum::Constraints::Equality::TYPE
+
+    # @return [true, false] false if any of the property values match the
+    #   reference property value; otherwise true.
+    def does_not_match?(actual)
+      return false unless can_match_properties?(actual)
+
+      expected = expected_value(actual)
+
+      return false if skip_property?(expected)
+
+      each_matching_property(
+        actual:      actual,
+        expected:    expected,
+        include_all: true
+      )
+        .none?
+    end
+
+    # (see Stannum::Constraints::Base#errors_for)
+    def errors_for(actual, errors: nil) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      errors ||= Stannum::Errors.new
+
+      return invalid_object_errors(errors) unless can_match_properties?(actual)
+
+      expected = expected_value(actual)
+      matching = each_non_matching_property(actual: actual, expected: expected)
+
+      return generic_errors(errors) if matching.count.zero?
+
+      matching.each do |property_name, value|
+        errors[property_name].add(
+          type,
+          message:  message,
+          expected: filter_parameters? ? '[FILTERED]' : expected_value(actual),
+          actual:   filter_parameters? ? '[FILTERED]' : value
+        )
+      end
+
+      errors
+    end
+
+    # @return [true, false] true if the property values match the reference
+    #   property value; otherwise false.
+    def matches?(actual)
+      return false unless can_match_properties?(actual)
+
+      expected = expected_value(actual)
+
+      return true if skip_property?(expected)
+
+      each_non_matching_property(actual: actual, expected: expected).none?
+    end
+    alias match? matches?
+
+    # (see Stannum::Constraints::Base#negated_errors_for)
+    def negated_errors_for(actual, errors: nil) # rubocop:disable Metrics/MethodLength
+      errors ||= Stannum::Errors.new
+
+      return invalid_object_errors(errors) unless can_match_properties?(actual)
+
+      expected = expected_value(actual)
+      matching = each_matching_property(
+        actual:      actual,
+        expected:    expected,
+        include_all: true
+      )
+
+      return generic_errors(errors) if matching.count.zero?
+
+      matching.each do |property_name, _|
+        errors[property_name].add(negated_type, message: negated_message)
+      end
+
+      errors
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'stannum/constraints/properties'
+require 'stannum/constraints/properties/base'
+
+module Stannum::Constraints::Properties
+  # Abstract base class for property matching constraints.
+  class Matching < Stannum::Constraints::Properties::Base
+    # @param reference_name [String, Symbol] the name of the reference property
+    #   to compare to.
+    # @param property_names [Array<String, Symbol>] the name or names of the
+    #   properties to compare.
+    # @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(reference_name, *property_names, **options)
+      @reference_name = reference_name
+
+      validate_reference_name
+
+      super(*property_names, reference_name: reference_name, **options)
+    end
+
+    # @return [String, Symbol] the name of the reference property to compare to.
+    attr_reader :reference_name
+
+    private
+
+    def each_matching_property( # rubocop:disable Metrics/MethodLength
+      actual:,
+      expected:,
+      include_all: false,
+      &block
+    )
+      unless block_given?
+        return to_enum(
+          __method__,
+          actual:      actual,
+          expected:    expected,
+          include_all: include_all
+        )
+      end
+
+      enumerator = each_property(actual)
+
+      unless include_all
+        enumerator = enumerator.reject { |_, value| skip_property?(value) }
+      end
+
+      enumerator = enumerator.select { |_, value| valid?(expected, value) }
+
+      block_given? ? enumerator.each(&block) : enumerator
+    end
+
+    def each_non_matching_property( # rubocop:disable Metrics/MethodLength
+      actual:,
+      expected:,
+      include_all: false,
+      &block
+    )
+      unless block_given?
+        return to_enum(
+          __method__,
+          actual:      actual,
+          expected:    expected,
+          include_all: include_all
+        )
+      end
+
+      enumerator = each_property(actual)
+
+      unless include_all
+        enumerator = enumerator.reject { |_, value| skip_property?(value) }
+      end
+
+      enumerator = enumerator.reject { |_, value| valid?(expected, value) }
+
+      block_given? ? enumerator.each(&block) : enumerator
+    end
+
+    def expected_value(actual)
+      actual[reference_name]
+    end
+
+    def filter_parameters?
+      return @filter_parameters unless @filter_parameters.nil?
+
+      filters = filtered_parameters.map { |param| Regexp.new(param.to_s) }
+
+      @filter_parameters =
+        [reference_name, *property_names].any? do |property_name|
+          filters.any? { |filter| filter.match?(property_name.to_s) }
+        end
+    end
+
+    def generic_errors(errors)
+      errors.add(Stannum::Constraints::Base::NEGATED_TYPE)
+    end
+
+    def valid?(expected, value)
+      value == expected
+    end
+
+    def validate_reference_name
+      tools.assertions.validate_name(reference_name, as: 'reference name')
+    end
+  end
+end

data/lib/stannum/constraints/properties.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'stannum/constraints'
+
+module Stannum::Constraints
+  # Namespace for Object property-specific constraints.
+  module Properties
+    autoload :Base,
+      'stannum/constraints/properties/base'
+    autoload :DoNotMatchProperty,
+      'stannum/constraints/properties/do_not_match_property'
+    autoload :MatchProperty,
+      'stannum/constraints/properties/match_property'
+    autoload :Matching,
+      'stannum/constraints/properties/matching'
+  end
+end

data/lib/stannum/constraints/tuples/extra_items.rb

@@ -78,7 +78,7 @@ module Stannum::Constraints::Tuples
     def each_extra_item(actual, &block)
       return if matches?(actual)
 
-      actual[expected_count..-1].each.with_index(expected_count, &block)
+      actual[expected_count..].each.with_index(expected_count, &block)
     end
   end
 end

data/lib/stannum/constraints/type.rb

@@ -107,7 +107,7 @@ module Stannum::Constraints
 
       raise ArgumentError,
         'expected type must be a Class or Module',
-        caller[1..-1]
+        caller[1..]
     end
   end
 end

data/lib/stannum/constraints/types/hash_type.rb

@@ -184,13 +184,17 @@ module Stannum::Constraints::Types
 
     def update_key_errors_for(actual:, errors:)
       non_matching_keys(actual).each do |key|
-        key_type.errors_for(key, errors: errors[:keys][key])
+        mapped_key = Stannum::Support::Coercion.error_key(key)
+
+        key_type.errors_for(key, errors: errors[:keys][mapped_key])
       end
     end
 
     def update_value_errors_for(actual:, errors:)
       non_matching_values(actual).each do |key, value|
-        value_type.errors_for(value, errors: errors[key])
+        mapped_key = Stannum::Support::Coercion.error_key(key)
+
+        value_type.errors_for(value, errors: errors[mapped_key])
       end
     end
 

data/lib/stannum/constraints.rb

@@ -15,7 +15,9 @@ module Stannum
     autoload :Hashes,     'stannum/constraints/hashes'
     autoload :Identity,   'stannum/constraints/identity'
     autoload :Nothing,    'stannum/constraints/nothing'
+    autoload :Parameters, 'stannum/constraints/parameters'
     autoload :Presence,   'stannum/constraints/presence'
+    autoload :Properties, 'stannum/constraints/properties'
     autoload :Signature,  'stannum/constraints/signature'
     autoload :Signatures, 'stannum/constraints/signatures'
     autoload :Tuples,     'stannum/constraints/tuples'

data/lib/stannum/contracts/builder.rb

@@ -18,6 +18,17 @@ module Stannum::Contracts
     # @return [Stannum::Contract] The contract to which constraints are added.
     attr_reader :contract
 
+    # Concatenate the constraints from the given other contract.
+    #
+    # @param other [Stannum::Contract] the other contract.
+    #
+    # @return [self] the contract builder.
+    #
+    # @see Stannum::Contracts::Base#concat.
+    def concat(other)
+      contract.concat(other)
+    end
+
     # Adds a constraint to the contract.
     #
     # @overload constraint(constraint, **options)
@@ -47,8 +58,8 @@ module Stannum::Contracts
     private
 
     def ambiguous_values_error(constraint)
-      'expected either a block or a constraint instance, but received both a' \
-        " block and #{constraint.inspect}"
+      'expected either a block or a constraint instance, but received both a ' \
+        "block and #{constraint.inspect}"
     end
 
     def resolve_constraint(constraint = nil, **options, &block)

data/lib/stannum/contracts/hash_contract.rb

@@ -121,6 +121,20 @@ module Stannum::Contracts
       options[:value_type]
     end
 
+    protected
+
+    def map_errors(errors, **options)
+      return super unless options[:property_type] == :key
+
+      property_name = options.fetch(:property_name, options[:property])
+      property_name = property_name.nil? ? [nil] : Array(property_name)
+      property_name = property_name.map do |key|
+        Stannum::Support::Coercion.error_key(key)
+      end
+
+      errors.dig(*property_name)
+    end
+
     private
 
     def add_type_constraint

data/lib/stannum/contracts/indifferent_hash_contract.rb

@@ -74,5 +74,18 @@ module Stannum::Contracts
         actual.fetch(property) { actual[property.to_s] }
       end
     end
+
+    private
+
+    def add_extra_keys_constraint
+      return if options[:allow_extra_keys]
+
+      keys = -> { expected_keys }
+
+      add_constraint(
+        Stannum::Constraints::Hashes::IndifferentExtraKeys.new(keys),
+        concatenatable: false
+      )
+    end
   end
 end

data/lib/stannum/contracts/parameters/arguments_contract.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'stannum/constraints/parameters/extra_arguments'
 require 'stannum/contracts/parameters'
 require 'stannum/support/coercion'
 
@@ -8,9 +9,6 @@ module Stannum::Contracts::Parameters
   #
   # An ArgumentsContract constrains the arguments given for a method.
   class ArgumentsContract < Stannum::Contracts::TupleContract
-    # The :type of the error generated for extra arguments.
-    EXTRA_ARGUMENTS_TYPE = 'stannum.constraints.parameters.extra_arguments'
-
     # Value used when arguments array does not have a value for the given index.
     UNDEFINED = Object.new.freeze
 
@@ -154,10 +152,7 @@ module Stannum::Contracts::Parameters
       count = -> { expected_count }
 
       @variadic_constraint = Stannum::Constraints::Delegator.new(
-        Stannum::Constraints::Tuples::ExtraItems.new(
-          count,
-          type: EXTRA_ARGUMENTS_TYPE
-        )
+        Stannum::Constraints::Parameters::ExtraArguments.new(count)
       )
 
       add_constraint @variadic_constraint

data/lib/stannum/contracts/parameters/keywords_contract.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'stannum/constraints/parameters/extra_keywords'
 require 'stannum/contracts/indifferent_hash_contract'
 require 'stannum/contracts/parameters'
 
@@ -8,9 +9,6 @@ module Stannum::Contracts::Parameters
   #
   # A KeywordsContract constrains the keywords given for a method.
   class KeywordsContract < Stannum::Contracts::IndifferentHashContract
-    # The :type of the error generated for extra keywords.
-    EXTRA_KEYWORDS_TYPE = 'stannum.constraints.parameters.extra_keywords'
-
     # Value used when keywords hash does not have a value for the given key.
     UNDEFINED = Object.new.freeze
 
@@ -156,10 +154,7 @@ module Stannum::Contracts::Parameters
       keys = -> { expected_keys }
 
       @variadic_constraint = Stannum::Constraints::Delegator.new(
-        Stannum::Constraints::Hashes::ExtraKeys.new(
-          keys,
-          type: EXTRA_KEYWORDS_TYPE
-        )
+        Stannum::Constraints::Parameters::ExtraKeywords.new(keys)
       )
 
       add_constraint @variadic_constraint

data/lib/stannum/contracts/tuple_contract.rb

@@ -168,7 +168,7 @@ module Stannum::Contracts
 
         index = 1 + definition.options.fetch(:property, -1)
 
-        index > count ? index : count
+        [index, count].max
       end
     end