domainic-type 0.1.0.alpha.3.2.0 → 0.1.0.alpha.3.3.0

data/lib/domainic/type/accessors.rb

@@ -4,12 +4,12 @@ module Domainic
   module Type
     # @rbs!
     #   type accessor = :abs | :begin | :chars | :class | :count | :end | :entries | :first | :keys | :last | :length |
-    #                   :self | :size | :values
+    #                   :real | :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
+    # - :abs, :real                - For absolute values
     # - :begin, :end               - For Range-like objects
     # - :class                     - For type checking
     # - :count, :length, :size     - For measuring collections
@@ -27,6 +27,7 @@ module Domainic
       entries
       chars
       abs
+      real
       count
       size
       length

data/lib/domainic/type/behavior/date_time_behavior.rb

@@ -28,13 +28,89 @@ module Domainic
       # @author {https://aaronmallen.me Aaron Allen}
       # @since 0.1.0
       module DateTimeBehavior
+        # The supported date/time patterns for parsing date/time strings
+        #
+        # @note This list is ordered from most specific to least specific to ensure that the most specific patterns are
+        #  tried first. This is important because some patterns are more lenient than others and may match a wider range
+        #  of input strings.
+        #
+        # @return [Array<String>] the supported date/time patterns
+        DATETIME_PATTERNS = [
+          # ISO 8601 variants (most specific first)
+          '%Y-%m-%dT%H:%M:%S.%N%:z',    # 2024-01-01T12:00:00.000+00:00
+          '%Y-%m-%dT%H:%M:%S%:z',       # 2024-01-01T12:00:00+00:00
+          '%Y-%m-%dT%H:%M:%S.%N',       # 2024-01-01T12:00:00.000
+          '%Y-%m-%dT%H:%M:%S',          # 2024-01-01T12:00:00
+          '%Y%m%dT%H%M%S%z',            # 20240101T120000+0000 (basic format)
+
+          # RFC formats
+          '%a, %d %b %Y %H:%M:%S %z',   # Thu, 31 Jan 2024 13:30:00 +0000
+          '%d %b %Y %H:%M:%S %z',       # 31 Jan 2024 13:30:00 +0000
+
+          # Common datetime formats with timezone
+          '%Y-%m-%d %H:%M:%S %z',       # 2024-01-01 12:00:00 +0000
+          '%d/%m/%Y %H:%M:%S %z',       # 31/01/2024 12:00:00 +0000
+
+          # Full date + time formats (24h)
+          '%Y-%m-%d %H:%M:%S',          # 2024-01-01 12:00:00
+          '%Y-%m-%d %H:%M',             # 2024-01-01 12:00
+          '%d/%m/%Y %H:%M:%S',          # 31/01/2024 12:00:00
+          '%d/%m/%Y %H:%M',             # 31/01/2024 12:00
+          '%d-%m-%Y %H:%M:%S',          # 31-01-2024 12:00:00
+          '%d-%m-%Y %H:%M',             # 31-01-2024 12:00
+          '%Y/%m/%d %H:%M:%S',          # 2024/01/31 12:00:00
+          '%Y/%m/%d %H:%M',             # 2024/01/31 12:00
+
+          # Full date + time formats (12h)
+          '%Y-%m-%d %I:%M:%S %p',       # 2024-01-01 01:30:00 PM
+          '%Y-%m-%d %I:%M %p',          # 2024-01-01 01:30 PM
+          '%d/%m/%Y %I:%M:%S %p',       # 31/01/2024 01:30:00 PM
+          '%d/%m/%Y %I:%M %p',          # 31/01/2024 01:30 PM
+
+          # Full month name formats
+          '%B %d, %Y %H:%M:%S',         # January 31, 2024 12:00:00
+          '%B %d, %Y %H:%M',            # January 31, 2024 12:00
+          '%d %B %Y %H:%M:%S',          # 31 January 2024 12:00:00
+          '%d %B %Y %H:%M',             # 31 January 2024 12:00
+
+          # Abbreviated month name formats
+          '%b %d, %Y %H:%M:%S',         # Jan 31, 2024 12:00:00
+          '%b %d, %Y %H:%M',            # Jan 31, 2024 12:00
+          '%d %b %Y %H:%M:%S',          # 31 Jan 2024 12:00:00
+          '%d %b %Y %H:%M',             # 31 Jan 2024 12:00
+
+          # Date-only formats (in order of specificity)
+          '%Y-%m-%d',                   # 2024-01-31
+          '%Y%m%d',                     # 20240131
+          '%B %d, %Y',                  # January 31, 2024
+          '%d %B %Y',                   # 31 January 2024
+          '%b %d, %Y',                  # Jan 31, 2024
+          '%d %b %Y',                   # 31 Jan 2024
+          '%d/%m/%Y',                   # 31/01/2024
+          '%d-%m-%Y',                   # 31-01-2024
+          '%Y/%m/%d',                   # 2024/01/31
+          '%m/%d/%Y'                    # 01/31/2024 (US format - last to avoid ambiguity)
+        ].freeze #: Array[String]
+
+        # Coerce a value to a Date, DateTime, or Time object
+        #
+        # @return [Proc] a lambda that coerces a value to a Date, DateTime, or Time object
         TO_DATETIME_COERCER = lambda { |value|
-          if [Date, DateTime, Time].any? { |type| value.is_a?(type) }
+          case value
+          when Date, DateTime, Time
             value
+          when Integer
+            Time.at(value).to_datetime
+          when String
+            DATETIME_PATTERNS.each do |pattern|
+              return DateTime.strptime(value, pattern)
+            rescue ArgumentError
+              next
+            end
           else
-            DateTime.parse(value.to_s)
+            DateTime.parse(value) # Fallback to Ruby's built-in parser and allow it to raise.
           end
-        } #: Proc
+        } #: ^(Date | DateTime | Integer | String | Time value) -> (Date | DateTime | Time)
 
         class << self
           private
