redcar 0.3.2dev → 0.3.3

data/lib/openssl/mocha/lib/mocha/parameter_matchers.rb

@@ -0,0 +1,9 @@
+module Mocha
+  
+  # Used as parameters for Expectation#with to restrict the parameter values which will match the expectation.
+  module ParameterMatchers; end
+  
+end
+
+
+Dir[File.expand_path(File.join(File.dirname(__FILE__), 'parameter_matchers', "*.rb"))].each { |lib| require lib }

data/lib/openssl/mocha/lib/mocha/parameter_matchers/all_of.rb

@@ -0,0 +1,39 @@
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: all_of -> parameter_matcher
+    #
+    # Matches if all +matchers+ match.
+    #   object = mock()
+    #   object.expects(:method_1).with(all_of(includes(1), includes(3)))
+    #   object.method_1([1, 3])
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(all_of(includes(1), includes(3)))
+    #   object.method_1([1, 2])
+    #   # error raised, because method_1 was not called with object including 1 and 3
+    def all_of(*matchers)
+      AllOf.new(*matchers)
+    end
+    
+    class AllOf # :nodoc:
+      
+      def initialize(*matchers)
+        @matchers = matchers
+      end
+    
+      def ==(parameter)
+        @matchers.all? { |matcher| matcher == parameter }
+      end
+      
+      def mocha_inspect
+        "all_of(#{@matchers.map { |matcher| matcher.mocha_inspect }.join(", ") })"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/openssl/mocha/lib/mocha/parameter_matchers/any_of.rb

@@ -0,0 +1,44 @@
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: any_of -> parameter_matcher
+    #
+    # Matches if any +matchers+ match.
+    #   object = mock()
+    #   object.expects(:method_1).with(any_of(1, 3))
+    #   object.method_1(1)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(any_of(1, 3))
+    #   object.method_1(3)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(any_of(1, 3))
+    #   object.method_1(2)
+    #   # error raised, because method_1 was not called with 1 or 3
+    def any_of(*matchers)
+      AnyOf.new(*matchers)
+    end
+    
+    class AnyOf # :nodoc:
+      
+      def initialize(*matchers)
+        @matchers = matchers
+      end
+    
+      def ==(parameter)
+        @matchers.any? { |matcher| matcher == parameter }
+      end
+      
+      def mocha_inspect
+        "any_of(#{@matchers.map { |matcher| matcher.mocha_inspect }.join(", ") })"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/openssl/mocha/lib/mocha/parameter_matchers/anything.rb

@@ -0,0 +1,30 @@
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: anything -> parameter_matcher
+    #
+    # Matches any object.
+    #   object = mock()
+    #   object.expects(:method_1).with(anything)
+    #   object.method_1('foo')
+    #   # no error raised
+    def anything
+      Anything.new
+    end
+    
+    class Anything # :nodoc:
+    
+      def ==(parameter)
+        return true
+      end
+      
+      def mocha_inspect
+        "anything"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/openssl/mocha/lib/mocha/parameter_matchers/has_entry.rb

@@ -0,0 +1,39 @@
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: has_entry(key, value) -> parameter_matcher
+    #
+    # Matches +Hash+ containing entry with +key+ and +value+.
+    #   object = mock()
+    #   object.expects(:method_1).with(has_entry('key_1', 1))
+    #   object.method_1('key_1' => 1, 'key_2' => 2)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(has_entry('key_1', 1))
+    #   object.method_1('key_1' => 2, 'key_2' => 1)
+    #   # error raised, because method_1 was not called with Hash containing entry: 'key_1' => 1
+    def has_entry(key, value)
+      HasEntry.new(key, value)
+    end
+
+    class HasEntry # :nodoc:
+      
+      def initialize(key, value)
+        @key, @value = key, value
+      end
+      
+      def ==(parameter)
+        parameter[@key] == @value
+      end
+      
+      def mocha_inspect
+        "has_entry(#{@key.mocha_inspect}, #{@value.mocha_inspect})"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/openssl/mocha/lib/mocha/parameter_matchers/has_key.rb

@@ -0,0 +1,39 @@
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: has_key(key) -> parameter_matcher
+    #
+    # Matches +Hash+ containing +key+.
+    #   object = mock()
+    #   object.expects(:method_1).with(has_key('key_1'))
+    #   object.method_1('key_1' => 1, 'key_2' => 2)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(has_key('key_1'))
+    #   object.method_1('key_2' => 2)
+    #   # error raised, because method_1 was not called with Hash containing key: 'key_1'
+    def has_key(key)
+      HasKey.new(key)
+    end
+
+    class HasKey # :nodoc:
+      
+      def initialize(key)
+        @key = key
+      end
+      
+      def ==(parameter)
+        parameter.keys.include?(@key)
+      end
+      
+      def mocha_inspect
+        "has_key(#{@key.mocha_inspect})"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/openssl/mocha/lib/mocha/parameter_matchers/has_value.rb

