delegate_matcher 0.3 → 0.4

data/lib/delegate_matcher/delegation.rb

@@ -4,6 +4,7 @@ require 'proc_extensions'
 module RSpec
   module Matchers
     module DelegateMatcher
+      # rubocop:disable Metrics/ClassLength
       class Delegation
         attr_accessor :expected
         attr_accessor :dispatcher
@@ -12,12 +13,12 @@ module RSpec
         def initialize(expected)
           self.expected   = expected
           self.dispatcher = DelegateMatcher::Dispatcher.new(expected)
-          self.delegate   = StubDelegate.new(expected)
+          self.delegate   = expected.to.map { |to| StubDelegate.new(expected, to) }
         end
 
         def delegation_ok?
           dispatcher.call
-          delegate.received
+          delegate.all?(&:received)
         end
 
         def ok?
@@ -28,7 +29,7 @@ module RSpec
           return true if expected.allow_nil.nil?
 
           begin
-            NilDelegate.new(expected) { dispatcher.call }
+            expected.to.each { |to| NilDelegate.new(expected, to) { dispatcher.call } }
             allow_nil = true
           rescue NoMethodError
             allow_nil = false
@@ -38,7 +39,8 @@ module RSpec
         end
 
         def arguments_ok?
-          expected.as_args.nil? || delegate.args.eql?(expected.as_args)
+          args_matcher = Mocks::ArgumentListMatcher.new(*expected.as_args)
+          delegate.all? { |delegate| args_matcher.args_match?(*delegate.args) }
         end
 
         # rubocop:disable Metrics/AbcSize
@@ -47,22 +49,27 @@ module RSpec
           when expected.block.nil?
             true
           when expected.block == false
-            delegate.block.nil?
+            delegate.all? { |d| d.block.nil? }
           when expected.block == true
-            delegate.block == dispatcher.block
+            delegate.all? { |d| d.block == dispatcher.block }
           else
-            delegate.block_source == expected.block_source
+            delegate.all? { |d| d.block_source == expected.block_source }
           end
         end
 
         def return_value_ok?
-          !expected.check_return || dispatcher.return_value == delegate.return_value
+          case
+          when !expected.check_return then true
+          when expected.return_value.nil? then  dispatcher.return_value == delegate_return_value
+          else dispatcher.return_value == expected.return_value
+          end
         end
 
-        def failure_message(negated)
-          # TODO: Should include the line below
-          # return nil if negated == delegate.received
+        def delegate_return_value
+          delegate.length == 1 ? delegate[0].return_value : delegate.map(&:return_value)
+        end
 
