remq 0.0.1a → 0.0.3

data/vendor/bundle/gems/rspec-expectations-2.12.1/features/syntax_configuration.feature

@@ -0,0 +1,68 @@
+Feature: Syntax Configuration
+
+  In addition to the long-supported `should` syntax, rspec-expectations
+  supports an alternate `expect` syntax. If you want your project to
+  only use one syntax, you can configure the available syntaxes.
+
+  Background:
+    Given a file named "syntaxes_spec.rb" with:
+      """ruby
+      describe "using the should syntax" do
+        specify { 3.should eq(3) }
+        specify { 3.should_not eq(4) }
+        specify { lambda { raise "boom" }.should raise_error("boom") }
+        specify { lambda { }.should_not raise_error }
+      end
+
+      describe "using the expect syntax" do
+        specify { expect(3).to eq(3) }
+        specify { expect(3).not_to eq(4) }
+        specify { expect { raise "boom" }.to raise_error("boom") }
+        specify { expect { }.not_to raise_error }
+      end
+      """
+
+  Scenario: Both syntaxes are available by default
+    When I run `rspec syntaxes_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Disable should syntax
+    Given a file named "disable_should_syntax.rb" with:
+      """ruby
+      RSpec.configure do |config|
+        config.expect_with :rspec do |c|
+          c.syntax = :expect
+        end
+      end
+      """
+    When I run `rspec disable_should_syntax.rb syntaxes_spec.rb`
+    Then the output should contain all of these:
+      | 8 examples, 4 failures    |
+      | undefined method `should' |
+
+  Scenario: Disable expect syntax
+    Given a file named "disable_expect_syntax.rb" with:
+      """ruby
+      RSpec.configure do |config|
+        config.expect_with :rspec do |c|
+          c.syntax = :should
+        end
+      end
+      """
+    When I run `rspec disable_expect_syntax.rb syntaxes_spec.rb`
+    Then the output should contain all of these:
+      | 8 examples, 4 failures    |
+      | undefined method `expect' |
+
+  Scenario: Explicitly enable both syntaxes
+    Given a file named "enable_both_syntaxes.rb" with:
+      """ruby
+      RSpec.configure do |config|
+        config.expect_with :rspec do |c|
+          c.syntax = [:should, :expect]
+        end
+      end
+      """
+    When I run `rspec enable_both_syntaxes.rb syntaxes_spec.rb`
+    Then the examples should all pass
+

data/vendor/bundle/gems/rspec-expectations-2.12.1/features/test_frameworks/test_unit.feature

@@ -0,0 +1,46 @@
+Feature: Test::Unit integration
+
+  RSpec-expectations is a stand-alone gem that can be used without
+  the rest of RSpec.  It can easily be used with another test
+  framework such as Test::Unit if you like RSpec's should/should_not
+  syntax but prefer the test organization of another framework.
+
+  Scenario: Basic Test::Unit usage
+    Given a file named "rspec_expectations_test.rb" with:
+      """ruby
+      require 'test/unit'
+      require 'rspec/expectations'
+
+      class RSpecExpectationsTest < Test::Unit::TestCase
+        RSpec::Matchers.define :be_an_integer do
+          match { |actual| Integer === actual }
+        end
+
+        def be_an_int
+          RSpec.deprecate(:be_an_int, :be_an_integer)
+          be_an_integer
+        end
+
+        def test_passing_expectation
+          x = 1 + 3
+          x.should == 4
+        end
+
+        def test_failing_expectation
+          array = [1, 2]
+          array.should be_empty
+        end
+
+        def test_expect_matcher
+          expect { @a = 5 }.to change { @a }.from(nil).to(5)
+        end
+
+        def test_custom_matcher_and_deprecation_warning
+          1.should be_an_int
+        end
+      end
+      """
+     When I run `ruby rspec_expectations_test.rb`
+     Then the output should contain "4 tests, 0 assertions, 1 failures, 0 errors" or "4 tests, 0 assertions, 0 failures, 1 errors"
+      And the output should contain "expected empty? to return true, got false"
+      And the output should contain "be_an_int is deprecated"

data/vendor/bundle/gems/rspec-expectations-2.12.1/lib/rspec/expectations/deprecation.rb

@@ -0,0 +1,38 @@
+module RSpec
+  unless respond_to?(:deprecate)
+    class << self
+      # Used internally by RSpec to display standard deprecation warnings.
+      # This is also defined in rspec-core, but we can't assume it's loaded
+      # since rspec-expectations should be usable w/o rspec-core.
+      def deprecate(method, alternate_method=nil, version=nil)
+        version_string = version ? "rspec-#{version}" : "a future version of RSpec"
+
+        message = <<-NOTICE
+
+*****************************************************************
+DEPRECATION WARNING: you are using deprecated behaviour that will
+be removed from #{version_string}.
+
+#{caller(0)[2]}
+
+* #{method} is deprecated.
+NOTICE
+      if alternate_method
+        message << <<-ADDITIONAL
+* please use #{alternate_method} instead.
+ADDITIONAL
+      end
+
+        message << "*****************************************************************"
+        warn_deprecation(message)
+      end
+
+      # Used internally by RSpec to display custom deprecation warnings.  This
+      # is also defined in rspec-core, but we can't assume it's loaded since
+      # rspec-expectations should be usable w/o rspec-core.
+      def warn_deprecation(message)
+        send :warn, message
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-2.12.1/lib/rspec/expectations/differ.rb

@@ -0,0 +1,115 @@
+require 'diff/lcs'
+require 'diff/lcs/hunk'
+require 'pp'
+
+module RSpec
+  module Expectations
+    class Differ
+      # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
+      def diff_as_string(data_new, data_old)
+        data_old = data_old.split(/\n/).map! { |e| e.chomp }
+        data_new = data_new.split(/\n/).map! { |e| e.chomp }
+        diffs = Diff::LCS.diff(data_old, data_new)
+        output = ""
+        return output if diffs.empty?
+        oldhunk = hunk = nil
+        file_length_difference = 0
+        diffs.each do |piece|
+          begin
+            hunk = Diff::LCS::Hunk.new(
+              data_old, data_new, piece, context_lines, file_length_difference
+            )
+            file_length_difference = hunk.file_length_difference
+            next unless oldhunk
+            # Hunks may overlap, which is why we need to be careful when our
+            # diff includes lines of context. Otherwise, we might print
+            # redundant lines.
+            if (context_lines > 0) and hunk.overlaps?(oldhunk)
+              hunk.unshift(oldhunk)
+            else
+              output << oldhunk.diff(format)
+            end
+          ensure
+            oldhunk = hunk
+            output << "\n"
+          end
+        end
+        #Handle the last remaining hunk
+        output << oldhunk.diff(format) << "\n"
+        color_diff output
+      end
+
+      def diff_as_object(actual, expected)
+        actual_as_string = object_to_string(actual)
+        expected_as_string = object_to_string(expected)
+        diff = diff_as_string(actual_as_string, expected_as_string)
+
+        if diff.empty?
+          "#{actual}.==(#{expected}) returned false even though the diff " \
+          "between #{actual} and #{expected} is empty. Check the " \
+          "implementation of #{actual}.==."
+        else
+          color_diff diff
+        end
+      end
+
+    protected
+
+      def format
+        :unified
+      end
+
+      def context_lines
+        3
+      end
+
+      def color(text, color_code)
+        "\e[#{color_code}m#{text}\e[0m"
+      end
+
+      def red(text)
+        color(text, 31)
+      end
+
+      def green(text)
+        color(text, 32)
+      end
+
+      def blue(text)
+        color(text, 34)
+      end
+
+      def color_diff(diff)
+        return diff unless RSpec::Matchers.configuration.color?
+
+        diff.lines.map { |line|
+          case line[0].chr
+          when "+"
+            green line
+          when "-"
+            red line
+          when "@"
+            line[1].chr == "@" ? blue(line) : line
+          else
+            line
+          end
+        }.join
+      end
+
+      def object_to_string(object)
+        case object
+        when Hash
+          object.keys.sort_by { |k| k.to_s }.map do |k|
+            %(#{PP.singleline_pp(k, "")} => #{PP.singleline_pp(object[k], "")})
+          end.join(",\n")
+        when String
+          object =~ /\n/ ? object : object.inspect
+        else
+          PP.pp(object,"")
+        end
+      end
+    end
+
+  end
+end
+

data/vendor/bundle/gems/rspec-expectations-2.12.1/lib/rspec/expectations/errors.rb

@@ -0,0 +1,9 @@
+module RSpec
+  module Expectations
+    if defined?(Test::Unit::AssertionFailedError)
+      class ExpectationNotMetError < Test::Unit::AssertionFailedError; end
+    else
+      class ExpectationNotMetError < ::StandardError; end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-2.12.1/lib/rspec/expectations/expectation_target.rb

@@ -0,0 +1,88 @@
+module RSpec
+  module Expectations
+    # Wraps the target of an expectation.
+    # @example
+    #   expect(something) # => ExpectationTarget wrapping something
+    #
+    #   # used with `to`
+    #   expect(actual).to eq(3)
+    #
+    #   # with `to_not`
+    #   expect(actual).to_not eq(3)
+    class ExpectationTarget
+      class << self
+        attr_accessor :deprecated_should_enabled
+        alias deprecated_should_enabled? deprecated_should_enabled
+      end
+
+      # @api private
+      def initialize(target)
+        @target = target
+      end
+
+      # Runs the given expectation, passing if `matcher` returns true.
+      # @example
+      #   expect(value).to eq(5)
+      #   expect { perform }.to raise_error
+      # @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
+      def to(matcher=nil, message=nil, &block)
+        prevent_operator_matchers(:to, matcher)
+        RSpec::Expectations::PositiveExpectationHandler.handle_matcher(@target, matcher, message, &block)
+      end
+
+      # Runs the given expectation, passing if `matcher` returns false.
+      # @example
+      #   expect(value).to_not eq(5)
+      #   expect(value).not_to eq(5)
+      # @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
+      def to_not(matcher=nil, message=nil, &block)
+        prevent_operator_matchers(:to_not, matcher)
+        RSpec::Expectations::NegativeExpectationHandler.handle_matcher(@target, matcher, message, &block)
+      end
+      alias not_to to_not
+
+      def self.enable_deprecated_should
+        return if deprecated_should_enabled?
+
+        def should(*args)
+          RSpec.deprecate "`expect { }.should`", "`expect { }.to`", 3
+          @target.should(*args)
+        end
+
+        def should_not(*args)
+          RSpec.deprecate "`expect { }.should_not`", "`expect { }.to_not`", 3
+          @target.should_not(*args)
+        end
+
+        self.deprecated_should_enabled = true
+      end
+
+      def self.disable_deprecated_should
+        return unless deprecated_should_enabled?
+
+        remove_method :should
+        remove_method :should_not
+
+        self.deprecated_should_enabled = false
+      end
+
+    private
+
+      def prevent_operator_matchers(verb, matcher)
+        return if matcher
+
+        raise ArgumentError, "The expect syntax does not support operator matchers, " +
+                             "so you must pass a matcher to `##{verb}`."
+      end
+    end
+  end
+end
+

