strict 1.5.0 → 2.1.0

data/lib/strict/rspec.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "strict"
+require "rspec/core"
+require "rspec/expectations"
+require "rspec/mocks"
+require "rspec/support/fuzzy_matcher"
+
+module Strict
+  module RSpec
+    module Support
+      NO_VIOLATIONS = [].freeze
+      INSTANCE_VARIABLE_GET = ::Object.instance_method(:instance_variable_get)
+      private_constant :NO_VIOLATIONS
+      private_constant :INSTANCE_VARIABLE_GET
+
+      class << self
+        def violations(validator, value)
+          return NO_VIOLATIONS if test_value?(validator, value)
+          return validator.violations(value) if Strict::DetailedValidator === validator
+          return NO_VIOLATIONS if validator === value
+
+          [Strict::Violation.new(path: [], code: :invalid, value: value, validator: validator)]
+        end
+
+        def test_value?(validator, value)
+          matcher?(value) || instance_double_valid_for?(validator, value)
+        end
+
+        def no_violations
+          NO_VIOLATIONS
+        end
+
+        def stubs_for(strict_class, stubs)
+          return stubs unless strict_class.respond_to?(:verify_implementation!)
+
+          strict_class.strict_instance_methods.to_h { |name, _method| [name, nil] }.merge(stubs)
+        end
+
+        def violation_details(violations)
+          descriptions = violations.map { |violation| "  - #{violation_description(violation)}" }
+          "violations:\n#{descriptions.join("\n")}"
+        end
+
+        private
+
+        def matcher?(value)
+          ::RSpec::Support.is_a_matcher?(value)
+        end
+
+        def instance_double_valid_for?(validator, value)
+          return false unless ::RSpec::Mocks::InstanceVerifyingDouble === value
+          return false unless ::Module === validator
+
+          doubled_module = INSTANCE_VARIABLE_GET.bind_call(value, :@doubled_module).target
+          doubled_module && !!(doubled_module <= validator)
+        end
+
+        def violation_description(violation)
+          location = violation.path.empty? ? "root" : violation.path.inspect
+
+          case violation.code
+          when :invalid
+            "at #{location}: expected #{format(violation.validator)}, got #{format(violation.value)}"
+          when :missing
+            "at #{location}: expected #{format(violation.validator)}, but the value was missing"
+          when :unexpected
+            "at #{location}: got unexpected #{format(violation.value)}"
+          end
+        end
+
+        def format(value)
+          ::RSpec::Support::ObjectFormatter.format(value)
+        end
+      end
+    end
+
+    module AcceptsMatchersAndDoubles
+      def violations(value, configuration = Strict.configuration)
+        return Support.no_violations if Support.test_value?(validator, value)
+
+        super
+      end
+    end
+
+    module AcceptsNestedMatchersAndDoubles
+      def violations(validator, value)
+        return Support.no_violations if Support.test_value?(validator, value)
+
+        super
+      end
+    end
+
+    module ComposableValue
+      def ===(other)
+        return false unless other.instance_of?(self.class)
+
+        self.class.strict_attributes.all? do |attribute|
+          expected = public_send(attribute.name)
+          actual = other.public_send(attribute.name)
+          ::RSpec::Support::FuzzyMatcher.values_match?(expected, actual)
+        end
+      end
+    end
+
+    module ExampleMethods
+      def strict_double(strict_class, stubs = {})
+        instance_double(strict_class, Support.stubs_for(strict_class, stubs))
+      end
+    end
+
+    Strict::Declaration.prepend(AcceptsMatchersAndDoubles)
+    Strict::Return.prepend(AcceptsMatchersAndDoubles)
+    Strict::Validation.singleton_class.prepend(AcceptsNestedMatchersAndDoubles)
+    Strict::Value.prepend(ComposableValue)
+
+    ::RSpec.configure do |config|
+      config.include ExampleMethods
+    end
+
+    ::RSpec::Matchers.define :conform_to do |interface|
+      match do |implementation|
+        @conformance_error = nil
+        interface.verify_implementation!(implementation)
+        true
+      rescue Strict::ImplementationDoesNotConformError => e
+        @conformance_error = e
+        false
+      end
+
+      failure_message do |implementation|
+        "expected #{implementation.inspect} to conform to #{interface.inspect}\n\n#{@conformance_error.message}"
+      end
+
+      failure_message_when_negated do |implementation|
+        "expected #{implementation.inspect} not to conform to #{interface.inspect}"
+      end
+    end
+
+    ::RSpec::Matchers.define :validate do |value|
+      match do |validator|
+        @violations = Support.violations(validator, value)
+        @violations.empty?
+      end
+
+      failure_message do |validator|
+        message = "expected #{validator.inspect} to validate #{value.inspect}"
+        "#{message}\n\n#{Support.violation_details(@violations)}"
+      end
+
+      failure_message_when_negated do |validator|
+        "expected #{validator.inspect} not to validate #{value.inspect}"
+      end
+    end
+
+    private_constant :Support, :AcceptsMatchersAndDoubles, :AcceptsNestedMatchersAndDoubles, :ComposableValue,
+                     :ExampleMethods
+  end
+end

