sublimetheme 1.0.0

data/path/gems/rspec-expectations-3.3.1/lib/rspec/matchers/aliased_matcher.rb

@@ -0,0 +1,116 @@
+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/path/gems/rspec-expectations-3.3.1/lib/rspec/matchers/built_in.rb

@@ -0,0 +1,52 @@
+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/path/gems/rspec-expectations-3.3.1/lib/rspec/matchers/built_in/all.rb

@@ -0,0 +1,85 @@
+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/path/gems/rspec-expectations-3.3.1/lib/rspec/matchers/built_in/base_matcher.rb

@@ -0,0 +1,181 @@
+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/path/gems/rspec-expectations-3.3.1/lib/rspec/matchers/built_in/be.rb

@@ -0,0 +1,285 @@
+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