domainic-type 0.1.0.alpha.2.1.0 → 0.1.0.alpha.3.0.1

data/lib/domainic/type/constraint/constraints/inclusion_constraint.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'domainic/type/constraint/behavior'
+
+module Domainic
+  module Type
+    module Constraint
+      # A constraint for validating that a collection includes a specific value.
+      #
+      # This constraint verifies that a collection contains an expected value by using
+      # the collection's #include? method. It works with any object that responds to
+      # #include?, such as Arrays, Sets, Strings, and Ranges.
+      #
+      # @example Array inclusion
+      #   constraint = InclusionConstraint.new(:self, 2)
+      #   constraint.satisfied?([1, 2, 3])  # => true
+      #   constraint.satisfied?([1, 3, 4])  # => false
+      #
+      # @example String inclusion
+      #   constraint = InclusionConstraint.new(:self, 'b')
+      #   constraint.satisfied?('abc')  # => true
+      #   constraint.satisfied?('ac')   # => false
+      #
+      # @example Range inclusion
+      #   constraint = InclusionConstraint.new(:self, 5)
+      #   constraint.satisfied?(1..10)  # => true
+      #   constraint.satisfied?(11..20) # => false
+      #
+      # @author {https://aaronmallen.me Aaron Allen}
+      # @since 0.1.0
+      class InclusionConstraint
+        include Behavior #[untyped, Enumerable[untyped], {}]
+
+        # Get a human-readable description of the inclusion requirement.
+        #
+        # @example
+        #   constraint = InclusionConstraint.new(:self, 42)
+        #   constraint.short_description # => "including 42"
+        #
+        # @return [String] A description of the inclusion requirement
+        # @rbs override
+        def short_description
+          "including #{@expected.inspect}"
+        end
+
+        # Get a human-readable description of why inclusion validation failed.
+        #
+        # @example
+        #   constraint = InclusionConstraint.new(:self, 42)
+        #   constraint.satisfied?([1, 2, 3])
+        #   constraint.short_violation_description # => 'excluding 42'
+        #
+        # @return [String] A description of which value was missing
+        # @rbs override
+        def short_violation_description
+          "excluding #{@expected.inspect}"
+        end
+
+        protected
+
+        # Check if the collection includes the expected value.
+        #
+        # Uses the collection's #include? method to verify that the expected
+        # value is present in the collection being validated.
+        #
+        # @return [Boolean] true if the collection includes the expected value
+        # @rbs override
+        def satisfies_constraint?
+          @actual.include?(@expected)
+        end
+      end
+    end
+  end
+end

