dxruby_rp5 0.0.1

data/spec/vendor/rspec-expectations-2.14.4/lib/rspec/expectations/syntax.rb

@@ -0,0 +1,164 @@
+module RSpec
+  module Expectations
+    # @api private
+    # Provides methods for enabling and disabling the available
+    # syntaxes provided by rspec-expectations.
+    module Syntax
+      extend self
+
+      # @method should
+      # Passes if `matcher` returns true.  Available on every `Object`.
+      # @example
+      #   actual.should eq expected
+      #   actual.should match /expression/
+      # @param [Matcher]
+      #   matcher
+      # @param [String] message optional message to display when the expectation fails
+      # @return [Boolean] true if the expectation succeeds (else raises)
+      # @see RSpec::Matchers
+
+      # @method should_not
+      # Passes if `matcher` returns false.  Available on every `Object`.
+      # @example
+      #   actual.should_not eq expected
+      # @param [Matcher]
+      #   matcher
+      # @param [String] message optional message to display when the expectation fails
+      # @return [Boolean] false if the negative expectation succeeds (else raises)
+      # @see RSpec::Matchers
+
+      # @method expect
+      # Supports `expect(actual).to matcher` syntax by wrapping `actual` in an
+      # `ExpectationTarget`.
+      # @example
+      #   expect(actual).to eq(expected)
+      #   expect(actual).not_to eq(expected)
+      # @return [ExpectationTarget]
+      # @see ExpectationTarget#to
+      # @see ExpectationTarget#not_to
+
+      # @api private
+      # Determines where we add `should` and `should_not`.
+      def default_should_host
+        @default_should_host ||= ::Object.ancestors.last
+      end
+
+      # @api private
+      # Enables the `should` syntax.
+      def enable_should(syntax_host = default_should_host)
+        return if should_enabled?(syntax_host)
+
+        syntax_host.module_eval do
+          def should(matcher=nil, message=nil, &block)
+            ::RSpec::Expectations::PositiveExpectationHandler.handle_matcher(self, matcher, message, &block)
+          end
+
+          def should_not(matcher=nil, message=nil, &block)
+            ::RSpec::Expectations::NegativeExpectationHandler.handle_matcher(self, matcher, message, &block)
+          end
+        end
+
+        ::RSpec::Expectations::ExpectationTarget.enable_deprecated_should if expect_enabled?
+      end
+
+      # @api private
+      # Disables the `should` syntax.
+      def disable_should(syntax_host = default_should_host)
+        return unless should_enabled?(syntax_host)
+
+        syntax_host.module_eval do
+          undef should
+          undef should_not
+        end
+
+        ::RSpec::Expectations::ExpectationTarget.disable_deprecated_should
+      end
+
+      # @api private
+      # Enables the `expect` syntax.
+      def enable_expect(syntax_host = ::RSpec::Matchers)
+        return if expect_enabled?(syntax_host)
+
+        syntax_host.module_eval do
+          def expect(*target, &target_block)
+            target << target_block if block_given?
+            raise ArgumentError.new("You must pass an argument or a block to #expect but not both.") unless target.size == 1
+            ::RSpec::Expectations::ExpectationTarget.new(target.first)
+          end
+        end
+
+        ::RSpec::Expectations::ExpectationTarget.enable_deprecated_should if should_enabled?
+      end
+
+      # @api private
+      # Disables the `expect` syntax.
+      def disable_expect(syntax_host = ::RSpec::Matchers)
+        return unless expect_enabled?(syntax_host)
+
+        syntax_host.module_eval do
+          undef expect
+        end
+
+        ::RSpec::Expectations::ExpectationTarget.disable_deprecated_should
+      end
+
+      # @api private
+      # Indicates whether or not the `should` syntax is enabled.
+      def should_enabled?(syntax_host = default_should_host)
+        syntax_host.method_defined?(:should)
+      end
+
+      # @api private
+      # Indicates whether or not the `expect` syntax is enabled.
+      def expect_enabled?(syntax_host = ::RSpec::Matchers)
+        syntax_host.method_defined?(:expect)
+      end
+
+      # @api private
+      # Generates a positive expectation expression.
+      def positive_expression(target_expression, matcher_expression)
+        expression_generator.positive_expression(target_expression, matcher_expression)
+      end
+
+      # @api private
+      # Generates a negative expectation expression.
+      def negative_expression(target_expression, matcher_expression)
+        expression_generator.negative_expression(target_expression, matcher_expression)
+      end
+
+      # @api private
+      # Selects which expression generator to use based on the configured syntax.
+      def expression_generator
+        if expect_enabled?
+          ExpectExpressionGenerator
+        else
+          ShouldExpressionGenerator
+        end
+      end
+
+      # @api private
+      # Generates expectation expressions for the `should` syntax.
+      module ShouldExpressionGenerator
+        def self.positive_expression(target_expression, matcher_expression)
+          "#{target_expression}.should #{matcher_expression}"
+        end
+
+        def self.negative_expression(target_expression, matcher_expression)
+          "#{target_expression}.should_not #{matcher_expression}"
+        end
+      end
+
+      # @api private
+      # Generates expectation expressions for the `expect` syntax.
+      module ExpectExpressionGenerator
+        def self.positive_expression(target_expression, matcher_expression)
+          "expect(#{target_expression}).to #{matcher_expression}"
+        end
+
+        def self.negative_expression(target_expression, matcher_expression)
+          "expect(#{target_expression}).not_to #{matcher_expression}"
+        end
+      end
+    end
+  end
+end

