tnargav 1.2.2 → 1.2.3

data/vendor/bundle/ruby/1.9.1/gems/rspec-expectations-2.11.3/lib/rspec/matchers/built_in/change.rb

@@ -0,0 +1,133 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class Change
+        def initialize(receiver=nil, message=nil, &block)
+          @message = message
+          @value_proc = block || lambda {receiver.__send__(message)}
+          @expected_after = @expected_before = @minimum = @maximum = @expected_delta = nil
+          @eval_before = @eval_after = false
+        end
+
+        def matches?(event_proc)
+          raise_block_syntax_error if block_given?
+
+          @actual_before = evaluate_value_proc
+          event_proc.call
+          @actual_after = evaluate_value_proc
+
+          (!change_expected? || changed?) && matches_before? && matches_after? && matches_expected_delta? && matches_min? && matches_max?
+        end
+        alias == matches?
+
+        def raise_block_syntax_error
+          raise SyntaxError.new(<<-MESSAGE)
+block passed to should or should_not change must use {} instead of do/end
+MESSAGE
+        end
+
+        def evaluate_value_proc
+          case val = @value_proc.call
+          when Enumerable
+            val.dup
+          else
+            val
+          end
+        end
+
+        def failure_message_for_should
+          if @eval_before && !expected_matches_actual?(@expected_before, @actual_before)
+            "#{message} should have initially been #{@expected_before.inspect}, but was #{@actual_before.inspect}"
+          elsif @eval_after && !expected_matches_actual?(@expected_after, @actual_after)
+            "#{message} should have been changed to #{@expected_after.inspect}, but is now #{@actual_after.inspect}"
+          elsif @expected_delta
+            "#{message} should have been changed by #{@expected_delta.inspect}, but was changed by #{actual_delta.inspect}"
+          elsif @minimum
+            "#{message} should have been changed by at least #{@minimum.inspect}, but was changed by #{actual_delta.inspect}"
+          elsif @maximum
+            "#{message} should have been changed by at most #{@maximum.inspect}, but was changed by #{actual_delta.inspect}"
+          else
+            "#{message} should have changed, but is still #{@actual_before.inspect}"
+          end
+        end
+
+        def actual_delta
+          @actual_after - @actual_before
+        end
+
+        def failure_message_for_should_not
+          "#{message} should not have changed, but did change from #{@actual_before.inspect} to #{@actual_after.inspect}"
+        end
+
+        def by(expected_delta)
+          @expected_delta = expected_delta
+          self
+        end
+
+        def by_at_least(minimum)
+          @minimum = minimum
+          self
+        end
+
+        def by_at_most(maximum)
+          @maximum = maximum
+          self
+        end      
+
+        def to(to)
+          @eval_after = true
+          @expected_after = to
+          self
+        end
+
+        def from (before)
+          @eval_before = true
+          @expected_before = before
+          self
+        end
+
+        def description
+          "change ##{message}"
+        end
+
+        private
+
+        def message
+          @message || "result"
+        end
+
+        def change_expected?
+          @expected_delta != 0
+        end
+
+        def changed?
+          @actual_before != @actual_after
+        end
+
+        def matches_before?
+          @eval_before ? expected_matches_actual?(@expected_before, @actual_before) : true
+        end
+
+        def matches_after?
+          @eval_after ? expected_matches_actual?(@expected_after, @actual_after) : true
+        end
+
+        def matches_expected_delta?
+          @expected_delta ? (@actual_before + @expected_delta == @actual_after) : true
+        end
+
+        def matches_min?
+          @minimum ? (@actual_after - @actual_before >= @minimum) : true
+        end
+
+        def matches_max?
+          @maximum ? (@actual_after - @actual_before <= @maximum) : true
+        end
+
+        def expected_matches_actual?(expected, actual)
+          expected === actual
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/rspec-expectations-2.11.3/lib/rspec/matchers/built_in/cover.rb

@@ -0,0 +1,21 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class Cover < BaseMatcher
+        def initialize(*expected)
+          @expected = expected
+        end
+
+        def matches?(range)
+          @actual = range
+          @expected.all? { |e| range.cover?(e) }
+        end
+
+        def does_not_match?(range)
+          @actual = range
+          expected.none? { |e| range.cover?(e) }
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/rspec-expectations-2.11.3/lib/rspec/matchers/built_in/eq.rb

