sublimetheme 1.0.0

data/path/gems/rspec-support-3.3.0/lib/rspec/support/fuzzy_matcher.rb

@@ -0,0 +1,48 @@
+module RSpec
+  module Support
+    # Provides a means to fuzzy-match between two arbitrary objects.
+    # Understands array/hash nesting. Uses `===` or `==` to
+    # perform the matching.
+    module FuzzyMatcher
+      # @api private
+      def self.values_match?(expected, actual)
+        if Hash === actual
+          return hashes_match?(expected, actual) if Hash === expected
+        elsif Array === expected && Enumerable === actual && !(Struct === actual)
+          return arrays_match?(expected, actual.to_a)
+        end
+
+        return true if expected == actual
+
+        begin
+          expected === actual
+        rescue ArgumentError
+          # Some objects, like 0-arg lambdas on 1.9+, raise
+          # ArgumentError for `expected === actual`.
+          false
+        end
+      end
+
+      # @private
+      def self.arrays_match?(expected_list, actual_list)
+        return false if expected_list.size != actual_list.size
+
+        expected_list.zip(actual_list).all? do |expected, actual|
+          values_match?(expected, actual)
+        end
+      end
+
+      # @private
+      def self.hashes_match?(expected_hash, actual_hash)
+        return false if expected_hash.size != actual_hash.size
+
+        expected_hash.all? do |expected_key, expected_value|
+          actual_value = actual_hash.fetch(expected_key) { return false }
+          values_match?(expected_value, actual_value)
+        end
+      end
+
+      private_class_method :arrays_match?, :hashes_match?
+    end
+  end
+end

data/path/gems/rspec-support-3.3.0/lib/rspec/support/hunk_generator.rb

@@ -0,0 +1,47 @@
+require 'diff/lcs'
+require 'diff/lcs/hunk'
+
+module RSpec
+  module Support
+    # @private
+    class HunkGenerator
+      def initialize(actual, expected)
+        @actual = actual
+        @expected = expected
+      end
+
+      def hunks
+        @file_length_difference = 0
+        @hunks ||= diffs.map do |piece|
+          build_hunk(piece)
+        end
+      end
+
+    private
+
+      def diffs
+        Diff::LCS.diff(expected_lines, actual_lines)
+      end
+
+      def expected_lines
+        @expected.split("\n").map! { |e| e.chomp }
+      end
+
+      def actual_lines
+        @actual.split("\n").map! { |e| e.chomp }
+      end
+
+      def build_hunk(piece)
+        Diff::LCS::Hunk.new(
+          expected_lines, actual_lines, piece, context_lines, @file_length_difference
+        ).tap do |h|
+          @file_length_difference = h.file_length_difference
+        end
+      end
+
+      def context_lines
+        3
+      end
+    end
+  end
+end

data/path/gems/rspec-support-3.3.0/lib/rspec/support/matcher_definition.rb

@@ -0,0 +1,42 @@
+module RSpec
+  module Support
+    # @private
+    def self.matcher_definitions
+      @matcher_definitions ||= []
+    end
+
+    # Used internally to break cyclic dependency between mocks, expectations,
+    # and support. We don't currently have a consistent implementation of our
+    # matchers, though we are considering changing that:
+    # https://github.com/rspec/rspec-mocks/issues/513
+    #
+    # @private
+    def self.register_matcher_definition(&block)
+      matcher_definitions << block
+    end
+
+    # Remove a previously registered matcher. Useful for cleaning up after
+    # yourself in specs.
+    #
+    # @private
+    def self.deregister_matcher_definition(&block)
+      matcher_definitions.delete(block)
+    end
+
+    # @private
+    def self.is_a_matcher?(object)
+      matcher_definitions.any? { |md| md.call(object) }
+    end
+
+    # @api private
+    #
+    # gives a string representation of an object for use in RSpec descriptions
+    def self.rspec_description_for_object(object)
+      if RSpec::Support.is_a_matcher?(object) && object.respond_to?(:description)
+        object.description
+      else
+        object
+      end
+    end
+  end
+end

data/path/gems/rspec-support-3.3.0/lib/rspec/support/method_signature_verifier.rb

