scoot 0.0.4 → 0.0.6

data/.bundle/gems/ruby/2.2.0/gems/rspec-expectations-3.3.1/lib/rspec/matchers/aliased_matcher.rb

@@ -1,116 +0,0 @@
-module RSpec
-  module Matchers
-    # Decorator that wraps a matcher and overrides `description`
-    # using the provided block in order to support an alias
-    # of a matcher. This is intended for use when composing
-    # matchers, so that you can use an expression like
-    # `include( a_value_within(0.1).of(3) )` rather than
-    # `include( be_within(0.1).of(3) )`, and have the corresponding
-    # description read naturally.
-    #
-    # @api private
-    class AliasedMatcher < MatcherDelegator
-      def initialize(base_matcher, description_block)
-        @description_block = description_block
-        super(base_matcher)
-      end
-
-      # Forward messages on to the wrapped matcher.
-      # Since many matchers provide a fluent interface
-      # (e.g. `a_value_within(0.1).of(3)`), we need to wrap
-      # the returned value if it responds to `description`,
-      # so that our override can be applied when it is eventually
-      # used.
-      def method_missing(*)
-        return_val = super
-        return return_val unless RSpec::Matchers.is_a_matcher?(return_val)
-        self.class.new(return_val, @description_block)
-      end
-
-      # Provides the description of the aliased matcher. Aliased matchers
-      # are designed to behave identically to the original matcher except
-      # for the description and failure messages. The description is different
-      # to reflect the aliased name.
-      #
-      # @api private
-      def description
-        @description_block.call(super)
-      end
-
-      # Provides the failure_message of the aliased matcher. Aliased matchers
-      # are designed to behave identically to the original matcher except
-      # for the description and failure messages. The failure_message is different
-      # to reflect the aliased name.
-      #
-      # @api private
-      def failure_message
-        @description_block.call(super)
-      end
-
-      # Provides the failure_message_when_negated of the aliased matcher. Aliased matchers
-      # are designed to behave identically to the original matcher except
-      # for the description and failure messages. The failure_message_when_negated is different
-      # to reflect the aliased name.
-      #
-      # @api private
-      def failure_message_when_negated
-        @description_block.call(super)
-      end
-    end
-
-    # Decorator used for matchers that have special implementations of
-    # operators like `==` and `===`.
-    # @private
-    class AliasedMatcherWithOperatorSupport < AliasedMatcher
-      # We undef these so that they get delegated via `method_missing`.
-      undef ==
-      undef ===
-    end
-
-    # @private
-    class AliasedNegatedMatcher < AliasedMatcher
-      def matches?(*args, &block)
-        if @base_matcher.respond_to?(:does_not_match?)
-          @base_matcher.does_not_match?(*args, &block)
-        else
-          !super
-        end
-      end
-
-      def does_not_match?(*args, &block)
-        @base_matcher.matches?(*args, &block)
-      end
-
-      def failure_message
-        optimal_failure_message(__method__, :failure_message_when_negated)
-      end
-
-      def failure_message_when_negated
-        optimal_failure_message(__method__, :failure_message)
-      end
-
-    private
-
-      DefaultFailureMessages = BuiltIn::BaseMatcher::DefaultFailureMessages
-
-      # For a matcher that uses the default failure messages, we prefer to
-      # use the override provided by the `description_block`, because it
-      # includes the phrasing that the user has expressed a preference for
-      # by going through the effort of defining a negated matcher.
-      #
-      # However, if the override didn't actually change anything, then we
-      # should return the opposite failure message instead -- the overriden
-      # message is going to be confusing if we return it as-is, as it represents
-      # the non-negated failure message for a negated match (or vice versa).
-      def optimal_failure_message(same, inverted)
-        if DefaultFailureMessages.has_default_failure_messages?(@base_matcher)
-          base_message = @base_matcher.__send__(same)
-          overriden    = @description_block.call(base_message)
-          return overriden if overriden != base_message
-        end
-
-        @base_matcher.__send__(inverted)
-      end
-    end
-  end
-end

data/.bundle/gems/ruby/2.2.0/gems/rspec-expectations-3.3.1/lib/rspec/matchers/built_in.rb

