jscop 0.1.2 → 0.1.3

data/vendor/cache/ruby/2.6.0/gems/rspec-support-3.9.2/lib/rspec/support/differ.rb

@@ -1,215 +0,0 @@
-RSpec::Support.require_rspec_support 'encoded_string'
-RSpec::Support.require_rspec_support 'hunk_generator'
-RSpec::Support.require_rspec_support "object_formatter"
-
-require 'pp'
-
-module RSpec
-  module Support
-    # rubocop:disable ClassLength
-    class Differ
-      def diff(actual, expected)
-        diff = ""
-
-        unless actual.nil? || expected.nil?
-          if all_strings?(actual, expected)
-            if any_multiline_strings?(actual, expected)
-              diff = diff_as_string(coerce_to_string(actual), coerce_to_string(expected))
-            end
-          elsif no_procs?(actual, expected) && no_numbers?(actual, expected)
-            diff = diff_as_object(actual, expected)
-          end
-        end
-
-        diff.to_s
-      end
-
-      # rubocop:disable MethodLength
-      def diff_as_string(actual, expected)
-        encoding = EncodedString.pick_encoding(actual, expected)
-
-        actual   = EncodedString.new(actual, encoding)
-        expected = EncodedString.new(expected, encoding)
-
-        output = EncodedString.new("\n", encoding)
-        hunks = build_hunks(actual, expected)
-
-        hunks.each_cons(2) do |prev_hunk, current_hunk|
-          begin
-            if current_hunk.overlaps?(prev_hunk)
-              add_old_hunk_to_hunk(current_hunk, prev_hunk)
-            else
-              add_to_output(output, prev_hunk.diff(format_type).to_s)
-            end
-          ensure
-            add_to_output(output, "\n")
-          end
-        end
-
-        finalize_output(output, hunks.last.diff(format_type).to_s) if hunks.last
-
-        color_diff output
-      rescue Encoding::CompatibilityError
-        handle_encoding_errors(actual, expected)
-      end
-      # rubocop:enable MethodLength
-
-      def diff_as_object(actual, expected)
-        actual_as_string = object_to_string(actual)
-        expected_as_string = object_to_string(expected)
-        diff_as_string(actual_as_string, expected_as_string)
-      end
-
-      def color?
-        @color
-      end
-
-      def initialize(opts={})
-        @color = opts.fetch(:color, false)
-        @object_preparer = opts.fetch(:object_preparer, lambda { |string| string })
-      end
-
-    private
-
-      def no_procs?(*args)
-        safely_flatten(args).none? { |a| Proc === a }
-      end
-
-      def all_strings?(*args)
-        safely_flatten(args).all? { |a| String === a }
-      end
-
-      def any_multiline_strings?(*args)
-        all_strings?(*args) && safely_flatten(args).any? { |a| multiline?(a) }
-      end
-
-      def no_numbers?(*args)
-        safely_flatten(args).none? { |a| Numeric === a }
-      end
-
-      def coerce_to_string(string_or_array)
-        return string_or_array unless Array === string_or_array
-        diffably_stringify(string_or_array).join("\n")
-      end
-
-      def diffably_stringify(array)
-        array.map do |entry|
-          if Array === entry
-            entry.inspect
-          else
-            entry.to_s.gsub("\n", "\\n").gsub("\r", "\\r")
-          end
-        end
-      end
-
-      if String.method_defined?(:encoding)
-        def multiline?(string)
-          string.include?("\n".encode(string.encoding))
-        end
-      else
-        def multiline?(string)
-          string.include?("\n")
-        end
-      end
-
-      def build_hunks(actual, expected)
-        HunkGenerator.new(actual, expected).hunks
-      end
-
-      def finalize_output(output, final_line)
-        add_to_output(output, final_line)
-        add_to_output(output, "\n")
-      end
-
-      def add_to_output(output, string)
-        output << string
-      end
-
-      def add_old_hunk_to_hunk(hunk, oldhunk)
-        hunk.merge(oldhunk)
-      end
-
-      def safely_flatten(array)
-        array = array.flatten(1) until (array == array.flatten(1))
-        array
-      end
-
-      def format_type
-        :unified
-      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 normal(text)
-        color(text, 0)
-      end
-
-      def color_diff(diff)
-        return diff unless color?
-
-        diff.lines.map do |line|
-          case line[0].chr
-          when "+"
-            green line
-          when "-"
-            red line
-          when "@"
-            line[1].chr == "@" ? blue(line) : normal(line)
-          else
-            normal(line)
-          end
-        end.join
-      end
-
-      def object_to_string(object)
-        object = @object_preparer.call(object)
-        case object
-        when Hash
-          hash_to_string(object)
-        when Array
-          PP.pp(ObjectFormatter.prepare_for_inspection(object), "".dup)
-        when String
-          object =~ /\n/ ? object : object.inspect
-        else
-          PP.pp(object, "".dup)
-        end
-      end
-
-      def hash_to_string(hash)
-        formatted_hash = ObjectFormatter.prepare_for_inspection(hash)
-        formatted_hash.keys.sort_by { |k| k.to_s }.map do |key|
-          pp_key   = PP.singleline_pp(key, "".dup)
-          pp_value = PP.singleline_pp(formatted_hash[key], "".dup)
-
-          "#{pp_key} => #{pp_value},"
-        end.join("\n")
-      end
-
-      def handle_encoding_errors(actual, expected)
-        if actual.source_encoding != expected.source_encoding
-          "Could not produce a diff because the encoding of the actual string " \
-          "(#{actual.source_encoding}) differs from the encoding of the expected " \
-          "string (#{expected.source_encoding})"
-        else
-          "Could not produce a diff because of the encoding of the string " \
-          "(#{expected.source_encoding})"
-        end
-      end
-    end
-    # rubocop:enable ClassLength
-  end
-end

