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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e4f8e0bb4883a197a5ed2f87b53a6dbc60ae70a41f48f6369881e8a5a5249b0
-  data.tar.gz: b512246f56da3aa04d9b068c080324a7ab507f96b6749a6ed8701a8bc8615901
+  metadata.gz: 56d315e14fd05fe94174f580d09843c227cc5d763e994b47fd4094c26365dafc
+  data.tar.gz: cf0288834c42fdd9d985ddb889484273dbae5278e0b8f0f1bd0021317c0387ae
 SHA512:
-  metadata.gz: 5d807fab460c97af3e8fc50acb0f834ae8bc881d56507c668908d1baaa3b983516280a79c361fe30da893e38aeffa04561f265605c9c33633c64578a4461550f
-  data.tar.gz: c243d9fc6559e8d3be625c7db153d9964d2e36bcda90a33ba2e75f0cb8e69269cfa53542dddabf8fa7a4671da676bde29db7ae4893c5659d1702f38ff5a8f50f
+  metadata.gz: d53f6f1acc6969c093bb3617acb04ec17d507571c514604c941e378ad80341e7145d5f15298ec4922e68fc646e5f984cfc3e49fa8a7f2ab501d30456329dc9a4
+  data.tar.gz: 9e5a0a9815c013086aeb5d183b66f2dfa3e0db4c31d62b8357ce0a2a12ca5bd3aafdad0a94d8c01781171a61df7a37d9dacd21b5d9d9256fe218ce62bc7b81e7

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

@@ -8,6 +8,9 @@ constraints:
   any:
     constant: Domainic::Type::Constraint::AnyConstraint
     require_path: domainic/type/constraint/constraints/any_constraint
+  attribute_presence:
+    constant: Domainic::Type::Constraint::AttributePresenceConstraint
+    require_path: domainic/type/constraint/constraints/attribute_presence_constraint
   case:
     constant: Domainic::Type::Constraint::CaseConstraint
     require_path: domainic/type/constraint/constraints/case_constraint
@@ -29,6 +32,9 @@ constraints:
   inclusion:
     constant: Domainic::Type::Constraint::InclusionConstraint
     require_path: domainic/type/constraint/constraints/inclusion_constraint
+  instance_of:
+    constant: Domainic::Type::Constraint::InstanceOfConstraint
+    require_path: domainic/type/constraint/constraints/instance_of_constraint
   match_pattern:
     constant: Domainic::Type::Constraint::MatchPatternConstraint
     require_path: domainic/type/constraint/constraints/match_pattern_constraint
@@ -84,6 +90,9 @@ types:
   hash:
     constant: Domainic::Type::HashType
     require_path: domainic/type/types/core/hash_type
+  instance_type:
+    constant: Domainic::Type::InstanceType
+    require_path: domainic/type/types/specialized/instance_type
   integer:
     constant: Domainic::Type::IntegerType
     require_path: domainic/type/types/core/integer_type