@@ -1,52 +0,0 @@
-RSpec::Support.require_rspec_matchers "built_in/base_matcher"
-
-module RSpec
-  module Matchers
-    # Container module for all built-in matchers. The matcher classes are here
-    # (rather than directly under `RSpec::Matchers`) in order to prevent name
-    # collisions, since `RSpec::Matchers` gets included into the user's namespace.
-    #
-    # Autoloading is used to delay when the matcher classes get loaded, allowing
-    # rspec-matchers to boot faster, and avoiding loading matchers the user is
-    # not using.
-    module BuiltIn
-      autoload :BeAKindOf,               'rspec/matchers/built_in/be_kind_of'
-      autoload :BeAnInstanceOf,          'rspec/matchers/built_in/be_instance_of'
-      autoload :BeBetween,               'rspec/matchers/built_in/be_between'
-      autoload :Be,                      'rspec/matchers/built_in/be'
-      autoload :BeComparedTo,            'rspec/matchers/built_in/be'
-      autoload :BeFalsey,                'rspec/matchers/built_in/be'
-      autoload :BeNil,                   'rspec/matchers/built_in/be'
-      autoload :BePredicate,             'rspec/matchers/built_in/be'
-      autoload :BeTruthy,                'rspec/matchers/built_in/be'
-      autoload :BeWithin,                'rspec/matchers/built_in/be_within'
-      autoload :Change,                  'rspec/matchers/built_in/change'
-      autoload :Compound,                'rspec/matchers/built_in/compound'
-      autoload :ContainExactly,          'rspec/matchers/built_in/contain_exactly'
-      autoload :Cover,                   'rspec/matchers/built_in/cover'
-      autoload :EndWith,                 'rspec/matchers/built_in/start_or_end_with'
-      autoload :Eq,                      'rspec/matchers/built_in/eq'
-      autoload :Eql,                     'rspec/matchers/built_in/eql'
-      autoload :Equal,                   'rspec/matchers/built_in/equal'
-      autoload :Exist,                   'rspec/matchers/built_in/exist'
-      autoload :Has,                     'rspec/matchers/built_in/has'
-      autoload :HaveAttributes,          'rspec/matchers/built_in/have_attributes'
-      autoload :Include,                 'rspec/matchers/built_in/include'
-      autoload :All,                     'rspec/matchers/built_in/all'
-      autoload :Match,                   'rspec/matchers/built_in/match'
-      autoload :NegativeOperatorMatcher, 'rspec/matchers/built_in/operators'
-      autoload :OperatorMatcher,         'rspec/matchers/built_in/operators'
-      autoload :Output,                  'rspec/matchers/built_in/output'
-      autoload :PositiveOperatorMatcher, 'rspec/matchers/built_in/operators'
-      autoload :RaiseError,              'rspec/matchers/built_in/raise_error'
-      autoload :RespondTo,               'rspec/matchers/built_in/respond_to'
-      autoload :Satisfy,                 'rspec/matchers/built_in/satisfy'
-      autoload :StartWith,               'rspec/matchers/built_in/start_or_end_with'
-      autoload :ThrowSymbol,             'rspec/matchers/built_in/throw_symbol'
-      autoload :YieldControl,            'rspec/matchers/built_in/yield'
-      autoload :YieldSuccessiveArgs,     'rspec/matchers/built_in/yield'
-      autoload :YieldWithArgs,           'rspec/matchers/built_in/yield'
-      autoload :YieldWithNoArgs,         'rspec/matchers/built_in/yield'
-    end
-  end
-end

data/.bundle/gems/ruby/2.2.0/gems/rspec-expectations-3.3.1/lib/rspec/matchers/built_in/all.rb

