strict 1.4.0 → 2.0.0

data/lib/strict/methods/module.rb

@@ -3,23 +3,42 @@
 module Strict
   module Methods
     class Module < ::Module
-      attr_reader :verifiable_method
+      def wrap(verifiable_method, invocation_target: :super)
+        case invocation_target
+        when :super
+          wrap_super(verifiable_method)
+        when :implementation
+          wrap_implementation(verifiable_method)
+        else
+          raise ArgumentError, "Unknown invocation target: #{invocation_target.inspect}"
+        end
+      end
 
-      def initialize(verifiable_method)
-        super()
+      private
 
-        @verifiable_method = verifiable_method
+      def wrap_super(verifiable_method)
         define_method verifiable_method.name do |*args, **kwargs, &block|
-          args, kwargs = verifiable_method.verify_parameters!(*args, **kwargs)
+          configuration = Strict.configuration
+          verified_arguments = verifiable_method.verify_parameters!(args, kwargs, configuration)
+          args, kwargs = verified_arguments if verified_arguments
 
           super(*args, **kwargs, &block).tap do |value|
-            verifiable_method.verify_returns!(value)
+            verifiable_method.verify_returns!(value, configuration)
           end
         end
       end
 
-      def inspect
-        "#<#{self.class} (#{verifiable_method.name})>"
+      def wrap_implementation(verifiable_method)
+        method_name = verifiable_method.name
+        define_method method_name do |*args, **kwargs, &block|
+          configuration = Strict.configuration
+          verified_arguments = verifiable_method.verify_parameters!(args, kwargs, configuration)
+          args, kwargs = verified_arguments if verified_arguments
+
+          implementation.public_send(method_name, *args, **kwargs, &block).tap do |value|
+            verifiable_method.verify_returns!(value, configuration)
+          end
+        end
       end
     end
   end

data/lib/strict/methods/verifiable_method.rb

@@ -1,11 +1,27 @@
 # frozen_string_literal: true
 
-require "forwardable"
-
 module Strict
   module Methods
     class VerifiableMethod # rubocop:disable Metrics/ClassLength
-      extend Forwardable
+      class << self
+        def from_method(method:, configuration:, instance:)
+          new(
+            method: method,
+            configuration: configuration,
+            instance: instance
+          )
+        end
+
+        def for_interface(owner:, name:, configuration:)
+          new(
+            method: nil,
+            owner: owner,
+            name: name,
+            configuration: configuration,
+            instance: true
+          )
+        end
+      end
 
       class UnknownParameterError < Error
         attr_reader :parameter_name
@@ -24,25 +40,41 @@ module Strict
         end
       end
 
-      def_delegator :method, :name
-
       attr_reader :parameters, :returns
 
-      def initialize(method:, parameters:, returns:, instance:)
+      def initialize(method:, configuration:, instance:, owner: nil, name: nil)
         @method = method
-        @parameters = parameters
-        @parameters_index = parameters.to_h { |p| [p.name, p] }
-        @returns = returns
+        @parameters = configuration.parameters
+        @parameters_index = parameters.to_h { |parameter| [parameter.name, parameter] }
+        @returns = configuration.returns
         @instance = instance
+        compile_invocation(invocation_parameters_for(method))
+        return if method
+
+        @owner = owner
+        @name = name
+      end
+
+      def compile_invocation(invocation_parameters)
+        @parameter_bindings = compile_parameter_bindings(invocation_parameters)
+        @keyword_parameter_names = parameter_bindings.filter_map do |binding|
+          binding.name if binding.kind == :keyword
+        end.freeze
+        @accepts_keyrest = parameter_bindings.any? { |binding| binding.kind == :keyrest }
+      end
+      private :compile_invocation
+
+      def name
+        method ? method.name : @name
       end
 
       def to_s
-        "#{method.owner}#{separator}#{name}"
+        "#{owner}#{separator}#{name}"
       end
 
       def verify_definition!
         expected_parameters = Set.new(parameters.map(&:name))
