remq 0.0.1a → 0.0.3

data/vendor/bundle/gems/rspec-expectations-2.12.1/lib/rspec/matchers/built_in/has.rb

@@ -0,0 +1,48 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class Has
+        def initialize(expected, *args)
+          @expected, @args = expected, args
+        end
+
+        def matches?(actual)
+          actual.__send__(predicate(@expected), *@args)
+        end
+        alias == matches?
+
+        def failure_message_for_should
+          "expected ##{predicate(@expected)}#{failure_message_args_description} to return true, got false"
+        end
+
+        def failure_message_for_should_not
+          "expected ##{predicate(@expected)}#{failure_message_args_description} to return false, got true"
+        end
+
+        def description
+          [method_description(@expected), args_description].compact.join(' ')
+        end
+
+        private
+
+        def predicate(sym)
+          "#{sym.to_s.sub("have_","has_")}?".to_sym
+        end
+
+        def method_description(method)
+          method.to_s.gsub('_', ' ')
+        end
+
+        def args_description
+          return nil if @args.empty?
+          @args.map { |arg| arg.inspect }.join(', ')
+        end
+
+        def failure_message_args_description
+          desc = args_description
+          "(#{desc})" if desc
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-2.12.1/lib/rspec/matchers/built_in/have.rb

@@ -0,0 +1,108 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class Have
+        def initialize(expected, relativity=:exactly)
+          @expected = case expected
+                      when :no then 0
+                      when String then expected.to_i
+                      else expected
+                      end
+          @relativity = relativity
+          @actual = @collection_name = @plural_collection_name = nil
+        end
+
+        def relativities
+          @relativities ||= {
+            :exactly => "",
+            :at_least => "at least ",
+            :at_most => "at most "
+          }
+        end
+
+        def matches?(collection_or_owner)
+          collection = determine_collection(collection_or_owner)
+          query_method = determine_query_method(collection)
+          raise not_a_collection unless query_method
+          @actual = collection.send(query_method)
+          case @relativity
+          when :at_least then @actual >= @expected
+          when :at_most  then @actual <= @expected
+          else                @actual == @expected
+          end
+        end
+        alias == matches?
+
+        def determine_collection(collection_or_owner)
+          if collection_or_owner.respond_to?(@collection_name)
+            collection_or_owner.send(@collection_name, *@args, &@block)
+          elsif (@plural_collection_name && collection_or_owner.respond_to?(@plural_collection_name))
+            collection_or_owner.send(@plural_collection_name, *@args, &@block)
+          elsif determine_query_method(collection_or_owner)
+            collection_or_owner
+          else
+            collection_or_owner.send(@collection_name, *@args, &@block)
+          end
+        end
+
+        def determine_query_method(collection)
+          [:size, :length, :count].detect {|m| collection.respond_to?(m)}
+        end
+
+        def not_a_collection
+          "expected #{@collection_name} to be a collection but it does not respond to #length, #size or #count"
+        end
+
+        def failure_message_for_should
+          "expected #{relative_expectation} #{@collection_name}, got #{@actual}"
+        end
+
+        def failure_message_for_should_not
+          if @relativity == :exactly
+            return "expected target not to have #{@expected} #{@collection_name}, got #{@actual}"
+          elsif @relativity == :at_most
+            return <<-EOF
+Isn't life confusing enough?
+Instead of having to figure out the meaning of this:
+  should_not have_at_most(#{@expected}).#{@collection_name}
+We recommend that you use this instead:
+  should have_at_least(#{@expected + 1}).#{@collection_name}
+EOF
+          elsif @relativity == :at_least
+            return <<-EOF
+Isn't life confusing enough?
+Instead of having to figure out the meaning of this:
+  should_not have_at_least(#{@expected}).#{@collection_name}
+We recommend that you use this instead:
+  should have_at_most(#{@expected - 1}).#{@collection_name}
+EOF
+          end
+        end
+
+        def description
+          "have #{relative_expectation} #{@collection_name}"
+        end
+
+        def respond_to?(m)
+          @expected.respond_to?(m) || super
+        end
+
+        private
+
+        def method_missing(method, *args, &block)
+          @collection_name = method
+          if inflector = (defined?(ActiveSupport::Inflector) && ActiveSupport::Inflector.respond_to?(:pluralize) ? ActiveSupport::Inflector : (defined?(Inflector) ? Inflector : nil))
+            @plural_collection_name = inflector.pluralize(method.to_s)
+          end
+          @args = args
+          @block = block
+          self
+        end
+
+        def relative_expectation
+          "#{relativities[@relativity]}#{@expected}"
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-2.12.1/lib/rspec/matchers/built_in/include.rb

@@ -0,0 +1,53 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class Include < BaseMatcher
+        def initialize(*expected)
+          @expected = expected
+        end
+
+        def matches?(actual)
+          @actual = actual
+          perform_match(:all?, :all?, @actual, @expected)
+        end
+
+        def does_not_match?(actual)
+          @actual = actual
+          perform_match(:none?, :any?, @actual, @expected)
+        end
+
+        def description
+          "include#{expected_to_sentence}"
+        end
+
+        def diffable?
+          true
+        end
+
+        private
+
+        def perform_match(predicate, hash_predicate, actuals, expecteds)
+          expecteds.send(predicate) do |expected|
+            if comparing_hash_values?(actuals, expected)
+              expected.send(hash_predicate) {|k,v|
+                actuals.has_key?(k) && actuals[k] == v
+              }
+            elsif comparing_hash_keys?(actuals, expected)
+              actuals.has_key?(expected)
+            else
+              actuals.include?(expected)
+            end
+          end
+        end
+
+        def comparing_hash_keys?(actual, expected)
+          actual.is_a?(Hash) && !expected.is_a?(Hash)
+        end
+
+        def comparing_hash_values?(actual, expected)
+          actual.is_a?(Hash) && expected.is_a?(Hash)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-2.12.1/lib/rspec/matchers/built_in/match.rb

@@ -0,0 +1,12 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class Match < BaseMatcher
+
+        def match(expected, actual)
+          actual.match expected
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-2.12.1/lib/rspec/matchers/built_in/match_array.rb

@@ -0,0 +1,51 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class MatchArray < BaseMatcher
+        def match(expected, actual)
+          return false unless actual.respond_to? :to_ary
+          @extra_items = difference_between_arrays(actual, expected)
+          @missing_items = difference_between_arrays(expected, actual)
+          @extra_items.empty? & @missing_items.empty?
+        end
+
+        def failure_message_for_should
+          if actual.respond_to? :to_ary
+            message =  "expected collection contained:  #{safe_sort(expected).inspect}\n"
+            message += "actual collection contained:    #{safe_sort(actual).inspect}\n"
+            message += "the missing elements were:      #{safe_sort(@missing_items).inspect}\n" unless @missing_items.empty?
+            message += "the extra elements were:        #{safe_sort(@extra_items).inspect}\n"   unless @extra_items.empty?
+          else
+            message = "expected an array, actual collection was #{actual.inspect}"
+          end
+
+          message
+        end
+
+        def failure_message_for_should_not
+          "Matcher does not support should_not"
+        end
+
+        def description
+          "contain exactly #{_pretty_print(expected)}"
+        end
+
+        private
+
+        def safe_sort(array)
+          array.sort rescue array
+        end
+
+        def difference_between_arrays(array_1, array_2)
+          difference = array_1.to_ary.dup
+          array_2.to_ary.each do |element|
+            if index = difference.index(element)
+              difference.delete_at(index)
+            end
+          end
+          difference
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-2.12.1/lib/rspec/matchers/built_in/raise_error.rb

@@ -0,0 +1,107 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class RaiseError
+        def initialize(expected_error_or_message=Exception, expected_message=nil, &block)
+          @block = block
+          @actual_error = nil
+          case expected_error_or_message
+          when String, Regexp
+            @expected_error, @expected_message = Exception, expected_error_or_message
+          else
+            @expected_error, @expected_message = expected_error_or_message, expected_message
+          end
+        end
+
+        def matches?(given_proc, negative_expectation = false)
+          @raised_expected_error = false
+          @with_expected_message = false
+          @eval_block = false
+          @eval_block_passed = false
+          begin
+            given_proc.call
+          rescue @expected_error => @actual_error
+            @raised_expected_error = true
+            @with_expected_message = verify_message
+          rescue Exception => @actual_error
+            # This clause should be empty, but rcov will not report it as covered
+            # unless something (anything) is executed within the clause
+            "http://eigenclass.org/hiki.rb?rcov-0.8.0"
+          end
+
+          unless negative_expectation
+            eval_block if @raised_expected_error && @with_expected_message && @block
+          end
+        ensure
+          return (@raised_expected_error & @with_expected_message) ? (@eval_block ? @eval_block_passed : true) : false
+        end
+        alias == matches?
+
+        def does_not_match?(given_proc)
+          !matches?(given_proc, :negative_expectation)
+        end
+
+        def eval_block
+          @eval_block = true
+          begin
+            @block[@actual_error]
+            @eval_block_passed = true
+          rescue Exception => err
+            @actual_error = err
+          end
+        end
+
+        def verify_message
+          case @expected_message
+          when nil
+            true
+          when Regexp
+            @expected_message =~ @actual_error.message
+          else
+            @expected_message == @actual_error.message
+          end
+        end
+
+        def failure_message_for_should
+          @eval_block ? @actual_error.message : "expected #{expected_error}#{given_error}"
+        end
+
+        def failure_message_for_should_not
+          "expected no #{expected_error}#{given_error}"
+        end
+
+        def description
+          "raise #{expected_error}"
+        end
+
+        private
+
+        def expected_error
+          case @expected_message
+          when nil
+            @expected_error
+          when Regexp
+            "#{@expected_error} with message matching #{@expected_message.inspect}"
+          else
+            "#{@expected_error} with #{@expected_message.inspect}"
+          end
+        end
+
+        def format_backtrace(backtrace)
+          formatter = Matchers.configuration.backtrace_formatter
+          formatter.format_backtrace(backtrace)
+        end
+
+        def given_error
+          return " but nothing was raised" unless @actual_error
+
+          backtrace = format_backtrace(@actual_error.backtrace)
+          [
+            ", got #{@actual_error.inspect} with backtrace:",
+            *backtrace
+          ].join("\n  # ")
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-2.12.1/lib/rspec/matchers/built_in/respond_to.rb

@@ -0,0 +1,74 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class RespondTo
+        def initialize(*names)
+          @names = names
+          @expected_arity = nil
+        end
+
+        def matches?(actual)
+          find_failing_method_names(actual, :reject).empty?
+        end
+        alias == matches?
+
+        def does_not_match?(actual)
+          find_failing_method_names(actual, :select).empty?
+        end
+
+        def failure_message_for_should
+          "expected #{@actual.inspect} to respond to #{@failing_method_names.collect {|name| name.inspect }.join(', ')}#{with_arity}"
+        end
+
+        def failure_message_for_should_not
+          failure_message_for_should.sub(/to respond to/, 'not to respond to')
+        end
+
+        def description
+          "respond to #{pp_names}#{with_arity}"
+        end
+
+        def with(n)
+          @expected_arity = n
+          self
+        end
+
+        def argument
+          self
+        end
+        alias :arguments :argument
+
+        private
+
+        def find_failing_method_names(actual, filter_method)
+          @actual = actual
+          @failing_method_names = @names.send(filter_method) do |name|
+            @actual.respond_to?(name) && matches_arity?(actual, name)
+          end
+        end
+
+        def matches_arity?(actual, name)
+          return true unless @expected_arity
+
+          actual_arity = actual.method(name).arity
+          if actual_arity < 0
+            # ~ inverts the one's complement and gives us the number of required args
+            ~actual_arity <= @expected_arity
+          else
+            actual_arity == @expected_arity
+          end
+        end
+
+        def with_arity
+          @expected_arity.nil?? "" :
+            " with #{@expected_arity} argument#{@expected_arity == 1 ? '' : 's'}"
+        end
+
+        def pp_names
+          # Ruby 1.9 returns the same thing for array.to_s as array.inspect, so just use array.inspect here
+          @names.length == 1 ? "##{@names.first}" : @names.inspect
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-2.12.1/lib/rspec/matchers/built_in/satisfy.rb

@@ -0,0 +1,30 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class Satisfy
+        def initialize(&block)
+          @block = block
+        end
+
+        def matches?(actual, &block)
+          @block = block if block
+          @actual = actual
+          @block.call(actual)
+        end
+        alias == matches?
+
+        def failure_message_for_should
+          "expected #{@actual} to satisfy block"
+        end
+
+        def failure_message_for_should_not
+          "expected #{@actual} not to satisfy block"
+        end
+
+        def description
+          "satisfy block"
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-2.12.1/lib/rspec/matchers/built_in/start_and_end_with.rb

@@ -0,0 +1,48 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class StartAndEndWith < BaseMatcher
+        def initialize(*expected)
+          @expected = expected.length == 1 ? expected.first : expected
+        end
+
+        def matches?(actual)
+          @actual = actual.respond_to?(:[]) ? actual : (raise ArgumentError.new("#{actual.inspect} does not respond to :[]"))
+          begin
+            @expected.respond_to?(:length) ? subset_matches?(@expected, @actual) : element_matches?(@expected, @actual)
+          rescue ArgumentError
+            raise ArgumentError.new("#{actual.inspect} does not have ordered elements")
+          end
+        end
+
+        def failure_message_for_should
+          "expected #{@actual.inspect} to #{self.class.name.split('::').last.sub(/With/,'').downcase} with #{@expected.inspect}"
+        end
+
+        def failure_message_for_should_not
+          "expected #{@actual.inspect} not to #{self.class.name.split('::').last.sub(/With/,'').downcase} with #{@expected.inspect}"
+        end
+      end
+
+      class StartWith < StartAndEndWith
+        def subset_matches?(expected, actual)
+          actual[0, expected.length] == expected
+        end
+
+        def element_matches?(expected, actual)
+          @actual[0] == @expected
+        end
+      end
+
+      class EndWith < StartAndEndWith
+        def subset_matches?(expected, actual)
+          actual[-expected.length, expected.length] == expected
+        end
+
+        def element_matches?(expected, actual)
+          actual[-1] == expected
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-2.12.1/lib/rspec/matchers/built_in/throw_symbol.rb

@@ -0,0 +1,94 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class ThrowSymbol
+        def initialize(expected_symbol = nil, expected_arg=nil)
+          @expected_symbol = expected_symbol
+          @expected_arg = expected_arg
+          @caught_symbol = @caught_arg = nil
+        end
+
+        def matches?(given_proc)
+          begin
+            if @expected_symbol.nil?
+              given_proc.call
+            else
+              @caught_arg = catch :proc_did_not_throw_anything do
+                catch @expected_symbol do
+                  given_proc.call
+                  throw :proc_did_not_throw_anything, :nothing_thrown
+                end
+              end
+
+              if @caught_arg == :nothing_thrown
+                @caught_arg = nil
+              else
+                @caught_symbol = @expected_symbol
+              end
+            end
+
+            # Ruby 1.8 uses NameError with `symbol'
+            # Ruby 1.9 uses ArgumentError with :symbol
+          rescue NameError, ArgumentError => e
+            unless e.message =~ /uncaught throw (`|\:)([a-zA-Z0-9_]*)(')?/
+              other_exception = e
+              raise
+            end
+            @caught_symbol = $2.to_sym
+          rescue => other_exception
+            raise
+          ensure
+            unless other_exception
+              if @expected_symbol.nil?
+                return !@caught_symbol.nil?
+              else
+                if @expected_arg.nil?
+                  return @caught_symbol == @expected_symbol
+                else
+                  return (@caught_symbol == @expected_symbol) & (@caught_arg == @expected_arg)
+                end
+              end
+            end
+          end
+        end
+        alias == matches?
+
+        def failure_message_for_should
+          "expected #{expected} to be thrown, got #{caught}"
+        end
+
+        def failure_message_for_should_not
+          "expected #{expected('no Symbol')}#{' not' if @expected_symbol} to be thrown, got #{caught}"
+        end
+
+        def description
+          "throw #{expected}"
+        end
+
+        private
+
+        def expected(symbol_desc = 'a Symbol')
+          throw_description(@expected_symbol || symbol_desc, @expected_arg)
+        end
+
+        def caught
+          throw_description(@caught_symbol || 'nothing', @caught_arg)
+        end
+
+        def throw_description(symbol, arg)
+          symbol_description = symbol.is_a?(String) ? symbol : symbol.inspect
+
+          arg_description = if arg
+                              " with #{arg.inspect}"
+                            elsif @expected_arg && @caught_symbol == @expected_symbol
+                              " with no argument"
+                            else
+                              ""
+                            end
+
+          symbol_description + arg_description
+        end
+      end
+    end
+  end
+end