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

data/sig/domainic/type/constraint/set.rbs

@@ -0,0 +1,159 @@
+module Domainic
+  module Type
+    module Constraint
+      # A class managing collections of type constraints.
+      #
+      # The Set class provides a structured way to manage multiple constraints,
+      # organizing them by their accessor method and constraint name. It handles
+      # the creation, storage, and retrieval of constraints while maintaining
+      # their relationships and configuration.
+      #
+      # Key features:
+      # - Organized storage by accessor and constraint name
+      # - Dynamic constraint resolution and creation
+      # - Flexible constraint lookup and enumeration
+      # - Support for both symbol and string identifiers
+      #
+      # @example Creating and managing constraints
+      #   set = Set.new
+      #   set.add(:self, :string, 'being a')
+      #   set.add(:length, :range, 'having length', minimum: 5)
+      #
+      #   set.constraint?(:self, 'being a')  # => true
+      #   set.constraints  # => [StringConstraint, RangeConstraint]
+      #   set.count       # => 2
+      #
+      # @author {https://aaronmallen.me Aaron Allen}
+      # @since 0.1.0
+      class Set
+        extend Forwardable
+
+        @lookup: Hash[Type::accessor, Hash[Symbol, Behavior]]
+
+        # Initialize a new empty constraint set.
+        #
+        # @return [void]
+        def initialize: () -> void
+
+        # Add a new constraint to the set.
+        #
+        # Creates and configures a new constraint instance based on the provided type
+        # and configuration. If a constraint with the same accessor and name already
+        # exists, it will be replaced.
+        #
+        # @param accessor [String, Symbol] The accessor method for the constraint
+        # @param constraint_type [String, Symbol] The type of constraint to create
+        # @param expectation [Object, nil] The expected value for the constraint
+        # @param options [Hash{Symbol, String => Object}] Additional options for the constraint
+        #
+        # @option options [String, Symbol] concerning The subject of the constraint.  This is used to namespace
+        #   constraints that may have compatibility issues with other constraints (i,e, min/max size constraints).
+        # @option options [String, Symbol, nil] description The quantifier description of the constraint when given
+        #   a string that ends with "not_described" it will not be included in the constraint set description.
+        # @option options [Boolean] :abort_on_failure Whether to stop on failure
+        # @option options [Array<Proc>, Proc] :coerce_with Coercers to run on the value before validating the
+        #   constraint.
+        #
+        # @return [void]
+        def add: (Type::accessor accessor, String | Symbol constraint_type, ?untyped expectation, **untyped options) -> void
+
+        # Get all constraints in the set.
+        #
+        # @return [Array<Behavior>] Array of all constraints
+        def all: () -> Array[Behavior]
+
+        # @yield [Behavior] The constraint to check
+        # @return [Boolean] true if all constraints match.
+        def all?: () -> bool
+                | (Class | Module) -> bool
+                | () { (Behavior) -> boolish } -> bool
+
+        # Get the total number of constraints.
+        #
+        # @return [Integer] The number of constraints
+        def count: () -> Integer
+
+        alias length count
+
+        alias size count
+
+        # The aggregate description of all constraints in the set.
+        #
+        # @return [String] The description of all constraints
+        def description: () -> String
+
+        # @yield [Behavior] The constraint to process
+        # @return [void]
+        def each: () { (Behavior) -> void } -> void
+
+        # Check if a specific constraint exists.
+        #
+        # @param accessor [Symbol] The accessor method for the constraint
+        # @param concerning [String, Symbol] The subject of the constraint.
+        #
+        # @return [Boolean] true if the constraint exists
+        def exist?: (Type::accessor accessor, Symbol | String concerning) -> bool
+
+        alias has_constraint? exist?
+
+        # Whether any constraints in the set have failed satisfaction.
+        #
+        # @return [Boolean] true if any constraints have failed
+        def failures?: () -> bool
+
+        # @yield [Behavior] The constraint to process
+        # @return [Array] The results of the block.
+        def filter_map: () { (Behavior) -> untyped } -> Array[Behavior]
+
+        # Get a specific constraint by its accessor and name.
+        #
+        # @param accessor [Symbol] The accessor method for the constraint
+        # @param concerning [String, Symbol] The subject of the constraint.
+        #
+        # @return [Behavior, nil] The constraint if found, nil otherwise
+        def find: (Type::accessor accessor, String | Symbol concerning) -> Behavior?
+
+        # Prepare a new constraint.
+        #
+        # This is useful for preparing a constraint to use as a sub-constraint for a more complex constraint.
+        #
+        # @param accessor [String, Symbol] The accessor method for the constraint
+        # @param constraint_type [String, Symbol] The type of constraint to create
+        # @param expectation [Object, nil] The expected value for the constraint
+        # @param options [Hash{Symbol, String => Object}] Additional options for the constraint
+        #
+        # @option options [String, Symbol, nil] description The quantifier description of the constraint when given
+        #   a string that ends with "not_described" it will not be included in the constraint set description.
+        # @option options [Boolean] :abort_on_failure Whether to stop on failure
+        # @option options [Array<Proc>, Proc] :coerce_with Coercers to run on the value before validating the
+        #   constraint.
+        #
+        # @return [Behavior] The new constraint instance
+        def prepare: (Type::accessor accessor, String | Symbol constraint_type, ?untyped expectation, **untyped options) -> Behavior
+
+        # The aggregate violation description of all constraints in the set.
+        #
+        # @return [String] The description of all constraints
+        def violation_description: () -> String
+
+        private
+
+        # Build a new constraint instance for the given type.
+        #
+        # @param constraint_type [String, Symbol] The type of constraint to create
+        # @param accessor [String, Symbol] The accessor method for the constraint
+        # @param quantifier_description [String, Symbol] The quantifier description of the constraint
+        #
+        # @return [Behavior] The new constraint instance
+        def build_constraint: (String | Symbol constraint_type, Type::accessor accessor, (String | Symbol)?) -> Behavior
+
+        # Ensure that the lookup hash is deep copied when duplicating.
+        #
+        # @param source [Set] The source object to copy
+        #
+        # @return [void]
+        def initialize_copy: ...
+      end
+    end
+  end
+end