data/vendor/bundle/gems/rspec-expectations-2.12.1/lib/rspec/expectations/extensions/array.rb

@@ -0,0 +1,9 @@
+# @private
+class Array
+  unless public_instance_methods.map {|m| m.to_s}.include?('none?')
+    # Supports +none?+ on early patch levels of Ruby 1.8.6
+    def none?(&block)
+      !any?(&block)
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-2.12.1/lib/rspec/expectations/extensions/object.rb

@@ -0,0 +1,39 @@
+module RSpec
+  module Expectations
+    module DeprecatedConstants
+      # Displays deprecation warning when it captures Rspec and Spec. Otherwise
+      # delegates to super.
+      def const_missing(name)
+        case name
+        when :Rspec, :Spec
+          RSpec.warn_deprecation <<-WARNING
+*****************************************************************
+DEPRECATION WARNING: you are using a deprecated constant that will
+be removed from a future version of RSpec.
+
+#{caller(0)[2]}
+
+* #{name} is deprecated.
+* RSpec is the new top-level module in RSpec-2
+***************************************************************
+WARNING
+          RSpec
+        else
+          begin
+            super
+          rescue Exception => e
+            e.backtrace.reject! {|l| l =~ Regexp.compile(__FILE__) }
+            raise e
+          end
+        end
+      end
+    end
+
+    # @deprecated (no replacement)
+    def differ=(ignore)
+      RSpec.deprecate("RSpec::Expectations.differ=(differ)", "nothing at all (diffing is now automatic and no longer configurable)")
+    end
+  end
+end
+
+extend RSpec::Expectations::DeprecatedConstants

