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

data/lib/domainic/type/types/core/symbol_type.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'domainic/type/behavior'
+require 'domainic/type/behavior/string_behavior'
+
+module Domainic
+  module Type
+    # A type for validating Symbol objects with string-like constraints
+    #
+    # This type provides symbol validation capabilities by leveraging string validation
+    # behaviors. It enables validation of symbols using string-based constraints while
+    # maintaining proper type checking for Symbol objects.
+    #
+    # Key features:
+    # - Basic symbol type validation
+    # - Case checking for symbol names
+    # - Character set validation for symbol names
+    # - Pattern matching against symbol names
+    # - Length constraints for symbol names
+    # - String content validation for symbol names
+    #
+    # @example Basic usage
+    #   type = SymbolType.new
+    #   type.validate(:hello)   # => true
+    #   type.validate("hello")  # => false
+    #
+    # @example Complex symbol validation
+    #   type = SymbolType.new
+    #     .being_ascii
+    #     .being_lowercase
+    #     .having_size_between(2, 30)
+    #     .matching(/^[a-z]/)
+    #
+    # @example Symbol name validation
+    #   type = SymbolType.new
+    #     .being_alphanumeric
+    #     .not_matching(/\W/)
+    #     .having_minimum_size(1)
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    class SymbolType
+      # @rbs! extend Behavior::ClassMethods
+
+      include Behavior
+      include Behavior::StringBehavior
+
+      intrinsic :self, :type, Symbol, abort_on_failure: true, description: :not_described
+    end
+  end
+end

data/lib/domainic/type/types/specification/anything_type.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'domainic/type/behavior'
+
+module Domainic
+  module Type
+    # @since 0.1.0
+    class AnythingType
+      include Behavior
+
+      # @rbs (*untyped types) -> self
+      def but(*types)
+        not_types = types.map do |type|
+          @constraints.prepare(:self, :not, @constraints.prepare(:self, :type, type))
+        end
+        constrain :self, :and, not_types, concerning: :exclusion
+      end
+      alias except but
+      alias excluding but
+    end
+  end
+end

data/lib/domainic/type/types/specification/duck_type.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'domainic/type/behavior'
+
+module Domainic
+  module Type
+    # A type that validates objects based on their method interface
+    #
+    # This type implements duck typing validation by checking whether objects respond
+    # to specific methods. It supports both positive validation (must respond to methods)
+    # and negative validation (must not respond to methods).
+    #
+    # @example Validating a simple interface
+    #   type = DuckType.responding_to(:to_s).not_responding_to(:to_h)
+    #   type.validate("string")  # => true
+    #   type.validate(Object.new)  # => true
+    #   type.validate({})  # => false (responds to :to_h)
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    class DuckType
+      include Behavior
+
+      # Add method exclusion constraints to the type
+      #
+      # @example
+      #   type = DuckType.new.not_responding_to(:foo, :bar)
+      #
+      # @param methods [Array<String, Symbol>] the methods that must not be present
+      #
+      # @return [self] the type for method chaining
+      # @rbs (*String | Symbol methods) -> self
+      def not_responding_to(*methods)
+        not_methods = methods.map do |method|
+          @constraints.prepare(:self, :not, @constraints.prepare(:self, :method_presence, method))
+        end
+        constrain :self, :and, not_methods, concerning: :method_exclusion
+      end
+
+      # Add method presence constraints to the type
+      #
+      # @example
+      #   type = DuckType.new.responding_to(:foo, :bar)
+      #
+      # @param methods [Array<String, Symbol>] the methods that must be present
+      #
+      # @return [self] the type for method chaining
+      # @rbs (*String | Symbol methods) -> self
+      def responding_to(*methods)
+        methods = methods.map { |method| @constraints.prepare :self, :method_presence, method }
+        constrain :self, :and, methods, concerning: :method_presence
+      end
+    end
+  end
+end

data/lib/domainic/type/types/specification/enum_type.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'domainic/type/behavior'
+
+module Domainic
+  module Type
+    # @since 0.1.0
+    class EnumType
+      include Behavior
+
+      # @rbs (*untyped literals, **untyped options) -> void
+      def initialize(*literals, **options)
+        super(**options.merge(literal: literals))
+      end
+
+      # @rbs (*untyped literals) -> void
+      def literal(*literals)
+        literals = literals.map do |literal|
+          @constraints.prepare :self, :equality, literal
+        end
+        constrain :self, :or, literals
+      end
+      alias value literal
+    end
+  end
+end