data/lib/strict/union.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module Strict
+  module Union
+    VARIANT_NAME = /\A[a-z][a-z0-9]*(?:_[a-z0-9]+)*\z/
+    private_constant :VARIANT_NAME
+    Variant = Data.define(:tag, :variant_class)
+    private_constant :Variant
+
+    def self.included(union_class)
+      union_class.extend(ClassMethods)
+      union_class.include(Instance)
+      union_class.instance_variable_set(:@strict_union_discriminator, nil)
+      union_class.instance_variable_set(:@strict_union_attributes, nil)
+      union_class.instance_variable_set(:@strict_union_variant_names, {})
+      union_class.instance_variable_set(:@strict_union_variants, {})
+    end
+
+    module ClassMethods # rubocop:disable Metrics/ModuleLength
+      def discriminator(name)
+        raise ArgumentError, "discriminator already declared for #{self}" if @strict_union_discriminator
+
+        discriminator = name.to_sym
+        strict_union_validate_attributes!(@strict_union_attributes, discriminator)
+        @strict_union_discriminator = discriminator
+        nil
+      end
+
+      def attributes(&definition)
+        raise ArgumentError, "attributes already declared for #{self}" if @strict_union_attributes
+        raise ArgumentError, "attributes must be declared before variants for #{self}" if @strict_union_variants.any?
+
+        definition ||= -> {}
+        attributes = Attributes::Dsl.run(&definition)
+        strict_union_validate_attributes!(attributes, @strict_union_discriminator)
+        @strict_union_attributes = attributes
+        nil
+      end
+
+      def variant(name, tag: name.to_sym, &definition)
+        discriminator = strict_union_discriminator!
+        name = name.to_sym
+        tag_key = strict_union_tag_key(tag)
+        constant_name = strict_union_validate_variant!(name, tag, tag_key)
+        variant_class = strict_union_build_variant(discriminator, name, tag, definition)
+        strict_union_validate_interrogation_method!(name, variant_class)
+        strict_union_register_variant(name, tag, tag_key, constant_name, variant_class)
+      end
+
+      def coercer
+        discriminator = @strict_union_discriminator
+        raise ArgumentError, "declare a discriminator before using the coercer for #{self}" unless discriminator
+
+        Unions::Coercer.new(self, discriminator:, variants: @strict_union_variants)
+      end
+
+      def ===(value)
+        @strict_union_variant_names&.value?(value.class) || false
+      end
+
+      private
+
+      def strict_union_validate_variant!(name, tag, tag_key)
+        constant_name = strict_union_constant_name(name)
+        raise ArgumentError, "variant #{name.inspect} already declared for #{self}" if
+          @strict_union_variant_names.key?(name)
+        raise ArgumentError, "tag #{tag.inspect} already declared for #{self}" if @strict_union_variants.key?(tag_key)
+        raise ArgumentError, "constant #{constant_name} is already defined for #{self}" if
+          const_defined?(constant_name, false)
+        raise ArgumentError, "variant convenience method #{name.inspect} already exists for #{self}" if
+          strict_union_method_defined?(singleton_class, name)
+
+        constant_name
+      end
+
+      def strict_union_validate_interrogation_method!(name, variant_class)
+        method_name = strict_union_interrogation_method(name)
+        owners = [self, *@strict_union_variant_names.values, variant_class]
+        conflicting_owner = owners.find { |owner| strict_union_method_defined?(owner, method_name) }
+        raise ArgumentError, "interrogation method #{method_name.inspect} already exists for #{conflicting_owner}" if
+          conflicting_owner
+
+        strict_union_validate_existing_interrogation_methods!(variant_class)
+      end
+
+      def strict_union_validate_existing_interrogation_methods!(variant_class)
+        @strict_union_variant_names.each_key do |variant_name|
+          existing_method = strict_union_interrogation_method(variant_name)
+          next if variant_class.instance_method(existing_method).owner.equal?(self)
+
+          raise ArgumentError, "interrogation method #{existing_method.inspect} already exists for #{variant_class}"
+        end
+      end
+
+      def strict_union_register_variant(name, tag, tag_key, constant_name, variant_class)
+        const_set(constant_name, variant_class)
+        @strict_union_variant_names[name] = variant_class
+        @strict_union_variants[tag_key] = Variant.new(tag:, variant_class:)
+        define_singleton_method(name) { |**attributes| variant_class.new(**attributes) }
+        define_method(strict_union_interrogation_method(name)) { variant_class === self }
+        variant_class
+      end
+
+      def strict_union_interrogation_method(name)
+        :"#{name}?"
+      end
+
+      def strict_union_method_defined?(owner, name)
+        owner.public_method_defined?(name) ||
+          owner.protected_method_defined?(name) ||
+          owner.private_method_defined?(name)
+      end
+
+      def strict_union_discriminator!
+        @strict_union_discriminator ||
+          raise(ArgumentError, "declare a discriminator before variants for #{self}")
+      end
+
+      def strict_union_build_variant(discriminator, name, tag, definition)
+        variant_class = Class.new(self)
+        attribute_definition = strict_union_evaluate_variant(variant_class, name, definition)
+        variant_class.include(Strict::Value)
+        strict_union_define_variant_attributes(variant_class, discriminator, tag, attribute_definition)
+        variant_class.define_singleton_method(:===, ::Module.instance_method(:===))
+        variant_class
+      end
+
+      def strict_union_evaluate_variant(variant_class, tag, definition)
+        return unless definition
+
+        attribute_definition = nil
+        variant_class.define_singleton_method(:attributes) do |&block|
+          raise ArgumentError, "attributes already declared for variant #{tag.inspect}" if attribute_definition
+
+          attribute_definition = block || -> {}
+          nil
+        end
+        variant_class.class_exec(&definition)
+        variant_class.singleton_class.remove_method(:attributes)
+        attribute_definition
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def strict_union_define_variant_attributes(variant_class, discriminator, tag, attribute_definition)
+        discriminator_coercer = strict_union_discriminator_coercer(discriminator, tag)
+        shared_attributes = @strict_union_attributes
+        variant_class.attributes do
+          strict_attribute discriminator, tag, default_value: tag, coerce: discriminator_coercer
+          discriminator_attribute = __strict_dsl_internal_attributes.fetch(discriminator)
+          shared_attributes&.each do |attribute|
+            __strict_dsl_internal_attributes[attribute.name] = attribute
+          end
+          instance_exec(&attribute_definition) if attribute_definition
+          unless __strict_dsl_internal_attributes.fetch(discriminator).equal?(discriminator_attribute)
+            ::Kernel.raise ::ArgumentError, "variants cannot redeclare discriminator #{discriminator.inspect}"
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def strict_union_validate_attributes!(attributes, discriminator)
+        return unless discriminator && attributes
+
+        storage = Attribute.instance_variable_for(discriminator)
+        conflicting_attribute = attributes.find { |attribute| attribute.instance_variable.eql?(storage) }
+        return unless conflicting_attribute
+
+        if conflicting_attribute.name.eql?(discriminator)
+          raise ArgumentError, "union attributes cannot redeclare discriminator #{discriminator.inspect}"
+        end
+
+        raise ArgumentError,
+              "union attributes cannot conflict with discriminator #{discriminator.inspect}: " \
+              "#{conflicting_attribute.name.inspect} uses #{storage}"
+      end
+
+      def strict_union_discriminator_coercer(discriminator, tag)
+        tag_key = strict_union_tag_key(tag)
+        lambda do |value|
+          unless strict_union_tag_key(value).eql?(tag_key)
+            raise ArgumentError, "discriminator #{discriminator.inspect} must equal #{tag.inspect}"
+          end
+
+          tag
+        end
+      end
+
+      def strict_union_tag_key(tag)
+        unless tag.is_a?(::String) || tag.is_a?(::Symbol)
+          raise ArgumentError, "variant tag must be a String or Symbol, got #{tag.inspect}"
+        end
+
+        tag.is_a?(::String) ? tag.to_sym : tag
+      end
+
+      def strict_union_constant_name(tag)
+        name = tag.to_s
+        unless VARIANT_NAME.match?(name)
+          raise ArgumentError, "variant name must be lower snake_case, got #{name.inspect}"
+        end
+
+        name.split("_").map { |part| part.sub(/\A./, &:upcase) }.join
+      end
+    end # rubocop:enable Metrics/ModuleLength
+
+    module Instance
+      def initialize(...)
+        raise TypeError, "cannot instantiate union #{self.class} directly; instantiate one of its variants"
+      end
+    end
+
+    private_constant :ClassMethods, :Instance
+  end
+end