@@ -0,0 +1,22 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class Eq < BaseMatcher
+        def match(expected, actual)
+          actual == expected
+        end
+
+        def failure_message_for_should
+          "\nexpected: #{expected.inspect}\n     got: #{actual.inspect}\n\n(compared using ==)\n"
+        end
+
+        def failure_message_for_should_not
+          "\nexpected: value != #{expected.inspect}\n     got: #{actual.inspect}\n\n(compared using ==)\n"
+        end
+
+        def diffable?; true; end
+      end
+    end
+  end
+end
+

data/vendor/bundle/ruby/1.9.1/gems/rspec-expectations-2.11.3/lib/rspec/matchers/built_in/eql.rb

@@ -0,0 +1,23 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class Eql < BaseMatcher
+        def match(expected, actual)
+          actual.eql? expected
+        end
+
+        def failure_message_for_should
+          "\nexpected: #{expected.inspect}\n     got: #{actual.inspect}\n\n(compared using eql?)\n"
+        end
+
+        def failure_message_for_should_not
+          "\nexpected: value != #{expected.inspect}\n     got: #{actual.inspect}\n\n(compared using eql?)\n"
+        end
+
+        def diffable?
+          true
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/rspec-expectations-2.11.3/lib/rspec/matchers/built_in/equal.rb

@@ -0,0 +1,44 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class Equal < BaseMatcher
+        def match(expected, actual)
+          actual.equal? expected
+        end
+
+        def failure_message_for_should
+          return <<-MESSAGE
+
+expected #{inspect_object(expected)}
+     got #{inspect_object(actual)}
+
+Compared using equal?, which compares object identity,
+but expected and actual are not the same object. Use
+'actual.should eq(expected)' if you don't care about
+object identity in this example.
+
+MESSAGE
+        end
+
+        def failure_message_for_should_not
+          return <<-MESSAGE
+
+expected not #{inspect_object(actual)}
+         got #{inspect_object(expected)}
+
+Compared using equal?, which compares object identity.
+
+MESSAGE
+        end
+
+        def diffable?; true; end
+
+        private
+
+        def inspect_object(o)
+          "#<#{o.class}:#{o.object_id}> => #{o.inspect}"
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/rspec-expectations-2.11.3/lib/rspec/matchers/built_in/exist.rb

@@ -0,0 +1,26 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class Exist < BaseMatcher
+        def initialize(*expected)
+          @expected = expected
+        end
+
+        def matches?(actual)
+          @actual = actual
+          predicates = [:exist?, :exists?].select { |p| @actual.respond_to?(p) }
+          existence_values = predicates.map { |p| @actual.send(p, *@expected) }
+          uniq_truthy_values = existence_values.map { |v| !!v }.uniq
+
+          case uniq_truthy_values.size
+          when 0; raise NoMethodError.new("#{@actual.inspect} does not respond to either #exist? or #exists?")
+          when 1; existence_values.first
+          else raise "#exist? and #exists? returned different values:\n\n" +
+            " exist?: #{existence_values.first}\n" +
+            "exists?: #{existence_values.last}"
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/rspec-expectations-2.11.3/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/ruby/1.9.1/gems/rspec-expectations-2.11.3/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/ruby/1.9.1/gems/rspec-expectations-2.11.3/lib/rspec/matchers/built_in/include.rb

@@ -0,0 +1,51 @@
+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[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/ruby/1.9.1/gems/rspec-expectations-2.11.3/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/ruby/1.9.1/gems/rspec-expectations-2.11.3/lib/rspec/matchers/built_in/match_array.rb

@@ -0,0 +1,45 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class MatchArray < BaseMatcher
+        def match(expected, actual)
+          @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
+          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?
+          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.dup
+          array_2.each do |element|
+            if index = difference.index(element)
+              difference.delete_at(index)
+            end
+          end
+          difference
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/rspec-expectations-2.11.3/lib/rspec/matchers/built_in/raise_error.rb

@@ -0,0 +1,97 @@
+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)
+          @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 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 given_error
+          @actual_error.nil? ? " but nothing was raised" : ", got #{@actual_error.inspect}"
+        end
+
+        def negative_expectation?
+          # YES - I'm a bad person... help me find a better way - ryand
+          caller.first(3).find { |s| s =~ /should_not/ }
+        end
+      end
+    end
+  end
+end