data/sig/domainic/type/definitions.rbs

@@ -0,0 +1,304 @@
+module Domainic
+  module Type
+    # A module providing convenient factory methods for creating type instances.
+    #
+    # This module serves as a temporary access point for type creation in the Domainic::Type
+    # system, offering a collection of factory methods with consistent naming patterns.
+    # Each method creates and configures a specific type instance, with optional nilable
+    # variants and aliases for common use cases.
+    #
+    # @note This module is considered temporary and may be significantly altered or removed
+    #   before the final release. It should not be considered part of the stable API.
+    #
+    # @example Basic type creation
+    #   include Domainic::Type::Definitions
+    #
+    #   string_type = _String()
+    #   array_type = _Array()
+    #   hash_type = _Hash()
+    #
+    # @example Creating nilable types
+    #   nullable_string = _String?()
+    #   nullable_array = _Array?()
+    #
+    # @example Using union types
+    #   string_or_symbol = _Union(String, Symbol)
+    #   boolean = _Boolean()  # Union of TrueClass and FalseClass
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    module Definitions
+      # Creates an AnythingType instance.
+      #
+      # @example
+      #   type = _Anything
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::AnythingType] the created type
+      def _Anything: (**__todo__ options) -> AnythingType
+
+      alias _Any _Anything
+
+      # Creates an ArrayType instance.
+      #
+      # @example
+      #   type = _Array
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::ArrayType] the created type
+      def _Array: (**__todo__ options) -> ArrayType
+
+      alias _List _Array
+
+      # Creates a nilable ArrayType instance.
+      #
+      # @example
+      #   type = _Array?
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (Array or NilClass)
+      def _Array?: (**__todo__ options) -> UnionType
+
+      alias _List? _Array?
+
+      # Creates a Boolean type.
+      #
+      # Represents a union of TrueClass and FalseClass.
+      #
+      # @example
+      #   type = _Boolean
+      #
+      # @return [Domainic::Type::UnionType] the created type
+      def _Boolean: () -> UnionType
+
+      alias _Bool _Boolean
+
+      # Creates a nilable Boolean type.
+      #
+      # @example
+      #   type = _Boolean?
+      #
+      # @return [Domainic::Type::UnionType] the created type (TrueClass, FalseClass, or NilClass)
+      def _Boolean?: () -> UnionType
+
+      alias _Bool? _Boolean?
+
+      # Creates a DuckType instance.
+      #
+      # DuckType allows specifying behavior based on method availability.
+      #
+      # @example
+      #   type = _Duck(respond_to: :to_s)
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::DuckType] the created type
+      def _Duck: (**__todo__ options) -> DuckType
+
+      alias _Interface _Duck
+
+      alias _Protocol _Duck
+
+      alias _RespondingTo _Duck
+
+      # Creates an EnumType instance.
+      #
+      # EnumType restricts values to a specific set of literals.
+      #
+      # @example
+      #   type = _Enum(:red, :green, :blue)
+      #
+      # @param literals [Array<Object>] the allowed literals
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::EnumType] the created type
+      def _Enum: (*untyped literals, **__todo__ options) -> EnumType
+
+      alias _Literal _Enum
+
+      # Creates a nilable EnumType instance.
+      #
+      # @example
+      #   type = _Enum?(:red, :green, :blue)
+      #
+      # @param literals [Array<Object>] the allowed literals
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (Enum or NilClass)
+      def _Enum?: (*untyped literals, **__todo__ options) -> UnionType
+
+      alias _Literal? _Enum?
+
+      # Creates a FloatType instance.
+      #
+      # @example
+      #   type = _Float
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::FloatType] the created type
+      def _Float: (**__todo__ options) -> FloatType
+
+      alias _Decimal _Float
+
+      alias _Real _Float
+
+      # Creates a nilable FloatType instance.
+      #
+      # @example
+      #   type = _Float?
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (Float or NilClass)
+      def _Float?: (**__todo__ options) -> UnionType
+
+      alias _Decimal? _Float?
+
+      alias _Real? _Float?
+
+      # Creates a HashType instance.
+      #
+      # @example
+      #   type = _Hash
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::HashType] the created type
+      def _Hash: (**__todo__ options) -> HashType
+
+      alias _Map _Hash
+
+      # Creates a nilable HashType instance.
+      #
+      # @example
+      #   type = _Hash?
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (Hash or NilClass)
+      def _Hash?: (**__todo__ options) -> UnionType
+
+      alias _Map? _Hash?
+
+      # Creates an IntegerType instance.
+      #
+      # @example
+      #   type = _Integer
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::IntegerType] the created type
+      def _Integer: (**__todo__ options) -> IntegerType
+
+      alias _Int _Integer
+
+      alias _Number _Integer
+
+      # Creates a nilable IntegerType instance.
+      #
+      # @example
+      #   type = _Integer?
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (Integer or NilClass)
+      def _Integer?: (**__todo__ options) -> UnionType
+
+      alias _Int? _Integer?
+
+      alias _Number? _Integer?
+
+      # Creates a Nilable (nullable) type.
+      #
+      # Combines one or more types with `NilClass` to allow nil values.
+      #
+      # @example
+      #   type = _Nilable(String, Symbol)
+      #
+      # @param types [Array<Class, Module, Behavior>] the base types
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (NilClass or other specified types)
+      def _Nilable: (*Class | Module | Behavior[untyped, untyped, untyped] types, **__todo__ options) -> UnionType
+
+      alias _Nullable _Nilable
+
+      # Creates a StringType instance.
+      #
+      # @example
+      #   type = _String
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::StringType] the created type
+      def _String: (**__todo__ options) -> StringType
+
+      alias _Text _String
+
+      # Creates a nilable StringType instance.
+      #
+      # @example
+      #   type = _String?
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (String or NilClass)
+      def _String?: (**__todo__ options) -> UnionType
+
+      alias _Text? _String?
+
+      # Creates a SymbolType instance.
+      #
+      # @example
+      #   type = _Symbol
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::SymbolType] the created type
+      def _Symbol: (**__todo__ options) -> SymbolType
+
+      alias _Interned _Symbol
+
+      # Creates a nilable SymbolType instance.
+      #
+      # @example
+      #   type = _Symbol?
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (Symbol or NilClass)
+      def _Symbol?: (**__todo__ options) -> UnionType
+
+      alias _Interned? _Symbol?
+
+      # Creates a UnionType instance.
+      #
+      # Allows combining multiple types into a single union type.
+      #
+      # @example
+      #   type = _Union(String, Symbol)
+      #
+      # @param types [Array<Class, Module, Behavior>] the types included in the union
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type
+      def _Union: (*Class | Module | Behavior[untyped, untyped, untyped] types, **__todo__ options) -> UnionType
+
+      alias _Either _Union
+
+      # Creates a VoidType instance.
+      #
+      # Represents an operation that returns no value.
+      #
+      # @example
+      #   type = _Void
+      #
+      # @return [Domainic::Type::VoidType] the created type
+      def _Void: () -> VoidType
+    end
+  end
+end