data/lib/domainic/type/constraint/constraints/attribute_presence_constraint.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'domainic/type/behavior'
+require 'domainic/type/constraint/behavior'
+
+module Domainic
+  module Type
+    module Constraint
+      # A constraint that validates the presence and types of object attributes
+      #
+      # This constraint verifies that objects respond to specified attributes and that
+      # those attributes return values matching their corresponding type constraints.
+      # It supports both Ruby core types (Class/Module) and custom type constraints
+      # that implement the Type::Behavior interface.
+      #
+      # @example Basic attribute validation
+      #   # Validate presence and basic Ruby types
+      #   constraint = AttributePresenceConstraint.new(:self,
+      #     username: String,
+      #     age: Integer
+      #   )
+      #
+      #   # Success case
+      #   user = User.new(username: "alice", age: 30)
+      #   constraint.satisfied?(user) # => true
+      #
+      #   # Missing attribute failure
+      #   user = User.new(username: "bob")
+      #   constraint.satisfied?(user) # => false
+      #   constraint.short_violation_description # => "missing attributes: age"
+      #
+      #   # Wrong type failure
+      #   user = User.new(username: 123, age: "30")
+      #   constraint.satisfied?(user) # => false
+      #   constraint.short_violation_description
+      #     # => "invalid attributes: username: 123, age: \"30\""
+      #
+      # @example With custom type constraints
+      #   # Combine with other type constraints
+      #   constraint = AttributePresenceConstraint.new(:self,
+      #     username: _String.having_size_between(3, 20),
+      #     role: _Enum(:admin, :user),
+      #     email: _String.matching(/@/)
+      #   )
+      #
+      # @author {https://aaronmallen.me Aaron Allen}
+      # @since 0.1.0
+      class AttributePresenceConstraint
+        include Behavior #[Hash[Symbol, Class | Module | Type::Behavior], untyped, {}]
+
+        # Get a description of what the constraint expects
+        #
+        # @return [String] the constraint description
+        # @rbs override
+        def short_description
+          "attributes #{@expected.map { |attribute, type| "#{attribute}: #{type.inspect}" }.join(', ')}".strip
+        end
+
+        # Get a description of why the constraint was violated
+        #
+        # @return [String] the violation description
+        # @rbs override
+        def short_violation_description
+          missing, invalid = violations
+          return '' if missing.empty? && invalid.empty?
+
+          # @type var missing: Array[Symbol]
+          # @type var invalid: Array[Symbol]
+
+          [
+            missing.empty? ? nil : "missing attributes: #{missing.join(', ')}",
+            invalid.empty? ? nil : "invalid attributes: #{format_invalid_attributes(invalid)}"
+          ].compact.join(' and ')
+        end
+
+        protected
+
+        # Coerce expectation hash keys into symbols
+        #
+        # @param expectation [Hash] the raw expectation hash
+        #
+        # @return [Hash] the coerced expectation
+        # @rbs override
+        def coerce_expectation(expectation)
+          return expectation unless expectation.is_a?(Hash)
+
+          expectation.transform_keys(&:to_sym)
+        end
+
+        # Format the list of invalid attributes for error messages
+        #
+        # @param invalid [Array<Symbol>] The list of invalid attribute names
+        #
+        # @return [String] formatted error message
+        # @rbs (Array[Symbol] invalid) -> String
+        def format_invalid_attributes(invalid)
+          invalid.map do |attribute| # use filter_map to exclude nil entries
+            "#{attribute}: #{@actual.public_send(attribute).inspect}"
+          end.join(', ')
+        end
+
+        # Check if the constraint is satisfied
+        #
+        # @return [Boolean] whether all attributes exist and have valid types
+        # @rbs override
+        def satisfies_constraint?
+          violations.all?(&:empty?)
+        end
+
+        # Check if a value satisfies a type constraint
+        #
+        # @param value [Object] the value to check
+        # @param type [Class, Module, Type::Behavior] the type to check against
+        #
+        # @return [Boolean] whether the value matches the type
+        # @rbs (untyped value, Class | Module | Type::Behavior type) -> bool
+        def satisfies_type?(value, type)
+          type === value || value.is_a?(type) # rubocop:disable Style/CaseEquality
+        end
+
+        # Validate the format of the expectation hash
+        #
+        # @param expectation [Hash] the expectation to validate
+        #
+        # @raise [ArgumentError] if the expectation is invalid
+        # @return [void]
+        # @rbs override
+        def validate_expectation!(expectation)
+          raise ArgumentError, 'Expectation must be a Hash' unless expectation.is_a?(Hash)
+          raise ArgumentError, 'Expectation must have symbolized keys' unless expectation.keys.all?(Symbol)
+
+          expectation.each_value do |value|
+            next if [Class, Module, Type::Behavior].any? { |type| value.is_a?(type) }
+
+            raise ArgumentError, 'Expectation must have values of Class, Module, or Domainic::Type'
+          end
+        end
+
+        # Get lists of missing and invalid attributes
+        #
+        # @return [Array(Array<Symbol>, Array<Symbol>)] missing and invalid attribute lists
+        # @rbs () -> Array[Array[Symbol]]
+        def violations
+          @violations ||= begin
+            missing = @expected.keys.reject { |attribute| @actual.respond_to?(attribute) }
+            invalid = @expected.reject do |attribute, type|
+              missing.include?(attribute) || satisfies_type?(@actual.public_send(attribute), type)
+            end.keys
+            [missing, invalid] #: Array[Array[Symbol]]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/domainic/type/constraint/constraints/instance_of_constraint.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'domainic/type/constraint/behavior'
+
+module Domainic
+  module Type
+    module Constraint
+      # A constraint for validating that a value is an instance of a specified class or module.
+      #
+      # This constraint checks if the value is a direct instance of the expected class or module
+      # (excluding subclasses or other related types).
+      #
+      # @example Basic instance validation
+      #   constraint = InstanceOfConstraint.new(:self, String)
+      #   constraint.satisfied?("test")     # => true
+      #   constraint.satisfied?(:symbol)   # => false
+      #
+      # @example Custom class validation
+      #   class MyClass; end
+      #   constraint = InstanceOfConstraint.new(:self, MyClass)
+      #   constraint.satisfied?(MyClass.new) # => true
+      #   constraint.satisfied?("test")      # => false
+      #
+      # @author {https://aaronmallen.me Aaron Allen}
+      # @since 0.1.0
+      class InstanceOfConstraint
+        include Behavior #[Class | Module, untyped, {}]
+
+        # Get a human-readable description of the instance requirement.
+        #
+        # @example
+        #   constraint = InstanceOfConstraint.new(:self, String)
+        #   constraint.description # => "instance of String"
+        #
+        # @return [String] A description of the expected instance type
+        # @rbs override
+        def short_description
+          "instance of #{@expected}"
+        end
+
+        # Get a human-readable description of why instance validation failed.
+        #
+        # @example
+        #   constraint = InstanceOfConstraint.new(:self, String)
+        #   constraint.satisfied?(:symbol)
+        #   constraint.short_violation_description # => "not an instance of String"
+        #
+        # @return [String] A description of the instance validation failure
+        # @rbs override
+        def short_violation_description
+          "not an instance of #{@expected}"
+        end
+
+        protected
+
+        # Check if the actual value is an instance of the expected class or module.
+        #
+        # @return [Boolean] true if the value is an instance of the expected class/module
+        # @rbs override
+        def satisfies_constraint?
+          @actual.class < @expected || @actual.instance_of?(@expected)
+        end
+
+        # Validate that the expected value is a Class or Module.
+        #
+        # @raise [ArgumentError] if the expected value is not a Class or Module
+        # @return [void]
+        # @rbs override
+        def validate_expectation!(expectation)
+          return if [Class, Module].any? { |mod| expectation.is_a?(mod) }
+
+          raise ArgumentError, 'Expectation must be a Class or Module'
+        end
+      end
+    end
+  end
+end