data/lib/strict/unions/coercer.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Strict
+  module Unions
+    class Coercer
+      NOT_PROVIDED = ::Object.new.freeze
+      private_constant :NOT_PROVIDED
+
+      def initialize(union_class, discriminator:, variants:)
+        @union_class = union_class
+        @discriminator = discriminator
+        @variants = variants
+      end
+
+      def call(value)
+        return value if value.nil? || union_class === value
+        return value unless value.respond_to?(:to_h)
+
+        coerce(value.to_h)
+      end
+
+      private
+
+      attr_reader :union_class, :discriminator, :variants
+
+      def coerce(hash)
+        tag = tag_from(hash)
+        variant = variant_for(normalized_tag(tag), original_tag: tag)
+        variant.variant_class.coercer.call(hash.merge(discriminator => variant.tag))
+      end
+
+      def tag_from(hash)
+        tag = hash.fetch(discriminator) { hash.fetch(discriminator.to_s, NOT_PROVIDED) }
+        if tag.equal?(NOT_PROVIDED)
+          raise ArgumentError, "missing discriminator #{discriminator.inspect} for #{union_class}"
+        end
+
+        tag
+      end
+
+      def variant_for(tag, original_tag:)
+        variants.fetch(tag)
+      rescue KeyError
+        expected = variants.values.map { |variant| variant.tag.inspect }.join(", ")
+        raise ArgumentError,
+              "unknown discriminator #{discriminator.inspect} for #{union_class}: #{original_tag.inspect}; " \
+              "expected one of #{expected}"
+      end
+
+      def normalized_tag(tag)
+        tag.is_a?(String) ? tag.to_sym : tag
+      end
+    end
+  end
+end