data/lib/domainic/type/constraint/constraints/match_pattern_constraint.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'domainic/type/constraint/behavior'
+
+module Domainic
+  module Type
+    module Constraint
+      # A constraint for validating that strings match a given pattern.
+      #
+      # This constraint verifies that a string value matches a specified regular expression
+      # pattern. It supports both Regexp objects and string patterns that are converted to
+      # regular expressions.
+      #
+      # @example Basic pattern matching
+      #   constraint = MatchPatternConstraint.new(:self, /\A\d+\z/)
+      #   constraint.satisfied?("123")  # => true
+      #   constraint.satisfied?("abc")  # => false
+      #
+      # @example String pattern conversion
+      #   constraint = MatchPatternConstraint.new(:self, '\A\w+@\w+\.\w+\z')
+      #   constraint.satisfied?("test@example.com")  # => true
+      #   constraint.satisfied?("invalid-email")     # => false
+      #
+      # @author {https://aaronmallen.me Aaron Allen}
+      # @since 0.1.0
+      class MatchPatternConstraint
+        include Behavior #[Regexp, untyped, {}]
+
+        # Get a human-readable description of the pattern requirement.
+        #
+        # @example
+        #   constraint = MatchPatternConstraint.new(:self, /\d+/)
+        #   constraint.short_description # => "matches /\\d+/"
+        #
+        # @return [String] A description of the pattern requirement
+        # @rbs override
+        def short_description
+          "matching #{@expected.inspect}"
+        end
+
+        # Get a human-readable description of why pattern validation failed.
+        #
+        # @example
+        #   constraint = MatchPatternConstraint.new(:self, /\d+/)
+        #   constraint.satisfied?("abc")
+        #   constraint.short_violation_description # => "does not match /\\d+/"
+        #
+        # @return [String] A description of the pattern mismatch
+        # @rbs override
+        def short_violation_description
+          "does not match #{@expected.inspect}"
+        end
+
+        protected
+
+        # Coerce string patterns into Regexp objects.
+        #
+        # @param expectation [String, Regexp] The pattern to coerce
+        #
+        # @return [Regexp] The coerced pattern
+        # @rbs override
+        def coerce_expectation(expectation)
+          expectation.is_a?(String) ? Regexp.new(expectation) : expectation #: Expected
+        end
+
+        # Check if the value matches the expected pattern.
+        #
+        # @return [Boolean] true if the value matches the pattern
+        # @rbs override
+        def satisfies_constraint?
+          @expected.match?(@actual)
+        end
+
+        # Validate that the expectation is a valid regular expression.
+        #
+        # @param expectation [Object] The pattern to validate
+        #
+        # @raise [ArgumentError] if the expectation is not a Regexp
+        # @return [void]
+        # @rbs override
+        def validate_expectation!(expectation)
+          raise ArgumentError, 'expectation must be a Regexp' unless expectation.is_a?(Regexp)
+        end
+      end
+    end
+  end
+end

data/lib/domainic/type/constraint/constraints/method_presence_constraint.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'domainic/type/constraint/behavior'
+
+module Domainic
+  module Type
+    module Constraint
+      # A constraint that validates whether an object responds to a specified method
+      #
+      # This constraint checks if an object implements a particular interface by verifying
+      # it responds to a given method name. The method name must be provided as a Symbol.
+      #
+      # @example
+      #   constraint = MethodPresenceConstraint.new(:to_s)
+      #   constraint.satisfied_by?(Object.new)  # => true
+      #   constraint.satisfied_by?(BasicObject.new)  # => false
+      #
+      # @author {https://aaronmallen.me Aaron Allen}
+      # @since 0.1.0
+      class MethodPresenceConstraint
+        include Behavior #[Symbol, untyped, {}]
+
+        # Get a short description of what this constraint expects
+        #
+        # @return [String] description of the expected method
+        # @rbs override
+        def short_description
+          "responding to #{@expected}"
+        end
+
+        # Get a short description of why the constraint was violated
+        #
+        # @return [String] description of the missing method
+        # @rbs override
+        def short_violation_description
+          "not responding to #{@expected}"
+        end
+
+        protected
+
+        # Coerce the expectation into a symbol
+        #
+        # @param expectation [Symbol] the method name to check
+        #
+        # @return [Symbol] coerced method name
+        # @rbs override
+        def coerce_expectation(expectation)
+          expectation.to_sym
+        end
+
+        # Check if the actual value satisfies the constraint
+        #
+        # @return [Boolean] true if the object responds to the expected method
+        # @rbs override
+        def satisfies_constraint?
+          @actual.respond_to?(@expected)
+        end
+
+        # Validate that the expectation is a Symbol
+        #
+        # @param expectation [Object] the expectation to validate
+        #
+        # @raise [ArgumentError] if the expectation is not a Symbol
+        # @return [void]
+        # @rbs override
+        def validate_expectation!(expectation)
+          raise ArgumentError, 'Expectation must be a Symbol' unless expectation.is_a?(Symbol)
+        end
+      end
+    end
+  end
+end