-        defined_parameters = Set.new(method.parameters.filter_map { |kind, name| name unless kind == :block })
+        defined_parameters = Set.new(parameter_bindings.map(&:name))
         return if expected_parameters == defined_parameters
 
         missing_parameters = expected_parameters - defined_parameters
@@ -54,97 +86,229 @@ module Strict
         )
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/BlockLength
-      # TODO(kkt): clean this up- it's late, though, and the tests are passing
-      def verify_parameters!(*args, **kwargs)
+      # rubocop:disable Metrics/AbcSize, Metrics/BlockLength, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      def verify_parameters!(args, kwargs, configuration)
         invalid_parameters = nil
         missing_parameters = nil
+        violations = nil
+        verified_args = nil
+        verified_kwargs = nil
+        positional_argument_count = args.length
+        positional_index = 0
 
-        positional_arguments = []
-        keyword_arguments = {}
-
-        # TODO(kkt): doesn't handle oddly sorted optional positional parameters like def foo(opt = nil, req)
-        method.parameters.each do |kind, name|
-          case kind
-          when POSITIONAL
-            parameter_kind = :positional
-            value = args.any? ? args.shift : NOT_PROVIDED
-          when REST
-            parameter_kind = :rest
-            value = [*args]
-            args.clear
-          when KEYWORD
-            parameter_kind = :keyword
-            value = kwargs.key?(name) ? kwargs.delete(name) : NOT_PROVIDED
-          when KEYREST
-            parameter_kind = :keyrest
-            value = { **kwargs }
-            kwargs.clear
-          end
-          next unless parameter_kind
+        parameter_bindings.each do |binding|
+          parameter = binding.parameter || parameter_named!(binding.name)
+          positional_start = positional_index
+          original_value = case binding.kind
+                           when :positional
+                             if positional_index < positional_argument_count
+                               positional_index += 1
+                               args.fetch(positional_start)
+                             else
+                               NOT_PROVIDED
+                             end
+                           when :optional_positional
+                             if positional_argument_count - positional_index > binding.required_after
+                               positional_index += 1
+                               args.fetch(positional_start)
+                             else
+                               NOT_PROVIDED
+                             end
+                           when :rest
+                             count = positional_argument_count - positional_index - binding.required_after
+                             count = 0 if count.negative?
+                             positional_index += count
+                             if positional_start.zero? && count == positional_argument_count
+                               args
+                             else
+                               args.slice(positional_start, count)
+                             end
+                           when :keyword
+                             kwargs.key?(binding.name) ? kwargs.fetch(binding.name) : NOT_PROVIDED
+                           when :keyrest
+                             keyrest_value(kwargs)
+                           end
 
-          parameter = parameter_named!(name)
-          if value.equal?(NOT_PROVIDED) && parameter.optional?
+          if original_value.equal?(NOT_PROVIDED) && parameter.optional?
             value = parameter.default_generator.call
-          elsif value.equal?(NOT_PROVIDED)
+            changed = true
+          elsif original_value.equal?(NOT_PROVIDED)
             missing_parameters ||= []
             missing_parameters << parameter.name
+            violations ||= []
+            violations << Validation.missing(parameter.validator, path: [parameter.name])
             next
+          else
+            value = original_value
+            changed = false
           end
 
           value = parameter.coerce(value)
-          if parameter.valid?(value)
-            case parameter_kind
-            when :positional
-              positional_arguments << value
+          changed ||= !value.equal?(original_value)
+          parameter_violations = parameter.violations(value, configuration)
+          if parameter_violations.empty?
+            case binding.kind
+            when :positional, :optional_positional
+              if verified_args
+                verified_args << value
+              elsif changed
+                verified_args = args.take(positional_start)
+                verified_args << value
+              end
             when :rest
-              positional_arguments.concat(value)
+              if verified_args
+                verified_args.concat(value)
+              elsif rest_changed?(args, positional_start, positional_index, value, parameter.coercer)
+                verified_args = args.take(positional_start)
+                verified_args.concat(value)
+              end
             when :keyword
-              keyword_arguments[name] = value
+              if changed
+                verified_kwargs ||= kwargs.dup
+                verified_kwargs[binding.name] = value
+              end
             when :keyrest
