dradis-mediawiki 3.18.0

data/test/vendor/mocha-0.9.5/lib/mocha/parameter_matchers.rb

@@ -0,0 +1,27 @@
+module Mocha
+  
+  # Used as parameters for Expectation#with to restrict the parameter values which will match the expectation. Can be nested.
+  module ParameterMatchers; end
+  
+end
+
+require 'mocha/parameter_matchers/object'
+
+require 'mocha/parameter_matchers/all_of'
+require 'mocha/parameter_matchers/any_of'
+require 'mocha/parameter_matchers/any_parameters'
+require 'mocha/parameter_matchers/anything'
+require 'mocha/parameter_matchers/equals'
+require 'mocha/parameter_matchers/has_entry'
+require 'mocha/parameter_matchers/has_entries'
+require 'mocha/parameter_matchers/has_key'
+require 'mocha/parameter_matchers/has_value'
+require 'mocha/parameter_matchers/includes'
+require 'mocha/parameter_matchers/instance_of'
+require 'mocha/parameter_matchers/is_a'
+require 'mocha/parameter_matchers/kind_of'
+require 'mocha/parameter_matchers/not'
+require 'mocha/parameter_matchers/optionally'
+require 'mocha/parameter_matchers/regexp_matches'
+require 'mocha/parameter_matchers/responds_with'
+require 'mocha/parameter_matchers/yaml_equivalent'

data/test/vendor/mocha-0.9.5/lib/mocha/parameter_matchers/all_of.rb

@@ -0,0 +1,42 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: all_of(*parameter_matchers) -> parameter_matcher
+    #
+    # Matches if all +parameter_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 < Base # :nodoc:
+      
+      def initialize(*matchers)
+        @matchers = matchers
+      end
+    
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        @matchers.all? { |matcher| matcher.to_matcher.matches?([parameter]) }
+      end
+      
+      def mocha_inspect
+        "all_of(#{@matchers.map { |matcher| matcher.mocha_inspect }.join(", ") })"
+      end
+      
+    end
+    
+  end
+  
+end

data/test/vendor/mocha-0.9.5/lib/mocha/parameter_matchers/any_of.rb

@@ -0,0 +1,47 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: any_of(*parameter_matchers) -> parameter_matcher
+    #
+    # Matches if any +parameter_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 < Base # :nodoc:
+      
+      def initialize(*matchers)
+        @matchers = matchers
+      end
+    
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        @matchers.any? { |matcher| matcher.to_matcher.matches?([parameter]) }
+      end
+      
+      def mocha_inspect
+        "any_of(#{@matchers.map { |matcher| matcher.mocha_inspect }.join(", ") })"
+      end
+      
+    end
+    
+  end
+  
+end

data/test/vendor/mocha-0.9.5/lib/mocha/parameter_matchers/any_parameters.rb

@@ -0,0 +1,40 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: any_parameters() -> parameter_matcher
+    #
+    # Matches any parameters.
+    #   object = mock()
+    #   object.expects(:method_1).with(any_parameters)
+    #   object.method_1(1, 2, 3, 4)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(any_parameters)
+    #   object.method_1(5, 6, 7, 8, 9, 0)
+    #   # no error raised
+    def any_parameters
+      AnyParameters.new
+    end
+
+    class AnyParameters < Base # :nodoc:
+      
+      def matches?(available_parameters)
+        while available_parameters.length > 0 do
+          available_parameters.shift
+        end
+        return true
+      end
+
+      def mocha_inspect
+        "any_parameters"
+      end
+
+    end
+    
+  end
+  
+end

data/test/vendor/mocha-0.9.5/lib/mocha/parameter_matchers/anything.rb

@@ -0,0 +1,33 @@
+require 'mocha/parameter_matchers/base'
+
+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 < Base # :nodoc:
+    
+      def matches?(available_parameters)
+        available_parameters.shift
+        return true
+      end
+      
+      def mocha_inspect
+        "anything"
+      end
+      
+    end
+    
+  end
+  
+end

data/test/vendor/mocha-0.9.5/lib/mocha/parameter_matchers/base.rb

@@ -0,0 +1,15 @@
+module Mocha
+  
+  module ParameterMatchers
+    
+    class Base # :nodoc:
+      
+      def to_matcher
+        self
+      end
+      
+    end
+    
+  end
+  
+end

data/test/vendor/mocha-0.9.5/lib/mocha/parameter_matchers/equals.rb