data/lib/domainic/type/constraint/constraints/none_constraint.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'domainic/type/constraint/behavior'
+
+module Domainic
+  module Type
+    module Constraint
+      # A constraint that ensures no element in an enumerable satisfies a given constraint.
+      #
+      # The NoneConstraint validates that none of the elements in an enumerable value meet
+      # the provided constraint. This enables validation rules like "must not contain any
+      # strings" or "must have no negative numbers".
+      #
+      # Key features:
+      # - Validates enumerable elements against a constraint
+      # - Short-circuits on first violating element
+      # - Provides clear error messages for violating elements
+      # - Handles non-enumerable values gracefully
+      #
+      # @example Validating an array contains no strings
+      #   string_constraint = StringConstraint.new(:self)
+      #   no_strings = NoneConstraint.new(:self, string_constraint)
+      #
+      #   no_strings.satisfied?([1, 2, 3])        # => true
+      #   no_strings.satisfied?(['a', 1, 'c'])    # => false
+      #   no_strings.satisfied?(nil)              # => false (not enumerable)
+      #
+      # @author {https://aaronmallen.me Aaron Allen}
+      # @since 0.1.0
+      class NoneConstraint
+        include Behavior #[Behavior[untyped, untyped, untyped], Enumerable, {}]
+
+        # Get a description of what the constraint expects.
+        #
+        # @return [String] a description negating the expected constraint description
+        # @rbs override
+        def short_description
+          "not #{@expected.short_description}"
+        end
+
+        # The description of the violations that caused the constraint to be unsatisfied.
+        #
+        # This method provides detailed feedback when any constraints are satisfied,
+        # listing all the ways in which the value failed validation.
+        #
+        # @return [String] The combined violation descriptions from all violating elements
+        # @rbs override
+        def short_violation_description
+          return 'not Enumerable' unless @actual.is_a?(Enumerable) # steep:ignore NoMethod
+
+          @actual.filter_map do |element|
+            next unless @expected.satisfied?(element)
+
+            @expected.short_description
+          end.uniq.join(', ')
+        end
+
+        protected
+
+        # Check if the value satisfies none of the expected constraints.
+        #
+        # @return [Boolean] whether no constraints are satisfied
+        # @rbs override
+        def satisfies_constraint?
+          @actual.none? { |element| @expected.satisfied?(element) }
+        end
+
+        # Validate that the expectation is a valid constraint.
+        #
+        # @param expectation [Object] the expectation to validate
+        #
+        # @raise [ArgumentError] if the expectation is not a valid Domainic::Type::Constraint
+        # @return [void]
+        # @rbs override
+        def validate_expectation!(expectation)
+          return if expectation.is_a?(Behavior)
+
+          raise ArgumentError, "expected a Domainic::Type::Constraint, got #{expectation.class}"
+        end
+      end
+    end
+  end
+end