data/vendor/bundle/gems/rspec-expectations-2.12.1/lib/rspec/expectations/extensions.rb

@@ -0,0 +1,2 @@
+require 'rspec/expectations/extensions/array'
+require 'rspec/expectations/extensions/object'

data/vendor/bundle/gems/rspec-expectations-2.12.1/lib/rspec/expectations/fail_with.rb

@@ -0,0 +1,55 @@
+module RSpec
+  module Expectations
+    class << self
+      # @private
+      def differ
+        @differ ||= Differ.new
+      end
+
+      # Raises an RSpec::Expectations::ExpectationNotMetError with message.
+      # @param [String] message
+      # @param [Object] expected
+      # @param [Object] actual
+      #
+      # Adds a diff to the failure message when `expected` and `actual` are
+      # both present.
+      def fail_with(message, expected=nil, actual=nil)
+        if !message
+          raise ArgumentError, "Failure message is nil. Does your matcher define the " +
+                               "appropriate failure_message_for_* method to return a string?"
+        end
+
+        if actual && expected
+          if all_strings?(actual, expected)
+            if any_multiline_strings?(actual, expected)
+              expected = expected.join(',') if Array === expected
+              message << "\nDiff:" << differ.diff_as_string(actual, expected)
+            end
+          elsif no_procs?(actual, expected) && no_numbers?(actual, expected)
+            message << "\nDiff:" << differ.diff_as_object(actual, expected)
+          end
+        end
+
+        raise(RSpec::Expectations::ExpectationNotMetError.new(message))
+      end
+
+    private
+
+      def no_procs?(*args)
+        args.flatten.none? {|a| Proc === a}
+      end
+
+      def all_strings?(*args)
+        args.flatten.all? {|a| String === a}
+      end
+
+      def any_multiline_strings?(*args)
+        all_strings?(*args) && args.any? {|a| a =~ /\n/}
+      end
+
+      def no_numbers?(*args)
+        args.flatten.none? {|a| Numeric === a}
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-2.12.1/lib/rspec/expectations/handler.rb