@@ -0,0 +1,39 @@
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: has_value(value) -> parameter_matcher
+    #
+    # Matches +Hash+ containing +value+.
+    #   object = mock()
+    #   object.expects(:method_1).with(has_value(1))
+    #   object.method_1('key_1' => 1, 'key_2' => 2)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(has_value(1))
+    #   object.method_1('key_2' => 2)
+    #   # error raised, because method_1 was not called with Hash containing value: 1
+    def has_value(value)
+      HasValue.new(value)
+    end
+
+    class HasValue # :nodoc:
+      
+      def initialize(value)
+        @value = value
+      end
+      
+      def ==(parameter)
+        parameter.values.include?(@value)
+      end
+      
+      def mocha_inspect
+        "has_value(#{@value.mocha_inspect})"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/openssl/mocha/lib/mocha/parameter_matchers/includes.rb

@@ -0,0 +1,37 @@
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: includes(item) -> parameter_matcher
+    #
+    # Matches any object that responds true to include?(item)
+    #   object = mock()
+    #   object.expects(:method_1).with(includes('foo'))
+    #   object.method_1(['foo', 'bar'])
+    #   # no error raised
+    #
+    #   object.method_1(['baz'])
+    #   # error raised, because ['baz'] does not include 'foo'.
+    def includes(item)
+      Includes.new(item)
+    end
+
+    class Includes # :nodoc:
+
+      def initialize(item)
+        @item = item
+      end
+
+      def ==(parameter)
+        return parameter.include?(@item)
+      end
+
+      def mocha_inspect
+        "includes(#{@item.mocha_inspect})"
+      end
+
+    end
+
+  end
+  
+end

data/lib/openssl/mocha/lib/mocha/parameter_matchers/instance_of.rb

@@ -0,0 +1,39 @@
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: instance_of(klass) -> parameter_matcher
+    #
+    # Matches any object that is an instance of +klass+
+    #   object = mock()
+    #   object.expects(:method_1).with(instance_of(String))
+    #   object.method_1('string')
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(instance_of(String))
+    #   object.method_1(99)
+    #   # error raised, because method_1 was not called with an instance of String
+    def instance_of(klass)
+      InstanceOf.new(klass)
+    end
+    
+    class InstanceOf # :nodoc:
+      
+      def initialize(klass)
+        @klass = klass
+      end
+    
+      def ==(parameter)
+        parameter.instance_of?(@klass)
+      end
+      
+      def mocha_inspect
+        "instance_of(#{@klass.mocha_inspect})"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/openssl/mocha/lib/mocha/parameter_matchers/kind_of.rb

@@ -0,0 +1,39 @@
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: kind_of(klass) -> parameter_matcher
+    #
+    # Matches any object that is a kind of +klass+
+    #   object = mock()
+    #   object.expects(:method_1).with(kind_of(Integer))
+    #   object.method_1(99)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(kind_of(Integer))
+    #   object.method_1('string')
+    #   # error raised, because method_1 was not called with a kind of Integer
+    def kind_of(klass)
+      KindOf.new(klass)
+    end
+    
+    class KindOf # :nodoc:
+      
+      def initialize(klass)
+        @klass = klass
+      end
+    
+      def ==(parameter)
+        parameter.kind_of?(@klass)
+      end
+      
+      def mocha_inspect
+        "kind_of(#{@klass.mocha_inspect})"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/openssl/mocha/lib/mocha/pretty_parameters.rb

@@ -0,0 +1,28 @@
+require 'mocha/inspect'
+
+module Mocha
+
+  class PrettyParameters
+  
+    def initialize(params)
+      @params = params
+      @params_string = params.mocha_inspect
+    end
+  
+    def pretty
+      remove_outer_array_braces!
+      remove_outer_hash_braces!
+      @params_string
+    end
+  
+    def remove_outer_array_braces!
+      @params_string = @params_string.gsub(/^\[|\]$/, '')
+    end
+  
+    def remove_outer_hash_braces!
+      @params_string = @params_string.gsub(/^\{|\}$/, '') if @params.size == 1
+    end
+  
+  end
+  
+end

data/lib/openssl/mocha/lib/mocha/return_values.rb

@@ -0,0 +1,31 @@
+require 'mocha/single_return_value'
+
+module Mocha # :nodoc:
+  
+  class ReturnValues # :nodoc:
+    
+    def self.build(*values)
+      new(*values.map { |value| SingleReturnValue.new(value) })
+    end
+    
+    attr_accessor :values
+    
+    def initialize(*values)
+      @values = values
+    end
+    
+    def next
+      case @values.size
+      when 0: nil
+      when 1: @values.first.evaluate
+      else @values.shift.evaluate
+      end
+    end
+    
+    def +(other)
+      self.class.new(*(@values + other.values))
+    end
+    
+  end
+  
+end

data/lib/openssl/mocha/lib/mocha/setup_and_teardown.rb

@@ -0,0 +1,23 @@
+require 'mocha/central'
+
+module Mocha
+  
+  module SetupAndTeardown
+  
+    def setup_stubs
+      $stubba = Mocha::Central.new
+    end
+    
+    def verify_stubs
+      $stubba.verify_all { yield if block_given? } if $stubba
+    end
+  
+    def teardown_stubs
+      if $stubba then
+        $stubba.unstub_all
+        $stubba = nil
+      end
+    end
+
+  end
+end