data/lib/domainic/type/types/specification/union_type.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'domainic/type/behavior'
+
+module Domainic
+  module Type
+    # @since 0.1.0
+    class UnionType
+      include Behavior
+
+      # @rbs (*Class | Module | Behavior[untyped, untyped, untyped] types, **untyped options) -> void
+      def initialize(*types, **options)
+        super(**options.merge(type: types))
+      end
+
+      # @rbs (*Class | Module | Behavior[untyped, untyped, untyped] types) -> self
+      def type(*types)
+        types = types.map do |type|
+          @constraints.prepare :self, :type, type
+        end
+        constrain :self, :or, types, concerning: :inclusion
+      end
+      alias or type
+    end
+  end
+end

data/lib/domainic/type/types/specification/void_type.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'domainic/type/behavior'
+
+module Domainic
+  module Type
+    # @since 0.1.0
+    class VoidType
+      include Behavior
+    end
+  end
+end

data/lib/domainic/type.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Domainic
+  # @since 0.1.0
+  module Type
+  end
+end

data/lib/domainic-type.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'domainic/type'

data/sig/domainic/type/accessors.rbs

@@ -0,0 +1,22 @@
+module Domainic
+  module Type
+    type accessor = :abs | :begin | :chars | :class | :count | :end | :entries | :first | :keys | :last | :length | :self | :size | :values
+
+    # A list of valid access methods that can be used to retrieve values for constraint validation.
+    # These methods represent common Ruby interfaces for accessing collection sizes, ranges, and values.
+    #
+    # - :abs                       - For absolute values
+    # - :begin, :end               - For Range-like objects
+    # - :class                     - For type checking
+    # - :count, :length, :size     - For measuring collections
+    # - :entries, :chars           - For accessing sequence elements
+    # - :first, :last              - For accessing sequence endpoints
+    # - :keys, :values             - For Hash-like objects
+    # - :self                      - For operating directly on the value
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    # @return [Array<Symbol>]
+    ACCESSORS: Array[accessor]
+  end
+end

data/sig/domainic/type/behavior/enumerable_behavior.rbs

