strict 1.4.0 → 2.0.0

data/lib/strict/declaration.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Strict
+  class Declaration
+    NOT_PROVIDED = ::Object.new.freeze
+    DECLARATION_NAME = /\A[a-z_][a-zA-Z0-9_]*[!?]?\z/
+    private_constant :DECLARATION_NAME
+
+    class << self
+      def make(
+        name,
+        validator = Validators::Anything.instance,
+        coerce: validator.respond_to?(:coercer) ? validator.coercer : false,
+        **defaults
+      )
+        validate_name!(name)
+        validate_defaults!(**defaults)
+        validate_coercer!(coerce)
+
+        new(
+          name: name.to_sym,
+          validator: validator,
+          default_generator: make_default_generator(**defaults),
+          coercer: coerce
+        )
+      end
+
+      private
+
+      def validate_name!(name)
+        supported_type = name.is_a?(::String) || name.is_a?(::Symbol)
+        return if supported_type && DECLARATION_NAME.match?(name.to_s)
+
+        raise ArgumentError, "Declaration name must be a supported String or Symbol, got #{name.inspect}"
+      end
+
+      def validate_defaults!(**defaults)
+        unless valid_defaults?(**defaults)
+          raise ArgumentError, "Only one of 'default', 'default_value', or 'default_generator' can be provided"
+        end
+
+        validate_default_generator!(**defaults)
+      end
+
+      def valid_defaults?(default: NOT_PROVIDED, default_value: NOT_PROVIDED, default_generator: NOT_PROVIDED)
+        defaults_provided = [default, default_value, default_generator].count do |default_option|
+          !default_option.equal?(NOT_PROVIDED)
+        end
+
+        defaults_provided <= 1
+      end
+
+      def validate_default_generator!(default_generator: NOT_PROVIDED, **)
+        return if default_generator.equal?(NOT_PROVIDED) || default_generator.respond_to?(:call)
+
+        raise ArgumentError, "default_generator must be callable, got #{default_generator.inspect}"
+      end
+
+      def validate_coercer!(coercer)
+        return if coercer_supported?(coercer)
+
+        raise ArgumentError, "Unsupported coercer: #{coercer.inspect}"
+      end
+
+      def coercer_supported?(coercer)
+        coercer.equal?(false)
+      end
+
+      def make_default_generator(default: NOT_PROVIDED, default_value: NOT_PROVIDED, default_generator: NOT_PROVIDED)
+        if !default.equal?(NOT_PROVIDED)
+          default.respond_to?(:call) ? default : -> { default }
+        elsif !default_value.equal?(NOT_PROVIDED)
+          -> { default_value }
+        elsif !default_generator.equal?(NOT_PROVIDED)
+          default_generator
+        else
+          NOT_PROVIDED
+        end
+      end
+    end
+
+    attr_reader :name, :validator, :default_generator, :coercer
+
+    def initialize(name:, validator:, default_generator:, coercer:)
+      @name = name.to_sym
+      @validator = validator
+      @default_generator = default_generator
+      @coercer = coercer
+      @optional = !default_generator.equal?(NOT_PROVIDED)
+      @detailed_validator = DetailedValidator === validator
+    end
+
+    def optional?
+      @optional
+    end
+
+    def valid?(value, configuration = Strict.configuration)
+      violations(value, configuration).empty?
+    end
+
+    def violations(value, configuration = Strict.configuration)
+      return Validation::NONE unless configuration.validate?
+      return validator.violations(value) if @detailed_validator
+      return Validation::NONE if validator === value
+
+      Validation.invalid(validator, value)
+    end
+  end
+end

data/lib/strict/detailed_validator.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Strict
+  module DetailedValidator
+    def ===(value)
+      violations(value).empty?
+    end
+  end
+end

data/lib/strict/error.rb

@@ -1,5 +1,12 @@
 # frozen_string_literal: true
 
 module Strict
-  Error = Class.new(StandardError)
+  class Error < StandardError
+    attr_reader :violations
+
+    def initialize(message = nil, violations: Validation::NONE)
+      @violations = violations.freeze
+      super(message)
+    end
+  end
 end

data/lib/strict/initialization_error.rb

@@ -4,20 +4,29 @@ module Strict
   class InitializationError < Error
     attr_reader :remaining_attributes, :invalid_attributes, :missing_attributes
 