data/vendor/cache/ruby/2.6.0/gems/rspec-support-3.9.2/lib/rspec/support/directory_maker.rb

@@ -1,63 +0,0 @@
-RSpec::Support.require_rspec_support 'ruby_features'
-
-module RSpec
-  module Support
-    # @api private
-    #
-    # Replacement for fileutils#mkdir_p because we don't want to require parts
-    # of stdlib in RSpec.
-    class DirectoryMaker
-      # @api private
-      #
-      # Implements nested directory construction
-      def self.mkdir_p(path)
-        stack = generate_stack(path)
-        path.split(File::SEPARATOR).each do |part|
-          stack = generate_path(stack, part)
-          begin
-            Dir.mkdir(stack) unless directory_exists?(stack)
-          rescue Errno::EEXIST => e
-            raise e unless directory_exists?(stack)
-          rescue Errno::ENOTDIR => e
-            raise Errno::EEXIST, e.message
-          end
-        end
-      end
-
-      if OS.windows_file_path?
-        def self.generate_stack(path)
-          if path.start_with?(File::SEPARATOR)
-            File::SEPARATOR
-          elsif path[1] == ':'
-            ''
-          else
-            '.'
-          end
-        end
-        def self.generate_path(stack, part)
-          if stack == ''
-            part
-          elsif stack == File::SEPARATOR
-            File.join('', part)
-          else
-            File.join(stack, part)
-          end
-        end
-      else
-        def self.generate_stack(path)
-          path.start_with?(File::SEPARATOR) ? File::SEPARATOR : "."
-        end
-        def self.generate_path(stack, part)
-          File.join(stack, part)
-        end
-      end
-
-      def self.directory_exists?(dirname)
-        File.exist?(dirname) && File.directory?(dirname)
-      end
-      private_class_method :directory_exists?
-      private_class_method :generate_stack
-      private_class_method :generate_path
-    end
-  end
-end

data/vendor/cache/ruby/2.6.0/gems/rspec-support-3.9.2/lib/rspec/support/encoded_string.rb