+        def failure_message(negated)
           message = [
             argument_failure_message(negated),
             block_failure_message(negated),
@@ -77,29 +84,34 @@ module RSpec
           when expected.as_args.nil? || negated ^ arguments_ok?
             ''
           else
-            "was called with #{delegate.argument_description}"
+            "was called with #{delegate[0].argument_description}"
           end
         end
 
         def block_failure_message(negated)
+          proc_source = ProcSource.new(delegate[0].block)
           case
-          when expected.block.nil? || (negated ^ block_ok?)
+          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 '#{ProcSource.new(delegate.block)}' was passed"
+            delegate.all? { |d| d.block.nil? } ? 'a block was not passed' : "a different block '#{proc_source}' was passed"
           else
-            'a block was passed'
+            %(a block #{proc_source} was passed)
           end
         end
 
-        def return_value_failure_message(_negated)
+        def return_value_failure_message(negated)
           case
-          when !delegate.received || return_value_ok?
+          when !delegate.any?(&:received) || negated ^ return_value_ok?
+            ''
+          when negated
             ''
+          when !expected.return_value.nil?
+            "a value of \"#{dispatcher.return_value}\" was returned instead of \"#{expected.return_value}\""
           else
-            format('a return value of %p was returned instead of the delegate return value', dispatcher.return_value)
+            "a value of \"#{dispatcher.return_value}\" was returned instead of \"#{delegate_return_value}\""
           end
         end
 
@@ -108,15 +120,12 @@ module RSpec
           when expected.allow_nil.nil? || negated ^ allow_nil_ok?
             ''
           when negated
-            "#{expected.to} was #{expected.allow_nil ? '' : 'not '}allowed to be nil"
+            %("#{expected.to_description}" was #{expected.allow_nil ? '' : 'not '}allowed to be nil)
           else
-            "#{expected.to} was #{expected.allow_nil ? 'not ' : ''}allowed to be nil"
+            %("#{expected.to_description}" 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

@@ -9,7 +9,10 @@ module RSpec
         end
 
         def call
-          self.return_value = expected.subject.send(expected.delegator_method_name, *expected.args, &block)
+          args = expected.args
+          args = [] if args && args[0].is_a?(Mocks::ArgumentMatchers::NoArgsMatcher)
+
+          self.return_value = expected.subject.send(expected.delegator_method_name, *args, &block)
         end
 
         def block

data/lib/delegate_matcher/expected.rb

@@ -4,11 +4,12 @@ module RSpec
       class Expected
         include Block
 
-        attr_accessor :subject, :to, :method_name, :as, :allow_nil, :check_return
+        attr_accessor :subject, :to, :method_name, :as, :allow_nil, :check_return, :return_value
         attr_reader   :args
 
         def initialize
           self.check_return = true
+          # @args = [Mocks::ArgumentMatchers::NoArgsMatcher::INSTANCE]
         end
 
         def prefix=(prefix)
@@ -22,8 +23,8 @@ module RSpec
             ''
           when @prefix
             "#{@prefix}_"
-          when to.is_a?(String) || to.is_a?(Symbol)
-            to.to_s.delete('@').downcase + '_'
+          when to[0].is_a?(String) || to[0].is_a?(Symbol)
+            to[0].to_s.delete('@').downcase + '_'
           else
             ''
           end
@@ -50,6 +51,10 @@ module RSpec
           "delegate #{delegator_description} to #{delegate_description}#{options_description}"
         end
 
+        def to_description
+          to.join(',')
+        end
+
         private
 
         def delegator_description
@@ -57,22 +62,23 @@ module RSpec
         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)
+          %("#{to_description}") +
+            case
+            when !args.eql?(as_args)
+              ".#{as}#{argument_description(as_args)}"
+            when as.to_s.eql?(delegator_method_name)
+              ''
+            else
+              ".#{as}"
+            end
         end
 
         def argument_description(arguments = args)
-          arguments ? "(#{arguments.map { |a| format('%p', a) }.join(', ')})" : ''
+          if arguments
+            "(#{arguments.map { |a| a.respond_to?(:description) ? a.description : a.inspect }.join(', ')})"
+          else
+            ''
+          end
         end
 
         def options_description
@@ -99,12 +105,19 @@ module RSpec
           when block == false
             ' without a block'
           else
-            " with block '#{block_source}'"
+            " with block \"#{block_source}\""
           end
         end
 
         def return_value_description
-          check_return ? '' : ' without using delegate return value'
+          case
+          when return_value
+            " and return \"#{return_value}\""
+          when !check_return
+            ' without using delegate return value'
+          else
+            ''
+          end
         end
       end
     end

data/lib/delegate_matcher/nil_delegate.rb

@@ -2,7 +2,7 @@ module RSpec
   module Matchers
     module DelegateMatcher
       class NilDelegate < Delegate
-        def initialize(expected, &block)
+        def initialize(expected, to, &block)
           super
           original_receiver = receiver
           self.receiver = nil
@@ -24,7 +24,7 @@ module RSpec
             silence_warnings { subject.class.const_set(name, value) }
           when a_method?
             allow(subject).to receive(name) { value }
-          else # is an object
+          else # an object
             fail 'cannot verify "allow_nil" expectations when delegating to an object' if value.nil?
           end
         end
@@ -33,6 +33,7 @@ module RSpec
           warn_level = $VERBOSE
           $VERBOSE = nil
           block.call
+        ensure
           $VERBOSE = warn_level
         end
       end

data/lib/delegate_matcher/stub_delegate.rb

@@ -4,14 +4,18 @@ module RSpec
       class StubDelegate < Delegate
         RSpec::Mocks::Syntax.enable_expect(self)
 
-        def initialize(expected)
-          self.expected = expected
-          self.received = false
+        attr_reader :return_value
+
+        def initialize(expected, to)
+          super
+          self.return_value = receiver.send(expected.as, *expected.args)
           stub_receiver
         end
 
         private
 
+        attr_writer :return_value
+
         def stub_receiver
           allow(receiver).to receive(expected.as) do |*args, &block|
             self.args     = args

data/lib/delegate_matcher/version.rb

@@ -1,3 +1,3 @@
 module DelegateMatcher
-  VERSION ||= '0.3'.freeze
+  VERSION ||= '0.4'.freeze
 end

data/spec/{lib → examples}/active_support_delegation_spec.rb

@@ -20,11 +20,19 @@ module ActiveSupportDelegation
     def initialize
       @author = Author.new
     end
+
+    def inspect
+      'post'
+    end
   end
 
   class Author
-    def name
-      @name ||= 'Catherine Asaro'
+    def initialize
+      @name = 'Catherine Asaro'
+    end
+
+    def name(*)
+      @name
     end
   end
 
@@ -41,6 +49,7 @@ module ActiveSupportDelegation
     it { should delegate(:name).to(:author).with_prefix(:writer) }
     it { should delegate(:name).to(:author).with_block }
     it { should delegate(:name).to(:author).with('Ms.') }
+    it { should delegate(:name).to(:author).with('Ms.').with_block }
 
     it { should delegate(:name).to(:class).with_prefix   }
     it { should delegate(:count).to(:@@authors)   }

data/spec/{lib → examples}/forwardable_delegation_spec.rb

@@ -15,11 +15,19 @@ module ForwardableDelegation
     def_delegator :author, :name, :writer
 
     def_delegator :'author.name', :length, :name_length
+
+    def inspect
+      'post'
+    end
   end
 
   class Author
-    def name
-      @name ||= 'Catherine Asaro'
+    def initialize
+      @name = 'Catherine Asaro'
+    end
+
+    def name(*)
+      @name
     end
   end
 
@@ -33,6 +41,7 @@ module ForwardableDelegation
     it { should delegate(:name).to(:author) }
     it { should delegate(:name).to(:author).with('Ms.') }
     it { should delegate(:name).to(:author).with_block }
+    it { should delegate(:name).to(:author).with('Ms.').with_block }
     it { should delegate(:name).to(:author).with_prefix }
     it { should delegate(:writer).to(:author).as(:name) }
 

data/spec/shared/author.rb

@@ -0,0 +1,23 @@
+module RSpec
+  module Matchers
+    module DelegateMatcher
+      class Author
+        def initialize(name = 'Catherine Asaro')
+          @name = name
+        end
+
+        def other_name
+          'Other Name'
+        end
+
+        def name(*args, &_)
+          "#{args.join}#{@name}"
+        end
+
+        def to_s
+          "Author: #{@name}"
+        end
+      end
+    end
+  end
+end

data/spec/{lib/shared/a_simple_delegator.rb → shared/basic.rb}

@@ -1,17 +1,15 @@
-shared_examples 'a simple delegator' do
+shared_examples 'a basic delegator' do
   it { should delegate(:name).to(receiver)      }
   it { should delegate(:name.to_s).to(receiver) }
 
   it { should_not delegate(:to_s).to(receiver) }
 
-  include_examples 'a delegator without a block'
-
   describe 'description' do
     let(:matcher) { delegate(:name).to(receiver) }
     before { matcher.matches? subject }
 
-    it { expect(matcher.description).to eq "delegate name to #{receiver}" }
-    it { expect(matcher.failure_message).to match(/expected .* to delegate name to #{receiver}/) }
-    it { expect(matcher.failure_message_when_negated).to match(/expected .* not to delegate name to #{receiver}/) }
+    it { expect(matcher.description).to eq %(delegate name to "#{receiver}") }
+    it { expect(matcher.failure_message).to match(/expected .* to delegate name to "#{receiver}"/) }
+    it { expect(matcher.failure_message_when_negated).to match(/expected .* not to delegate name to "#{receiver}"/) }
   end
 end

data/spec/{lib/shared → shared}/nil_check.rb

@@ -1,27 +1,27 @@
 shared_examples 'a delegator with a nil check' do
-  it { should     delegate(:name).to(receiver).allow_nil        }
-  it { should     delegate(:name).to(receiver).allow_nil(true)  }
-  it { should_not delegate(:name).to(receiver).allow_nil(false) }
+  it { should     delegate(:name_allow_nil).to(receiver).as(:name).allow_nil        }
+  it { should     delegate(:name_allow_nil).to(receiver).as(:name).allow_nil(true)  }
+  it { should_not delegate(:name_allow_nil).to(receiver).as(:name).allow_nil(false) }
 
   describe 'description' do
     before { matcher.matches? subject }
 
     context 'with allow nil at default' do
-      let(:matcher) { delegate(:name).to(receiver).allow_nil }
-      it { expect(matcher.description).to eq %(delegate name to #{receiver} with nil allowed) }
-      it { expect(matcher.failure_message_when_negated).to match(/#{receiver} was allowed to be nil/) }
+      let(:matcher) { delegate(:name_allow_nil).to(receiver).as(:name).allow_nil }
+      it { expect(matcher.description).to match(/with nil allowed/) }
+      it { expect(matcher.failure_message_when_negated).to match(/ was allowed to be nil/) }
     end
 
     context 'with allow nil true' do
-      let(:matcher) { delegate(:name).to(receiver).allow_nil(true) }
-      it { expect(matcher.description).to eq %(delegate name to #{receiver} with nil allowed) }
-      it { expect(matcher.failure_message_when_negated).to match(/#{receiver} was allowed to be nil/) }
+      let(:matcher) { delegate(:name_allow_nil).to(receiver).as(:name).allow_nil(true) }
+      it { expect(matcher.description).to match(/with nil allowed/) }
+      it { expect(matcher.failure_message_when_negated).to match(/ was allowed to be nil/) }
     end
 
     context 'with allow nil false' do
-      let(:matcher) { delegate(:name).to(receiver).allow_nil(false) }
-      it { expect(matcher.description).to eq %(delegate name to #{receiver} with nil not allowed) }
-      it { expect(matcher.failure_message).to match(/#{receiver} was allowed to be nil/) }
+      let(:matcher) { delegate(:name_allow_nil).to(receiver).as(:name).allow_nil(false) }
+      it { expect(matcher.description).to match(/ with nil not allowed/) }
+      it { expect(matcher.failure_message).to match(/ was allowed to be nil/) }
     end
   end
 end
@@ -36,17 +36,17 @@ shared_examples 'a delegator without a nil check' do
 
     context 'with allow nil at default' do
       let(:matcher) { delegate(:name).to(receiver).allow_nil }
-      it { expect(matcher.failure_message).to match(/#{receiver} was not allowed to be nil/) }
+      it { expect(matcher.failure_message).to match(/"#{receiver}" was not allowed to be nil/) }
     end
 
     context 'with allow nil true' do
       let(:matcher) { delegate(:name).to(receiver).allow_nil(true) }
-      it { expect(matcher.failure_message).to match(/#{receiver} was not allowed to be nil/) }
+      it { expect(matcher.failure_message).to match(/"#{receiver}" was not allowed to be nil/) }
     end
 
     context 'with allow nil false' do
       let(:matcher) { delegate(:name).to(receiver).allow_nil(false) }
-      it { expect(matcher.failure_message_when_negated).to match(/#{receiver} was not allowed to be nil/) }
+      it { expect(matcher.failure_message_when_negated).to match(/"#{receiver}" was not allowed to be nil/) }
     end
   end
 end

data/spec/shared/post_delegation.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+module RSpec
+  module Matchers
+    module DelegateMatcher
+      shared_context 'Post delegation' do
+        subject { klass.new }
+
+        let(:klass) do
+          Class.new do
+            include PostMethods
+
+            def initialize
+              @author = Author.new
+            end
+
+            def name
+              @author.name
+            end
+          end
+        end
+
+        before do
+          klass.class_eval method_definition
+          matcher.matches? subject
+        end
+
+        def method_definition
+          klass = self.class
+          while klass != Object
+            return klass.description if klass.respond_to?(:description) && klass.description =~ /def \w*name/
+            klass = klass.parent
+          end
+
+          '# Could not find "def \w*name..." method definition'
+        end
+
+        let(:matcher) { delegate(:name).to(:@author) }
+      end
+    end
+  end
+end

data/spec/shared/post_methods.rb

@@ -0,0 +1,15 @@
+module RSpec
+  module Matchers
+    module DelegateMatcher
+      module PostMethods
+        def to_s
+          'post'
+        end
+
+        def inspect
+          'post'
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -15,7 +15,7 @@ Coveralls.wear! if Coveralls.will_run?
 
 require 'delegate_matcher'
 
-Dir[File.dirname(__FILE__) + '/lib/shared/*.rb'].each { |f| require f }
+Dir[File.dirname(__FILE__) + '/shared/*.rb'].each { |f| require f }
 
 RSpec.configure do |config|
   config.color = true

data/spec/to_a_class_method_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+module RSpec
+  module Matchers
+    module DelegateMatcher
+      describe 'class delegation' do
+        let(:klass) do
+          Class.new do
+            include PostMethods
+
+            class << self
+              def author
+                @author ||= Author.new
+              end
+
+              def name
+                author.name
+              end
+
+              def name_allow_nil
+                author.name if author
+              end
+            end
+          end
+        end
+
+        subject { klass }
+
+        let(:receiver) { :author }
+
+        it_behaves_like 'a basic delegator'
+        it_behaves_like 'a delegator without a nil check'
+        it_behaves_like 'a delegator with a nil check'
+      end
+    end
+  end
+end

data/spec/to_a_class_variable_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+module RSpec
+  module Matchers
+    module DelegateMatcher
+      describe 'delegation to a class variable' do
+        # Note that defining Post as an anonymous class caused the class variable @@author to not be available,
+        # so we create an explicit Post class and remove it after all specs are run
+        before(:all) do
+          class Post
+            include PostMethods
+
+            # rubocop:disable Style/ClassVars
+            @@author = Author.new
+
+            def name
+              @@author.name
+            end
+
+            def name_allow_nil
+              @@author.name if @@author
+            end
+          end
+        end
+
+        subject { Post.new }
+
+        let(:receiver) { :@@author }
+
+        it_behaves_like 'a basic delegator'
+        it_behaves_like 'a delegator without a nil check'
+        it_behaves_like 'a delegator with a nil check'
+
+        after(:all) { DelegateMatcher.module_eval { remove_const :Post } }
+      end
+    end
+  end
+end

data/spec/to_a_constant_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+module RSpec
+  module Matchers
+    module DelegateMatcher
+      describe 'class delegation' do
+        # Note that defining Post as an anonymous class caused the constant AUTHOR to not be available,
+        # so we create an explicit Post class and remove it after all specs are run
+        before(:all) do
+          class Post
+            include PostMethods
+
+            AUTHOR = Author.new
+
+            def name
+              AUTHOR.name
+            end
+
+            def name_allow_nil
+              AUTHOR.name if AUTHOR
+            end
+          end
+        end
+
+        subject { Post.new }
+
+        let(:receiver) { :AUTHOR }
+
+        it_behaves_like 'a basic delegator'
+        it_behaves_like 'a delegator without a nil check'
+        it_behaves_like 'a delegator with a nil check'
+
+        after(:all) { DelegateMatcher.module_eval { remove_const :Post } }
+      end
+    end
+  end
+end