-    def initialize(initializable_class:, remaining_attributes:, invalid_attributes:, missing_attributes:) # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/MethodLength
+    def initialize(
+      initializable_class:,
+      remaining_attributes:,
+      invalid_attributes:,
+      missing_attributes:,
+      violations: Validation::NONE
+    )
       super(
         message_from(
           initializable_class: initializable_class,
           remaining_attributes: remaining_attributes,
           invalid_attributes: invalid_attributes,
           missing_attributes: missing_attributes
-        )
+        ),
+        violations: violations
       )
 
       @remaining_attributes = remaining_attributes
       @invalid_attributes = invalid_attributes
       @missing_attributes = missing_attributes
     end
+    # rubocop:enable Metrics/MethodLength
 
     private
 

data/lib/strict/interface.rb

@@ -2,31 +2,49 @@
 
 module Strict
   module Interface
-    def self.extended(mod)
-      mod.extend(Strict::Method)
+    def self.included(mod)
+      mod.include(Strict::Method)
       mod.include(Interfaces::Instance)
+      mod.extend(ClassMethods)
     end
 
-    def coercer
-      Interfaces::Coercer.new(self)
-    end
+    module ClassMethods
+      def coercer
+        Interfaces::Coercer.new(self)
+      end
+
+      def implemented_by?(implementation)
+        verify_implementation!(implementation)
+        true
+      rescue Strict::ImplementationDoesNotConformError
+        false
+      end
+
+      def verify_implementation!(implementation)
+        strict_interface_conformance.verify!(implementation)
+      end
+
+      def expose(method_name, &)
+        method_name = method_name.to_sym
+        configuration = Methods::Dsl.run(&)
+        verifiable_method = Methods::VerifiableMethod.for_interface(
+          owner: self,
+          name: method_name,
+          configuration: configuration
+        )
 
-    def expose(method_name, &block)
-      sig = sig(&block)
-      parameter_list = [
-        *sig.parameters.map { |parameter| "#{parameter.name}:" },
-        "&block"
-      ].join(", ")
-      argument_list = [
-        *sig.parameters.map { |parameter| "#{parameter.name}: #{parameter.name}" },
-        "&block"
-      ].join(", ")
-
-      module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-        def #{method_name}(#{parameter_list})              # def method_name(one:, two:, three:, &block)
-          implementation.#{method_name}(#{argument_list})  #   implementation.method_name(one: one, two: two, three: three, &block)
-        end                                                # end
-      RUBY
+        strict_instance_methods[method_name] = verifiable_method
+        strict_interface_conformance.compile(verifiable_method)
+        strict_method_wrapper(self).wrap(verifiable_method, invocation_target: :implementation)
+      end
+
+      private
+
+      def strict_interface_conformance
+        @strict_interface_conformance ||= Interfaces::Conformance.new(self)
+      end
     end
+
+    private_constant :ClassMethods
   end
 end