@@ -44,39 +120,39 @@ module Domainic
           # @note this in my opinion is better than polluting the namespace of the including class even with a private
           #   method. This way, the method is only available within the module itself. See {#being_between}.
           #
-          # @param after [Date, DateTime, String, Time, nil] minimum size value from positional args
-          # @param before [Date, DateTime, String, Time, nil] maximum size value from positional args
+          # @param after [Date, DateTime, Integer, String, Time, nil] minimum size value from positional args
+          # @param before [Date, DateTime, Integer, String, Time, nil] maximum size value from positional args
           # @param options [Hash] keyword arguments containing after/before values
           #
           # @raise [ArgumentError] if minimum or maximum value can't be determined
-          # @return [Array<Date, DateTime, String, Time, nil>] parsed [after, before] values
+          # @return [Array<Date, DateTime, Integer, String, Time, nil>] parsed [after, before] values
           # @rbs (
-          #   (Date | DateTime | String | Time)? after,
-          #   (Date | DateTime | String | Time)? before,
-          #   Hash[Symbol, (Date | DateTime | String | Time)?] options
-          #   ) -> Array[(Date | DateTime | String | Time)?]
+          #   (Date | DateTime | Integer | String | Time)? after,
+          #   (Date | DateTime | Integer | String | Time)? before,
+          #   Hash[Symbol, (Date | DateTime | Integer | String | Time)?] options
+          #   ) -> Array[(Date | DateTime | Integer | String | Time)?]
           def parse_being_between_arguments!(after, before, options)
             after ||= options[:after]
             before ||= options[:before]
             raise_being_between_argument_error!(caller, after, before, options) if after.nil? || before.nil?
 
-            [after, before] #: Array[(Date | DateTime | String | Time)?]
+            [after, before] #: Array[(Date | DateTime | Integer | String | Time)?]
           end
 
           # Raise appropriate ArgumentError for being_between
           #
           # @param original_caller [Array<String>] caller stack for error
-          # @param after [Date, DateTime, String, Time, nil] after value from positional args
-          # @param before [Date, DateTime, String, Time, nil] before value from positional args
+          # @param after [Date, DateTime, Integer, String, Time, nil] after value from positional args
+          # @param before [Date, DateTime, Integer, String, Time, nil] before value from positional args
           # @param options [Hash] keyword arguments containing after/before values
           #
           # @raise [ArgumentError] with appropriate message
           # @return [void]
           # @rbs (
           #   Array[String] original_caller,
-          #   (Date | DateTime | String | Time)? after,
-          #   (Date | DateTime | String | Time)? before,
-          #   Hash[Symbol, (Date | DateTime | String | Time)?] options
+          #   (Date | DateTime | Integer | String | Time)? after,
+          #   (Date | DateTime | Integer | String | Time)? before,
+          #   Hash[Symbol, (Date | DateTime | Integer | String | Time)?] options
           #   ) -> void
           def raise_being_between_argument_error!(original_caller, after, before, options)
             message = if options.empty?
@@ -93,66 +169,70 @@ module Domainic
 
         # Constrain the value to be chronologically after a given date/time
         #
-        # @param other [Date, DateTime, String, Time] the date/time to compare against
+        # @param other [Date, DateTime, Integer, String, Time] the date/time to compare against
         # @return [self] self for method chaining
