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

data/sig/domainic/type/constraint/constraints/emptiness_constraint.rbs

@@ -0,0 +1,54 @@
+module Domainic
+  module Type
+    module Constraint
+      # A constraint for validating that a collection is empty.
+      #
+      # This constraint ensures that an enumerable collection contains no elements
+      # by checking the collection's #empty? method. It works with any object that
+      # includes the Enumerable module and responds to #empty?.
+      #
+      # @example Basic emptiness validation
+      #   constraint = EmptinessConstraint.new(:self)
+      #   constraint.satisfied?([])        # => true
+      #   constraint.satisfied?([1, 2, 3]) # => false
+      #
+      # @example With different collection types
+      #   constraint = EmptinessConstraint.new(:self)
+      #   constraint.satisfied?(Set.new)    # => true
+      #   constraint.satisfied?(['a', 'b']) # => false
+      #
+      # @author {https://aaronmallen.me Aaron Allen}
+      # @since 0.1.0
+      class EmptinessConstraint
+        include Behavior[nil, untyped, { }]
+
+        # Get a human-readable description of the emptiness requirement.
+        #
+        # @example
+        #   constraint = EmptinessConstraint.new(:self)
+        #   constraint.description # => "empty"
+        #
+        # @return [String] A description of the emptiness requirement
+        def short_description: ...
+
+        # Get a human-readable description of why emptiness validation failed.
+        #
+        # @example
+        #   constraint = EmptinessConstraint.new(:self)
+        #   constraint.satisfied?([1, 2, 3])
+        #   constraint.short_violation_description # => "not empty"
+        #
+        # @return [String] A description of the emptiness failure
+        def short_violation_description: ...
+
+        # Check if the collection is empty.
+        #
+        # Uses the collection's #empty? method to determine if it contains
+        # any elements.
+        #
+        # @return [Boolean] true if the collection is empty
+        def satisfies_constraint?: ...
+      end
+    end
+  end
+end

data/sig/domainic/type/constraint/constraints/equality_constraint.rbs

@@ -0,0 +1,60 @@
+module Domainic
+  module Type
+    module Constraint
+      # A constraint for validating that values are equal to an expected value.
+      #
+      # This constraint uses Ruby's standard equality operator (==) to compare values,
+      # allowing for type-specific equality definitions while maintaining consistent
+      # behavior across different value types.
+      #
+      # @example Basic equality validation
+      #   constraint = EqualityConstraint.new(:self, 42)
+      #   constraint.satisfied?(42)    # => true
+      #   constraint.satisfied?(41)    # => false
+      #
+      # @example Complex object comparison
+      #   point = Struct.new(:x, :y).new(1, 2)
+      #   constraint = EqualityConstraint.new(:self, point)
+      #   constraint.satisfied?(Struct.new(:x, :y).new(1, 2)) # => true
+      #   constraint.satisfied?(Struct.new(:x, :y).new(2, 1)) # => false
+      #
+      # @example Array comparison
+      #   constraint = EqualityConstraint.new(:self, [1, 2, 3])
+      #   constraint.satisfied?([1, 2, 3]) # => true
+      #   constraint.satisfied?([3, 2, 1]) # => false
+      #
+      # @author {https://aaronmallen.me Aaron Allen}
+      # @since 0.1.0
+      class EqualityConstraint
+        include Behavior[untyped, untyped, { }]
+
+        # Get a human-readable description of the equality requirement.
+        #
+        # @example
+        #   constraint = EqualityConstraint.new(:self, 42)
+        #   constraint.description # => "equal to 42"
+        #
+        # @return [String] A description of the expected value
+        def short_description: ...
+
+        # Get a human-readable description of why equality validation failed.
+        #
+        # @example
+        #   constraint = EqualityConstraint.new(:self, 42)
+        #   constraint.satisfied?(41)
+        #   constraint.short_violation_description # => "not equal to 42"
+        #
+        # @return [String] A description of the equality failure
+        def short_violation_description: ...
+
+        # Check if the actual value equals the expected value.
+        #
+        # Uses Ruby's standard equality operator (==) for comparison, allowing
+        # objects to define their own equality behavior.
+        #
+        # @return [Boolean] true if the values are equal
+        def satisfies_constraint?: ...
+      end
+    end
+  end
+end

data/sig/domainic/type/constraint/constraints/finiteness_constraint.rbs