data/lib/domainic/type/definitions.rb

@@ -218,6 +218,35 @@ module Domainic
       end
       alias _Map? _Hash?
 
+      # Create an InstanceType instance.
+      #
+      # @example
+      #   _type = _Instance.of(User)
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::InstanceType]
+      # @rbs (**__todo__ options) -> InstanceType
+      def _Instance(**options)
+        require 'domainic/type/types/specialized/instance_type'
+        Domainic::Type::InstanceType.new(**options)
+      end
+      alias _Record _Instance
+
+      # Create an InstanceType instance.
+      #
+      # @example
+      #   _type = _Instance?(of: User)
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (Integer or NilClass)
+      # @rbs (**__todo__ options) -> UnionType
+      def _Instance?(**options)
+        _Nilable(_Instance(**options))
+      end
+      alias _Record? _Instance?
+
       # Creates an IntegerType instance.
       #
       # @example

data/lib/domainic/type/types/specialized/instance_type.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'domainic/type/behavior'
+
+module Domainic
+  module Type
+    # A type for validation that an object is an instance of a specific class or module.
+    #
+    # This class provides flexible constraints for ensuring objects conform to
+    # expected types, including specific class or module checks, as well as
+    # constraints on attributes within those objects.
+    #
+    # Key features:
+    # - Instance type constraints for classes and modules
+    # - Attribute presence constraints
+    # - Extensible through the Domainic type system
+    #
+    # @example Basic usage
+    #   type = InstanceType.new
+    #   type.of(String)                    # enforce instance of String
+    #   type.constrain("example")          # => true
+    #   type.constrain(123)                # => false
+    #
+    # @example Attribute constraints
+    #   type = InstanceType.new
+    #   type.having_attributes(name: String, age: Integer) # enforce attribute presence and types
+    #   type.constrain(OpenStruct.new(name: "John", age: 30)) # => true
+    #   type.constrain(OpenStruct.new(name: "John"))          # => false
+    #
+    # @example Combined constraints
+    #   type = InstanceType.new
+    #   type
+    #     .of(User)                          # enforce instance of User
+    #     .having_attributes(:email => String, :admin => Symbol) # attribute constraints
+    #   type.validate(User.new(email: "admin@example.com", admin: :admin)) # => true
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    class InstanceType
+      # @rbs! extend Behavior::ClassMethods
+
+      include Behavior
+
+      # Constrain that the object has specific attributes.
+      #
+      # @example
+      #   type.having_attributes(name: String, age: Integer)
+      #   type.constrain(OpenStruct.new(name: "John", age: 30)) # => true
+      #   type.constrain(OpenStruct.new(name: "John"))          # => false
+      #
+      # @param attributes [Hash{String, Symbol => Class, Module, Behavior}] the attributes and their expected types
+      # @return [self] self for method chaining
+      # @rbs (Hash[String | Symbol, Class | Module | Behavior] attributes) -> self
+      def having_attributes(attributes)
+        constrain :self, :attribute_presence, attributes, description: 'having'
+      end
+
+      # Constrain that the object is an instance of the specified class or module.
+      #
+      # @example
+      #   type.of(String)
+      #   type.constrain("example")       # => true
+      #   type.constrain(123)             # => false
+      #
+      # @param type [Class, Module, Behavior] the expected class, module, or behavior
+      # @return [self] self for method chaining
+      # @rbs (Class | Module | Behavior type) -> self
+      def of(type)
+        constrain :self, :instance_of, type, description: 'of'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+module Domainic
+  module Type
+    module Constraint
+      # A constraint that validates the presence and types of object attributes
+      #
+      # This constraint verifies that objects respond to specified attributes and that
+      # those attributes return values matching their corresponding type constraints.
+      # It supports both Ruby core types (Class/Module) and custom type constraints
+      # that implement the Type::Behavior interface.
+      #
+      # @example Basic attribute validation
+      #   # Validate presence and basic Ruby types
+      #   constraint = AttributePresenceConstraint.new(:self,
+      #     username: String,
+      #     age: Integer
+      #   )
+      #
+      #   # Success case
+      #   user = User.new(username: "alice", age: 30)
+      #   constraint.satisfied?(user) # => true
+      #
+      #   # Missing attribute failure
+      #   user = User.new(username: "bob")
+      #   constraint.satisfied?(user) # => false
+      #   constraint.short_violation_description # => "missing attributes: age"
+      #
+      #   # Wrong type failure
+      #   user = User.new(username: 123, age: "30")
+      #   constraint.satisfied?(user) # => false
+      #   constraint.short_violation_description
+      #     # => "invalid attributes: username: 123, age: \"30\""
+      #
+      # @example With custom type constraints
+      #   # Combine with other type constraints
+      #   constraint = AttributePresenceConstraint.new(:self,
+      #     username: _String.having_size_between(3, 20),
+      #     role: _Enum(:admin, :user),
+      #     email: _String.matching(/@/)
+      #   )
+      #
+      # @author {https://aaronmallen.me Aaron Allen}
+      # @since 0.1.0
+      class AttributePresenceConstraint
+        include Behavior[Hash[Symbol, Class | Module | Type::Behavior], untyped, { }]
+
+        # Get a description of what the constraint expects
+        #
+        # @return [String] the constraint description
+        def short_description: ...
+
+        # Get a description of why the constraint was violated
+        #
+        # @return [String] the violation description
+        def short_violation_description: ...
+
+        # Coerce expectation hash keys into symbols
+        #
+        # @param expectation [Hash] the raw expectation hash
+        #
+        # @return [Hash] the coerced expectation
+        def coerce_expectation: ...
+
+        # Format the list of invalid attributes for error messages
+        #
+        # @param invalid [Array<Symbol>] The list of invalid attribute names
+        #
+        # @return [String] formatted error message
+        def format_invalid_attributes: (Array[Symbol] invalid) -> String
+
+        # Check if the constraint is satisfied
+        #
+        # @return [Boolean] whether all attributes exist and have valid types
+        def satisfies_constraint?: ...
+
+        # Check if a value satisfies a type constraint
+        #
+        # @param value [Object] the value to check
+        # @param type [Class, Module, Type::Behavior] the type to check against
+        #
+        # @return [Boolean] whether the value matches the type
+        def satisfies_type?: (untyped value, Class | Module | Type::Behavior type) -> bool
+
+        # Validate the format of the expectation hash
+        #
+        # @param expectation [Hash] the expectation to validate
+        #
+        # @raise [ArgumentError] if the expectation is invalid
+        # @return [void]
+        def validate_expectation!: ...
+
+        # Get lists of missing and invalid attributes
+        #
+        # @return [Array(Array<Symbol>, Array<Symbol>)] missing and invalid attribute lists
+        def violations: () -> Array[Array[Symbol]]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module Domainic
+  module Type
+    module Constraint
+      # A constraint for validating that a value is an instance of a specified class or module.
+      #
+      # This constraint checks if the value is a direct instance of the expected class or module
+      # (excluding subclasses or other related types).
+      #
+      # @example Basic instance validation
+      #   constraint = InstanceOfConstraint.new(:self, String)
+      #   constraint.satisfied?("test")     # => true
+      #   constraint.satisfied?(:symbol)   # => false
+      #
+      # @example Custom class validation
+      #   class MyClass; end
+      #   constraint = InstanceOfConstraint.new(:self, MyClass)
+      #   constraint.satisfied?(MyClass.new) # => true
+      #   constraint.satisfied?("test")      # => false
+      #
+      # @author {https://aaronmallen.me Aaron Allen}
+      # @since 0.1.0
+      class InstanceOfConstraint
+        include Behavior[Class | Module, untyped, { }]
+
+        # Get a human-readable description of the instance requirement.
+        #
+        # @example
+        #   constraint = InstanceOfConstraint.new(:self, String)
+        #   constraint.description # => "instance of String"
+        #
+        # @return [String] A description of the expected instance type
+        def short_description: ...
+
+        # Get a human-readable description of why instance validation failed.
+        #
+        # @example
+        #   constraint = InstanceOfConstraint.new(:self, String)
+        #   constraint.satisfied?(:symbol)
+        #   constraint.short_violation_description # => "not an instance of String"
+        #
+        # @return [String] A description of the instance validation failure
+        def short_violation_description: ...
+
+        # Check if the actual value is an instance of the expected class or module.
+        #
+        # @return [Boolean] true if the value is an instance of the expected class/module
+        def satisfies_constraint?: ...
+
+        # Validate that the expected value is a Class or Module.
+        #
+        # @raise [ArgumentError] if the expected value is not a Class or Module
+        # @return [void]
+        def validate_expectation!: ...
+      end
+    end
+  end
+end