data/lib/domainic/type/constraint/constraints/nor_constraint.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'domainic/type/constraint/behavior'
+
+module Domainic
+  module Type
+    module Constraint
+      # A constraint that ensures none of the provided constraints are satisfied.
+      #
+      # The NorConstraint validates that none of the elements in an enumerable value meet
+      # any of the provided constraints. This enables validation rules like "must not contain
+      # any strings or negative numbers".
+      #
+      # Key features:
+      # - Validates enumerable elements against multiple constraints with NOR logic
+      # - Short-circuits on first satisfying constraint for performance
+      # - Provides clear error messages for violating constraints
+      # - Handles non-enumerable values gracefully
+      # - Supports incremental constraint addition
+      #
+      # @example Validating an array contains no strings or negative numbers
+      #   string_constraint = StringConstraint.new(:self)
+      #   negative_number_constraint = NegativeNumberConstraint.new(:self)
+      #   no_strings_or_negatives = NorConstraint.new(:self, [string_constraint, negative_number_constraint])
+      #
+      #   no_strings_or_negatives.satisfied?([1, 2, 3])            # => true
+      #   no_strings_or_negatives.satisfied?(['a', 1, 'c'])        # => false
+      #   no_strings_or_negatives.satisfied?([1, -2, 3])           # => false
+      #   no_strings_or_negatives.satisfied?(nil)                  # => false (not enumerable)
+      #
+      # @author {https://aaronmallen.me Aaron Allen}
+      # @since 0.1.0
+      class NorConstraint
+        include Behavior #[Array[Behavior[untyped, untyped, untyped]], untyped, {}]
+
+        # Get a description of what the constraint expects.
+        #
+        # @return [String] a description combining all constraint descriptions with 'nor'
+        # @rbs override
+        def short_description
+          descriptions = @expected.map(&:short_description)
+          return descriptions.first if descriptions.size == 1
+
+          *first, last = descriptions
+          "#{first.join(', ')} nor #{last}"
+        end
+
+        # The description of the violations that caused the constraint to be unsatisfied.
+        #
+        # This method provides detailed feedback about which constraints were satisfied,
+        # listing all violations that caused the validation to fail.
+        #
+        # @return [String] The combined violation descriptions from all satisfied constraints
+        # @rbs override
+        def short_violation_description
+          violations = @expected.select { |constraint| constraint.satisfied?(@actual) }
+          descriptions = violations.map(&:short_violation_description)
+          return descriptions.first if descriptions.size == 1
+          return '' if descriptions.empty?
+
+          *first, last = descriptions
+          "#{first.join(', ')} and #{last}"
+        end
+
+        protected
+
+        # Coerce the expectation into an array and append new constraints.
+        #
+        # This enables both initializing with an array of constraints and adding
+        # new constraints incrementally via expecting().
+        #
+        # @param expectation [Behavior] the constraint to add
+        #
+        # @return [Array<Behavior>] the updated array of constraints
+        # @rbs (untyped expectation) -> Array[Behavior[untyped, untyped, untyped]]
+        def coerce_expectation(expectation)
+          expectation.is_a?(Array) ? (@expected || []).concat(expectation) : (@expected || []) << expectation
+        end
+
+        # Check if none of the values satisfy any of the expected constraints.
+        #
+        # Short-circuits on the first satisfying constraint for efficiency.
+        #
+        # @return [Boolean] whether none of the constraints are satisfied
+        # @rbs override
+        def satisfies_constraint?
+          @expected.none? { |constraint| constraint.satisfied?(@actual) }
+        end
+
+        # Validate that the expectation is an array of valid constraints.
+        #
+        # @param expectation [Object] the expectation to validate
+        #
+        # @raise [ArgumentError] if the expectation is not a valid Domainic::Type::Constraint
+        # @return [void]
+        # @rbs override
+        def validate_expectation!(expectation)
+          return if expectation.is_a?(Array) && expectation.all?(Behavior)
+
+          raise ArgumentError, 'Expectation must be a Domainic::Type::Constraint'
+        end
+      end
+    end
+  end
+end