@@ -0,0 +1,82 @@
+module Domainic
+  module Type
+    module Constraint
+      # A constraint for validating that numeric values are finite or infinite.
+      #
+      # This constraint verifies whether a numeric value is finite or infinite by calling
+      # Ruby's standard finite?/infinite? methods. It's useful for ensuring numbers remain
+      # within computable bounds and handling edge cases in numerical computations.
+      #
+      # @example Basic finiteness check
+      #   constraint = FinitenessConstraint.new(:self).expecting(:finite)
+      #   constraint.satisfied?(42)      # => true
+      #   constraint.satisfied?(Float::INFINITY)  # => false
+      #
+      # @example Checking for infinity
+      #   constraint = FinitenessConstraint.new(:self).expecting(:infinite)
+      #   constraint.satisfied?(Float::INFINITY)  # => true
+      #   constraint.satisfied?(42)      # => false
+      #
+      # @author {https://aaronmallen.me Aaron Allen}
+      # @since 0.1.0
+      class FinitenessConstraint
+        type expected = :finite | :finite? | :infinite | :infinite?
+
+        include Behavior[expected, Numeric, { }]
+
+        # Get a human-readable description of the finiteness requirement.
+        #
+        # @return [String] Description of the finiteness requirement
+        def short_description: ...
+
+        # Get a human-readable description of why finiteness validation failed.
+        #
+        # @return [String] Description of the validation failure
+        def short_violation_description: ...
+
+        # Coerce the expectation into the correct method name format.
+        #
+        # Ensures the expectation ends with a question mark to match Ruby's
+        # standard method naming for predicate methods.
+        #
+        # @param expectation [Symbol, String] The finiteness check to perform
+        #
+        # @return [Symbol] The coerced method name
+        def coerce_expectation: ...
+
+        # Check if the value satisfies the finiteness constraint.
+        #
+        # @return [Boolean] true if the value matches the finiteness requirement
+        def satisfies_constraint?: ...
+
+        # Validate that the expectation is a valid finiteness check.
+        #
+        # @param expectation [Object] The value to validate
+        #
+        # @raise [ArgumentError] if the expectation is not :finite, :finite?, :infinite, or :infinite?
+        # @return [void]
+        def validate_expectation!: ...
+
+        private
+
+        # Interpret the result from Ruby's finite?/infinite? methods.
+        #
+        # Handles the different return values from Ruby's finiteness checking methods:
+        # - finite? returns true/false
+        # - infinite? returns nil (for finite numbers), 1 (for +∞), or -1 (for -∞)
+        #
+        # @example
+        #   interpret_result(true)   # => true
+        #   interpret_result(false)  # => false
+        #   interpret_result(nil)    # => false
+        #   interpret_result(1)      # => true
+        #   interpret_result(-1)     # => true
+        #
+        # @param result [Boolean, Integer, nil] The result from finite? or infinite?
+        #
+        # @return [Boolean] true if the result indicates the desired finiteness state
+        def interpret_result: ((bool | Numeric)? result) -> bool
+      end
+    end
+  end
+end

data/sig/domainic/type/constraint/constraints/inclusion_constraint.rbs

@@ -0,0 +1,59 @@
+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
+        def short_description: ...
+
+        # 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
+        def short_violation_description: ...
+
+        # 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
+        def satisfies_constraint?: ...
+      end
+    end
+  end
+end

data/sig/domainic/type/constraint/constraints/match_pattern_constraint.rbs

@@ -0,0 +1,66 @@
+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
+        def short_description: ...
+
+        # 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
+        def short_violation_description: ...
+
+        # Coerce string patterns into Regexp objects.
+        #
+        # @param expectation [String, Regexp] The pattern to coerce
+        #
+        # @return [Regexp] The coerced pattern
+        def coerce_expectation: ...
+
+        # Check if the value matches the expected pattern.
+        #
+        # @return [Boolean] true if the value matches the pattern
+        def satisfies_constraint?: ...
+
+        # 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]
+        def validate_expectation!: ...
+      end
+    end
+  end
+end

data/sig/domainic/type/constraint/constraints/method_presence_constraint.rbs

@@ -0,0 +1,51 @@
+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
+        def short_description: ...
+
+        # Get a short description of why the constraint was violated
+        #
+        # @return [String] description of the missing method
+        def short_violation_description: ...
+
+        # Coerce the expectation into a symbol
+        #
+        # @param expectation [Symbol] the method name to check
+        #
+        # @return [Symbol] coerced method name
+        def coerce_expectation: ...
+
+        # Check if the actual value satisfies the constraint
+        #
+        # @return [Boolean] true if the object responds to the expected method
+        def satisfies_constraint?: ...
+
+        # 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]
+        def validate_expectation!: ...
+      end
+    end
+  end
+end

data/sig/domainic/type/constraint/constraints/none_constraint.rbs

@@ -0,0 +1,57 @@
+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
+        def short_description: ...
+
+        # 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
+        def short_violation_description: ...
+
+        # Check if the value satisfies none of the expected constraints.
+        #
+        # @return [Boolean] whether no constraints are satisfied
+        def satisfies_constraint?: ...
+
+        # 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]
+        def validate_expectation!: ...
+      end
+    end
+  end
+end

data/sig/domainic/type/constraint/constraints/nor_constraint.rbs

@@ -0,0 +1,72 @@
+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'
+        def short_description: ...
+
+        # 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
+        def short_violation_description: ...
+
+        # 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
+        def coerce_expectation: (untyped expectation) -> Array[Behavior[untyped, untyped, untyped]]
+
+        # 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
+        def satisfies_constraint?: ...
+
+        # 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]
+        def validate_expectation!: ...
+      end
+    end
+  end
+end

data/sig/domainic/type/constraint/constraints/not_constraint.rbs

@@ -0,0 +1,56 @@
+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
+        def short_description: ...
+
+        # 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.
+        def short_violation_description: ...
+
+        # Check if the value does not satisfy the expected constraint.
+        #
+        # @return [Boolean] whether the constraint is satisfied
+        def satisfies_constraint?: ...
+
+        # 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]
+        def validate_expectation!: ...
+      end
+    end
+  end
+end

data/sig/domainic/type/constraint/constraints/or_constraint.rbs

@@ -0,0 +1,74 @@
+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'
+        def short_description: ...
+
+        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
+        def short_violation_description: ...
+
+        # 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
+        def coerce_expectation: (untyped expectation) -> Array[Behavior[untyped, untyped, untyped]]
+
+        # 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
+        def satisfies_constraint?: ...
+
+        # 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]
+        def validate_expectation!: ...
+      end
+    end
+  end
+end