-        # @rbs (Date | DateTime | String | Time other) -> Behavior
+        # @rbs (Date | DateTime | Integer | String | Time other) -> Behavior
         def being_after(other)
           # @type self: Object & Behavior
-          constrain :self, :range, { minimum: other },
+          constrain :self, :range, { minimum: TO_DATETIME_COERCER.call(other) },
                     coerce_with: TO_DATETIME_COERCER, description: 'being', inclusive: false
         end
         alias after being_after
 
         # Constrain the value to be chronologically before a given date/time
         #
-        # @param other [Date, DateTime, String, Time] the date/time to compare against
+        # @param other [Date, DateTime, Integer, String, Time] the date/time to compare against
         # @return [self] self for method chaining
-        # @rbs (Date | DateTime | String | Time other) -> Behavior
+        # @rbs (Date | DateTime | Integer | String | Time other) -> Behavior
         def being_before(other)
           # @type self: Object & Behavior
-          constrain :self, :range, { maximum: other },
+          constrain :self, :range, { maximum: TO_DATETIME_COERCER.call(other) },
                     coerce_with: TO_DATETIME_COERCER, description: 'being', inclusive: false
         end
         alias before being_before
 
         # Constrain the value to be chronologically between two date/times
         #
-        # @param after [Date, DateTime, String, Time] the earliest allowed date/time
-        # @param before [Date, DateTime, String, Time] the latest allowed date/time
+        # @param after [Date, DateTime, Integer, String, Time] the earliest allowed date/time
+        # @param before [Date, DateTime, Integer, String, Time] the latest allowed date/time
         # @param options [Hash] alternative way to specify after/before via keywords
-        # @option options [Date, DateTime, String, Time] :after earliest allowed date/time
-        # @option options [Date, DateTime, String, Time] :before latest allowed date/time
+        # @option options [Date, DateTime, Integer, String, Time] :after earliest allowed date/time
+        # @option options [Date, DateTime, Integer, String, Time] :before latest allowed date/time
         # @return [self] self for method chaining
-        # @rbs (Date | DateTime | String | Time after, Date | DateTime | String | Time before) -> Behavior
+        # @rbs (
+        #   Date | DateTime | Integer | String | Time after,
+        #   Date | DateTime | Integer | String | Time before
+        #   ) -> Behavior
         def being_between(after = nil, before = nil, **options)
           # @type self: Object & Behavior
           after, before =
             DateTimeBehavior.send(:parse_being_between_arguments!, after, before, options.transform_keys(&:to_sym))
-          constrain :self, :range, { minimum: after, maximum: before },
+          constrain :self, :range,
+                    { minimum: TO_DATETIME_COERCER.call(after), maximum: TO_DATETIME_COERCER.call(before) },
                     coerce_with: TO_DATETIME_COERCER, description: 'being', inclusive: false
         end
         alias between being_between
 
         # Constrain the value to be exactly equal to a given date/time
         #
-        # @param other [Date, DateTime, String, Time] the date/time to compare against
+        # @param other [Date, DateTime, Integer, String, Time] the date/time to compare against
         # @return [self] self for method chaining
-        # @rbs (Date | DateTime | String | Time other) -> Behavior
+        # @rbs (Date | DateTime | Integer | String | Time other) -> Behavior
         def being_equal_to(other)
           # @type self: Object & Behavior
-          constrain :self, :equality, other,
+          constrain :self, :equality, TO_DATETIME_COERCER.call(other),
                     coerce_with: TO_DATETIME_COERCER, description: 'being'
         end
         alias at being_equal_to
 
         # Constrain the value to be chronologically on or after a given date/time
         #
-        # @param other [Date, DateTime, String, Time] the date/time to compare against
+        # @param other [Date, DateTime, Integer, String, Time] the date/time to compare against
         # @return [self] self for method chaining
-        # @rbs (Date | DateTime | String | Time other) -> Behavior
+        # @rbs (Date | DateTime | Integer | String | Time other) -> Behavior
         def being_on_or_after(other)
           # @type self: Object & Behavior
-          constrain :self, :range, { minimum: other },
+          constrain :self, :range, { minimum: TO_DATETIME_COERCER.call(other) },
                     coerce_with: TO_DATETIME_COERCER, description: 'being'
         end
         alias at_or_after being_on_or_after
@@ -161,12 +241,12 @@ module Domainic
 
         # Constrain the value to be chronologically on or before a given date/time
         #