data/sig/domainic/type/definitions.rbs

@@ -184,6 +184,30 @@ module Domainic
 
       alias _Map? _Hash?
 
+      # Create an InstanceType instance.
+      #
+      # @example
+      #   _type = _Instance.of(User)
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::InstanceType]
+      def _Instance: (**__todo__ options) -> InstanceType
+
+      alias _Record _Instance
+
+      # Create an InstanceType instance.
+      #
+      # @example
+      #   _type = _Instance?(of: User)
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (Integer or NilClass)
+      def _Instance?: (**__todo__ options) -> UnionType
+
+      alias _Record? _Instance?
+
       # Creates an IntegerType instance.
       #
       # @example

data/sig/domainic/type/types/specialized/instance_type.rbs

@@ -0,0 +1,63 @@
+module Domainic
+  module Type
+    # A type for validation that an object is an instance of a specific class or module.
+    #
+    # This class provides flexible constraints for ensuring objects conform to
+    # expected types, including specific class or module checks, as well as
+    # constraints on attributes within those objects.
+    #
+    # Key features:
+    # - Instance type constraints for classes and modules
+    # - Attribute presence constraints
+    # - Extensible through the Domainic type system
+    #
+    # @example Basic usage
+    #   type = InstanceType.new
+    #   type.of(String)                    # enforce instance of String
+    #   type.constrain("example")          # => true
+    #   type.constrain(123)                # => false
+    #
+    # @example Attribute constraints
+    #   type = InstanceType.new
+    #   type.having_attributes(name: String, age: Integer) # enforce attribute presence and types
+    #   type.constrain(OpenStruct.new(name: "John", age: 30)) # => true
+    #   type.constrain(OpenStruct.new(name: "John"))          # => false
+    #
+    # @example Combined constraints
+    #   type = InstanceType.new
+    #   type
+    #     .of(User)                          # enforce instance of User
+    #     .having_attributes(:email => String, :admin => Symbol) # attribute constraints
+    #   type.validate(User.new(email: "admin@example.com", admin: :admin)) # => true
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    class InstanceType
+      extend Behavior::ClassMethods
+
+      include Behavior
+
+      # Constrain that the object has specific attributes.
+      #
+      # @example
+      #   type.having_attributes(name: String, age: Integer)
+      #   type.constrain(OpenStruct.new(name: "John", age: 30)) # => true
+      #   type.constrain(OpenStruct.new(name: "John"))          # => false
+      #
+      # @param attributes [Hash{String, Symbol => Class, Module, Behavior}] the attributes and their expected types
+      # @return [self] self for method chaining
+      def having_attributes: (Hash[String | Symbol, Class | Module | Behavior] attributes) -> self
+
+      # Constrain that the object is an instance of the specified class or module.
+      #
+      # @example
+      #   type.of(String)
+      #   type.constrain("example")       # => true
+      #   type.constrain(123)             # => false
+      #
+      # @param type [Class, Module, Behavior] the expected class, module, or behavior
+      # @return [self] self for method chaining
+      def of: (Class | Module | Behavior type) -> self
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: domainic-type
 version: !ruby/object:Gem::Version