data/lib/domainic/type/constraint/constraints/not_constraint.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'domainic/type/constraint/behavior'
+
+module Domainic
+  module Type
+    module Constraint
+      # A constraint that negates another constraint's validation logic.
+      #
+      # The NotConstraint inverts the validation result of its inner constraint,
+      # allowing for negative validation rules. This enables expressing conditions
+      # like "not equal to", "not included in", etc.
+      #
+      # Key features:
+      # - Inverts any constraint's validation logic
+      # - Maintains clear error messages with proper negation
+      # - Can be composed with other logical constraints
+      # - Preserves the original constraint's type safety
+      #
+      # @example Validating a value is not a specific type
+      #   string_constraint = StringConstraint.new(:self)
+      #   not_string = NotConstraint.new(:self, string_constraint)
+      #
+      #   not_string.satisfied?(123)     # => true
+      #   not_string.satisfied?("test")  # => false
+      #
+      # @author {https://aaronmallen.me Aaron Allen}
+      # @since 0.1.0
+      class NotConstraint
+        include Behavior #[Behavior[untyped, untyped, untyped], {}, {}]
+
+        # Get a description of what the constraint expects.
+        #
+        # @return [String] the negated constraint description
+        # @rbs override
+        def short_description
+          "not #{@expected.short_description}"
+        end
+
+        # The description of the violations that caused the constraint to be unsatisfied.
+        #
+        # This is used to help compose a error message when the constraint is not satisfied.
+        # Implementing classes can override this to provide more specific failure messages.
+        #
+        # @return [String] The description of the constraint when it fails.
+        # @rbs override
+        def short_violation_description
+          @expected.short_description
+        end
+
+        protected
+
+        # Check if the value does not satisfy the expected constraint.
+        #
+        # @return [Boolean] whether the constraint is satisfied
+        # @rbs override
+        def satisfies_constraint?
+          !@expected.satisfied?(@actual)
+        end
+
+        # Validate that the expectation is a valid constraint.
+        #
+        # @param expectation [Object] the expectation to validate
+        #
+        # @raise [ArgumentError] if the expectation is not a valid constraint
+        # @return [void]
+        # @rbs override
+        def validate_expectation!(expectation)
+          return if expectation.is_a?(Behavior)
+
+          raise ArgumentError, "expected a Domainic::Type::Constraint, got #{expectation.class}"
+        end
+      end
+    end
+  end
+end

data/lib/domainic/type/constraint/constraints/or_constraint.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'domainic/type/constraint/behavior'
+
+module Domainic
+  module Type
+    module Constraint
+      # A constraint that combines multiple constraints with logical OR behavior.
+      #
+      # The OrConstraint validates that a value satisfies at least one of its provided constraints,
+      # implementing logical OR behavior. This enables validation rules like "must be either a
+      # string or a symbol" or "must be nil or a positive number".
+      #
+      # Key features:
+      # - Combines multiple constraints with OR logic
+      # - Short-circuits on first passing constraint
+      # - Provides clear error messages listing all failed attempts
+      # - Supports incremental constraint addition
+      #
+      # @example Validating a value is either a String or Symbol
+      #   string_constraint = StringConstraint.new(:self)
+      #   symbol_constraint = SymbolConstraint.new(:self)
+      #   string_or_symbol = OrConstraint.new(:self, [string_constraint, symbol_constraint])
+      #
+      #   string_or_symbol.satisfied?("test")  # => true
+      #   string_or_symbol.satisfied?(:test)   # => true
+      #   string_or_symbol.satisfied?(123)     # => false
+      #
+      # @author {https://aaronmallen.me Aaron Allen}
+      # @since 0.1.0
+      class OrConstraint
+        include Behavior #[Array[Behavior[untyped, untyped, untyped]], untyped, {}]
+
+        # Get a description of what the constraint expects.
+        #
+        # @return [String] a description combining all constraint descriptions with 'or'
+        # @rbs override
+        def short_description
+          descriptions = @expected.map(&:short_description)
+          return descriptions.first if descriptions.size == 1
+
+          *first, last = descriptions
+          "#{first.join(', ')} or #{last}"
+        end
+
+        # @rbs! def expecting: (Behavior[untyped, untyped, untyped]) -> self
+
+        # The description of the violations that caused the constraint to be unsatisfied.
+        #
+        # This method provides detailed feedback when no constraints are satisfied,
+        # listing all the ways in which the value failed validation. Uses 'and' in the
+        # message because all constraints failed (e.g., "was not a string AND was not a
+        # symbol" rather than "was not a string OR was not a symbol").
+        #
+        # @return [String] The combined violation descriptions from all constraints
+        # @rbs override
+        def short_violation_description
+          violations = @expected.reject { |constraint| constraint.satisfied?(@actual) }
+          descriptions = violations.map(&:short_violation_description)
+          return descriptions.first if descriptions.size == 1
+
+          *first, last = descriptions
+          "#{first.join(', ')} and #{last}"
+        end
+
+        protected
+
+        # Coerce the expectation into an array and append new constraints.
+        #
+        # This enables both initializing with an array of constraints and adding
+        # new constraints incrementally via expecting().
+        #
+        # @param expectation [Behavior] the constraint to add
+        #
+        # @return [Array<Behavior>] the updated array of constraints
+        # @rbs (untyped expectation) -> Array[Behavior[untyped, untyped, untyped]]
+        def coerce_expectation(expectation)
+          expectation.is_a?(Array) ? (@expected || []).concat(expectation) : (@expected || []) << expectation
+        end
+
+        # Check if the value satisfies any of the expected constraints.
+        #
+        # Short-circuits on the first satisfied constraint for efficiency.
+        #
+        # @return [Boolean] whether any constraint is satisfied
+        # @rbs override
+        def satisfies_constraint?
+          @expected.any? { |constraint| constraint.satisfied?(@actual) }
+        end
+
+        # Validate that the expectation is an array of valid constraints.
+        #
+        # @param expectation [Object] the expectation to validate
+        #
+        # @raise [ArgumentError] if the expectation is not valid
+        # @return [void]
+        # @rbs override
+        def validate_expectation!(expectation)
+          return if expectation.is_a?(Array) && expectation.all?(Behavior)
+
+          raise ArgumentError, 'Expectation must be a Domainic::Type::Constraint'
+        end
+      end
+    end
+  end
+end