data/lib/strict/validation.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Strict
+  module Validation
+    NONE = [].freeze
+    ROOT_PATH = [].freeze
+
+    module_function
+
+    def violations(validator, value)
+      return validator.violations(value) if DetailedValidator === validator
+      return NONE if validator === value
+
+      invalid(validator, value)
+    end
+
+    def invalid(validator, value)
+      [Violation.new(path: ROOT_PATH, code: :invalid, value: value, validator: validator)]
+    end
+
+    def missing(validator, path:)
+      Violation.new(path: path, code: :missing, value: nil, validator: validator)
+    end
+
+    def unexpected(value, path:)
+      Violation.new(path: path, code: :unexpected, value: value, validator: nil)
+    end
+
+    def prepend_path(violations, *segments)
+      violations.map do |violation|
+        Violation.new(
+          path: segments + violation.path,
+          code: violation.code,
+          value: violation.value,
+          validator: violation.validator
+        )
+      end
+    end
+  end
+end

data/lib/strict/validators/all_of.rb

@@ -3,16 +3,24 @@
 module Strict
   module Validators
     class AllOf
+      include DetailedValidator
+
       attr_reader :subvalidators
 
       def initialize(*subvalidators)
         @subvalidators = subvalidators
       end
 
-      def ===(value)
-        subvalidators.all? do |subvalidator|
-          subvalidator === value
+      def violations(value)
+        violations = nil
+        subvalidators.each do |subvalidator|
+          subvalidator_violations = Validation.violations(subvalidator, value)
+          next if subvalidator_violations.empty?
+
+          violations ||= []
+          violations.concat(subvalidator_violations)
         end
+        violations || Validation::NONE
       end
 
       def inspect

data/lib/strict/validators/array_of.rb

@@ -3,16 +3,31 @@
 module Strict
   module Validators
     class ArrayOf
+      include DetailedValidator
+
       attr_reader :element_validator
 
       def initialize(element_validator)
         @element_validator = element_validator
       end
 
-      def ===(value)
-        Array === value && value.all? do |v|
-          element_validator === v
+      def coercer
+        element_coercer = element_validator.coercer if element_validator.respond_to?(:coercer)
+        Coercers::Array.new(element_coercer)
+      end
+
+      def violations(value)
+        return Validation.invalid(self, value) unless Array === value
+
+        violations = nil
+        value.each_with_index do |element, index|
+          element_violations = Validation.violations(element_validator, element)
+          next if element_violations.empty?
+
+          violations ||= []
+          violations.concat(Validation.prepend_path(element_violations, index))
         end
