sublimetheme 1.0.0

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

@@ -0,0 +1,418 @@
+RSpec::Support.require_rspec_support "method_signature_verifier"
+
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @private
+      # Object that is yielded to `expect` when one of the
+      # yield matchers is used. Provides information about
+      # the yield behavior of the object-under-test.
+      class YieldProbe
+        def self.probe(block)
+          probe = new(block)
+          return probe unless probe.has_block?
+          probe.assert_valid_expect_block!
+          block.call(probe)
+          probe.assert_used!
+          probe
+        end
+
+        attr_accessor :num_yields, :yielded_args
+
+        def initialize(block)
+          @block = block
+          @used = false
+          self.num_yields, self.yielded_args = 0, []
+        end
+
+        def has_block?
+          Proc === @block
+        end
+
+        def to_proc
+          @used = true
+
+          probe = self
+          Proc.new do |*args|
+            probe.num_yields += 1
+            probe.yielded_args << args
+            nil # to indicate the block does not return a meaningful value
+          end
+        end
+
+        def single_yield_args
+          yielded_args.first
+        end
+
+        def yielded_once?(matcher_name)
+          case num_yields
+          when 1 then true
+          when 0 then false
+          else
+            raise "The #{matcher_name} matcher is not designed to be used with a " \
+                  "method that yields multiple times. Use the yield_successive_args " \
+                  "matcher for that case."
+          end
+        end
+
+        def successive_yield_args
+          yielded_args.map do |arg_array|
+            arg_array.size == 1 ? arg_array.first : arg_array
+          end
+        end
+
+        def assert_used!
+          return if @used
+          raise "You must pass the argument yielded to your expect block on " \
+                "to the method-under-test as a block. It acts as a probe that " \
+                "allows the matcher to detect whether or not the method-under-test " \
+                "yields, and, if so, how many times, and what the yielded arguments " \
+                "are."
+        end
+
+        if RUBY_VERSION.to_f > 1.8
+          def assert_valid_expect_block!
+            block_signature = RSpec::Support::BlockSignature.new(@block)
+            return if RSpec::Support::StrictSignatureVerifier.new(block_signature, [self]).valid?
+            raise "Your expect block must accept an argument to be used with this " \
+                  "matcher. Pass the argument as a block on to the method you are testing."
+          end
+        else
+          # :nocov:
+          # On 1.8.7, `lambda { }.arity` and `lambda { |*a| }.arity` both return -1,
+          # so we can't distinguish between accepting no args and an arg splat.
+          # It's OK to skip, this, though; it just provides a nice error message
+          # when the user forgets to accept an arg in their block. They'll still get
+          # the `assert_used!` error message from above, which is sufficient.
+          def assert_valid_expect_block!
+            # nothing to do
+          end
+          # :nocov:
+        end
+      end
+
+      # @api private
+      # Provides the implementation for `yield_control`.
+      # Not intended to be instantiated directly.
+      class YieldControl < BaseMatcher
+        def initialize
+          at_least(:once)
+        end
+
+        # @api public
+        # Specifies that the method is expected to yield once.
+        def once
+          exactly(1)
+          self
+        end
+
+        # @api public
+        # Specifies that the method is expected to yield twice.
+        def twice
+          exactly(2)
+          self
+        end
+
+        # @api public
+        # Specifies that the method is expected to yield thrice.
+        def thrice
+          exactly(3)
+          self
+        end
+
+        # @api public
+        # Specifies that the method is expected to yield the given number of times.
+        def exactly(number)
+          set_expected_yields_count(:==, number)
+          self
+        end
+
+        # @api public
+        # Specifies the maximum number of times the method is expected to yield
+        def at_most(number)
+          set_expected_yields_count(:<=, number)
+          self
+        end
+
+        # @api public
+        # Specifies the minimum number of times the method is expected to yield
+        def at_least(number)
+          set_expected_yields_count(:>=, number)
+          self
+        end
+
+        # @api public
+        # No-op. Provides syntactic sugar.
+        def times
+          self
+        end
+
+        # @private
+        def matches?(block)
+          @probe = YieldProbe.probe(block)
+          return false unless @probe.has_block?
+
+          @probe.num_yields.__send__(@expectation_type, @expected_yields_count)
+        end
+
+        # @private
+        def does_not_match?(block)
+          !matches?(block) && @probe.has_block?
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message
+          'expected given block to yield control' + failure_reason
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          'expected given block not to yield control' + failure_reason
+        end
+
+        # @private
+        def supports_block_expectations?
+          true
+        end
+
+      private
+
+        def set_expected_yields_count(relativity, n)
+          @expectation_type = relativity
+          @expected_yields_count = case n
+                                   when Numeric then n
+                                   when :once then 1
+                                   when :twice then 2
+                                   when :thrice then 3
+                                   end
+        end
+
+        def failure_reason
+          return " but was not a block" unless @probe.has_block?
+          return '' unless @expected_yields_count
+          " #{human_readable_expectation_type}#{human_readable_count(@expected_yields_count)}" \
+          " but yielded #{human_readable_count(@probe.num_yields)}"
+        end
+
+        def human_readable_expectation_type
+          case @expectation_type
+          when :<= then 'at most '
+          when :>= then 'at least '
+          else ''
+          end
+        end
+
+        def human_readable_count(count)
+          case count
+          when 1 then "once"
+          when 2 then "twice"
+          else "#{count} times"
+          end
+        end
+      end
+
+      # @api private
+      # Provides the implementation for `yield_with_no_args`.
+      # Not intended to be instantiated directly.
+      class YieldWithNoArgs < BaseMatcher
+        # @private
+        def matches?(block)
+          @probe = YieldProbe.probe(block)
+          return false unless @probe.has_block?
+          @probe.yielded_once?(:yield_with_no_args) && @probe.single_yield_args.empty?
+        end
+
+        # @private
+        def does_not_match?(block)
+          !matches?(block) && @probe.has_block?
+        end
+
+        # @private
+        def failure_message
+          "expected given block to yield with no arguments, but #{positive_failure_reason}"
+        end
+
+        # @private
+        def failure_message_when_negated
+          "expected given block not to yield with no arguments, but #{negative_failure_reason}"
+        end
+
+        # @private
+        def supports_block_expectations?
+          true
+        end
+
+      private
+
+        def positive_failure_reason
+          return "was not a block" unless @probe.has_block?
+          return "did not yield" if @probe.num_yields.zero?
+          "yielded with arguments: #{description_of @probe.single_yield_args}"
+        end
+
+        def negative_failure_reason
+          return "was not a block" unless @probe.has_block?
+          "did"
+        end
+      end
+
+      # @api private
+      # Provides the implementation for `yield_with_args`.
+      # Not intended to be instantiated directly.
+      class YieldWithArgs < BaseMatcher
+        def initialize(*args)
+          @expected = args
+        end
+
+        # @private
+        def matches?(block)
+          @probe = YieldProbe.probe(block)
+          return false unless @probe.has_block?
+          @actual = @probe.single_yield_args
+          @probe.yielded_once?(:yield_with_args) && args_match?
+        end
+
+        # @private
+        def does_not_match?(block)
+          !matches?(block) && @probe.has_block?
+        end
+
+        # @private
+        def failure_message
+          "expected given block to yield with arguments, but #{positive_failure_reason}"
+        end
+
+        # @private
+        def failure_message_when_negated
+          "expected given block not to yield with arguments, but #{negative_failure_reason}"
+        end
+
+        # @private
+        def description
+          desc = "yield with args"
+          desc << "(#{expected_arg_description})" unless @expected.empty?
+          desc
+        end
+
+        # @private
+        def supports_block_expectations?
+          true
+        end
+
+      private
+
+        def positive_failure_reason
+          return "was not a block" unless @probe.has_block?
+          return "did not yield" if @probe.num_yields.zero?
+          @positive_args_failure
+        end
+
+        def expected_arg_description
+          @expected.map { |e| description_of e }.join(", ")
+        end
+
+        def negative_failure_reason
+          if !@probe.has_block?
+            "was not a block"
+          elsif all_args_match?
+            "yielded with expected arguments" \
+              "\nexpected not: #{surface_descriptions_in(@expected).inspect}" +
+              "\n         got: #{actual_formatted}"
+          else
+            "did"
+          end
+        end
+
+        def args_match?
+          if @expected.empty? # expect {...}.to yield_with_args
+            @positive_args_failure = "yielded with no arguments" if @actual.empty?
+            return !@actual.empty?
+          end
+
+          unless (match = all_args_match?)
+            @positive_args_failure = "yielded with unexpected arguments" \
+              "\nexpected: #{surface_descriptions_in(@expected).inspect}" +
+              "\n     got: #{actual_formatted}"
+          end
+
+          match
+        end
+
+        def all_args_match?
+          values_match?(@expected, @actual)
+        end
+      end
+
+      # @api private
+      # Provides the implementation for `yield_successive_args`.
+      # Not intended to be instantiated directly.
+      class YieldSuccessiveArgs < BaseMatcher
+        def initialize(*args)
+          @expected = args
+        end
+
+        # @private
+        def matches?(block)
+          @probe = YieldProbe.probe(block)
+          return false unless @probe.has_block?
+          @actual = @probe.successive_yield_args
+          args_match?
+        end
+
+        def does_not_match?(block)
+          !matches?(block) && @probe.has_block?
+        end
+
+        # @private
+        def failure_message
+          "expected given block to yield successively with arguments, but #{positive_failure_reason}"
+        end
+
+        # @private
+        def failure_message_when_negated
+          "expected given block not to yield successively with arguments, but #{negative_failure_reason}"
+        end
+
+        # @private
+        def description
+          desc = "yield successive args"
+          desc << "(#{expected_arg_description})"
+          desc
+        end
+
+        # @private
+        def supports_block_expectations?
+          true
+        end
+
+      private
+
+        def args_match?
+          values_match?(@expected, @actual)
+        end
+
+        def expected_arg_description
+          @expected.map { |e| description_of e }.join(", ")
+        end
+
+        def positive_failure_reason
+          return "was not a block" unless @probe.has_block?
+
+          "yielded with unexpected arguments" \
+          "\nexpected: #{surface_descriptions_in(@expected).inspect}" \
+          "\n     got: #{actual_formatted}"
+        end
+
+        def negative_failure_reason
+          return "was not a block" unless @probe.has_block?
+
+          "yielded with expected arguments" \
+          "\nexpected not: #{surface_descriptions_in(@expected).inspect}" \
+          "\n         got: #{actual_formatted}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,184 @@
+RSpec::Support.require_rspec_support "fuzzy_matcher"
+
+module RSpec
+  module Matchers
+    # Mixin designed to support the composable matcher features
+    # of RSpec 3+. Mix it into your custom matcher classes to
+    # allow them to be used in a composable fashion.
+    #
+    # @api public
+    module Composable
+      # Creates a compound `and` expectation. The matcher will
+      # only pass if both sub-matchers pass.
+      # This can be chained together to form an arbitrarily long
+      # chain of matchers.
+      #
+      # @example
+      #   expect(alphabet).to start_with("a").and end_with("z")
+      #   expect(alphabet).to start_with("a") & end_with("z")
+      #
+      # @note The negative form (`expect(...).not_to matcher.and other`)
+      #   is not supported at this time.
+      def and(matcher)
+        BuiltIn::Compound::And.new self, matcher
+      end
+      alias & and
+
+      # Creates a compound `or` expectation. The matcher will
+      # pass if either sub-matcher passes.
+      # This can be chained together to form an arbitrarily long
+      # chain of matchers.
+      #
+      # @example
+      #   expect(stoplight.color).to eq("red").or eq("green").or eq("yellow")
+      #   expect(stoplight.color).to eq("red") | eq("green") | eq("yellow")
+      #
+      # @note The negative form (`expect(...).not_to matcher.or other`)
+      #   is not supported at this time.
+      def or(matcher)
+        BuiltIn::Compound::Or.new self, matcher
+      end
+      alias | or
+
+      # Delegates to `#matches?`. Allows matchers to be used in composable
+      # fashion and also supports using matchers in case statements.
+      def ===(value)
+        matches?(value)
+      end
+
+    private
+
+      # This provides a generic way to fuzzy-match an expected value against
+      # an actual value. It understands nested data structures (e.g. hashes
+      # and arrays) and is able to match against a matcher being used as
+      # the expected value or within the expected value at any level of
+      # nesting.
+      #
+      # Within a custom matcher you are encouraged to use this whenever your
+      # matcher needs to match two values, unless it needs more precise semantics.
+      # For example, the `eq` matcher _does not_ use this as it is meant to
+      # use `==` (and only `==`) for matching.
+      #
+      # @param expected [Object] what is expected
+      # @param actual [Object] the actual value
+      #
+      # @!visibility public
+      def values_match?(expected, actual)
+        expected = with_matchers_cloned(expected)
+        Support::FuzzyMatcher.values_match?(expected, actual)
+      end
+
+      # Returns the description of the given object in a way that is
+      # aware of composed matchers. If the object is a matcher with
+      # a `description` method, returns the description; otherwise
+      # returns `object.inspect`.
+      #
+      # You are encouraged to use this in your custom matcher's
+      # `description`, `failure_message` or
+      # `failure_message_when_negated` implementation if you are
+      # supporting matcher arguments.
+      #
+      # @!visibility public
+      def description_of(object)
+        RSpec::Support::ObjectFormatter.format(object)
+      end
+
+      # Transforms the given data structue (typically a hash or array)
+      # into a new data structure that, when `#inspect` is called on it,
+      # will provide descriptions of any contained matchers rather than
+      # the normal `#inspect` output.
+      #
+      # You are encouraged to use this in your custom matcher's
+      # `description`, `failure_message` or
+      # `failure_message_when_negated` implementation if you are
+      # supporting any arguments which may be a data structure
+      # containing matchers.
+      #
+      # @!visibility public
+      def surface_descriptions_in(item)
+        if Matchers.is_a_describable_matcher?(item)
+          DescribableItem.new(item)
+        elsif Hash === item
+          Hash[surface_descriptions_in(item.to_a)]
+        elsif Struct === item
+          RSpec::Support::ObjectFormatter.format(item)
+        elsif should_enumerate?(item)
+          begin
+            item.map { |subitem| surface_descriptions_in(subitem) }
+          rescue IOError # STDOUT is enumerable but `map` raises an error
+            RSpec::Support::ObjectFormatter.format(item)
+          end
+        else
+          item
+        end
+      end
+
+      # @private
+      # Historically, a single matcher instance was only checked
+      # against a single value. Given that the matcher was only
+      # used once, it's been common to memoize some intermediate
+      # calculation that is derived from the `actual` value in
+      # order to reuse that intermediate result in the failure
+      # message.
+      #
+      # This can cause a problem when using such a matcher as an
+      # argument to another matcher in a composed matcher expression,
+      # since the matcher instance may be checked against multiple
+      # values and produce invalid results due to the memoization.
+      #
+      # To deal with this, we clone any matchers in `expected` via
+      # this method when using `values_match?`, so that any memoization
+      # does not "leak" between checks.
+      def with_matchers_cloned(object)
+        if Matchers.is_a_matcher?(object)
+          object.clone
+        elsif Hash === object
+          Hash[with_matchers_cloned(object.to_a)]
+        elsif Struct === object
+          object
+        elsif should_enumerate?(object)
+          begin
+            object.map { |subobject| with_matchers_cloned(subobject) }
+          rescue IOError # STDOUT is enumerable but `map` raises an error
+            object
+          end
+        else
+          object
+        end
+      end
+
+      if String.ancestors.include?(Enumerable) # 1.8.7
+        # :nocov:
+        # Strings are not enumerable on 1.9, and on 1.8 they are an infinitely
+        # nested enumerable: since ruby lacks a character class, it yields
+        # 1-character strings, which are themselves enumerable, composed of a
+        # a single 1-character string, which is an enumerable, etc.
+        #
+        # @api private
+        def should_enumerate?(item)
+          return false if String === item
+          Enumerable === item && !(Range === item)
+        end
+        # :nocov:
+      else
+        # @api private
+        def should_enumerate?(item)
+          Enumerable === item && !(Range === item)
+        end
+      end
+      module_function :surface_descriptions_in, :should_enumerate?
+
+      # Wraps an item in order to surface its `description` via `inspect`.
+      # @api private
+      DescribableItem = Struct.new(:item) do
+        def inspect
+          "(#{item.description})"
+        end
+
+        def pretty_print(pp)
+          pp.text "(#{item.description})"
+        end
+      end
+    end
+  end
+end