@@ -0,0 +1,238 @@
+module Domainic
+  module Type
+    module Behavior
+      # A module providing enumerable-specific validation behaviors for types.
+      #
+      # This module extends the base Type::Behavior with methods specifically designed for validating enumerable
+      # collections. It provides a fluent interface for common enumerable validations such as uniqueness, emptiness,
+      # ordering, and size constraints.
+      #
+      # @example Basic usage
+      #   class ArrayType
+      #     include Domainic::Type::Behavior::EnumerableBehavior
+      #
+      #     def initialize
+      #       super
+      #       being_empty                  # validates array is empty
+      #       having_minimum_count(5)      # validates at least 5 elements
+      #       containing(1, 2, 3)          # validates specific elements
+      #     end
+      #   end
+      #
+      # @example Combining constraints
+      #   class OrderedArrayType
+      #     include Domainic::Type::Behavior::EnumerableBehavior
+      #
+      #     def initialize
+      #       super
+      #       being_ordered
+      #       being_populated
+      #       having_maximum_count(10)
+      #     end
+      #   end
+      #
+      # @author {https://aaronmallen.me Aaron Allen}
+      # @since 0.1.0
+      module EnumerableBehavior
+        include SizableBehavior
+
+        def being_distinct: () -> untyped
+
+        alias being_unique being_distinct
+
+        alias distinct being_distinct
+
+        alias unique being_distinct
+
+        # Validate that the enumerable contains duplicate elements.
+        #
+        # Creates an inverse uniqueness constraint that ensures the collection has at least one duplicate element.
+        #
+        # @example
+        #   type.being_duplicative
+        #   type.validate([1, 1, 2])   # => true
+        #   type.validate([1, 2, 3])   # => false
+        #
+        # @return [self] self for method chaining
+        def being_duplicative: () -> Behavior
+
+        alias being_redundant being_duplicative
+
+        alias being_repetitive being_duplicative
+
+        alias duplicative being_duplicative
+
+        alias redundant being_duplicative
+
+        alias repetitive being_duplicative
+
+        # Validate that the enumerable is empty.
+        #
+        # Creates a constraint that ensures the collection has no elements.
+        #
+        # @example
+        #   type.being_empty
+        #   type.validate([])     # => true
+        #   type.validate([1])    # => false
+        #
+        # @return [self] self for method chaining
+        def being_empty: () -> Behavior
+
+        alias being_vacant being_empty
+
+        alias empty being_empty
+
+        alias vacant being_empty
+
+        # Validate that the enumerable contains elements.
+        #
+        # Creates an inverse emptiness constraint that ensures the collection has at least one element.
+        #
+        # @example
+        #   type.being_populated
+        #   type.validate([1])    # => true
+        #   type.validate([])     # => false
+        #
+        # @return [self] self for method chaining
+        def being_populated: () -> Behavior
+
+        alias being_inhabited being_populated
+
+        alias being_occupied being_populated
+
+        alias populated being_populated
+
+        alias inhabited being_populated
+
+        alias occupied being_populated
+
+        # Validate that the enumerable elements are in sorted order.
+        #
+        # Creates a constraint that ensures the collection's elements are in ascending order based on their natural
+        # comparison methods.
+        #
+        # @example
+        #   type.being_ordered
+        #   type.validate([1, 2, 3])   # => true
+        #   type.validate([3, 1, 2])   # => false
+        #
+        # @return [self] self for method chaining
+        def being_sorted: () -> Behavior
+
+        alias being_aranged being_sorted
+
+        alias being_ordered being_sorted
+
+        alias being_sequential being_sorted
+
+        alias aranged being_sorted
+
+        alias ordered being_sorted
+
+        alias sorted being_sorted
+
+        alias sequential being_sorted
+
+        # Validate that the enumerable elements are not in sorted order.
+        #
+        # Creates an inverse ordering constraint that ensures the collection's elements are not in ascending order.
+        #
+        # @example
+        #   type.being_unordered
+        #   type.validate([3, 1, 2])   # => true
+        #   type.validate([1, 2, 3])   # => false
+        #
+        # @return [self] self for method chaining
+        def being_unsorted: () -> Behavior
+
+        alias being_disordered being_unsorted
+
+        alias being_unordered being_unsorted
+
+        alias disordered being_unsorted
+
+        alias unsorted being_unsorted
+
+        alias unordered being_unsorted
+
+        # Validate that the enumerable contains specific entries.
+        #
+        # Creates a series of inclusion constraints ensuring the collection contains all specified elements.
+        #
+        # @example
+        #   type.containing(1, 2)
+        #   type.validate([1, 2, 3])   # => true
+        #   type.validate([1, 3])      # => false
+        #
+        # @param entries [Array<Object>] the elements that must be present
+        # @return [self] self for method chaining
+        def containing: (*untyped entries) -> Behavior
+
+        alias including containing
+
+        # Validate that the enumerable contains a specific last entry.
+        #
+        # Creates an equality constraint on the collection's last entry ensuring it is equal to the specified value.
+        #
+        # @example
+        #   type.having_last_entry(3)
+        #   type.validate([1, 2, 3])   # => true
+        #   type.validate([1, 3, 2])   # => false
+        #
+        # @param literal [Object] the value that must be the last entry
+        # @return [self] self for method chaining
+        def ending_with: (untyped literal) -> Behavior
+
+        alias closing_with ending_with
+
+        alias finishing_with ending_with
+
+        # Validate that the enumerable does not contain specific entries.
+        #
+        # Creates a series of exclusion constraints ensuring the collection does not contain any of the specified
+        # elements.
+        #
+        # @example
+        #   type.excluding(1, 2)
+        #   type.validate([3, 4, 5])   # => true
+        #   type.validate([1, 2, 3])   # => false
+        #
+        # @param entries [Array<Object>] the elements that must not be present
+        # @return [self] self for method chaining
+        def excluding: (*untyped entries) -> Behavior
+
+        alias omitting excluding
+
+        # Validate that the enumerable contains elements of a specific type.
+        #
+        # Creates a type constraint on the collection's elements ensuring they are all of the specified type.
+        #
+        # @example
+        #   type.of(String)
+        #   type.validate(['a', 'b', 'c'])   # => true
+        #   type.validate(['a', 1, 'c'])     # => false
+        #
+        # @param type [Class, Module, Behavior] the type that all elements must be
+        # @return [self] self for method chaining
+        def of: (Class | Module | Behavior type) -> Behavior
+
+        # Validate that the enumerable contains a specific first entry.
+        #
+        # Creates an equality constraint on the collection's first entry ensuring it is equal to the specified value.
+        #
+        # @example
+        #   type.having_first_entry(1)
+        #   type.validate([1, 2, 3])   # => true
+        #   type.validate([2, 3, 1])   # => false
+        #
+        # @param literal [Object] the value that must be the first entry
+        # @return [self] self for method chaining
+        def starting_with: (untyped literal) -> Behavior
+
+        alias begining_with starting_with
+
+        alias leading_with starting_with
+      end
+    end
+  end
+end