delegate_matcher 0.0.3 → 0.1

data/lib/delegate_matcher/delegate.rb

@@ -0,0 +1,79 @@
+module RSpec
+  module Matchers
+    module DelegateMatcher
+      class Delegate
+        RSpec::Mocks::Syntax.enable_expect(self)
+
+        attr_reader :received, :args, :block
+
+        def initialize(expected)
+          self.expected = expected
+          self.received = false
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def receiver
+          @receiver ||= case
+                        when a_class_variable?
+                          subject.class.class_variable_get(name)
+                        when an_instance_variable?
+                          subject.instance_variable_get(name)
+                        when a_constant?
+                          subject.class.const_get(name)
+                        when a_method?
+                          fail "#{subject.inspect} does not respond to #{name}" unless subject.respond_to?(name, true)
+                          fail "#{subject.inspect}'s' #{name} method expects parameters" unless [0, -1].include?(subject.method(name).arity)
+                          subject.send(name)
+                        else # is an object
+                          to
+                        end
+        end
+
+        def argument_description
+          args ? "(#{args.map { |a| format('%p', a) }.join(', ')})" : ''
+        end
+
+        def return_value
+          self
+        end
+
+        private
+
+        attr_accessor :expected
+        attr_writer :received, :args, :block
+
+        def subject
+          expected.subject
+        end
+
+        def to
+          expected.to
+        end
+
+        def name
+          to.to_s
+        end
+
+        def a_class_variable?
+          a_reference? && name.start_with?('@@')
+        end
+
+        def an_instance_variable?
+          a_reference? && name.start_with?('@')
+        end
+
+        def a_constant?
+          a_reference? && name =~ /^[A-Z]/
+        end
+
+        def a_method?
+          a_reference?
+        end
+
+        def a_reference?
+          to.is_a?(String) || to.is_a?(Symbol)
+        end
+      end
+    end
+  end
+end

data/lib/delegate_matcher/delegate_matcher.rb

@@ -1,282 +1,57 @@
 require 'rspec/matchers'
 
-RSpec::Matchers.define(:delegate) do |method|
-  match do |delegator|
-    fail 'need to provide a "to"' unless delegate
+module RSpec
+  module Matchers
+    define(:delegate) do |method_name|
+      match do |subject|
+        delegation_ok?(method_name, subject)
+      end
 
-    @method    = method
-    @delegator = delegator
+      description do
+        expected.description
+      end
 
-    allow_nil_ok? && delegate? && arguments_ok? && block_ok?
-  end
-
-  description do
-    "delegate #{delegator_description} to #{delegate_description}#{nil_description}#{block_description}"
-  end
+      def failure_message
+        delegation.failure_message(false) || super
+      end
 
-  def failure_message
-    failure_message_details(false) || super
-  end
+      def failure_message_when_negated
+        delegation.failure_message(true) || super
+      end
 
-  def failure_message_when_negated
-    failure_message_details(true) || super
-  end
+      chain(:to)              { |to|               expected.to           = to }
+      chain(:as)              { |as|               expected.as           = as }
+      chain(:allow_nil)       { |allow_nil = true| expected.allow_nil    = allow_nil }
+      chain(:with_prefix)     { |prefix = nil|     expected.prefix       = prefix }
+      chain(:with)            { |*args|            expected.args         = args }
+      chain(:with_a_block)    {                    expected.block        = true  }
+      chain(:without_a_block) {                    expected.block        = false }
+      chain(:without_return)  {                    expected.check_return = false }
 
-  chain(:to)              { |delegate|         @delegate           = delegate }
-  chain(:as)              { |delegate_method|  @delegate_method    = delegate_method }
-  chain(:allow_nil)       { |allow_nil = true| @expected_nil_check = allow_nil }
-  chain(:with_prefix)     { |prefix = nil|     @prefix             = prefix || delegate.to_s.sub(/@/, '') }
-  chain(:with)            { |*args|            @expected_args      = args; @args ||= args }
-  chain(:with_a_block)    {                    @expected_block     = true  }
-  chain(:without_a_block) {                    @expected_block     = false }
+      alias_method :with_block,    :with_a_block
+      alias_method :without_block, :without_a_block
 
-  alias_method :with_block,    :with_a_block
-  alias_method :without_block, :without_a_block
+      private
 
-  private
+      def delegation
+        @delegation ||= DelegateMatcher::Delegation.new(expected)
+      end
 
-  attr_reader :method, :delegator, :delegate, :prefix, :args
-  attr_reader :expected_nil_check, :actual_nil_check
-  attr_reader :expected_args,      :actual_args
-  attr_reader :expected_block,     :actual_block
-  attr_reader :actual_return_value
+      def expected
+        @expected ||= DelegateMatcher::Expected.new
+      end
 