@@ -0,0 +1,273 @@
+require 'rspec/support'
+RSpec::Support.require_rspec_support "ruby_features"
+RSpec::Support.require_rspec_support "matcher_definition"
+
+module RSpec
+  module Support
+    # Extracts info about the number of arguments and allowed/required
+    # keyword args of a given method.
+    #
+    # @private
+    class MethodSignature
+      attr_reader :min_non_kw_args, :max_non_kw_args, :optional_kw_args, :required_kw_args
+
+      def initialize(method)
+        @method           = method
+        @optional_kw_args = []
+        @required_kw_args = []
+        classify_parameters
+      end
+
+      def non_kw_args_arity_description
+        case max_non_kw_args
+        when min_non_kw_args then min_non_kw_args.to_s
+        when INFINITY then "#{min_non_kw_args} or more"
+        else "#{min_non_kw_args} to #{max_non_kw_args}"
+        end
+      end
+
+      def valid_non_kw_args?(positional_arg_count)
+        min_non_kw_args <= positional_arg_count &&
+          positional_arg_count <= max_non_kw_args
+      end
+
+      if RubyFeatures.optional_and_splat_args_supported?
+        def description
+          @description ||= begin
+            parts = []
+
+            unless non_kw_args_arity_description == "0"
+              parts << "arity of #{non_kw_args_arity_description}"
+            end
+
+            if @optional_kw_args.any?
+              parts << "optional keyword args (#{@optional_kw_args.map(&:inspect).join(", ")})"
+            end
+
+            if @required_kw_args.any?
+              parts << "required keyword args (#{@required_kw_args.map(&:inspect).join(", ")})"
+            end
+
+            parts << "any additional keyword args" if @allows_any_kw_args
+
+            parts.join(" and ")
+          end
+        end
+
+        def missing_kw_args_from(given_kw_args)
+          @required_kw_args - given_kw_args
+        end
+
+        def invalid_kw_args_from(given_kw_args)
+          return [] if @allows_any_kw_args
+          given_kw_args - @allowed_kw_args
+        end
+
+        def has_kw_args_in?(args)
+          Hash === args.last && could_contain_kw_args?(args)
+        end
+
+        # Without considering what the last arg is, could it
+        # contain keyword arguments?
+        def could_contain_kw_args?(args)
+          return false if args.count <= min_non_kw_args
+          @allows_any_kw_args || @allowed_kw_args.any?
+        end
+
+        def classify_parameters
+          optional_non_kw_args = @min_non_kw_args = 0
+          @allows_any_kw_args = false
+
+          @method.parameters.each do |(type, name)|
+            case type
+            # def foo(a:)
+            when :keyreq  then @required_kw_args << name
+            # def foo(a: 1)
+            when :key     then @optional_kw_args << name
+            # def foo(**kw_args)
+            when :keyrest then @allows_any_kw_args = true
+            # def foo(a)
+            when :req     then @min_non_kw_args += 1
+            # def foo(a = 1)
+            when :opt     then optional_non_kw_args += 1
+            # def foo(*a)
+            when :rest    then optional_non_kw_args = INFINITY
+            end
+          end
+
+          @max_non_kw_args = @min_non_kw_args  + optional_non_kw_args
+          @allowed_kw_args = @required_kw_args + @optional_kw_args
+        end
+      else
+        def description
+          "arity of #{non_kw_args_arity_description}"
+        end
+
+        def missing_kw_args_from(_given_kw_args)
+          []
+        end
+
+        def invalid_kw_args_from(_given_kw_args)
+          []
+        end
+
+        def has_kw_args_in?(_args)
+          false
+        end
+
+        def could_contain_kw_args?(*)
+          false
+        end
+
+        def classify_parameters
+          arity = @method.arity
+          if arity < 0
+            # `~` inverts the one's complement and gives us the
+            # number of required args
+            @min_non_kw_args = ~arity
+            @max_non_kw_args = INFINITY
+          else
+            @min_non_kw_args = arity
+            @max_non_kw_args = arity
+          end
+        end
+      end
+
+      INFINITY = 1 / 0.0
+    end
+
+    # Deals with the slightly different semantics of block arguments.
+    # For methods, arguments are required unless a default value is provided.
+    # For blocks, arguments are optional, even if no default value is provided.
+    #
+    # However, we want to treat block args as required since you virtually
+    # always want to pass a value for each received argument and our
+    # `and_yield` has treated block args as required for many years.
+    #
+    # @api private
+    class BlockSignature < MethodSignature
+      if RubyFeatures.optional_and_splat_args_supported?
+        def classify_parameters
+          super
+          @min_non_kw_args = @max_non_kw_args unless @max_non_kw_args == INFINITY
+        end
+      end
+    end
+
+    # Abstract base class for signature verifiers.
+    #
+    # @api private
+    class MethodSignatureVerifier
+      attr_reader :non_kw_args, :kw_args
+
+      def initialize(signature, args)
+        @signature = signature
+        @non_kw_args, @kw_args = split_args(*args)
+      end
+
+      def valid?
+        missing_kw_args.empty? &&
+          invalid_kw_args.empty? &&
+          valid_non_kw_args?
+      end
+
+      def error_message
+        if missing_kw_args.any?
+          "Missing required keyword arguments: %s" % [
+            missing_kw_args.join(", ")
+          ]
+        elsif invalid_kw_args.any?
+          "Invalid keyword arguments provided: %s" % [
+            invalid_kw_args.join(", ")
+          ]
+        elsif !valid_non_kw_args?
+          "Wrong number of arguments. Expected %s, got %s." % [
+            @signature.non_kw_args_arity_description,
+            non_kw_args.length
+          ]
+        end
+      end
+
+    private
+
+      def valid_non_kw_args?
+        @signature.valid_non_kw_args?(non_kw_args.length)
+      end
+
+      def missing_kw_args
+        @signature.missing_kw_args_from(kw_args)
+      end
+
+      def invalid_kw_args
+        @signature.invalid_kw_args_from(kw_args)
+      end
+
+      def split_args(*args)
+        kw_args = if @signature.has_kw_args_in?(args)
+                    args.pop.keys
+                  else
+                    []
+                  end
+
+        [args, kw_args]
+      end
+    end
+
+    # Figures out wether a given method can accept various arguments.
+    # Surprisingly non-trivial.
+    #
+    # @private
+    StrictSignatureVerifier = MethodSignatureVerifier
+
+    # Allows matchers to be used instead of providing keyword arguments. In
+    # practice, when this happens only the arity of the method is verified.
+    #
+    # @private
+    class LooseSignatureVerifier < MethodSignatureVerifier
+    private
+
+      def split_args(*args)
+        if RSpec::Support.is_a_matcher?(args.last) && @signature.could_contain_kw_args?(args)
+          args.pop
+          @signature = SignatureWithKeywordArgumentsMatcher.new(@signature)
+        end
+
+        super(*args)
+      end
+
+      # If a matcher is used in a signature in place of keyword arguments, all
+      # keyword argument validation needs to be skipped since the matcher is
+      # opaque.
+      #
+      # Instead, keyword arguments will be validated when the method is called
+      # and they are actually known.
+      #
+      # @private
+      class SignatureWithKeywordArgumentsMatcher
+        def initialize(signature)
+          @signature = signature
+        end
+
+        def missing_kw_args_from(_kw_args)
+          []
+        end
+
+        def invalid_kw_args_from(_kw_args)
+          []
+        end
+
+        def non_kw_args_arity_description
+          @signature.non_kw_args_arity_description
+        end
+
+        def valid_non_kw_args?(*args)
+          @signature.valid_non_kw_args?(*args)
+        end
+
+        def has_kw_args_in?(args)
+          @signature.has_kw_args_in?(args)
+        end
+      end
+    end
+  end
+end