-        # @param other [Date, DateTime, String, Time] the date/time to compare against
+        # @param other [Date, DateTime, Integer, String, Time] the date/time to compare against
         # @return [self] self for method chaining
-        # @rbs (Date | DateTime | String | Time other) -> Behavior
+        # @rbs (Date | DateTime | Integer | String | Time other) -> Behavior
         def being_on_or_before(other)
           # @type self: Object & Behavior
-          constrain :self, :range, { maximum: other },
+          constrain :self, :range, { maximum: TO_DATETIME_COERCER.call(other) },
                     coerce_with: TO_DATETIME_COERCER, description: 'being'
         end
         alias at_or_before being_on_or_before

data/lib/domainic/type/config/registry.yml

@@ -78,6 +78,12 @@ types:
   anything:
     constant: Domainic::Type::AnythingType
     require_path: domainic/type/types/specification/anything_type
+  big_decimal:
+    constant: Domainic::Type::BigDecimalType
+    require_path: domainic/type/types/core_extended/big_decimal_type
+  complex:
+    constant: Domainic::Type::ComplexType
+    require_path: domainic/type/types/core/complex_type
   cuid:
     constant: Domainic::Type::CUIDType
     require_path: domainic/type/types/identifier/cuid_type
@@ -87,6 +93,9 @@ types:
   date_time:
     constant: Domainic::Type::DateTimeType
     require_path: domainic/type/types/datetime/date_time_type
+  date_time_string:
+    constant: Domainic::Type::DateTimeStringType
+    require_path: domainic/type/types/datetime/date_time_string_type
   duck:
     constant: Domainic::Type::DuckType
     require_path: domainic/type/types/specification/duck_type
@@ -111,6 +120,15 @@ types:
   integer:
     constant: Domainic::Type::IntegerType
     require_path: domainic/type/types/core/integer_type
+  range:
+    constant: Domainic::Type::RangeType
+    require_path: domainic/type/types/core/range_type
+  rational:
+    constant: Domainic::Type::RationalType
+    require_path: domainic/type/types/core/rational_type
+  set:
+    constant: Domainic::Type::SetType
+    require_path: domainic/type/types/core_extended/set_type
   string:
     constant: Domainic::Type::StringType
     require_path: domainic/type/types/core/string_type
@@ -120,6 +138,9 @@ types:
   time:
     constant: Domainic::Type::TimeType
     require_path: domainic/type/types/datetime/time_type
+  timestamp:
+    constant: Domainic::Type::TimestampType
+    require_path: domainic/type/types/datetime/timestamp_type
   union:
     constant: Domainic::Type::UnionType
     require_path: domainic/type/types/specification/union_type

data/lib/domainic/type/definitions.rb

@@ -77,6 +77,36 @@ module Domainic
       end
       alias _List? _Array?
 
+      # Creates a BigDecimalType instance.
+      #
+      # @example
+      #   type = _BigDecimal
+      #   type.validate(BigDecimal('123.45')) # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::BigDecimalType] the created type
+      # @rbs (**__todo__ options) -> BigDecimalType
+      def _BigDecimal(**options)
+        require 'domainic/type/types/core_extended/big_decimal_type'
+        Domainic::Type::BigDecimalType.new(**options)
+      end
+
+      # Creates a nilable BigDecimalType instance.
+      #
+      # @example
+      #   type = _BigDecimal?
+      #   type.validate(BigDecimal('123.45')) # => true
+      #   type.validate(nil)                  # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (BigDecimal or NilClass)
+      # @rbs (**__todo__ options) -> UnionType
+      def _BigDecimal?(**options)
+        _Nilable(_BigDecimal(**options))
+      end
+
       # Creates a Boolean type.
       #
       # Represents a union of TrueClass and FalseClass.
@@ -133,6 +163,35 @@ module Domainic
       end
       alias _Cuid? _CUID?
 
+      # Creates a ComplexType instance.
+      #
+      # @example
+      #   type = _Complex
+      #   type.validate(Complex(1, 2)) # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::ComplexType] the created type
+      # @rbs (**__todo__ options) -> ComplexType
+      def _Complex(**options)
+        require 'domainic/type/types/core/complex_type'
+        Domainic::Type::ComplexType.new(**options)
+      end
+
+      # Creates a nilable ComplexType instance.
+      #
+      # @example
+      #   type = _Complex?
+      #   type.validate(Complex(1, 2)) # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (Complex or NilClass)
+      # @rbs (**__todo__ options) -> UnionType
+      def _Complex?(**options)
+        _Nilable(_Complex(**options))
+      end
+
       # Creates a DateType instance.
       #
       # DateType restricts values to valid `Date` objects.