data/lib/domainic/type/constraint/constraints/ordering_constraint.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'domainic/type/constraint/behavior'
+
+module Domainic
+  module Type
+    module Constraint
+      # A constraint for validating that collection elements are in sorted order.
+      #
+      # This constraint ensures that elements in a collection are in ascending order
+      # by comparing the collection to its sorted version. The constraint works with
+      # any collection whose elements implement the Comparable module and respond to
+      # the <=> operator.
+      #
+      # @example Basic ordering validation
+      #   constraint = OrderingConstraint.new(:self)
+      #   constraint.satisfied?([1, 2, 3])     # => true
+      #   constraint.satisfied?([1, 3, 2])     # => false
+      #
+      # @example With string elements
+      #   constraint = OrderingConstraint.new(:self)
+      #   constraint.satisfied?(['a', 'b', 'c']) # => true
+      #   constraint.satisfied?(['c', 'a', 'b']) # => false
+      #
+      # @example With mixed types that can be compared
+      #   constraint = OrderingConstraint.new(:self)
+      #   constraint.satisfied?([1, 1.5, 2])     # => true
+      #   constraint.satisfied?([2, 1, 1.5])     # => false
+      #
+      # @author {https://aaronmallen.me Aaron Allen}
+      # @since 0.1.0
+      class OrderingConstraint
+        include Behavior #[nil, untyped, {}]
+
+        # Get a human-readable description of the ordering requirement.
+        #
+        # @example
+        #   constraint = OrderingConstraint.new(:self)
+        #   constraint.description # => "ordered"
+        #
+        # @return [String] A description of the ordering requirement
+        # @rbs override
+        def short_description
+          'ordered'
+        end
+
+        # Get a human-readable description of why ordering validation failed.
+        #
+        # @example
+        #   constraint = OrderingConstraint.new(:self)
+        #   constraint.satisfied?([3, 1, 2])
+        #   constraint.short_violation_description # => "not ordered"
+        #
+        # @return [String] A description of the ordering failure
+        # @rbs override
+        def short_violation_description
+          'not ordered'
+        end
+
+        protected
+
+        # Check if the collection elements are in sorted order.
+        #
+        # Compares the collection to its sorted version to determine if the
+        # elements are already in ascending order.
+        #
+        # @return [Boolean] true if the elements are in sorted order
+        # @rbs override
+        def satisfies_constraint?
+          @actual.sort == @actual
+        end
+      end
+    end
+  end
+end