data/path/gems/rspec-support-3.3.0/lib/rspec/support/object_formatter.rb

@@ -0,0 +1,93 @@
+module RSpec
+  module Support
+    # Provide additional output details beyond what `inspect` provides when
+    # printing Time, DateTime, or BigDecimal
+    module ObjectFormatter
+      # @api private
+      def self.format(object)
+        prepare_for_inspection(object).inspect
+      end
+
+      # rubocop:disable MethodLength
+
+      # @private
+      # Prepares the provided object to be formatted by wrapping it as needed
+      # in something that, when `inspect` is called on it, will produce the
+      # desired output.
+      #
+      # This allows us to apply the desired formatting to hash/array data structures
+      # at any level of nesting, simply by walking that structure and replacing items
+      # with custom items that have `inspect` defined to return the desired output
+      # for that item. Then we can just use `Array#inspect` or `Hash#inspect` to
+      # format the entire thing.
+      def self.prepare_for_inspection(object)
+        case object
+        when Array
+          return object.map { |o| prepare_for_inspection(o) }
+        when Hash
+          return prepare_hash(object)
+        when Time
+          inspection = format_time(object)
+        else
+          if defined?(DateTime) && DateTime === object
+            inspection = format_date_time(object)
+          elsif defined?(BigDecimal) && BigDecimal === object
+            inspection = "#{object.to_s 'F'} (#{object.inspect})"
+          elsif RSpec::Support.is_a_matcher?(object) && object.respond_to?(:description)
+            inspection = object.description
+          else
+            return object
+          end
+        end
+
+        InspectableItem.new(inspection)
+      end
+      # rubocop:enable MethodLength
+
+      # @private
+      def self.prepare_hash(input)
+        input.inject({}) do |hash, (k, v)|
+          hash[prepare_for_inspection(k)] = prepare_for_inspection(v)
+          hash
+        end
+      end
+
+      TIME_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+      if Time.method_defined?(:nsec)
+        # @private
+        def self.format_time(time)
+          time.strftime("#{TIME_FORMAT}.#{"%09d" % time.nsec} %z")
+        end
+      else # for 1.8.7
+        # @private
+        def self.format_time(time)
+          time.strftime("#{TIME_FORMAT}.#{"%06d" % time.usec} %z")
+        end
+      end
+
+      DATE_TIME_FORMAT = "%a, %d %b %Y %H:%M:%S.%N %z"
+      # ActiveSupport sometimes overrides inspect. If `ActiveSupport` is
+      # defined use a custom format string that includes more time precision.
+      # @private
+      def self.format_date_time(date_time)
+        if defined?(ActiveSupport)
+          date_time.strftime(DATE_TIME_FORMAT)
+        else
+          date_time.inspect
+        end
+      end
+
+      # @private
+      InspectableItem = Struct.new(:inspection) do
+        def inspect
+          inspection
+        end
+
+        def pretty_print(pp)
+          pp.text inspection
+        end
+      end
+    end
+  end
+end