@@ -195,6 +254,39 @@ module Domainic
         _Nilable(_DateTime(**options))
       end
 
+      # Creates a DateTimeStringType instance.
+      #
+      # DateTimeStringType restricts values to valid date-time strings.
+      #
+      # @example
+      #   type = _DateTimeString
+      #   type.validate('2024-01-01T12:00:00Z') # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::DateTimeStringType] the created type
+      # @rbs (**__todo__ options) -> DateTimeStringType
+      def _DateTimeString(**options)
+        require 'domainic/type/types/datetime/date_time_string_type'
+        Domainic::Type::DateTimeStringType.new(**options)
+      end
+      alias _DateString _DateTimeString
+
+      # Creates a nilable DateTimeStringType instance.
+      #
+      # @example
+      #   _DateTimeString? === '2024-01-01T12:00:00Z' # => true
+      #   _DateTimeString? === nil                    # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (DateTimeStringType or NilClass)
+      # @rbs (**__todo__ options) -> UnionType
+      def _DateTimeString?(**options)
+        _Nilable(_DateTimeString(**options))
+      end
+      alias _DateString? _DateTimeString?
+
       # Creates a DuckType instance.
       #
       # DuckType allows specifying behavior based on method availability.
@@ -477,6 +569,95 @@ module Domainic
       end
       alias _Nullable _Nilable
 
+      # Creates a RangeType instance.
+      #
+      # @example
+      #   type = _Range
+      #   type.validate(1..10) # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::RangeType] the created type
+      # @rbs (**__todo__ options) -> RangeType
+      def _Range(**options)
+        require 'domainic/type/types/core/range_type'
+        Domainic::Type::RangeType.new(**options)
+      end
+
+      # Creates a nilable RangeType instance.
+      #
+      # @example
+      #   type = _Range?
+      #   type.validate(1..10) # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (Range or NilClass)
+      # @rbs (**__todo__ options) -> UnionType
+      def _Range?(**options)
+        _Nilable(_Range(**options))
+      end
+
+      # Creates a RationalType instance.
+      #
+      # @example
+      #   type = _Rational
+      #   type.validate(Rational(1, 2)) # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::RationalType] the created type
+      # @rbs (**__todo__ options) -> RationalType
+      def _Rational(**options)
+        require 'domainic/type/types/core/rational_type'
+        Domainic::Type::RationalType.new(**options)
+      end
+
+      # Creates a nilable RationalType instance.
+      #
+      # @example
+      #   type = _Rational?
+      #   type.validate(Rational(1, 2)) # => true
+      #   type.validate(nil)            # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (Rational or NilClass)
+      # @rbs (**__todo__ options) -> UnionType
+      def _Rational?(**options)
+        _Nilable(_Rational(**options))
+      end
+
+      # Creates a SetType instance.
+      #
+      # @example
+      #   type = _Set
+      #   type.validate(Set[1, 2, 3]) # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::SetType] the created type
+      # @rbs (**__todo__ options) -> SetType
+      def _Set(**options)
+        require 'domainic/type/types/core_extended/set_type'
+        Domainic::Type::SetType.new(**options)
+      end
+
+      # Creates a nilable SetType instance.
+      #
+      # @example
+      #   type = _Set?
+      #   type.validate(Set[1, 2, 3]) # => true
+      #   type.validate(nil)          # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (Set or NilClass)
+      # @rbs (**__todo__ options) -> UnionType
+      def _Set?(**options)
+        _Nilable(_Set(**options))
+      end
+
       # Creates a StringType instance.
       #
       # @example
@@ -568,6 +749,37 @@ module Domainic
         _Nilable(_Time(**options))
       end
 
+      # Creates a TimestampType instance.
+      #
+      # TimestampType restricts values to valid timestamps.
+      #
+      # @example
+      #   type = _Timestamp
+      #   type.validate(1640995200) # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::TimestampType] the created type
+      # @rbs (**__todo__ options) -> TimestampType
+      def _Timestamp(**options)
+        require 'domainic/type/types/datetime/timestamp_type'
+        Domainic::Type::TimestampType.new(**options)
+      end
+
+      # Creates a nilable TimestampType instance.
+      #
+      # @example
+      #   _Timestamp? === 1640995200 # => true
+      #   _Timestamp? === nil        # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (TimestampType or NilClass)
+      # @rbs (**__todo__ options) -> UnionType
+      def _Timestamp?(**options)
+        _Nilable(_Timestamp(**options))
+      end
+
       # Creates a URIType instance.
       #
       # URIType restricts values to valid URIs.