-              keyword_arguments.merge!(value)
+              if keyrest_changed?(kwargs, value, parameter.coercer)
+                verified_kwargs = merge_keyrest(verified_kwargs, kwargs, value)
+              end
             end
           else
             invalid_parameters ||= {}
             invalid_parameters[parameter] = value
+            violations ||= []
+            violations.concat(Validation.prepend_path(parameter_violations, parameter.name))
           end
         end
 
-        if args.empty? && kwargs.empty? && invalid_parameters.nil? && missing_parameters.nil?
-          [positional_arguments, keyword_arguments]
-        else
-          raise Strict::MethodCallError.new(
-            verifiable_method: self,
-            remaining_args: args,
-            remaining_kwargs: kwargs,
-            invalid_parameters: invalid_parameters,
-            missing_parameters: missing_parameters
-          )
+        if positional_index == positional_argument_count && no_additional_keywords?(kwargs) &&
+           invalid_parameters.nil? && missing_parameters.nil?
+          return if verified_args.nil? && verified_kwargs.nil?
+
+          return [verified_args || args, verified_kwargs || kwargs]
+        end
+
+        remaining_args = args.slice(positional_index, positional_argument_count - positional_index) || []
+        remaining_kwargs = remaining_kwargs_from(kwargs)
+        violations ||= []
+        remaining_args.each_with_index do |argument, offset|
+          violations << Validation.unexpected(argument, path: [positional_index + offset])
+        end
+        remaining_kwargs.each do |name, value|
+          violations << Validation.unexpected(value, path: [name])
         end
+        raise Strict::MethodCallError.new(
+          verifiable_method: self,
+          remaining_args: remaining_args,
+          remaining_kwargs: remaining_kwargs,
+          invalid_parameters: invalid_parameters,
+          missing_parameters: missing_parameters,
+          violations: violations
+        )
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/BlockLength
+      # rubocop:enable Metrics/AbcSize, Metrics/BlockLength, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
-      def verify_returns!(value)
-        value = returns.coerce(value)
-        return if returns.valid?(value)
+      def verify_returns!(value, configuration)
+        violations = returns.violations(value, configuration)
+        return if violations.empty?
 
-        raise Strict::MethodReturnError.new(verifiable_method: self, value: value)
+        raise Strict::MethodReturnError.new(verifiable_method: self, value: value, violations: violations)
       end
 
       private
 
-      POSITIONAL = Set.new(%i[req opt])
-      private_constant :POSITIONAL
-      REST = :rest
-      private_constant :REST
-      KEYWORD = Set.new(%i[keyreq key])
-      private_constant :KEYWORD
-      KEYREST = :keyrest
-      private_constant :KEYREST
+      ParameterBinding = Data.define(:kind, :name, :parameter, :required_after)
+      private_constant :ParameterBinding
+      PARAMETER_KINDS = {
+        req: :positional,
+        opt: :optional_positional,
+        rest: :rest,
+        keyreq: :keyword,
+        key: :keyword,
+        keyrest: :keyrest
+      }.freeze
+      private_constant :PARAMETER_KINDS
       NOT_PROVIDED = ::Object.new.freeze
       private_constant :NOT_PROVIDED
 