-  def delegate?(test_delegate = delegate_double)
-    case
-    when delegate_is_a_class_variable?
-      delegate_to_class_variable(test_delegate)
-    when delegate_is_an_instance_variable?
-      delegate_to_instance_variable(test_delegate)
-    when delegate_is_a_constant?
-      delegate_to_constant
-    when delegate_is_a_method?
-      delegate_to_method(test_delegate)
-    else
-      delegate_to_object
-    end
+      def delegation_ok?(method_name, subject)
+        fail 'need to provide a "to"' unless expected.to
 
-    return_value_ok?
-  end
-
-  def delegate_is_a_class_variable?
-    delegate.to_s.start_with?('@@')
-  end
-
-  def delegate_is_an_instance_variable?
-    delegate.to_s[0] == '@'
-  end
-
-  def delegate_is_a_constant?
-    (delegate.is_a?(String) || delegate.is_a?(Symbol)) && (delegate.to_s =~ /^[A-Z]/)
-  end
-
-  def delegate_is_a_method?
-    delegate.is_a?(String) || delegate.is_a?(Symbol)
-  end
-
-  def delegate_to_class_variable(test_delegate)
-    actual_delegate = delegator.class.class_variable_get(delegate)
-    delegator.class.class_variable_set(delegate, test_delegate)
-    call
-  ensure
-    delegator.class.class_variable_set(delegate, actual_delegate)
-  end
-
-  def delegate_to_instance_variable(test_delegate)
-    actual_delegate = delegator.instance_variable_get(delegate)
-    delegator.instance_variable_set(delegate, test_delegate)
-    call
-  ensure
-    delegator.instance_variable_set(delegate, actual_delegate)
-  end
-
-  def delegate_to_constant
-    ensure_allow_nil_is_not_specified_for('a constant')
-    stub_delegation(delegator.class.const_get(delegate))
-    call
-  end
+        expected.method_name = method_name
+        expected.subject     = subject
 