data/spec/vendor/rspec-expectations-2.14.4/lib/rspec/expectations/version.rb

@@ -0,0 +1,9 @@
+module RSpec
+  module Expectations
+    # @private
+    module Version
+      STRING = '2.14.4'
+    end
+  end
+end
+

data/spec/vendor/rspec-expectations-2.14.4/lib/rspec/expectations.rb

@@ -0,0 +1,73 @@
+require 'rspec/expectations/extensions'
+require 'rspec/matchers'
+require 'rspec/expectations/expectation_target'
+require 'rspec/matchers/configuration'
+require 'rspec/expectations/fail_with'
+require 'rspec/expectations/errors'
+require 'rspec/expectations/deprecation'
+require 'rspec/expectations/handler'
+require 'rspec/expectations/version'
+require 'rspec/expectations/differ'
+
+module RSpec
+  # RSpec::Expectations adds two instance methods to every object:
+  #
+  #     should(matcher=nil)
+  #     should_not(matcher=nil)
+  #
+  # Both methods take an optional matcher object (See
+  # [RSpec::Matchers](../RSpec/Matchers)).  When `should` is invoked with a
+  # matcher, it turns around and calls `matcher.matches?(self)`.  For example,
+  # in the expression:
+  #
+  #     order.total.should eq(Money.new(5.55, :USD))
+  #
+  # the `should` method invokes the equivalent of `eq.matches?(order.total)`. If
+  # `matches?` returns true, the expectation is met and execution continues. If
+  # `false`, then the spec fails with the message returned by
+  # `eq.failure_message_for_should`.
+  #
+  # Given the expression:
+  #
+  #     order.entries.should_not include(entry)
+  #
+  # the `should_not` method invokes the equivalent of
+  # `include.matches?(order.entries)`, but it interprets `false` as success, and
+  # `true` as a failure, using the message generated by
+  # `eq.failure_message_for_should_not`.
+  #
+  # rspec-expectations ships with a standard set of useful matchers, and writing
+  # your own matchers is quite simple.
+  #
+  # See [RSpec::Matchers](../RSpec/Matchers) for more information about the
+  # built-in matchers that ship with rspec-expectations, and how to write your
+  # own custom matchers.
+  module Expectations
+
+    # @api private
+    KERNEL_METHOD_METHOD = ::Kernel.instance_method(:method)
+
+    # @api private
+    #
+    # Used internally to get a method handle for a particular object
+    # and method name.
+    #
+    # Includes handling for a few special cases:
+    #
+    #   - Objects that redefine #method (e.g. an HTTPRequest struct)
+    #   - BasicObject subclasses that mixin a Kernel dup (e.g. SimpleDelegator)
+    if RUBY_VERSION.to_i >= 2
+      def self.method_handle_for(object, method_name)
+        KERNEL_METHOD_METHOD.bind(object).call(method_name)
+      end
+    else
+      def self.method_handle_for(object, method_name)
+        if ::Kernel === object
+          KERNEL_METHOD_METHOD.bind(object).call(method_name)
+        else
+          object.method(method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module RSpec
+  module Matchers
+    # @deprecated use +be_within+ instead.
+    def be_close(expected, delta)
+      RSpec.deprecate("be_close(#{expected}, #{delta})", :replacement => "be_within(#{delta}).of(#{expected})")
+      be_within(delta).of(expected)
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      #
+      # Used _internally_ as a base class for matchers that ship with
+      # rspec-expectations.
+      #
+      # ### Warning:
+      #
+      # This class is for internal use, and subject to change without notice.  We
+      # strongly recommend that you do not base your custom matchers on this
+      # class. If/when this changes, we will announce it and remove this warning.
+      class BaseMatcher
+        include RSpec::Matchers::Pretty
+
+        attr_reader :actual, :expected, :rescued_exception
+
+        def initialize(expected = nil)
+          @expected = expected
+        end
+
+        def matches?(actual)
+          @actual = actual
+          match(expected, actual)
+        end
+
+        def match_unless_raises(*exceptions)
+          exceptions.unshift Exception if exceptions.empty?
+          begin
+            yield
+            true
+          rescue *exceptions => @rescued_exception
+            false
+          end
+        end
+
+        def failure_message_for_should
+          assert_ivars :@actual, :@expected
+          "expected #{@actual.inspect} to #{name_to_sentence}#{expected_to_sentence}"
+        end
+
+        def failure_message_for_should_not
+          assert_ivars :@actual, :@expected
+          "expected #{@actual.inspect} not to #{name_to_sentence}#{expected_to_sentence}"
+        end
+
+        def description
+          expected ? "#{name_to_sentence} #{@expected.inspect}" : name_to_sentence
+        end
+
+        def diffable?
+          false
+        end
+
+        def ==(other)
+          matches?(other)
+        end
+
+        private
+
+        def assert_ivars *ivars
+          raise "#{self.class.name} needs to supply #{to_sentence ivars}" unless ivars.all? { |v| instance_variables.map(&:intern).include? v }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,197 @@
+require 'rspec/matchers/dsl'
+
+module RSpec
+  module Matchers
+    module BuiltIn
+      class BeTrue < BaseMatcher
+        def match(_, actual)
+          !!actual
+        end
+
+        def failure_message_for_should
+          "expected: true value\n     got: #{actual.inspect}"
+        end
+
+        def failure_message_for_should_not
+          "expected: non-true value\n     got: #{actual.inspect}"
+        end
+      end
+
+      class BeFalse < BaseMatcher
+        def match(_, actual)
+          !actual
+        end
+
+        def failure_message_for_should
+          "expected: false value\n     got: #{actual.inspect}"
+        end
+
+        def failure_message_for_should_not
+          "expected: non-false value\n     got: #{actual.inspect}"
+        end
+      end
+
+      class BeNil < BaseMatcher
+        def match(_, actual)
+          actual.nil?
+        end
+
+        def failure_message_for_should
+          "expected: nil\n     got: #{actual.inspect}"
+        end
+
+        def failure_message_for_should_not
+          "expected: not nil\n     got: nil"
+        end
+      end
+
+      module BeHelpers
+        private
+
+        def args_to_s
+          @args.empty? ? "" : parenthesize(inspected_args.join(', '))
+        end
+
+        def parenthesize(string)
+          "(#{string})"
+        end
+
+        def inspected_args
+          @args.collect{|a| a.inspect}
+        end
+
+        def expected_to_sentence
+          split_words(@expected)
+        end
+
+        def args_to_sentence
+          to_sentence(@args)
+        end
+      end
+
+      class Be < BaseMatcher
+        include BeHelpers
+
+        def initialize(*args, &block)
+          @args = args
+        end
+
+        def match(_, actual)
+          !!actual
+        end
+
+        def failure_message_for_should
+          "expected #{@actual.inspect} to evaluate to true"
+        end
+
+        def failure_message_for_should_not
+          "expected #{@actual.inspect} to evaluate to false"
+        end
+
+        [:==, :<, :<=, :>=, :>, :===, :=~].each do |operator|
+          define_method operator do |operand|
+            BeComparedTo.new(operand, operator)
+          end
+        end
+      end
+
+      class BeComparedTo < Be
+        def initialize(operand, operator)
+          @expected, @operator = operand, operator
+            @args = []
+        end
+
+        def matches?(actual)
+          @actual = actual
+          @actual.__send__ @operator, @expected
+        end
+
+        def failure_message_for_should
+          "expected: #{@operator} #{@expected.inspect}\n     got: #{@operator.to_s.gsub(/./, ' ')} #{@actual.inspect}"
+        end
+
+        def failure_message_for_should_not
+          message = <<-MESSAGE
+`#{negative_expectation_expression}` not only FAILED,
+it is a bit confusing.
+          MESSAGE
+
+          raise message << ([:===,:==].include?(@operator) ?
+                            "It might be more clearly expressed without the \"be\"?" :
+                            "It might be more clearly expressed in the positive?")
+        end
+
+        def description
+          "be #{@operator} #{expected_to_sentence}#{args_to_sentence}"
+        end
+
+        def negative_expectation_expression
+          Expectations::Syntax.negative_expression("actual", "be #{@operator} #{@expected}")
+        end
+      end
+
+      class BePredicate < BaseMatcher
+        include BeHelpers
+
+        def initialize(*args, &block)
+          @expected = parse_expected(args.shift)
+          @args = args
+          @block = block
+        end
+
+        def matches?(actual)
+          @actual = actual
+          begin
+            return @result = actual.__send__(predicate, *@args, &@block)
+          rescue NameError => predicate_missing_error
+            "this needs to be here or rcov will not count this branch even though it's executed in a code example"
+          end
+
+          begin
+            return @result = actual.__send__(present_tense_predicate, *@args, &@block)
+          rescue NameError
+            raise predicate_missing_error
+          end
+        end
+
+        alias === matches?
+
+        def failure_message_for_should
+          "expected #{predicate}#{args_to_s} to return true, got #{@result.inspect}"
+        end
+
+        def failure_message_for_should_not
+          "expected #{predicate}#{args_to_s} to return false, got #{@result.inspect}"
+        end
+
+        def description
+          "#{prefix_to_sentence}#{expected_to_sentence}#{args_to_sentence}"
+        end
+
+        private
+
+        def predicate
+          "#{@expected}?".to_sym
+        end
+
+        def present_tense_predicate
+          "#{@expected}s?".to_sym
+        end
+
+        def parse_expected(expected)
+          @prefix, expected = prefix_and_expected(expected)
+          expected
+        end
+
+        def prefix_and_expected(symbol)
+          symbol.to_s =~ /^(be_(an?_)?)(.*)/
+          return $1, $3
+        end
+
+        def prefix_to_sentence
+          split_words(@prefix)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class BeAnInstanceOf < BaseMatcher
+        def match(expected, actual)
+          actual.instance_of? expected
+        end
+
+        def description
+          "be an instance of #{expected}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class BeAKindOf < BaseMatcher
+        def match(expected, actual)
+          actual.kind_of? expected
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class BeWithin
+        def initialize(delta)
+          @delta = delta
+        end
+
+        def matches?(actual)
+          @actual = actual
+          raise needs_expected     unless defined? @expected
+          raise needs_subtractable unless @actual.respond_to? :-
+          (@actual - @expected).abs <= @tolerance
+        end
+        alias == matches?
+
+        def of(expected)
+          @expected  = expected
+          @tolerance = @delta
+          @unit      = ''
+          self
+        end
+
+        def percent_of(expected)
+          @expected  = expected
+          @tolerance = @delta * @expected.abs / 100.0
+          @unit      = '%'
+          self
+        end
+
+        def failure_message_for_should
+          "expected #{@actual} to #{description}"
+        end
+
+        def failure_message_for_should_not
+          "expected #{@actual} not to #{description}"
+        end
+
+        def description
+          "be within #{@delta}#{@unit} of #{@expected}"
+        end
+
+        private
+
+        def needs_subtractable
+          ArgumentError.new "The actual value (#{@actual.inspect}) must respond to `-`"
+        end
+
+        def needs_expected
+          ArgumentError.new "You must set an expected value using #of: be_within(#{@delta}).of(expected_value)"
+        end
+      end
+    end
+  end
+end