data/lib/strict/interfaces/conformance.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Strict
+  module Interfaces
+    class Conformance
+      def initialize(interface)
+        @interface = interface
+        @method_expectations = []
+      end
+
+      def compile(verifiable_method)
+        parameter_names = verifiable_method.parameters.map(&:name).freeze
+
+        method_expectations << MethodExpectation.new(
+          name: verifiable_method.name,
+          parameter_names: parameter_names,
+          expected_parameter_mask: (1 << parameter_names.length) - 1
+        )
+      end
+
+      def verify!(receiver)
+        errors = errors_for(receiver)
+        return unless errors
+
+        missing_methods, invalid_method_definitions = errors
+        raise Strict::ImplementationDoesNotConformError.new(
+          interface: interface,
+          receiver: receiver,
+          missing_methods: missing_methods,
+          invalid_method_definitions: invalid_method_definitions
+        )
+      end
+
+      private
+
+      MethodExpectation = Data.define(:name, :parameter_names, :expected_parameter_mask)
+      private_constant :MethodExpectation
+
+      attr_reader :interface, :method_expectations
+
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      def errors_for(receiver)
+        missing_methods = nil
+        invalid_method_definitions = nil
+
+        method_expectations.each do |expectation|
+          unless receiver.respond_to?(expectation.name)
+            (missing_methods ||= []) << expectation.name
+            next
+          end
+
+          invalid_definition = invalid_definition_for(expectation, receiver.method(expectation.name).parameters)
+          next unless invalid_definition
+
+          (invalid_method_definitions ||= {})[expectation.name] = invalid_definition
+        end
+
+        return unless missing_methods || invalid_method_definitions
+
+        [missing_methods, invalid_method_definitions || {}]
+      end
+
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      def invalid_definition_for(expectation, implementation_parameters)
+        matched_parameter_mask = 0
+        has_keyword_splat = false
+        implementation_parameters.each do |kind, parameter_name|
+          case kind
+          when :keyrest
+            has_keyword_splat = true
+          when :keyreq, :key
+            parameter_index = expectation.parameter_names.index(parameter_name)
+            matched_parameter_mask |= 1 << parameter_index if parameter_index
+          end
+        end
+
+        additional_parameters = nil
+        non_keyword_parameters = nil
+
+        implementation_parameters.each do |kind, parameter_name|
+          parameter_index = expectation.parameter_names.index(parameter_name)
+          case kind
+          when :keyreq
+            (additional_parameters ||= []) << parameter_name unless parameter_index
+          when :req
+            if parameter_index
+              matched_parameter_mask |= 1 << parameter_index
+              (non_keyword_parameters ||= []) << parameter_name
+            else
+              (additional_parameters ||= []) << parameter_name
+            end
+          when :opt
+            next unless parameter_index && !has_keyword_splat
+            next if matched_parameter_mask.anybits?(1 << parameter_index)
+
+            matched_parameter_mask |= 1 << parameter_index
+            (non_keyword_parameters ||= []) << parameter_name
+          end
+        end
+
+        missing_parameters = missing_parameters_from(expectation, matched_parameter_mask) unless has_keyword_splat
+        return unless missing_parameters || additional_parameters || non_keyword_parameters
+
+        {
+          additional_parameters: additional_parameters || [],
+          missing_parameters: missing_parameters || [],
+          non_keyword_parameters: non_keyword_parameters || []
+        }
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+      def missing_parameters_from(expectation, matched_parameter_mask)
+        return if matched_parameter_mask == expectation.expected_parameter_mask
+
+        Set.new.tap do |missing_parameters|
+          expectation.parameter_names.each_with_index do |parameter_name, index|
+            missing_parameters << parameter_name if matched_parameter_mask.nobits?(1 << index)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/strict/interfaces/instance.rb

@@ -5,59 +5,11 @@ module Strict
     module Instance
       attr_reader :implementation
 
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def initialize(implementation)
-        missing_methods = nil
-        invalid_method_definitions = Hash.new do |h, k|
-          h[k] = { additional_parameters: [], missing_parameters: [], non_keyword_parameters: [] }
-        end
-
-        self.class.strict_instance_methods.each do |method_name, strict_method| # rubocop:disable Metrics/BlockLength
-          unless implementation.respond_to?(method_name)
-            missing_methods ||= []
-            missing_methods << method_name
-            next
-          end
-
-          expected_parameters = Set.new(strict_method.parameters.map(&:name))
-          defined_parameters = Set.new
-          has_keyword_splat = false
-
-          implementation.method(method_name).parameters.each do |kind, parameter_name|
-            case kind
-            when :block, :rest
-              next
-            when :keyrest
-              has_keyword_splat = true
-              next
-            end
-
-            if expected_parameters.include?(parameter_name)
-              defined_parameters.add(parameter_name)
-              invalid_method_definitions[method_name][:non_keyword_parameters] << parameter_name if kind != :keyreq
-            else
-              invalid_method_definitions[method_name][:additional_parameters] << parameter_name
-            end
-          end
-
-          next if has_keyword_splat
-
-          missing_parameters = expected_parameters - defined_parameters
-          invalid_method_definitions[method_name][:missing_parameters] = missing_parameters if missing_parameters.any?
-        end
-
-        if missing_methods || !invalid_method_definitions.empty?
-          raise Strict::ImplementationDoesNotConformError.new(
-            interface: self.class,
-            receiver: implementation,
-            missing_methods: missing_methods,
-            invalid_method_definitions: invalid_method_definitions
-          )
-        end
+        self.class.verify_implementation!(implementation)
 
         @implementation = implementation
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
     end
   end
 end

data/lib/strict/method.rb

@@ -2,71 +2,90 @@
 
 module Strict
   module Method
-    def self.extended(mod)
-      return if mod.singleton_class?
-
-      mod.singleton_class.extend(self)
+    def self.included(mod)
+      mod.extend(ClassMethods)
     end
 
