dxruby_rp5 0.0.1

data/spec/vendor/rspec-expectations-2.14.4/lib/rspec/matchers/built_in/change.rb

@@ -0,0 +1,141 @@
+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, String
+            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 #{failure_message_for_expected_after}, 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 failure_message_for_expected_after
+          if RSpec::Matchers.is_a_matcher?(@expected_after)
+            @expected_after.description
+          else
+            @expected_after.inspect
+          end
+        end
+
+        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 || actual == expected
+        end
+      end
+    end
+  end
+end

data/spec/vendor/rspec-expectations-2.14.4/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/spec/vendor/rspec-expectations-2.14.4/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/spec/vendor/rspec-expectations-2.14.4/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/spec/vendor/rspec-expectations-2.14.4/lib/rspec/matchers/built_in/equal.rb

@@ -0,0 +1,48 @@
+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
+`#{eq_expression}` 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
+
+        def eq_expression
+          Expectations::Syntax.positive_expression("actual", "eq(expected)")
+        end
+      end
+    end
+  end
+end

data/spec/vendor/rspec-expectations-2.14.4/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/spec/vendor/rspec-expectations-2.14.4/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/spec/vendor/rspec-expectations-2.14.4/lib/rspec/matchers/built_in/have.rb

@@ -0,0 +1,124 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class Have
+        QUERY_METHODS = [:size, :length, :count].freeze
+
+        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)
+          case collection
+          when enumerator_class
+            for query_method in QUERY_METHODS
+              next unless collection.respond_to?(query_method)
+              @actual = collection.__send__(query_method)
+              break unless @actual.nil?
+            end
+            raise not_a_collection if @actual.nil?
+          else
+            query_method = determine_query_method(collection)
+            raise not_a_collection unless query_method
+            @actual = collection.__send__(query_method)
+          end
+          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)
+          QUERY_METHODS.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:
+  #{Expectations::Syntax.negative_expression("actual", "have_at_most(#{@expected}).#{@collection_name}")}
+We recommend that you use this instead:
+  #{Expectations::Syntax.positive_expression("actual", "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:
+  #{Expectations::Syntax.negative_expression("actual", "have_at_least(#{@expected}).#{@collection_name}")}
+We recommend that you use this instead:
+  #{Expectations::Syntax.positive_expression("actual", "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
+
+        def enumerator_class
+          RUBY_VERSION < '1.9' ? Enumerable::Enumerator : Enumerator
+        end
+      end
+    end
+  end
+end

data/spec/vendor/rspec-expectations-2.14.4/lib/rspec/matchers/built_in/include.rb

@@ -0,0 +1,61 @@
+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?
+          # Matchers do not diff well, since diff uses their inspect
+          # output, which includes their instance variables and such.
+          @expected.none? { |e| RSpec::Matchers.is_a_matcher?(e) }
+        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)
+            elsif comparing_with_matcher?(actual, expected)
+              actual.any? { |value| expected.matches?(value) }
+            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
+
+        def comparing_with_matcher?(actual, expected)
+          actual.is_a?(Array) && RSpec::Matchers.is_a_matcher?(expected)
+        end
+      end
+    end
+  end
+end

data/spec/vendor/rspec-expectations-2.14.4/lib/rspec/matchers/built_in/match.rb

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

data/spec/vendor/rspec-expectations-2.14.4/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