@@ -1,85 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `all`.
-      # Not intended to be instantiated directly.
-      class All < BaseMatcher
-        # @private
-        attr_reader :matcher, :failed_objects
-
-        def initialize(matcher)
-          @matcher = matcher
-          @failed_objects = {}
-        end
-
-        # @private
-        def does_not_match?(_actual)
-          raise NotImplementedError, '`expect().not_to all( matcher )` is not supported.'
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          unless iterable?
-            return "#{improve_hash_formatting(super)}, but was not iterable"
-          end
-
-          all_messages = [improve_hash_formatting(super)]
-          failed_objects.each do |index, matcher_failure_message|
-            all_messages << failure_message_for_item(index, matcher_failure_message)
-          end
-          all_messages.join("\n\n")
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          improve_hash_formatting "all #{description_of matcher}"
-        end
-
-      private
-
-        def match(_expected, _actual)
-          return false unless iterable?
-
-          index_failed_objects
-          failed_objects.empty?
-        end
-
-        def index_failed_objects
-          actual.each_with_index do |actual_item, index|
-            cloned_matcher = matcher.clone
-            matches = cloned_matcher.matches?(actual_item)
-            failed_objects[index] = cloned_matcher.failure_message unless matches
-          end
-        end
-
-        def failure_message_for_item(index, failure_message)
-          failure_message = indent_multiline_message(add_new_line_if_needed(failure_message))
-          indent_multiline_message("object at index #{index} failed to match:#{failure_message}")
-        end
-
-        def add_new_line_if_needed(message)
-          message.start_with?("\n") ? message : "\n#{message}"
-        end
-
-        def indent_multiline_message(message)
-          message = message.sub(/\n+\z/, '')
-          message.lines.map do |line|
-            line =~ /\S/ ? '   ' + line : line
-          end.join
-        end
-
-        def initialize_copy(other)
-          @matcher = @matcher.clone
-          super
-        end
-
-        def iterable?
-          @actual.respond_to?(:each_with_index)
-        end
-      end
-    end
-  end
-end

data/.bundle/gems/ruby/2.2.0/gems/rspec-expectations-3.3.1/lib/rspec/matchers/built_in/base_matcher.rb

@@ -1,181 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      #
-      # Used _internally_ as a base class for matchers that ship with
-      # rspec-expectations and rspec-rails.
-      #
-      # ### 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::Composable
-
-        # @api private
-        # Used to detect when no arg is passed to `initialize`.
-        # `nil` cannot be used because it's a valid value to pass.
-        UNDEFINED = Object.new.freeze
-
-        # @private
-        attr_reader :actual, :expected, :rescued_exception
-
-        def initialize(expected=UNDEFINED)
-          @expected = expected unless UNDEFINED.equal?(expected)
-        end
-
-        # @api private
-        # Indicates if the match is successful. Delegates to `match`, which
-        # should be defined on a subclass. Takes care of consistently
-        # initializing the `actual` attribute.
-        def matches?(actual)
-          @actual = actual
-          match(expected, actual)
-        end
-
-        # @api private
-        # Used to wrap a block of code that will indicate failure by
-        # raising one of the named exceptions.
-        #
-        # This is used by rspec-rails for some of its matchers that
-        # wrap rails' assertions.
-        def match_unless_raises(*exceptions)
-          exceptions.unshift Exception if exceptions.empty?
-          begin
-            yield
-            true
-          rescue *exceptions => @rescued_exception
-            false
-          end
-        end
-
-        # @api private
-        # Generates a description using {EnglishPhrasing}.
-        # @return [String]
-        def description
-          desc = EnglishPhrasing.split_words(self.class.matcher_name)
-          desc << EnglishPhrasing.list(@expected) if defined?(@expected)
-          desc
-        end
-
-        # @api private
-        # Matchers are not diffable by default. Override this to make your
-        # subclass diffable.
-        def diffable?
-          false
-        end
-
-        # @api private
-        # Most matchers are value matchers (i.e. meant to work with `expect(value)`)
-        # rather than block matchers (i.e. meant to work with `expect { }`), so
-        # this defaults to false. Block matchers must override this to return true.
-        def supports_block_expectations?
-          false
-        end
-
-        # @api private
-        def expects_call_stack_jump?
-          false
-        end
-
-        # @private
-        def expected_formatted
-          RSpec::Support::ObjectFormatter.format(@expected)
-        end
-
-        # @private
-        def actual_formatted
-          RSpec::Support::ObjectFormatter.format(@actual)
-        end
-
-        # @private
-        def self.matcher_name
-          @matcher_name ||= underscore(name.split("::").last)
-        end
-
-        # @private
-        # Borrowed from ActiveSupport.
-        def self.underscore(camel_cased_word)
-          word = camel_cased_word.to_s.dup
-          word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-          word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
-          word.tr!("-", "_")
-          word.downcase!
-          word
-        end
-        private_class_method :underscore
-
-      private
-
-        def assert_ivars(*expected_ivars)
-          return unless (expected_ivars - present_ivars).any?
-          ivar_list = EnglishPhrasing.list(expected_ivars)
-          raise "#{self.class.name} needs to supply#{ivar_list}"
-        end
-
-        if RUBY_VERSION.to_f < 1.9
-          # :nocov:
-          def present_ivars
-            instance_variables.map { |v| v.to_sym }
-          end
-          # :nocov:
-        else
-          alias present_ivars instance_variables
-        end
-
-        # @private
-        module HashFormatting
-          # `{ :a => 5, :b => 2 }.inspect` produces:
-          #
-          #     {:a=>5, :b=>2}
-          #
-          # ...but it looks much better as:
-          #
-          #     {:a => 5, :b => 2}
-          #
-          # This is idempotent and safe to run on a string multiple times.
-          def improve_hash_formatting(inspect_string)
-            inspect_string.gsub(/(\S)=>(\S)/, '\1 => \2')
-          end
-          module_function :improve_hash_formatting
-        end
-
-        include HashFormatting
-
-        # @api private
-        # Provides default implementations of failure messages, based on the `description`.
-        module DefaultFailureMessages
-          # @api private
-          # Provides a good generic failure message. Based on `description`.
-          # When subclassing, if you are not satisfied with this failure message
-          # you often only need to override `description`.
-          # @return [String]
-          def failure_message
-            "expected #{description_of @actual} to #{description}"
-          end
-
-          # @api private
-          # Provides a good generic negative failure message. Based on `description`.
-          # When subclassing, if you are not satisfied with this failure message
-          # you often only need to override `description`.
-          # @return [String]
-          def failure_message_when_negated
-            "expected #{description_of @actual} not to #{description}"
-          end
-
-          # @private
-          def self.has_default_failure_messages?(matcher)
-            matcher.method(:failure_message).owner == self &&
-            matcher.method(:failure_message_when_negated).owner == self
-          rescue NameError
-            false
-          end
-        end
-
-        include DefaultFailureMessages
-      end
-    end
-  end
-end