-  version: 0.1.0.alpha.3.0.1
+  version: 0.1.0.alpha.3.0.2
 platform: ruby
 authors:
 - Aaron Allen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-24 00:00:00.000000000 Z
+date: 2024-12-25 00:00:00.000000000 Z
 dependencies: []
 description: Stop wrestling with complex type validations and unclear error messages.
   Domainic::Type brings type validation to Ruby that is both powerful and delightful
@@ -37,6 +37,7 @@ files:
 - lib/domainic/type/constraint/constraints/all_constraint.rb
 - lib/domainic/type/constraint/constraints/and_constraint.rb
 - lib/domainic/type/constraint/constraints/any_constraint.rb
+- lib/domainic/type/constraint/constraints/attribute_presence_constraint.rb
 - lib/domainic/type/constraint/constraints/case_constraint.rb
 - lib/domainic/type/constraint/constraints/character_set_constraint.rb
 - lib/domainic/type/constraint/constraints/divisibility_constraint.rb
@@ -44,6 +45,7 @@ files:
 - lib/domainic/type/constraint/constraints/equality_constraint.rb
 - lib/domainic/type/constraint/constraints/finiteness_constraint.rb
 - lib/domainic/type/constraint/constraints/inclusion_constraint.rb
+- lib/domainic/type/constraint/constraints/instance_of_constraint.rb
 - lib/domainic/type/constraint/constraints/match_pattern_constraint.rb
 - lib/domainic/type/constraint/constraints/method_presence_constraint.rb
 - lib/domainic/type/constraint/constraints/none_constraint.rb