@@ -1,161 +0,0 @@
-module RSpec
-  module Support
-    # @private
-    class EncodedString
-      # Reduce allocations by storing constants.
-      UTF_8    = "UTF-8"
-      US_ASCII = "US-ASCII"
-
-      # Ruby's default replacement string is:
-      #   U+FFFD ("\xEF\xBF\xBD"), for Unicode encoding forms, else
-      #   ?      ("\x3F")
-      REPLACE = "?"
-
-      def initialize(string, encoding=nil)
-        @encoding = encoding
-        @source_encoding = detect_source_encoding(string)
-        @string = matching_encoding(string)
-      end
-      attr_reader :source_encoding
-
-      delegated_methods = String.instance_methods.map(&:to_s) & %w[eql? lines == encoding empty?]
-      delegated_methods.each do |name|
-        define_method(name) { |*args, &block| @string.__send__(name, *args, &block) }
-      end
-
-      def <<(string)
-        @string << matching_encoding(string)
-      end
-
-      if Ruby.jruby?
-        def split(regex_or_string)
-          @string.split(matching_encoding(regex_or_string))
-        rescue ArgumentError
-          # JRuby raises an ArgumentError when splitting a source string that
-          # contains invalid bytes.
-          remove_invalid_bytes(@string).split regex_or_string
-        end
-      else
-        def split(regex_or_string)
-          @string.split(matching_encoding(regex_or_string))
-        end
-      end
-
-      def to_s
-        @string
-      end
-      alias :to_str :to_s
-
-      if String.method_defined?(:encoding)
-
-        private
-
-        # Encoding Exceptions:
-        #
-        # Raised by Encoding and String methods:
-        #   Encoding::UndefinedConversionError:
-        #     when a transcoding operation fails
-        #     if the String contains characters invalid for the target encoding
-        #     e.g. "\x80".encode('UTF-8','ASCII-8BIT')
-        #     vs "\x80".encode('UTF-8','ASCII-8BIT', undef: :replace, replace: '<undef>')
-        #     # => '<undef>'
-        #   Encoding::CompatibilityError
-        #     when Encoding.compatibile?(str1, str2) is nil
-        #     e.g. utf_16le_emoji_string.split("\n")
-        #     e.g. valid_unicode_string.encode(utf8_encoding) << ascii_string
-        #   Encoding::InvalidByteSequenceError:
-        #     when the string being transcoded contains a byte invalid for
-        #     either the source or target encoding
-        #     e.g. "\x80".encode('UTF-8','US-ASCII')
-        #     vs "\x80".encode('UTF-8','US-ASCII', invalid: :replace, replace: '<byte>')
-        #     # => '<byte>'
-        #   ArgumentError
-        #     when operating on a string with invalid bytes
-        #     e.g."\x80".split("\n")
-        #   TypeError
-        #     when a symbol is passed as an encoding
-        #     Encoding.find(:"UTF-8")
-        #     when calling force_encoding on an object
-        #     that doesn't respond to #to_str
-        #
-        # Raised by transcoding methods:
-        #   Encoding::ConverterNotFoundError:
-        #     when a named encoding does not correspond with a known converter
-        #     e.g. 'abc'.force_encoding('UTF-8').encode('foo')
-        #     or a converter path cannot be found
-        #     e.g. "\x80".force_encoding('ASCII-8BIT').encode('Emacs-Mule')
-        #
-        # Raised by byte <-> char conversions
-        #   RangeError: out of char range
-        #     e.g. the UTF-16LE emoji: 128169.chr
-        def matching_encoding(string)
-          string = remove_invalid_bytes(string)
-          string.encode(@encoding)
-        rescue Encoding::UndefinedConversionError, Encoding::InvalidByteSequenceError
-          # Originally defined as a constant to avoid uneeded allocations, this hash must
-          # be defined inline (without {}) to avoid warnings on Ruby 2.7
-          #
-          # In MRI 2.1 'invalid: :replace' changed to also replace an invalid byte sequence
-          # see https://github.com/ruby/ruby/blob/v2_1_0/NEWS#L176
-          # https://www.ruby-forum.com/topic/6861247
-          # https://twitter.com/nalsh/status/553413844685438976
-          #
-          # For example, given:
-          #   "\x80".force_encoding("Emacs-Mule").encode(:invalid => :replace).bytes.to_a
-          #
-          # On MRI 2.1 or above: 63  # '?'
-          # else               : 128 # "\x80"
-          #
-          string.encode(@encoding, :invalid => :replace, :undef => :replace, :replace => REPLACE)
-        rescue Encoding::ConverterNotFoundError
-          # Originally defined as a constant to avoid uneeded allocations, this hash must
-          # be defined inline (without {}) to avoid warnings on Ruby 2.7
-          string.dup.force_encoding(@encoding).encode(:invalid => :replace, :replace => REPLACE)
-        end
-
-        # Prevents raising ArgumentError
-        if String.method_defined?(:scrub)
-          # https://github.com/ruby/ruby/blob/eeb05e8c11/doc/NEWS-2.1.0#L120-L123
-          # https://github.com/ruby/ruby/blob/v2_1_0/string.c#L8242
-          # https://github.com/hsbt/string-scrub
-          # https://github.com/rubinius/rubinius/blob/v2.5.2/kernel/common/string.rb#L1913-L1972
-          def remove_invalid_bytes(string)
-            string.scrub(REPLACE)
-          end
-        else
-          # http://stackoverflow.com/a/8711118/879854
-          # Loop over chars in a string replacing chars
-          # with invalid encoding, which is a pretty good proxy
-          # for the invalid byte sequence that causes an ArgumentError
-          def remove_invalid_bytes(string)
-            string.chars.map do |char|
-              char.valid_encoding? ? char : REPLACE
-            end.join
-          end
-        end
-
-        def detect_source_encoding(string)
-          string.encoding
-        end
-
-        def self.pick_encoding(source_a, source_b)
-          Encoding.compatible?(source_a, source_b) || Encoding.default_external
-        end
-      else
-
-        def self.pick_encoding(_source_a, _source_b)
-        end
-
-        private
-
-        def matching_encoding(string)
-          string
-        end
-
-        def detect_source_encoding(_string)
-          US_ASCII
-        end
-      end
-    end
-  end
-end

data/vendor/cache/ruby/2.6.0/gems/rspec-support-3.9.2/lib/rspec/support/fuzzy_matcher.rb

@@ -1,48 +0,0 @@
-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/vendor/cache/ruby/2.6.0/gems/rspec-support-3.9.2/lib/rspec/support/hunk_generator.rb

@@ -1,47 +0,0 @@
-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/vendor/cache/ruby/2.6.0/gems/rspec-support-3.9.2/lib/rspec/support/matcher_definition.rb

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