-    def sig(&block)
-      instance = singleton_class? ? self : singleton_class
-      instance.instance_variable_set(:@__strict_method_internal_last_sig_configuration, Methods::Dsl.run(&block))
-    end
+    module ClassMethods
+      def self.extended(mod)
+        return if mod.singleton_class?
 
-    def strict_class_methods
-      instance = singleton_class? ? self : singleton_class
-      if instance.instance_variable_defined?(:@__strict_method_internal_class_methods)
-        instance.instance_variable_get(:@__strict_method_internal_class_methods)
-      else
-        instance.instance_variable_set(:@__strict_method_internal_class_methods, {})
+        mod.singleton_class.extend(self)
       end
-    end
 
-    def strict_instance_methods
-      instance = singleton_class? ? self : singleton_class
-      if instance.instance_variable_defined?(:@__strict_method_internal_instance_methods)
-        instance.instance_variable_get(:@__strict_method_internal_instance_methods)
-      else
-        instance.instance_variable_set(:@__strict_method_internal_instance_methods, {})
+      def sig(&)
+        instance = singleton_class? ? self : singleton_class
+        instance.instance_variable_set(:@__strict_method_internal_last_sig_configuration, Methods::Dsl.run(&))
       end
-    end
 
-    # rubocop:disable Metrics/MethodLength
-    def singleton_method_added(method_name)
-      super
+      def strict_class_methods
+        instance = singleton_class? ? self : singleton_class
+        if instance.instance_variable_defined?(:@__strict_method_internal_class_methods)
+          instance.instance_variable_get(:@__strict_method_internal_class_methods)
+        else
+          instance.instance_variable_set(:@__strict_method_internal_class_methods, {})
+        end
+      end
 
-      sig = singleton_class.instance_variable_get(:@__strict_method_internal_last_sig_configuration)
-      singleton_class.instance_variable_set(:@__strict_method_internal_last_sig_configuration, nil)
-      return unless sig
+      def strict_instance_methods
+        instance = singleton_class? ? self : singleton_class
+        if instance.instance_variable_defined?(:@__strict_method_internal_instance_methods)
+          instance.instance_variable_get(:@__strict_method_internal_instance_methods)
+        else
+          instance.instance_variable_set(:@__strict_method_internal_instance_methods, {})
+        end
+      end
 
-      verifiable_method = Methods::VerifiableMethod.new(
-        method: singleton_class.instance_method(method_name),
-        parameters: sig.parameters,
-        returns: sig.returns,
-        instance: false
-      )
-      verifiable_method.verify_definition!
-      strict_class_methods[method_name] = verifiable_method
-      singleton_class.prepend(Methods::Module.new(verifiable_method))
-    end
+      # rubocop:disable Metrics/MethodLength
+      def singleton_method_added(method_name)
+        super
 
-    def method_added(method_name)
-      super
+        sig = singleton_class.instance_variable_get(:@__strict_method_internal_last_sig_configuration)
+        singleton_class.instance_variable_set(:@__strict_method_internal_last_sig_configuration, nil)
+        return unless sig
 
-      sig = singleton_class.instance_variable_get(:@__strict_method_internal_last_sig_configuration)
-      singleton_class.instance_variable_set(:@__strict_method_internal_last_sig_configuration, nil)
-      return unless sig
+        verifiable_method = Methods::VerifiableMethod.from_method(
+          method: singleton_class.instance_method(method_name),
+          configuration: sig,
+          instance: false
+        )
+        verifiable_method.verify_definition!
+        strict_class_methods[method_name] = verifiable_method
+        strict_method_wrapper(singleton_class).wrap(verifiable_method)
+      end
 
-      verifiable_method = Methods::VerifiableMethod.new(
-        method: instance_method(method_name),
-        parameters: sig.parameters,
-        returns: sig.returns,
-        instance: true
-      )
-      verifiable_method.verify_definition!
-      strict_instance_methods[method_name] = verifiable_method
-      prepend(Methods::Module.new(verifiable_method))
+      def method_added(method_name)
+        super
+
+        sig = singleton_class.instance_variable_get(:@__strict_method_internal_last_sig_configuration)
+        singleton_class.instance_variable_set(:@__strict_method_internal_last_sig_configuration, nil)
+        return unless sig
+
+        verifiable_method = Methods::VerifiableMethod.from_method(
+          method: instance_method(method_name),
+          configuration: sig,
+          instance: true
+        )
+        verifiable_method.verify_definition!
+        strict_instance_methods[method_name] = verifiable_method
+        strict_method_wrapper(self).wrap(verifiable_method)
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      private
+
+      def strict_method_wrapper(owner)
+        if owner.instance_variable_defined?(:@__strict_method_internal_wrapper)
+          owner.instance_variable_get(:@__strict_method_internal_wrapper)
+        else
+          Methods::Module.new.tap do |wrapper|
+            owner.instance_variable_set(:@__strict_method_internal_wrapper, wrapper)
+            owner.prepend(wrapper)
+          end
+        end
+      end
     end