@@ -0,0 +1,42 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: equals(value) -> parameter_matcher
+    #
+    # Matches +Object+ equalling +value+.
+    #   object = mock()
+    #   object.expects(:method_1).with(equals(2))
+    #   object.method_1(2)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(equals(2))
+    #   object.method_1(3)
+    #   # error raised, because method_1 was not called with Object equalling 3
+    def equals(value)
+      Equals.new(value)
+    end
+
+    class Equals < Base # :nodoc:
+      
+      def initialize(value)
+        @value = value
+      end
+      
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        parameter == @value
+      end
+      
+      def mocha_inspect
+        @value.mocha_inspect
+      end
+      
+    end
+    
+  end
+  
+end

data/test/vendor/mocha-0.9.5/lib/mocha/parameter_matchers/has_entries.rb

@@ -0,0 +1,45 @@
+require 'mocha/parameter_matchers/base'
+require 'mocha/parameter_matchers/all_of'
+require 'mocha/parameter_matchers/has_entry'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: has_entries(entries) -> parameter_matcher
+    #
+    # Matches +Hash+ containing all +entries+.
+    #   object = mock()
+    #   object.expects(:method_1).with(has_entries('key_1' => 1, 'key_2' => 2))
+    #   object.method_1('key_1' => 1, 'key_2' => 2, 'key_3' => 3)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(has_entries('key_1' => 1, 'key_2' => 2))
+    #   object.method_1('key_1' => 1, 'key_2' => 99)
+    #   # error raised, because method_1 was not called with Hash containing entries: 'key_1' => 1, 'key_2' => 2
+    def has_entries(entries)
+      HasEntries.new(entries)
+    end
+    
+    class HasEntries < Base # :nodoc:
+      
+      def initialize(entries)
+        @entries = entries
+      end
+      
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        has_entry_matchers = @entries.map { |key, value| HasEntry.new(key, value) }
+        AllOf.new(*has_entry_matchers).matches?([parameter])
+      end
+      
+      def mocha_inspect
+        "has_entries(#{@entries.mocha_inspect})"
+      end
+      
+    end
+    
+  end
+  
+end

data/test/vendor/mocha-0.9.5/lib/mocha/parameter_matchers/has_entry.rb

@@ -0,0 +1,56 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: has_entry(key, value) -> parameter_matcher
+    #            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' => 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
+    #
+    #   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(*options)
+      key, value = options.shift, options.shift
+      key, value = key.to_a[0][0..1] if key.is_a?(Hash)
+      HasEntry.new(key, value)
+    end
+    
+    class HasEntry < Base # :nodoc:
+      
+      def initialize(key, value)
+        @key, @value = key, value
+      end
+      
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        matching_keys = parameter.keys.select { |key| @key.to_matcher.matches?([key]) }
+        matching_keys.any? { |key| @value.to_matcher.matches?([parameter[key]]) }
+      end
+      
+      def mocha_inspect
+        "has_entry(#{@key.mocha_inspect} => #{@value.mocha_inspect})"
+      end
+      
+    end
+    
+  end
+  
+end

data/test/vendor/mocha-0.9.5/lib/mocha/parameter_matchers/has_key.rb

@@ -0,0 +1,42 @@
+require 'mocha/parameter_matchers/base'
+
+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 < Base # :nodoc:
+      
+      def initialize(key)
+        @key = key
+      end
+      
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        parameter.keys.any? { |key| @key.to_matcher.matches?([key]) }
+      end
+      
+      def mocha_inspect
+        "has_key(#{@key.mocha_inspect})"
+      end
+      
+    end
+    
+  end
+  
+end

data/test/vendor/mocha-0.9.5/lib/mocha/parameter_matchers/has_value.rb

@@ -0,0 +1,42 @@
+require 'mocha/parameter_matchers/base'
+
+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 < Base # :nodoc:
+      
+      def initialize(value)
+        @value = value
+      end
+      
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        parameter.values.any? { |value| @value.to_matcher.matches?([value]) }
+      end
+      
+      def mocha_inspect
+        "has_value(#{@value.mocha_inspect})"
+      end
+      
+    end
+    
+  end
+  
+end

data/test/vendor/mocha-0.9.5/lib/mocha/parameter_matchers/includes.rb

@@ -0,0 +1,40 @@
+require 'mocha/parameter_matchers/base'
+
+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 < Base # :nodoc:
+
+      def initialize(item)
+        @item = item
+      end
+
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        return parameter.include?(@item)
+      end
+
+      def mocha_inspect
+        "includes(#{@item.mocha_inspect})"
+      end
+
+    end
+
+  end
+  
+end