data/sig/domainic/type/types/core/array_type.rbs

@@ -0,0 +1,42 @@
+module Domainic
+  module Type
+    # A type for validating Array objects with flexible element and size constraints
+    #
+    # This class provides a comprehensive set of validations specifically designed for Array
+    # objects, including element type checking, value inclusion/exclusion, ordering, and all
+    # standard enumerable validations.
+    #
+    # Key features:
+    # - Element type validation
+    # - Element presence/absence validation
+    # - Uniqueness constraints
+    # - Order constraints
+    # - Size constraints (via EnumerableBehavior)
+    # - Standard collection validations (via EnumerableBehavior)
+    #
+    # @example Basic usage
+    #   type = ArrayType.new
+    #   type.of(String)                # enforce element type
+    #   type.containing(1, 2)          # require specific elements
+    #   type.having_size(3)            # exact size constraint
+    #   type.being_distinct            # unique elements
+    #
+    # @example Complex constraints
+    #   type = ArrayType.new
+    #   type
+    #     .of(Integer)                 # type constraints
+    #     .being_ordered               # must be sorted
+    #     .having_size_between(2, 5)   # size range
+    #     .starting_with(1)            # first element
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    class ArrayType
+      extend Behavior::ClassMethods
+
+      include Behavior
+
+      include Behavior::EnumerableBehavior
+    end
+  end
+end