+        violations || Validation::NONE
       end
 
       def inspect

data/lib/strict/validators/hash_of.rb

@@ -3,6 +3,8 @@
 module Strict
   module Validators
     class HashOf
+      include DetailedValidator
+
       attr_reader :key_validator, :value_validator
 
       def initialize(key_validator, value_validator)
@@ -10,11 +12,29 @@ module Strict
         @value_validator = value_validator
       end
 
-      def ===(value)
-        Hash === value && value.all? do |k, v|
-          key_validator === k && value_validator === v
+      def coercer
+        key_coercer = key_validator.coercer if key_validator.respond_to?(:coercer)
+        value_coercer = value_validator.coercer if value_validator.respond_to?(:coercer)
+        Coercers::Hash.new(key_coercer, value_coercer)
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def violations(value)
+        return Validation.invalid(self, value) unless Hash === value
+
+        violations = nil
+        value.each do |key, entry_value|
+          key_violations = Validation.violations(key_validator, key)
+          value_violations = Validation.violations(value_validator, entry_value)
+          next if key_violations.empty? && value_violations.empty?
+
+          violations ||= []
+          violations.concat(Validation.prepend_path(key_violations, key))
+          violations.concat(Validation.prepend_path(value_violations, key))
         end
+        violations || Validation::NONE
       end
+      # rubocop:enable Metrics/MethodLength
 
       def inspect
         "HashOf(#{key_validator.inspect} => #{value_validator.inspect})"

data/lib/strict/value.rb

@@ -3,20 +3,34 @@
 module Strict
   module Value
     def self.included(mod)
-      mod.extend(Reader::Attributes)
+      Attributes::GeneratedMethods.install_on(mod, writable: false)
     end
 
     def with(**attributes)
-      self.class.new(**to_h.merge(attributes))
+      self.class.new(**Attributes::Instance.attribute_values(self), **attributes)
+    end
+
+    def deconstruct_keys(keys)
+      attributes = Attributes::Instance.attribute_values(self)
+      keys ? attributes.slice(*keys) : attributes
     end
 
     def eql?(other)
-      self.class.equal?(other.class) && to_h.eql?(other.to_h)
+      return false unless self.class.equal?(other.class)
+
+      self.class.strict_attributes.all? do |attribute|
+        public_send(attribute.name).eql?(other.public_send(attribute.name))
+      end
     end
     alias == eql?
 
     def hash
-      [self.class, to_h].hash
+      value_class = self.class
+      components = [value_class]
+      value_class.strict_attributes.each do |attribute|
+        components << public_send(attribute.name)
+      end
+      components.hash
     end
   end
 end

data/lib/strict/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Strict
-  VERSION = "1.5.0"
+  VERSION = "2.1.0"
 end

data/lib/strict/violation.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Strict
+  Violation = Data.define(:path, :code, :value, :validator) do
+    def initialize(path:, code:, value:, validator:)
+      super(path: path.dup.freeze, code: code, value: value, validator: validator)
+    end
+  end
+end

data/lib/strict.rb

@@ -2,6 +2,7 @@
 
 require "zeitwerk"
 loader = Zeitwerk::Loader.for_gem
+loader.ignore("#{__dir__}/strict/rspec.rb")
 loader.setup
 
 module Strict
@@ -9,7 +10,7 @@ module Strict
 
   class << self
     def configuration
-      thread_configuration || global_configuration
+      execution_context_override || global_configuration
     end
 
     def configure
@@ -19,28 +20,28 @@ module Strict
     end
 
     def with_overrides(**overrides)
-      original_thread_configuration = thread_configuration
+      original_override = execution_context_override
 
       begin
-        self.thread_configuration = Strict::Configuration.new(**configuration.to_h.merge(overrides))
+        self.execution_context_override = Strict::Configuration.new(**configuration.to_h, **overrides)
         yield
       ensure
-        self.thread_configuration = original_thread_configuration
+        self.execution_context_override = original_override
       end
     end
 
     private
 
     def overridden?
-      !!thread_configuration
+      !!execution_context_override
     end
 
-    def thread_configuration
-      Thread.current[:configuration]
+    def execution_context_override
+      Thread.current[:__strict_configuration_override]
     end
 
-    def thread_configuration=(configuration)
-      Thread.current[:configuration] = configuration
+    def execution_context_override=(configuration)
+      Thread.current[:__strict_configuration_override] = configuration
     end
 
     def global_configuration