@@ -0,0 +1,63 @@
+module RSpec
+  module Expectations
+
+    class ExpectationHandler
+      def self.message_must_be_string(msg)
+        "WARNING: ignoring the provided expectation message argument " +
+        "(#{msg.inspect}) since it is not a string."
+      end
+
+      def self.check_message(msg)
+        ::Kernel.warn message_must_be_string(msg) unless msg.nil? || msg.is_a?(String)
+      end
+    end
+
+    class PositiveExpectationHandler < ExpectationHandler
+
+      def self.handle_matcher(actual, matcher, message=nil, &block)
+        check_message(message)
+        ::RSpec::Matchers.last_should = :should
+        ::RSpec::Matchers.last_matcher = matcher
+        return ::RSpec::Matchers::BuiltIn::PositiveOperatorMatcher.new(actual) if matcher.nil?
+
+        match = matcher.matches?(actual, &block)
+        return match if match
+
+        message ||= matcher.respond_to?(:failure_message_for_should) ?
+                    matcher.failure_message_for_should :
+                    matcher.failure_message
+
+        if matcher.respond_to?(:diffable?) && matcher.diffable?
+          ::RSpec::Expectations.fail_with message, matcher.expected, matcher.actual
+        else
+          ::RSpec::Expectations.fail_with message
+        end
+      end
+    end
+
+    class NegativeExpectationHandler < ExpectationHandler
+      def self.handle_matcher(actual, matcher, message=nil, &block)
+        check_message(message)
+        ::RSpec::Matchers.last_should = :should_not
+        ::RSpec::Matchers.last_matcher = matcher
+        return ::RSpec::Matchers::BuiltIn::NegativeOperatorMatcher.new(actual) if matcher.nil?
+
+        match = matcher.respond_to?(:does_not_match?) ?
+                !matcher.does_not_match?(actual, &block) :
+                matcher.matches?(actual, &block)
+        return match unless match
+
+        message ||= matcher.respond_to?(:failure_message_for_should_not) ?
+                    matcher.failure_message_for_should_not :
+                    matcher.negative_failure_message
+
+        if matcher.respond_to?(:diffable?) && matcher.diffable?
+          ::RSpec::Expectations.fail_with message, matcher.expected, matcher.actual
+        else
+          ::RSpec::Expectations.fail_with message
+        end
+      end
+    end
+  end
+end
+

data/vendor/bundle/gems/rspec-expectations-2.12.1/lib/rspec/expectations/syntax.rb

@@ -0,0 +1,118 @@
+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).to_not eq(expected)
+      # @return [ExpectationTarget]
+      # @see ExpectationTarget#to
+      # @see ExpectationTarget#to_not
+
+      # @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
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-2.12.1/lib/rspec/expectations/version.rb

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