data/sig/domainic/type/types/core/float_type.rbs

@@ -0,0 +1,33 @@
+module Domainic
+  module Type
+    # A type for validating Float objects with extensive numeric validation capabilities.
+    #
+    # This class provides a comprehensive set of validations specifically designed for
+    # floating-point values, including basic type checking and all numeric validations
+    # like finiteness, polarity, and range constraints. It properly handles floating-point
+    # arithmetic by using appropriate tolerances in comparisons.
+    #
+    # @example Basic usage
+    #   type = FloatType.new
+    #   type.validate(3.14)   # => true
+    #   type.validate(42)     # => false
+    #   type.validate("3.14") # => false
+    #
+    # @example With numeric constraints
+    #   type = FloatType.new
+    #   type
+    #     .being_positive
+    #     .being_finite
+    #     .being_less_than(10.0)
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    class FloatType
+      extend Behavior::ClassMethods
+
+      include Behavior
+
+      include Behavior::NumericBehavior
+    end
+  end
+end

data/sig/domainic/type/types/core/hash_type.rbs

@@ -0,0 +1,107 @@
+module Domainic
+  module Type
+    # A type for validating Hash objects with flexible key and value constraints
+    #
+    # This class provides a comprehensive set of validations specifically designed
+    # for Hash objects, including key/value type checking, inclusion/exclusion of
+    # specific keys or values, and all standard enumerable validations.
+    #
+    # Key features:
+    # - Key type validation
+    # - Value type validation
+    # - Key presence/absence checking
+    # - Value presence/absence checking
+    # - Size constraints (via EnumerableBehavior)
+    # - Standard collection validations (via EnumerableBehavior)
+    #
+    # @example Basic usage
+    #   type = HashType.new
+    #   type.of(String => Integer)          # enforce key/value types
+    #   type.containing_keys('a', 'b')      # require specific keys
+    #   type.containing_values(1, 2)        # require specific values
+    #   type.having_size(2)                 # exact size constraint
+    #
+    # @example Complex constraints
+    #   type = HashType.new
+    #   type
+    #     .of(Symbol => String)             # type constraints
+    #     .containing_keys(:name, :email)   # required keys
+    #     .excluding_values(nil, '')        # no empty values
+    #     .having_size_between(2, 5)        # size range
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    class HashType
+      extend Behavior::ClassMethods
+
+      include Behavior
+
+      include Behavior::EnumerableBehavior
+
+      # Validate that the hash contains specific keys
+      #
+      # @example
+      #   type.containing_keys(:name, :email)
+      #   type.validate({ name: 'John', email: 'john@example.com' })  # => true
+      #   type.validate({ name: 'John' })                            # => false
+      #
+      # @param keys [Array<Object>] the keys that must be present
+      # @return [self] self for method chaining
+      def containing_keys: (*untyped keys) -> self
+
+      alias including_keys containing_keys
+
+      # Validate that the hash contains specific values
+      #
+      # @example
+      #   type.containing_values('active', 'pending')
+      #   type.validate({ status: 'active' })   # => true
+      #   type.validate({ status: 'inactive' }) # => false
+      #
+      # @param values [Array<Object>] the values that must be present
+      # @return [self] self for method chaining
+      def containing_values: (*untyped values) -> self
+
+      alias including_values containing_values
+
+      # Validate that the hash does not contain specific keys
+      #
+      # @example
+      #   type.excluding_keys(:admin, :superuser)
+      #   type.validate({ user: 'John' })           # => true
+      #   type.validate({ admin: true })            # => false
+      #
+      # @param keys [Array<Object>] the keys that must not be present
+      # @return [self] self for method chaining
+      def excluding_keys: (*untyped keys) -> self
+
+      alias omitting_keys excluding_keys
+
+      # Validate that the hash does not contain specific values
+      #
+      # @example
+      #   type.excluding_values(nil, '')
+      #   type.validate({ name: 'John' })   # => true
+      #   type.validate({ name: nil })      # => false
+      #
+      # @param values [Array<Object>] the values that must not be present
+      # @return [self] self for method chaining
+      def excluding_values: (*untyped values) -> self
+
+      alias omitting_values excluding_values
+
+      # Validate the hash to have the given key type and value type.
+      #
+      # @example
+      #   type.of(String => Integer)
+      #   type.validate({ 'a' => 1 })   # => true
+      #   type.validate({ 1 => 'a' })   # => false
+      #
+      # @param key_to_value_type [Hash{Object => Object}] the key type and value type that the hash must have
+      #
+      # @raise [ArgumentError] if the key_to_value_type pair is not a Hash or does not have exactly one entry
+      # @return [self] self for method chaining
+      def of: (Hash[untyped, untyped] key_to_value_type) -> self
+    end
+  end
+end

data/sig/domainic/type/types/core/integer_type.rbs

@@ -0,0 +1,32 @@
+module Domainic
+  module Type
+    # A type for validating Integer objects with extensive numeric validation capabilities.
+    #
+    # This class provides a comprehensive set of validations specifically designed for
+    # integer values, including basic type checking and all numeric validations like
+    # divisibility, parity, polarity, and range constraints.
+    #
+    # @example Basic usage
+    #   type = IntegerType.new
+    #   type.validate(42)     # => true
+    #   type.validate(3.14)   # => false
+    #   type.validate("42")   # => false
+    #
+    # @example With numeric constraints
+    #   type = IntegerType.new
+    #   type
+    #     .being_positive
+    #     .being_even
+    #     .being_less_than(100)
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    class IntegerType
+      extend Behavior::ClassMethods
+
+      include Behavior
+
+      include Behavior::NumericBehavior
+    end
+  end
+end