domainic-type 0.1.0.alpha.3.0.2 → 0.1.0.alpha.3.1.0

data/sig/domainic/type/types/identifier/uuid_type.rbs

@@ -0,0 +1,469 @@
+module Domainic
+  # NOTE: This file is located at lib/domainic/type/types/identifier/uuid_type.rb
+  module Type
+    # A type for validating UUIDs according to RFC 4122 standards
+    #
+    # This type provides comprehensive UUID validation following RFC 4122 standards.
+    # It supports both standard (hyphenated) and compact formats for all UUID versions
+    # (1 through 7), while enforcing proper formatting and version-specific constraints.
+    #
+    # Key features:
+    # - RFC 4122 compliant UUID format validation
+    # - Support for versions 1-7
+    # - Standard (hyphenated) and compact format support
+    # - Length validation (36 chars for standard, 32 for compact)
+    # - Version-specific validation
+    #
+    # @example Basic usage
+    #   type = UUIDType.new
+    #   type.validate("123e4567-e89b-12d3-a456-426614174000")  # => true
+    #   type.validate("invalid")                                # => false
+    #
+    # @example With version constraints
+    #   type = UUIDType.new.being_version(4)
+    #   type.validate("123e4567-e89b-42d3-a456-426614174000")  # => true
+    #
+    # @example With format constraints
+    #   type = UUIDType.new.being_compact
+    #   type.validate("123e4567e89b12d3a456426614174000")      # => true
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    class UUIDType
+      extend Behavior::ClassMethods
+
+      include Behavior
+
+      # Contains UUID validation regular expressions and version-specific modules
+      #
+      # This module provides both standard (hyphenated) and compact format regular
+      # expressions for UUID validation, along with version-specific submodules for
+      # more granular validation requirements.
+      #
+      # @since 0.1.0
+      module UUID
+        # Regular expression for standard (hyphenated) UUID format
+        #
+        # Validates UUIDs in the format: 8-4-4-4-12 hexadecimal digits with hyphens
+        # Example: "123e4567-e89b-12d3-a456-426614174000"
+        #
+        # @since 0.1.0
+        STANDARD_REGEXP: Regexp
+
+        # Regular expression for compact (non-hyphenated) UUID format
+        #
+        # Validates UUIDs in the format: 32 continuous hexadecimal digits
+        # Example: "123e4567e89b12d3a456426614174000"
+        #
+        # @since 0.1.0
+        COMPACT_REGEXP: Regexp
+
+        # Version 1 UUID validation patterns
+        #
+        # Provides regular expressions for validating time-based Version 1 UUIDs.
+        # These UUIDs are generated using a timestamp and node ID.
+        #
+        # @since 0.1.0
+        module V1
+          # Standard format regex for Version 1 UUIDs
+          # @return [Regexp] Pattern matching hyphenated Version 1 UUIDs
+          STANDARD_REGEXP: Regexp
+
+          # Compact format regex for Version 1 UUIDs
+          # @return [Regexp] Pattern matching non-hyphenated Version 1 UUIDs
+          COMPACT_REGEXP: Regexp
+        end
+
+        # Version 2 UUID validation patterns
+        #
+        # Provides regular expressions for validating DCE Security Version 2 UUIDs.
+        # These UUIDs incorporate local domain identifiers.
+        #
+        # @since 0.1.0
+        module V2
+          # Standard format regex for Version 2 UUIDs
+          # @return [Regexp] Pattern matching hyphenated Version 2 UUIDs
+          STANDARD_REGEXP: Regexp
+
+          # Compact format regex for Version 2 UUIDs
+          # @return [Regexp] Pattern matching non-hyphenated Version 2 UUIDs
+          COMPACT_REGEXP: Regexp
+        end
+
+        # Version 3 UUID validation patterns
+        #
+        # Provides regular expressions for validating name-based Version 3 UUIDs
+        # using MD5 hashing.
+        #
+        # @since 0.1.0
+        module V3
+          # Standard format regex for Version 3 UUIDs
+          # @return [Regexp] Pattern matching hyphenated Version 3 UUIDs
+          STANDARD_REGEXP: Regexp
+
+          # Compact format regex for Version 3 UUIDs
+          # @return [Regexp] Pattern matching non-hyphenated Version 3 UUIDs
+          COMPACT_REGEXP: Regexp
+        end
+
+        # Version 4 UUID validation patterns
+        #
+        # Provides regular expressions for validating randomly generated Version 4
+        # UUIDs. These are the most commonly used UUID format.
+        #
+        # @since 0.1.0
+        module V4
+          # Standard format regex for Version 4 UUIDs
+          # @return [Regexp] Pattern matching hyphenated Version 4 UUIDs
+          STANDARD_REGEXP: Regexp
+
+          # Compact format regex for Version 4 UUIDs
+          # @return [Regexp] Pattern matching non-hyphenated Version 4 UUIDs
+          COMPACT_REGEXP: Regexp
+        end
+
+        # Version 5 UUID validation patterns
+        #
+        # Provides regular expressions for validating name-based Version 5 UUIDs
+        # using SHA-1 hashing.
+        #
+        # @since 0.1.0
+        module V5
+          # Standard format regex for Version 5 UUIDs
+          # @return [Regexp] Pattern matching hyphenated Version 5 UUIDs
+          STANDARD_REGEXP: Regexp
+
+          # Compact format regex for Version 5 UUIDs
+          # @return [Regexp] Pattern matching non-hyphenated Version 5 UUIDs
+          COMPACT_REGEXP: Regexp
+        end
+
+        # Version 6 UUID validation patterns
+        #
+        # Provides regular expressions for validating ordered-time Version 6 UUIDs.
+        # These UUIDs are similar to Version 1 but with improved timestamp ordering.
+        #
+        # @since 0.1.0
+        module V6
+          # Standard format regex for Version 6 UUIDs
+          # @return [Regexp] Pattern matching hyphenated Version 6 UUIDs
+          STANDARD_REGEXP: Regexp
+
+          # Compact format regex for Version 6 UUIDs
+          # @return [Regexp] Pattern matching non-hyphenated Version 6 UUIDs
+          COMPACT_REGEXP: Regexp
+        end
+
+        # Version 7 UUID validation patterns
+        #
+        # Provides regular expressions for validating Unix Epoch time-based Version 7
+        # UUIDs. These UUIDs use millisecond precision timestamps.
+        #
+        # @since 0.1.0
+        module V7
+          # Standard format regex for Version 7 UUIDs
+          # @return [Regexp] Pattern matching hyphenated Version 7 UUIDs
+          STANDARD_REGEXP: Regexp
+
+          # Compact format regex for Version 7 UUIDs
+          # @return [Regexp] Pattern matching non-hyphenated Version 7 UUIDs
+          COMPACT_REGEXP: Regexp
+        end
+      end
+
+      # Constrain UUID to compact format
+      #
+      # Creates a constraint ensuring the UUID is in compact format (32 characters,
+      # no hyphens). Useful when working with systems that prefer compact UUIDs.
+      #
+      # @example
+      #   type.being_compact
+      #   type.validate("123e4567e89b12d3a456426614174000")  # => true
+      #   type.validate("123e4567-e89b-12d3-a456-426614174000")  # => false
+      #
+      # @return [self] self for method chaining
+      def being_compact: () -> self
+
+      alias compact being_compact
+
+      # Constrain UUID to standard format
+      #
+      # Creates a constraint ensuring the UUID is in standard format (36 characters,
+      # with hyphens). This is the default format per RFC 4122.
+      #
+      # @example
+      #   type.being_standard
+      #   type.validate("123e4567-e89b-12d3-a456-426614174000")  # => true
+      #   type.validate("123e4567e89b12d3a456426614174000")      # => false
+      #
+      # @return [self] self for method chaining
+      def being_standard: () -> self
+
+      alias standard being_standard
+
+      # Constrain UUID to specific version
+      #
+      # Creates a constraint ensuring the UUID matches a specific version (1-7) in
+      # either standard or compact format.
+      #
+      # @example
+      #   type.being_version(4)
+      #   type.validate("123e4567-e89b-42d3-a456-426614174000")  # => true
+      #   type.validate("123e4567-e89b-12d3-a456-426614174000")  # => false
+      #
+      # @param version [Integer] UUID version (1-7)
+      # @param format [Symbol] :standard or :compact
+      # @return [self] self for method chaining
+      # @raise [ArgumentError] if format is neither :standard nor :compact
+      def being_version: (Integer version, ?format: :compact | :standard) -> self
+
+      # Constrain UUID to Version 5 compact format
+      #
+      # Creates a constraint ensuring the UUID is a Version 5 UUID in compact format.
+      # Version 5 UUIDs are name-based using SHA-1 hashing.
+      #
+      # @return [self] self for method chaining
+      def being_version_five_compact: () -> self
+
+      alias being_v5_compact being_version_five_compact
+
+      alias v5_compact being_version_five_compact
+
+      # Constrain UUID to Version 5 standard format
+      #
+      # Creates a constraint ensuring the UUID is a Version 5 UUID in standard format.
+      # Version 5 UUIDs are name-based using SHA-1 hashing.
+      #
+      # @example
+      #   type.being_v5
+      #   type.validate("123e4567-e89b-52d3-a456-426614174000")  # => true
+      #
+      # @return [self] self for method chaining
+      def being_version_five_standard: () -> self
+
+      alias being_v5 being_version_five_standard
+
+      alias being_v5_standard being_version_five_standard
+
+      alias being_version_five being_version_five_standard
+
+      alias v5 being_version_five_standard
+
+      # Constrain UUID to Version 4 compact format
+      #
+      # Creates a constraint ensuring the UUID is a Version 4 UUID in compact format.
+      # Version 4 UUIDs are randomly generated and are the most commonly used format.
+      #
+      # @example
+      #   type.being_v4_compact
+      #   type.validate("123e4567e89b42d3a456426614174000")  # => true
+      #
+      # @return [self] self for method chaining
+      def being_version_four_compact: () -> self
+
+      alias being_v4_compact being_version_four_compact
+
+      alias v4_compact being_version_four_compact
+
+      # Constrain UUID to Version 4 standard format
+      #
+      # Creates a constraint ensuring the UUID is a Version 4 UUID in standard format.
+      # Version 4 UUIDs are randomly generated and are the most commonly used format.
+      #
+      # @example
+      #   type.being_v4
+      #   type.validate("123e4567-e89b-42d3-a456-426614174000")  # => true
+      #
+      # @return [self] self for method chaining
+      def being_version_four_standard: () -> self
+
+      alias being_v4 being_version_four_standard
+
+      alias being_v4_standard being_version_four_standard
+
+      alias being_version_four being_version_four_standard
+
+      alias v4 being_version_four_standard
+
+      # Constrain UUID to Version 1 compact format
+      #
+      # Creates a constraint ensuring the UUID is a Version 1 UUID in compact format.
+      # Version 1 UUIDs are time-based using a timestamp and node ID.
+      #
+      # @example
+      #   type.being_v1_compact
+      #   type.validate("123e4567e89b12d3a456426614174000")  # => true
+      #
+      # @return [self] self for method chaining
+      def being_version_one_compact: () -> self
+
+      alias being_v1_compact being_version_one_compact
+
+      alias v1_compact being_version_one_compact
+
+      # Constrain UUID to Version 1 standard format
+      #
+      # Creates a constraint ensuring the UUID is a Version 1 UUID in standard format.
+      # Version 1 UUIDs are time-based using a timestamp and node ID.
+      #
+      # @example
+      #   type.being_v1
+      #   type.validate("123e4567-e89b-12d3-a456-426614174000")  # => true
+      #
+      # @return [self] self for method chaining
+      def being_version_one_standard: () -> self
+
+      alias being_v1 being_version_one_standard
+
+      alias being_v1_standard being_version_one_standard
+
+      alias being_version_one being_version_one_standard
+
+      alias v1 being_version_one_standard
+
+      # Constrain UUID to Version 7 compact format
+      #
+      # Creates a constraint ensuring the UUID is a Version 7 UUID in compact format.
+      # Version 7 UUIDs use Unix Epoch timestamps with millisecond precision.
+      #
+      # @example
+      #   type.being_v7_compact
+      #   type.validate("123e4567e89b72d3a456426614174000")  # => true
+      #
+      # @return [self] self for method chaining
+      def being_version_seven_compact: () -> self
+
+      alias being_v7_compact being_version_seven_compact
+
+      alias v7_compact being_version_seven_compact
+
+      # Constrain UUID to Version 7 standard format
+      #
+      # Creates a constraint ensuring the UUID is a Version 7 UUID in standard format.
+      # Version 7 UUIDs use Unix Epoch timestamps with millisecond precision.
+      #
+      # @example
+      #   type.being_v7
+      #   type.validate("123e4567-e89b-72d3-a456-426614174000")  # => true
+      #
+      # @return [self] self for method chaining
+      def being_version_seven_standard: () -> self
+
+      alias being_v7 being_version_seven_standard
+
+      alias being_v7_standard being_version_seven_standard
+
+      alias being_version_seven being_version_seven_standard
+
+      alias v7 being_version_seven_standard
+
+      # Constrain UUID to Version 6 compact format
+      #
+      # Creates a constraint ensuring the UUID is a Version 6 UUID in compact format.
+      # Version 6 UUIDs are similar to Version 1 but with improved timestamp ordering.
+      #
+      # @example
+      #   type.being_v6_compact
+      #   type.validate("123e4567e89b62d3a456426614174000")  # => true
+      #
+      # @return [self] self for method chaining
+      def being_version_six_compact: () -> self
+
+      alias being_v6_compact being_version_six_compact
+
+      alias v6_compact being_version_six_compact
+
+      # Constrain UUID to Version 6 standard format
+      #
+      # Creates a constraint ensuring the UUID is a Version 6 UUID in standard format.
+      # Version 6 UUIDs are similar to Version 1 but with improved timestamp ordering.
+      #
+      # @example
+      #   type.being_v6
+      #   type.validate("123e4567-e89b-62d3-a456-426614174000")  # => true
+      #
+      # @return [self] self for method chaining
+      def being_version_six_standard: () -> self
+
+      alias being_v6 being_version_six_standard
+
+      alias being_v6_standard being_version_six_standard
+
+      alias being_version_six being_version_six_standard
+
+      alias v6 being_version_six_standard
+
+      # Constrain UUID to Version 3 compact format
+      #
+      # Creates a constraint ensuring the UUID is a Version 3 UUID in compact format.
+      # Version 3 UUIDs are name-based using MD5 hashing.
+      #
+      # @example
+      #   type.being_v3_compact
+      #   type.validate("123e4567e89b32d3a456426614174000")  # => true
+      #
+      # @return [self] self for method chaining
+      def being_version_three_compact: () -> self
+
+      alias being_v3_compact being_version_three_compact
+
+      alias v3_compact being_version_three_compact
+
+      # Constrain UUID to Version 3 standard format
+      #
+      # Creates a constraint ensuring the UUID is a Version 3 UUID in standard format.
+      # Version 3 UUIDs are name-based using MD5 hashing.
+      #
+      # @example
+      #   type.being_v3
+      #   type.validate("123e4567-e89b-32d3-a456-426614174000")  # => true
+      #
+      # @return [self] self for method chaining
+      def being_version_three_standard: () -> self
+
+      alias being_v3 being_version_three_standard
+
+      alias being_v3_standard being_version_three_standard
+
+      alias being_version_three being_version_three_standard
+
+      alias v3 being_version_three_standard
+
+      # Constrain UUID to Version 2 compact format
+      #
+      # Creates a constraint ensuring the UUID is a Version 2 UUID in compact format.
+      # Version 2 UUIDs are DCE Security version that incorporate local domain identifiers.
+      #
+      # @example
+      #   type.being_v2_compact
+      #   type.validate("123e4567e89b22d3a456426614174000")  # => true
+      #
+      # @return [self] self for method chaining
+      def being_version_two_compact: () -> self
+
+      alias being_v2_compact being_version_two_compact
+
+      alias v2_compact being_version_two_compact
+
+      # Constrain UUID to Version 2 standard format
+      #
+      # Creates a constraint ensuring the UUID is a Version 2 UUID in standard format.
+      # Version 2 UUIDs are DCE Security version that incorporate local domain identifiers.
+      #
+      # @example
+      #   type.being_v2
+      #   type.validate("123e4567-e89b-22d3-a456-426614174000")  # => true
+      #
+      # @return [self] self for method chaining
+      def being_version_two_standard: () -> self
+
+      alias being_v2 being_version_two_standard
+
+      alias being_v2_standard being_version_two_standard
+
+      alias being_version_two being_version_two_standard
+
+      alias v2 being_version_two_standard
+    end
+  end
+end