-  def delegate_to_method(test_delegate)
-    ensure_delegate_method_is_valid
-    allow(delegator).to receive(delegate) { test_delegate }
-    call
-  end
-
-  def delegate_to_object
-    ensure_allow_nil_is_not_specified_for('an object')
-    stub_delegation(delegate)
-    call
-  end
-
-  def ensure_allow_nil_is_not_specified_for(target)
-    fail %(cannot verify "allow_nil" expectations when delegating to #{target}) unless expected_nil_check.nil?
-  end
-
-  def ensure_delegate_method_is_valid
-    fail "#{delegator} does not respond to #{delegate}"          unless delegator.respond_to?(delegate, true)
-    fail "#{delegator}'s' #{delegate} method expects parameters" unless [0, -1].include?(delegator.method(delegate).arity)
-  end
-
-  def delegator_method
-    @delegator_method || (prefix ? :"#{prefix}_#{method}" : method)
-  end
-
-  def delegate_method
-    @delegate_method || method
-  end
-
-  def call
-    @actual_return_value = delegator.send(delegator_method, *args, &block)
-  end
-
-  def block
-    @block ||= proc {}
-  end
-
-  def delegate_double
-    double('delegate').tap { |delegate| stub_delegation(delegate) }
-  end
-
-  def stub_delegation(delegate)
-    @delegated = false
-    allow(delegate).to(receive(delegate_method)) do |*args, &block|
-      @actual_args  = args
-      @actual_block = block
-      @delegated    = true
-      expected_return_value
-    end
-  end
-
-  def expected_return_value
-    self
-  end
-
-  def allow_nil_ok?
-    return true if expected_nil_check.nil?
-    return true unless delegate.is_a?(String) || delegate.is_a?(Symbol)
-
-    begin
-      actual_nil_check = true
-      delegate?(nil)
-      @return_value_when_delegate_nil = actual_return_value
-    rescue NoMethodError
-      actual_nil_check = false
-    end
-
-    expected_nil_check == actual_nil_check && @return_value_when_delegate_nil.nil?
-  end
-
-  def arguments_ok?
-    expected_args.nil? || actual_args.eql?(expected_args)
-  end
-
-  def block_ok?
-    case
-    when expected_block.nil?
-      true
-    when expected_block
-      actual_block == block
-    else
-      actual_block.nil?
-    end
-  end
-
-  def return_value_ok?
-    actual_return_value == expected_return_value
-  end
-
-  def delegator_description
-    "#{delegator_method}#{argument_description(args)}"
-  end
-
-  def delegate_description
-    case
-    when !args.eql?(expected_args)
-      "#{delegate}.#{delegate_method}#{argument_description(expected_args)}"
-    when delegate_method.eql?(delegator_method)
-      "#{delegate}"
-    else
-      "#{delegate}.#{delegate_method}"
-    end
-  end
-
-  def argument_description(args)
-    args ? "(#{args.map { |a| format('%p', a) }.join(', ')})" : ''
-  end
-
-  def nil_description
-    case
-    when expected_nil_check.nil?
-      ''
-    when expected_nil_check
-      ' with nil allowed'
-    else
-      ' with nil not allowed'
-    end
-  end
-
-  def block_description
-    case
-    when expected_block.nil?
-      ''
-    when expected_block
-      ' with a block'
-    else
-      ' without a block'
-    end
-  end
-
-  def failure_message_details(negated)
-    message = [
-      argument_failure_message(negated),
-      block_failure_message(negated),
-      return_value_failure_message(negated),
-      allow_nil_failure_message(negated)
-    ].reject(&:empty?).join(' and ')
-    message.empty? ? nil : message
-  end
-
-  def argument_failure_message(negated)
-    case
-    when expected_args.nil? || negated ^ arguments_ok?
-      ''
-    else
-      "was called with #{argument_description(actual_args)}"
-    end
-  end
-
-  def block_failure_message(negated)
-    case
-    when expected_block.nil? || (negated ^ block_ok?)
-      ''
-    when negated
-      "a block was #{expected_block ? '' : 'not '}passed"
-    when expected_block
-      actual_block.nil? ? 'a block was not passed' : "a different block #{actual_block} was passed"
-    else
-      'a block was passed'
-    end
-  end
-
-  def return_value_failure_message(_negated)
-    case
-    when !@delegated || return_value_ok?
-      ''
-    else
-      format('a return value of %p was returned instead of the delegate return value', actual_return_value)
-    end
-  end
-
-  def allow_nil_failure_message(negated)
-    case
-    when expected_nil_check.nil? || negated ^ allow_nil_ok?
-      ''
-    when !@return_value_when_delegate_nil.nil?
-      'did not return nil'
-    when negated
-      "#{delegate} was #{expected_nil_check ? '' : 'not '}allowed to be nil"
-    else
-      "#{delegate} was #{expected_nil_check ? 'not ' : ''}allowed to be nil"
+        delegation.ok?
+      end
     end
   end
 end
+
+# TODO: Handle delegation to a class method?
+# TODO: How to handle delegation if delegate_double is called with something else

data/lib/delegate_matcher/delegation.rb

@@ -0,0 +1,115 @@
+require 'rspec/matchers'
+
+module RSpec
+  module Matchers
+    module DelegateMatcher
+      class Delegation
+        attr_accessor :expected
+        attr_accessor :dispatcher
+        attr_accessor :delegate
+
+        def initialize(expected)
+          self.expected   = expected
+          self.dispatcher = DelegateMatcher::Dispatcher.new(expected)
+          self.delegate   = StubDelegate.new(expected)
+        end
+
+        def delegation_ok?
+          dispatcher.call
+          delegate.received
+        end
+
+        def ok?
+          allow_nil_ok? && delegation_ok? && arguments_ok? && block_ok? && return_value_ok?
+        end
+
+        def allow_nil_ok?
+          return true if expected.allow_nil.nil?
+
+          begin
+            NilDelegate.new(expected) { dispatcher.call }
+            allow_nil = true
+          rescue NoMethodError
+            allow_nil = false
+          end
+
+          allow_nil == expected.allow_nil
+        end
+
+        def arguments_ok?
+          expected.as_args.nil? || delegate.args.eql?(expected.as_args)
+        end
+
+        def block_ok?
+          case
+          when expected.block.nil?
+            true
+          when expected.block
+            delegate.block == dispatcher.block
+          else
+            delegate.block.nil?
+          end
+        end
+
+        def return_value_ok?
+          !expected.check_return || dispatcher.return_value == delegate.return_value
+        end
+
+        def failure_message(negated)
+          message = [
+            argument_failure_message(negated),
+            block_failure_message(negated),
+            return_value_failure_message(negated),
+            allow_nil_failure_message(negated)
+          ].reject(&:empty?).join(' and ')
+          message.empty? ? nil : message
+        end
+
+        def argument_failure_message(negated)
+          case
+          when expected.as_args.nil? || negated ^ arguments_ok?
+            ''
+          else
+            "was called with #{delegate.argument_description}"
+          end
+        end
+
+        def block_failure_message(negated)
+          case
+          when expected.block.nil? || (negated ^ block_ok?)
+            ''
+          when negated
+            "a block was #{expected.block ? '' : 'not '}passed"
+          when expected.block
+            delegate.block.nil? ? 'a block was not passed' : "a different block #{delegate.block} was passed"
+          else
+            'a block was passed'
+          end
+        end
+
+        def return_value_failure_message(_negated)
+          case
+          when !delegate.received || return_value_ok?
+            ''
+          else
+            format('a return value of %p was returned instead of the delegate return value', dispatcher.return_value)
+          end
+        end
+
+        def allow_nil_failure_message(negated)
+          case
+          when expected.allow_nil.nil? || negated ^ allow_nil_ok?
+            ''
+          when negated
+            "#{expected.to} was #{expected.allow_nil ? '' : 'not '}allowed to be nil"
+          else
+            "#{expected.to} was #{expected.allow_nil ? 'not ' : ''}allowed to be nil"
+          end
+        end
+      end
+    end
+  end
+end
+
+# TODO: use default prefix with constants - lower case method prefix
+# TODO: How to handle delegation is delegate_double is called with something else

data/lib/delegate_matcher/dispatcher.rb

@@ -0,0 +1,26 @@
+module RSpec
+  module Matchers
+    module DelegateMatcher
+      class Dispatcher
+        attr_reader :return_value
+
+        def initialize(expected)
+          self.expected = expected
+        end
+
+        def call
+          self.return_value = expected.subject.send(expected.delegator_method_name, *expected.args, &block)
+        end
+
+        def block
+          @block ||= proc {}
+        end
+
+        private
+
+        attr_accessor :expected
+        attr_writer :return_value
+      end
+    end
+  end
+end

data/lib/delegate_matcher/expected.rb

@@ -0,0 +1,108 @@
+module RSpec
+  module Matchers
+    module DelegateMatcher
+      class Expected
+        attr_accessor :subject, :to, :method_name, :block, :as, :allow_nil, :check_return
+        attr_reader   :args
+
+        def initialize
+          self.check_return = true
+        end
+
+        def prefix=(prefix)
+          @has_prefix = true
+          @prefix     = prefix
+        end
+
+        def prefix
+          case
+          when !@has_prefix
+            ''
+          when @prefix
+            "#{@prefix}_"
+          when to.is_a?(String) || to.is_a?(Symbol)
+            to.to_s.delete('@').downcase + '_'
+          else
+            ''
+          end
+        end
+
+        def args=(args)
+          @args_set ? @as_args = args : @args = args
+          @args_set = true
+        end
+
+        def as_args
+          @as_args || args
+        end
+
+        def as
+          @as || method_name
+        end
+
+        def delegator_method_name
+          "#{prefix}#{method_name}"
+        end
+
+        def description
+          "delegate #{delegator_description} to #{delegate_description}#{options_description}"
+        end
+
+        private
+
+        def delegator_description
+          "#{delegator_method_name}#{argument_description}"
+        end
+
+        def delegate_description
+          case
+          when !args.eql?(as_args)
+            "#{to}.#{as}#{as_argument_description}"
+          when as.to_s.eql?(delegator_method_name)
+            "#{to}"
+          else
+            "#{to}.#{as}"
+          end
+        end
+
+        def as_argument_description
+          argument_description(as_args)
+        end
+
+        def argument_description(arguments = args)
+          arguments ? "(#{arguments.map { |a| format('%p', a) }.join(', ')})" : ''
+        end
+
+        def options_description
+          "#{nil_description}#{block_description}#{return_value_description}"
+        end
+
+        def nil_description
+          case
+          when allow_nil.nil?
+            ''
+          when allow_nil
+            ' with nil allowed'
+          else
+            ' with nil not allowed'
+          end
+        end
+
+        def block_description
+          case
+          when block.nil?
+            ''
+          when block
+            ' with a block'
+          else
+            ' without a block'
+          end
+        end
+
+        def return_value_description
+          check_return ? '' : ' without using delegate return value'
+        end
+      end
+    end
+  end
+end

data/lib/delegate_matcher/nil_delegate.rb

@@ -0,0 +1,41 @@
+module RSpec
+  module Matchers
+    module DelegateMatcher
+      class NilDelegate < Delegate
+        def initialize(expected, &block)
+          super
+          original_receiver = receiver
+          self.receiver = nil
+          block.call
+        ensure
+          self.receiver = original_receiver
+        end
+
+        private
+
+        # rubocop:disable Metrics/AbcSize
+        def receiver=(value)
+          case
+          when a_class_variable?
+            subject.class.class_variable_set(name, value)
+          when an_instance_variable?
+            subject.instance_variable_set(name, value)
+          when a_constant?
+            silence_warnings { subject.class.const_set(name, value) }
+          when a_method?
+            allow(subject).to receive(name) { value }
+          else # is an object
+            fail 'cannot verify "allow_nil" expectations when delegating to an object' if value.nil?
+          end
+        end
+
+        def silence_warnings(&block)
+          warn_level = $VERBOSE
+          $VERBOSE = nil
+          block.call
+          $VERBOSE = warn_level
+        end
+      end
+    end
+  end
+end