@@ -65,6 +67,7 @@ files:
 - lib/domainic/type/types/core/integer_type.rb
 - lib/domainic/type/types/core/string_type.rb
 - lib/domainic/type/types/core/symbol_type.rb
+- lib/domainic/type/types/specialized/instance_type.rb
 - lib/domainic/type/types/specification/anything_type.rb
 - lib/domainic/type/types/specification/duck_type.rb
 - lib/domainic/type/types/specification/enum_type.rb
@@ -82,6 +85,7 @@ files:
 - sig/domainic/type/constraint/constraints/all_constraint.rbs
 - sig/domainic/type/constraint/constraints/and_constraint.rbs
 - sig/domainic/type/constraint/constraints/any_constraint.rbs
+- sig/domainic/type/constraint/constraints/attribute_presence_constraint.rbs
 - sig/domainic/type/constraint/constraints/case_constraint.rbs
 - sig/domainic/type/constraint/constraints/character_set_constraint.rbs
 - sig/domainic/type/constraint/constraints/divisibility_constraint.rbs
@@ -89,6 +93,7 @@ files:
 - sig/domainic/type/constraint/constraints/equality_constraint.rbs
 - sig/domainic/type/constraint/constraints/finiteness_constraint.rbs
 - sig/domainic/type/constraint/constraints/inclusion_constraint.rbs