data/sig/domainic/type/types/network/email_address_type.rbs

@@ -0,0 +1,127 @@
+module Domainic
+  module Type
+    # A type for validating email addresses according to RFC standards
+    #
+    # This type provides comprehensive email address validation following RFC 5321 and 5322
+    # standards. It supports constraints on all email components (local part, hostname, TLD)
+    # while enforcing basic email requirements like maximum length and character set rules.
+    #
+    # Key features:
+    # - RFC compliant email format validation
+    # - Maximum length enforcement (254 characters)
+    # - ASCII character set requirement
+    # - Hostname and TLD validation
+    # - Local part pattern matching
+    #
+    # @example Basic usage
+    #   type = EmailAddressType.new
+    #   type.validate("user@example.com")  # => true
+    #   type.validate("invalid")           # => false
+    #
+    # @example With domain constraints
+    #   type = EmailAddressType.new
+    #     .having_hostname("example.com", "company.com")
+    #     .having_top_level_domain("com", "org")
+    #
+    # @example With local part validation
+    #   type = EmailAddressType.new
+    #     .having_local_matching(/^[a-z]+$/)
+    #     .not_having_local_matching(/^admin/)
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    class EmailAddressType
+      extend Behavior::ClassMethods
+
+      include Behavior
+
+      include Behavior::StringBehavior::MatchingBehavior
+
+      include Behavior::SizableBehavior
+
+      include Behavior::URIBehavior
+
+      # Constrain email to allowed hostnames
+      #
+      # Creates a constraint ensuring the domain part of the email matches one of the
+      # specified hostnames. This is useful for restricting emails to specific domains.
+      #
+      # @example
+      #   type.having_hostname("example.com", "company.com")
+      #   type.validate("user@example.com")  # => true
+      #   type.validate("user@other.com")    # => false
+      #
+      # @param hostnames [Array<String>] List of allowed hostnames
+      # @return [self] self for method chaining
+      def having_hostname: (*String hostnames) -> self
+
+      alias allowing_host having_hostname
+
+      alias allowing_hostname having_hostname
+
+      alias host having_hostname
+
+      alias hostname having_hostname
+
+      alias with_host having_hostname
+
+      alias with_hostname having_hostname
+
+      # Constrain email local part to match pattern
+      #
+      # Creates a constraint requiring the local part (before @) to match the given pattern.
+      # Useful for enforcing username conventions or restrictions.
+      #
+      # @example
+      #   type.having_local_matching(/^[a-z]+$/)
+      #   type.validate("user@example.com")    # => true
+      #   type.validate("123@example.com")     # => false
+      #
+      # @param pattern [Regexp] Pattern the local part must match
+      # @return [self] self for method chaining
+      def having_local_matching: (String | Regexp pattern) -> self
+
+      alias matching_local having_local_matching
+
+      alias with_local_matching having_local_matching
+
+      # Constrain email to exclude specific hostnames
+      #
+      # Creates a constraint ensuring the domain part of the email does not match any
+      # of the specified hostnames. Useful for blacklisting certain domains.
+      #
+      # @example
+      #   type.not_having_hostname("example.com")
+      #   type.validate("user@company.com")    # => true
+      #   type.validate("user@example.com")    # => false
+      #
+      # @param hostnames [Array<String>] List of forbidden hostnames
+      # @return [self] self for method chaining
+      def not_having_hostname: (*String hostnames) -> self
+
+      alias forbidding_host not_having_hostname
+
+      alias forbidding_hostname not_having_hostname
+
+      alias not_host not_having_hostname
+
+      alias not_hostname not_having_hostname
+
+      # Constrain email local part to not match pattern
+      #
+      # Creates a constraint ensuring the local part (before @) does not match the given
+      # pattern. Useful for preventing certain username patterns.
+      #
+      # @example
+      #   type.not_having_local_matching(/^admin/)
+      #   type.validate("user@example.com")     # => true
+      #   type.validate("admin@example.com")    # => false
+      #
+      # @param pattern [Regexp] Pattern the local part must not match
+      # @return [self] self for method chaining
+      def not_having_local_matching: (String | Regexp pattern) -> self
+
+      alias not_matching_local not_having_local_matching
+    end
+  end
+end