-    # rubocop:enable Metrics/MethodLength
+
+    private_constant :ClassMethods
   end
 end

data/lib/strict/method_call_error.rb

@@ -4,7 +4,15 @@ module Strict
   class MethodCallError < Error
     attr_reader :verifiable_method, :remaining_args, :remaining_kwargs, :invalid_parameters, :missing_parameters
 
-    def initialize(verifiable_method:, remaining_args:, remaining_kwargs:, invalid_parameters:, missing_parameters:) # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+    def initialize(
+      verifiable_method:,
+      remaining_args:,
+      remaining_kwargs:,
+      invalid_parameters:,
+      missing_parameters:,
+      violations: Validation::NONE
+    )
       super(
         message_from(
           verifiable_method: verifiable_method,
@@ -12,7 +20,8 @@ module Strict
           remaining_kwargs: remaining_kwargs,
           invalid_parameters: invalid_parameters,
           missing_parameters: missing_parameters
-        )
+        ),
+        violations: violations
       )
 
       @verifiable_method = verifiable_method
@@ -21,6 +30,7 @@ module Strict
       @invalid_parameters = invalid_parameters
       @missing_parameters = missing_parameters
     end
+    # rubocop:enable Metrics/MethodLength, Metrics/ParameterLists
 
     private
 

data/lib/strict/method_return_error.rb

@@ -4,8 +4,8 @@ module Strict
   class MethodReturnError < Error
     attr_reader :verifiable_method, :value
 
-    def initialize(verifiable_method:, value:)
-      super(message_from(verifiable_method: verifiable_method, value: value))
+    def initialize(verifiable_method:, value:, violations: Validation::NONE)
+      super(message_from(verifiable_method: verifiable_method, value: value), violations: violations)
 
       @verifiable_method = verifiable_method
       @value = value

data/lib/strict/methods/dsl.rb

@@ -4,9 +4,9 @@ module Strict
   module Methods
     class Dsl < BasicObject
       class << self
-        def run(&block)
+        def run(&)
           dsl = new
-          dsl.instance_eval(&block)
+          dsl.instance_eval(&)
           ::Strict::Methods::Configuration.new(
             parameters: dsl.__strict_dsl_internal_parameters.values,
             returns: dsl.__strict_dsl_internal_returns
@@ -22,22 +22,30 @@ module Strict
       def initialize
         @__strict_dsl_internal_parameters = {}
         @__strict_dsl_internal_returns = ::Strict::Return.make
+        @__strict_dsl_internal_returns_declared = false
       end
 
-      def returns(*args, **kwargs)
-        self.__strict_dsl_internal_returns = ::Strict::Return.make(*args, **kwargs)
+      def returns(*, **)
+        ::Kernel.raise ::ArgumentError, "Return value is already declared" if @__strict_dsl_internal_returns_declared
+
+        self.__strict_dsl_internal_returns = ::Strict::Return.make(*, **)
+        @__strict_dsl_internal_returns_declared = true
         nil
       end
 
-      def strict_parameter(*args, **kwargs)
-        parameter = ::Strict::Parameter.make(*args, **kwargs)
+      def strict_parameter(*, **)
+        parameter = ::Strict::Parameter.make(*, **)
+        if __strict_dsl_internal_parameters.key?(parameter.name)
+          ::Kernel.raise ::ArgumentError, "Parameter #{parameter.name.inspect} is already declared"
+        end
+
         __strict_dsl_internal_parameters[parameter.name] = parameter
         nil
       end
 
-      def method_missing(name, *args, **kwargs)
+      def method_missing(name, *, **)
         if respond_to_missing?(name)
-          strict_parameter(name, *args, **kwargs)
+          strict_parameter(name, *, **)
         else
           super
         end