data/.bundle/gems/ruby/2.2.0/gems/rspec-expectations-3.3.1/lib/rspec/matchers/built_in/be.rb

@@ -1,285 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `be_truthy`.
-      # Not intended to be instantiated directly.
-      class BeTruthy < BaseMatcher
-        # @api private
-        # @return [String]
-        def failure_message
-          "expected: truthy value\n     got: #{actual_formatted}"
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          "expected: falsey value\n     got: #{actual_formatted}"
-        end
-
-      private
-
-        def match(_, actual)
-          !!actual
-        end
-      end
-
-      # @api private
-      # Provides the implementation for `be_falsey`.
-      # Not intended to be instantiated directly.
-      class BeFalsey < BaseMatcher
-        # @api private
-        # @return [String]
-        def failure_message
-          "expected: falsey value\n     got: #{actual_formatted}"
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          "expected: truthy value\n     got: #{actual_formatted}"
-        end
-
-      private
-
-        def match(_, actual)
-          !actual
-        end
-      end
-
-      # @api private
-      # Provides the implementation for `be_nil`.
-      # Not intended to be instantiated directly.
-      class BeNil < BaseMatcher
-        # @api private
-        # @return [String]
-        def failure_message
-          "expected: nil\n     got: #{actual_formatted}"
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          "expected: not nil\n     got: nil"
-        end
-
-      private
-
-        def match(_, actual)
-          actual.nil?
-        end
-      end
-
-      # @private
-      module BeHelpers
-      private
-
-        def args_to_s
-          @args.empty? ? "" : parenthesize(inspected_args.join(', '))
-        end
-
-        def parenthesize(string)
-          "(#{string})"
-        end
-
-        def inspected_args
-          @args.map { |a| RSpec::Support::ObjectFormatter.format(a) }
-        end
-
-        def expected_to_sentence
-          EnglishPhrasing.split_words(@expected)
-        end
-
-        def args_to_sentence
-          EnglishPhrasing.list(@args)
-        end
-      end
-
-      # @api private
-      # Provides the implementation for `be`.
-      # Not intended to be instantiated directly.
-      class Be < BaseMatcher
-        include BeHelpers
-
-        def initialize(*args)
-          @args = args
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          "expected #{actual_formatted} to evaluate to true"
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          "expected #{actual_formatted} to evaluate to false"
-        end
-
-        [:==, :<, :<=, :>=, :>, :===, :=~].each do |operator|
-          define_method operator do |operand|
-            BeComparedTo.new(operand, operator)
-          end
-        end
-
-      private
-
-        def match(_, actual)
-          !!actual
-        end
-      end
-
-      # @api private
-      # Provides the implementation of `be <operator> value`.
-      # Not intended to be instantiated directly.
-      class BeComparedTo < BaseMatcher
-        include BeHelpers
-
-        def initialize(operand, operator)
-          @expected, @operator = operand, operator
-          @args = []
-        end
-
-        def matches?(actual)
-          @actual = actual
-          @actual.__send__ @operator, @expected
-        rescue ArgumentError
-          false
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          "expected: #{@operator} #{expected_formatted}\n     got: #{@operator.to_s.gsub(/./, ' ')} #{actual_formatted}"
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          message = "`expect(#{actual_formatted}).not_to be #{@operator} #{expected_formatted}`"
-          if [:<, :>, :<=, :>=].include?(@operator)
-            message + " not only FAILED, it is a bit confusing."
-          else
-            message
-          end
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          "be #{@operator} #{expected_to_sentence}#{args_to_sentence}"
-        end
-      end
-
-      # @api private
-      # Provides the implementation of `be_<predicate>`.
-      # Not intended to be instantiated directly.
-      class BePredicate < BaseMatcher
-        include BeHelpers
-
-        def initialize(*args, &block)
-          @expected = parse_expected(args.shift)
-          @args = args
-          @block = block
-        end
-
-        def matches?(actual, &block)
-          @actual  = actual
-          @block ||= block
-          predicate_accessible? && predicate_matches?
-        end
-
-        def does_not_match?(actual, &block)
-          @actual  = actual
-          @block ||= block
-          predicate_accessible? && !predicate_matches?
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          failure_message_expecting(true)
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          failure_message_expecting(false)
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          "#{prefix_to_sentence}#{expected_to_sentence}#{args_to_sentence}"
-        end
-
-      private
-
-        def predicate_accessible?
-          actual.respond_to?(predicate) || actual.respond_to?(present_tense_predicate)
-        end
-
-        # support 1.8.7, evaluate once at load time for performance
-        if String === methods.first
-          # :nocov:
-          def private_predicate?
-            @actual.private_methods.include? predicate.to_s
-          end
-          # :nocov:
-        else
-          def private_predicate?
-            @actual.private_methods.include? predicate
-          end
-        end
-
-        def predicate_matches?
-          method_name = actual.respond_to?(predicate) ? predicate : present_tense_predicate
-          @predicate_matches = actual.__send__(method_name, *@args, &@block)
-        end
-
-        def predicate
-          :"#{@expected}?"
-        end
-
-        def present_tense_predicate
-          :"#{@expected}s?"
-        end
-
-        def parse_expected(expected)
-          @prefix, expected = prefix_and_expected(expected)
-          expected
-        end
-
-        def prefix_and_expected(symbol)
-          Matchers::BE_PREDICATE_REGEX.match(symbol.to_s).captures.compact
-        end
-
-        def prefix_to_sentence
-          EnglishPhrasing.split_words(@prefix)
-        end
-
-        def failure_message_expecting(value)
-          validity_message ||
-            "expected `#{actual_formatted}.#{predicate}#{args_to_s}` to return #{value}, got #{description_of @predicate_matches}"
-        end
-
-        def validity_message
-          return nil if predicate_accessible?
-
-          msg = "expected #{@actual} to respond to `#{predicate}`"
-
-          if private_predicate?
-            msg << " but `#{predicate}` is a private method"
-          elsif predicate == :true?
-            msg << " or perhaps you meant `be true` or `be_truthy`"
-          elsif predicate == :false?
-            msg << " or perhaps you meant `be false` or `be_falsey`"
-          end
-
-          msg
-        end
-      end
-    end
-  end
-end