data/sig/domainic/type/types/network/hostname_type.rbs

@@ -0,0 +1,76 @@
+module Domainic
+  module Type
+    # A type for validating hostnames according to RFC 1034 and RFC 1123 standards
+    #
+    # This type provides comprehensive hostname validation, ensuring that values conform to
+    # DNS standards for hostnames. It supports constraints on the domain structure, such as
+    # top-level domain validation and hostname pattern matching.
+    #
+    # Key features:
+    # - RFC-compliant hostname validation
+    # - Maximum length enforcement (253 characters)
+    # - ASCII character set requirement
+    # - Validation of allowed or disallowed hostnames and TLDs
+    #
+    # @example Basic usage
+    #   type = HostNameType.new
+    #   type.validate("example.com") # => true
+    #   type.validate("invalid_host") # => false
+    #
+    # @example With domain constraints
+    #   type = HostNameType.new
+    #     .having_top_level_domain("com", "org")
+    #
+    # @example With hostname inclusion/exclusion
+    #   type = HostNameType.new
+    #     .having_hostname("example.com")
+    #     .not_having_hostname("forbidden.com")
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    class HostnameType
+      extend Behavior::ClassMethods
+
+      include Behavior
+
+      include Behavior::StringBehavior::MatchingBehavior
+
+      include Behavior::SizableBehavior
+
+      include Behavior::URIBehavior
+
+      RFC_HOSTNAME_REGEXP: Regexp
+
+      # Constrain hostname to allowed hostnames
+      #
+      # Creates a constraint ensuring the hostname matches one of the specified hostnames.
+      # This is useful for restricting to specific domains.
+      #
+      # @example
+      #   type.having_hostname("example.com", "company.com")
+      #   type.validate("example.com") # => true
+      #   type.validate("other.com")   # => false
+      #
+      # @param hostnames [Array<String>] List of allowed hostnames
+      # @return [self] self for method chaining
+      def matching: (*String hostnames) -> self
+
+      alias allowing matching
+
+      # Constrain hostname to exclude specific hostnames
+      #
+      # Ensures the hostname does not match any of the specified hostnames. Useful for blacklisting.
+      #
+      # @example
+      #   type.not_having_hostname("forbidden.com")
+      #   type.validate("allowed.com") # => true
+      #   type.validate("forbidden.com") # => false
+      #
+      # @param hostnames [Array<String>] List of forbidden hostnames
+      # @return [self] self for method chaining
+      def not_matching: (*String hostnames) -> self
+
+      alias forbidding not_matching
+    end
+  end
+end