-      attr_reader :method, :parameters_index
+      attr_reader :method, :parameters_index, :parameter_bindings, :keyword_parameter_names
+
+      def owner
+        method ? method.owner : @owner
+      end
+
+      def invocation_parameters_for(method)
+        return method.parameters if method
+
+        parameters.map { |parameter| [:keyreq, parameter.name] }
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def compile_parameter_bindings(invocation_parameters)
+        required_after = 0
+        invocation_parameters.reverse_each.filter_map do |kind, name|
+          compiled_kind = PARAMETER_KINDS[kind]
+          next unless compiled_kind
+
+          binding = ParameterBinding.new(
+            kind: compiled_kind,
+            name: name,
+            parameter: parameters_index[name],
+            required_after: required_after
+          )
+          required_after += 1 if kind == :req
+          binding
+        end.reverse.freeze
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def keyrest_value(kwargs)
+        return kwargs if keyword_parameter_names.empty?
+
+        kwargs.except(*keyword_parameter_names)
+      end
+
+      def rest_changed?(args, start, finish, value, coercer)
+        return true if coercer
+        return false if value.equal?(args)
+        return true unless value.length == finish - start
+
+        value.each_index.any? { |index| !value.fetch(index).equal?(args.fetch(start + index)) }
+      end
+
+      def keyrest_changed?(kwargs, value, coercer)
+        return true if coercer
+        return false if value.equal?(kwargs)
+
+        original_size = 0
+        kwargs.each do |name, original_value|
+          next if keyword_parameter_names.include?(name)
+
+          original_size += 1
+          return true unless value.key?(name) && value.fetch(name).equal?(original_value)
+        end
+        value.size != original_size
+      end
+
+      def merge_keyrest(verified_kwargs, kwargs, value)
+        return value if keyword_parameter_names.empty? && !value.equal?(kwargs)
+        return verified_kwargs if keyword_parameter_names.empty?
+
+        merged_kwargs = verified_kwargs || kwargs.dup
+        merged_kwargs.delete_if do |name, _value|
+          !keyword_parameter_names.include?(name)
+        end
+        merged_kwargs.merge!(value) { |_name, explicit_value, _keyrest_value| explicit_value }
+      end
+
+      def no_additional_keywords?(kwargs)
+        @accepts_keyrest || kwargs.none? { |name, _value| !keyword_parameter_names.include?(name) }
+      end
+
+      def remaining_kwargs_from(kwargs)
+        return {} if @accepts_keyrest
+
+        kwargs.except(*keyword_parameter_names)
+      end
 
       def instance?
         @instance

data/lib/strict/object.rb

@@ -3,7 +3,7 @@
 module Strict
   module Object
     def self.included(mod)
-      mod.extend(Accessor::Attributes)
+      Attributes::GeneratedMethods.install_on(mod, writable: true)
     end
   end
 end

data/lib/strict/parameter.rb

@@ -1,64 +1,15 @@
 # frozen_string_literal: true
 
 module Strict
-  class Parameter
-    NOT_PROVIDED = ::Object.new.freeze
-
+  class Parameter < Declaration
     class << self
-      def make(name, validator = Validators::Anything.instance, coerce: false, **defaults)
-        unless valid_defaults?(**defaults)
-          raise ArgumentError, "Only one of 'default', 'default_value', or 'default_generator' can be provided"
-        end
-
-        new(
-          name: name.to_sym,
-          validator: validator,
-          default_generator: make_default_generator(**defaults),
-          coercer: coerce
-        )
-      end
-
       private
 
-      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 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
+      def coercer_supported?(coercer)
+        super || coercer.respond_to?(:call)
       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)
-    end
-
-    def optional?
-      @optional
-    end
-
-    def valid?(value)
-      validator === value
-    end
-
     def coerce(value)
       return value unless coercer
 

data/lib/strict/return.rb

@@ -3,26 +3,30 @@
 module Strict
   class Return
     class << self
-      def make(validator = Validators::Anything.instance, coerce: false)
-        new(validator: validator, coercer: coerce)
+      def make(validator = Validators::Anything.instance, **unsupported)
+        raise ArgumentError, "Unsupported return options: #{unsupported.keys.join(', ')}" if unsupported.any?
+
+        new(validator: validator)
       end
     end
 
-    attr_reader :validator, :coercer
+    attr_reader :validator
 
-    def initialize(validator:, coercer:)
+    def initialize(validator:)
       @validator = validator
-      @coercer = coercer
+      @detailed_validator = DetailedValidator === validator
     end
 
-    def valid?(value)
-      validator === value
+    def valid?(value, configuration = Strict.configuration)
+      violations(value, configuration).empty?
     end
 
-    def coerce(value)
-      return value unless coercer
+    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
 
-      coercer.call(value)
+      Validation.invalid(validator, value)
     end
   end
 end