+- sig/domainic/type/constraint/constraints/instance_of_constraint.rbs
 - sig/domainic/type/constraint/constraints/match_pattern_constraint.rbs
 - sig/domainic/type/constraint/constraints/method_presence_constraint.rbs
 - sig/domainic/type/constraint/constraints/none_constraint.rbs
@@ -110,21 +115,22 @@ files:
 - sig/domainic/type/types/core/integer_type.rbs
 - sig/domainic/type/types/core/string_type.rbs
 - sig/domainic/type/types/core/symbol_type.rbs
+- sig/domainic/type/types/specialized/instance_type.rbs
 - sig/domainic/type/types/specification/anything_type.rbs
 - sig/domainic/type/types/specification/duck_type.rbs
 - sig/domainic/type/types/specification/enum_type.rbs
 - sig/domainic/type/types/specification/union_type.rbs
 - sig/domainic/type/types/specification/void_type.rbs
 - sig/manifest.yaml
-homepage: https://github.com/domainic/domainic/tree/domainic-type-v0.1.0-alpha.3.0.1/domainic-type
+homepage: https://github.com/domainic/domainic/tree/domainic-type-v0.1.0-alpha.3.0.2/domainic-type
 licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/domainic/domainic/issues
-  changelog_uri: https://github.com/domainic/domainic/releases/tag/domainic-type-v0.1.0-alpha.3.0.1
-  homepage_uri: https://github.com/domainic/domainic/tree/domainic-type-v0.1.0-alpha.3.0.1/domainic-type
+  changelog_uri: https://github.com/domainic/domainic/releases/tag/domainic-type-v0.1.0-alpha.3.0.2
+  homepage_uri: https://github.com/domainic/domainic/tree/domainic-type-v0.1.0-alpha.3.0.2/domainic-type
   rubygems_mfa_required: 'true'
-  source_code_uri: https://github.com/domainic/domainic/tree/domainic-type-v0.1.0-alpha.3.0.1/domainic-type
+  source_code_uri: https://github.com/domainic/domainic/tree/domainic-type-v0.1.0-alpha.3.0.2/domainic-type
 post_install_message:
 rdoc_options: []
 require_paths: