jscop 0.1.2 → 0.1.3

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

@@ -1,275 +0,0 @@
-RSpec::Support.require_rspec_support 'matcher_definition'
-
-module RSpec
-  module Support
-    # Provide additional output details beyond what `inspect` provides when
-    # printing Time, DateTime, or BigDecimal
-    # @api private
-    class ObjectFormatter # rubocop:disable Metrics/ClassLength
-      ELLIPSIS = "..."
-
-      attr_accessor :max_formatted_output_length
-
-      # Methods are deferred to a default instance of the class to maintain the interface
-      # For example, calling ObjectFormatter.format is still possible
-      def self.default_instance
-        @default_instance ||= new
-      end
-
-      def self.format(object)
-        default_instance.format(object)
-      end
-
-      def self.prepare_for_inspection(object)
-        default_instance.prepare_for_inspection(object)
-      end
-
-      def initialize(max_formatted_output_length=200)
-        @max_formatted_output_length = max_formatted_output_length
-        @current_structure_stack = []
-      end
-
-      def format(object)
-        if max_formatted_output_length.nil?
-          prepare_for_inspection(object).inspect
-        else
-          formatted_object = prepare_for_inspection(object).inspect
-          if formatted_object.length < max_formatted_output_length
-            formatted_object
-          else
-            beginning = truncate_string formatted_object, 0, max_formatted_output_length / 2
-            ending = truncate_string formatted_object, -max_formatted_output_length / 2, -1
-            beginning + ELLIPSIS + ending
-          end
-        end
-      end
-
-      # 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 prepare_for_inspection(object)
-        case object
-        when Array
-          prepare_array(object)
-        when Hash
-          prepare_hash(object)
-        else
-          inspector_class = INSPECTOR_CLASSES.find { |inspector| inspector.can_inspect?(object) }
-          inspector_class.new(object, self)
-        end
-      end
-
-      def prepare_array(array)
-        with_entering_structure(array) do
-          array.map { |element| prepare_element(element) }
-        end
-      end
-
-      def prepare_hash(input_hash)
-        with_entering_structure(input_hash) do
-          sort_hash_keys(input_hash).inject({}) do |output_hash, key_and_value|
-            key, value = key_and_value.map { |element| prepare_element(element) }
-            output_hash[key] = value
-            output_hash
-          end
-        end
-      end
-
-      def sort_hash_keys(input_hash)
-        if input_hash.keys.all? { |k| k.is_a?(String) || k.is_a?(Symbol) }
-          Hash[input_hash.sort_by { |k, _v| k.to_s }]
-        else
-          input_hash
-        end
-      end
-
-      def prepare_element(element)
-        if recursive_structure?(element)
-          case element
-          when Array then InspectableItem.new('[...]')
-          when Hash then InspectableItem.new('{...}')
-          else raise # This won't happen
-          end
-        else
-          prepare_for_inspection(element)
-        end
-      end
-
-      def with_entering_structure(structure)
-        @current_structure_stack.push(structure)
-        return_value = yield
-        @current_structure_stack.pop
-        return_value
-      end
-
-      def recursive_structure?(object)
-        @current_structure_stack.any? { |seen_structure| seen_structure.equal?(object) }
-      end
-
-      InspectableItem = Struct.new(:text) do
-        def inspect
-          text
-        end
-
-        def pretty_print(pp)
-          pp.text(text)
-        end
-      end
-
-      BaseInspector = Struct.new(:object, :formatter) do
-        def self.can_inspect?(_object)
-          raise NotImplementedError
-        end
-
-        def inspect
-          raise NotImplementedError
-        end
-
-        def pretty_print(pp)
-          pp.text(inspect)
-        end
-      end
-
-      class TimeInspector < BaseInspector
-        FORMAT = "%Y-%m-%d %H:%M:%S"
-
-        def self.can_inspect?(object)
-          Time === object
-        end
-
-        if Time.method_defined?(:nsec)
-          def inspect
-            object.strftime("#{FORMAT}.#{"%09d" % object.nsec} %z")
-          end
-        else # for 1.8.7
-          def inspect
-            object.strftime("#{FORMAT}.#{"%06d" % object.usec} %z")
-          end
-        end
-      end
-
-      class DateTimeInspector < BaseInspector
-        FORMAT = "%a, %d %b %Y %H:%M:%S.%N %z"
-
-        def self.can_inspect?(object)
-          defined?(DateTime) && DateTime === object
-        end
-
-        # ActiveSupport sometimes overrides inspect. If `ActiveSupport` is
-        # defined use a custom format string that includes more time precision.
-        def inspect
-          if defined?(ActiveSupport)
-            object.strftime(FORMAT)
-          else
-            object.inspect
-          end
-        end
-      end
-
-      class BigDecimalInspector < BaseInspector
-        def self.can_inspect?(object)
-          defined?(BigDecimal) && BigDecimal === object
-        end
-
-        def inspect
-          "#{object.to_s('F')} (#{object.inspect})"
-        end
-      end
-
-      class DescribableMatcherInspector < BaseInspector
-        def self.can_inspect?(object)
-          Support.is_a_matcher?(object) && object.respond_to?(:description)
-        end
-
-        def inspect
-          object.description
-        end
-      end
-
-      class UninspectableObjectInspector < BaseInspector
-        OBJECT_ID_FORMAT = '%#016x'
-
-        def self.can_inspect?(object)
-          object.inspect
-          false
-        rescue NoMethodError
-          true
-        end
-
-        def inspect
-          "#<#{klass}:#{native_object_id}>"
-        end
-
-        def klass
-          Support.class_of(object)
-        end
-
-        # http://stackoverflow.com/a/2818916
-        def native_object_id
-          OBJECT_ID_FORMAT % (object.__id__ << 1)
-        rescue NoMethodError
-          # In Ruby 1.9.2, BasicObject responds to none of #__id__, #object_id, #id...
-          '-'
-        end
-      end
-
-      class DelegatorInspector < BaseInspector
-        def self.can_inspect?(object)
-          defined?(Delegator) && Delegator === object
-        end
-
-        def inspect
-          "#<#{object.class}(#{formatter.format(object.send(:__getobj__))})>"
-        end
-      end
-
-      class InspectableObjectInspector < BaseInspector
-        def self.can_inspect?(object)
-          object.inspect
-          true
-        rescue NoMethodError
-          false
-        end
-
-        def inspect
-          object.inspect
-        end
-      end
-
-      INSPECTOR_CLASSES = [
-        TimeInspector,
-        DateTimeInspector,
-        BigDecimalInspector,
-        UninspectableObjectInspector,
-        DescribableMatcherInspector,
-        DelegatorInspector,
-        InspectableObjectInspector
-      ].tap do |classes|
-        # 2.4 has improved BigDecimal formatting so we do not need
-        # to provide our own.
-        # https://github.com/ruby/bigdecimal/pull/42
-        classes.delete(BigDecimalInspector) if RUBY_VERSION >= '2.4'
-      end
-
-    private
-
-      # Returns the substring defined by the start_index and end_index
-      # If the string ends with a partial ANSI code code then that
-      # will be removed as printing partial ANSI
-      # codes to the terminal can lead to corruption
-      def truncate_string(str, start_index, end_index)
-        cut_str = str[start_index..end_index]
-
-        # ANSI color codes are like: \e[33m so anything with \e[ and a
-        # number without a 'm' is an incomplete color code
-        cut_str.sub(/\e\[\d+$/, '')
-      end
-    end
-  end
-end

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

@@ -1,76 +0,0 @@
-module RSpec
-  module Support
-    # Provides recursive constant lookup methods useful for
-    # constant stubbing.
-    module RecursiveConstMethods
-      # We only want to consider constants that are defined directly on a
-      # particular module, and not include top-level/inherited constants.
-      # Unfortunately, the constant API changed between 1.8 and 1.9, so
-      # we need to conditionally define methods to ignore the top-level/inherited
-      # constants.
-      #
-      # Given:
-      #   class A; B = 1; end
-      #   class C < A; end
-      #
-      # On 1.8:
-      #   - C.const_get("Hash") # => ::Hash
-      #   - C.const_defined?("Hash") # => false
-      #   - C.constants # => ["B"]
-      #   - None of these methods accept the extra `inherit` argument
-      # On 1.9:
-      #   - C.const_get("Hash") # => ::Hash
-      #   - C.const_defined?("Hash") # => true
-      #   - C.const_get("Hash", false) # => raises NameError
-      #   - C.const_defined?("Hash", false) # => false
-      #   - C.constants # => [:B]
-      #   - C.constants(false) #=> []
-      if Module.method(:const_defined?).arity == 1
-        def const_defined_on?(mod, const_name)
-          mod.const_defined?(const_name)
-        end
-
-        def get_const_defined_on(mod, const_name)
-          return mod.const_get(const_name) if const_defined_on?(mod, const_name)
-
-          raise NameError, "uninitialized constant #{mod.name}::#{const_name}"
-        end
-
-        def constants_defined_on(mod)
-          mod.constants.select { |c| const_defined_on?(mod, c) }
-        end
-      else
-        def const_defined_on?(mod, const_name)
-          mod.const_defined?(const_name, false)
-        end
-
-        def get_const_defined_on(mod, const_name)
-          mod.const_get(const_name, false)
-        end
-
-        def constants_defined_on(mod)
-          mod.constants(false)
-        end
-      end
-
-      def recursive_const_get(const_name)
-        normalize_const_name(const_name).split('::').inject(Object) do |mod, name|
-          get_const_defined_on(mod, name)
-        end
-      end
-
-      def recursive_const_defined?(const_name)
-        parts = normalize_const_name(const_name).split('::')
-        parts.inject([Object, '']) do |(mod, full_name), name|
-          yield(full_name, name) if block_given? && !(Module === mod)
-          return false unless const_defined_on?(mod, name)
-          [get_const_defined_on(mod, name), [mod.name, name].join('::')]
-        end
-      end
-
-      def normalize_const_name(const_name)
-        const_name.sub(/\A::/, '')
-      end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-module RSpec
-  module Support
-    # Allows a thread to lock out other threads from a critical section of code,
-    # while allowing the thread with the lock to reenter that section.
-    #
-    # Based on Monitor as of 2.2 -
-    # https://github.com/ruby/ruby/blob/eb7ddaa3a47bf48045d26c72eb0f263a53524ebc/lib/monitor.rb#L9
-    #
-    # Depends on Mutex, but Mutex is only available as part of core since 1.9.1:
-    #   exists - http://ruby-doc.org/core-1.9.1/Mutex.html
-    #   dne    - http://ruby-doc.org/core-1.9.0/Mutex.html
-    #
-    # @private
-    class ReentrantMutex
-      def initialize
-        @owner = nil
-        @count = 0
-        @mutex = Mutex.new
-      end
-
-      def synchronize
-        enter
-        yield
-      ensure
-        exit
-      end
-
-    private
-
-      def enter
-        @mutex.lock if @owner != Thread.current
-        @owner = Thread.current
-        @count += 1
-      end
-
-      def exit
-        @count -= 1
-        return unless @count == 0
-        @owner = nil
-        @mutex.unlock
-      end
-    end
-
-    if defined? ::Mutex
-      # On 1.9 and up, this is in core, so we just use the real one
-      Mutex = ::Mutex
-    else # For 1.8.7
-      # :nocov:
-      RSpec::Support.require_rspec_support "mutex"
-      # :nocov:
-    end
-  end
-end

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

@@ -1,185 +0,0 @@
-require 'rbconfig'
-RSpec::Support.require_rspec_support "comparable_version"
-
-module RSpec
-  module Support
-    # @api private
-    #
-    # Provides query methods for different OS or OS features.
-    module OS
-      module_function
-
-      def windows?
-        !!(RbConfig::CONFIG['host_os'] =~ /cygwin|mswin|mingw|bccwin|wince|emx/)
-      end
-
-      def windows_file_path?
-        ::File::ALT_SEPARATOR == '\\'
-      end
-    end
-
-    # @api private
-    #
-    # Provides query methods for different rubies
-    module Ruby
-      module_function
-
-      def jruby?
-        RUBY_PLATFORM == 'java'
-      end
-
-      def jruby_version
-        @jruby_version ||= ComparableVersion.new(JRUBY_VERSION)
-      end
-
-      def jruby_9000?
-        jruby? && JRUBY_VERSION >= '9.0.0.0'
-      end
-
-      def rbx?
-        defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
-      end
-
-      def non_mri?
-        !mri?
-      end
-
-      def mri?
-        !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby'
-      end
-    end
-
-    # @api private
-    #
-    # Provides query methods for ruby features that differ among
-    # implementations.
-    module RubyFeatures
-      module_function
-
-      if Ruby.jruby?
-        # On JRuby 1.7 `--1.8` mode, `Process.respond_to?(:fork)` returns true,
-        # but when you try to fork, it raises an error:
-        #   NotImplementedError: fork is not available on this platform
-        #
-        # When we drop support for JRuby 1.7 and/or Ruby 1.8, we can drop
-        # this special case.
-        def fork_supported?
-          false
-        end
-      else
-        def fork_supported?
-          Process.respond_to?(:fork)
-        end
-      end
-
-      def optional_and_splat_args_supported?
-        Method.method_defined?(:parameters)
-      end
-
-      def caller_locations_supported?
-        respond_to?(:caller_locations, true)
-      end
-
-      if Exception.method_defined?(:cause)
-        def supports_exception_cause?
-          true
-        end
-      else
-        def supports_exception_cause?
-          false
-        end
-      end
-
-      if RUBY_VERSION.to_f >= 2.7
-        def supports_taint?
-          false
-        end
-      else
-        def supports_taint?
-          true
-        end
-      end
-      ripper_requirements = [ComparableVersion.new(RUBY_VERSION) >= '1.9.2']
-
-      ripper_requirements.push(false) if Ruby.rbx?
-
-      if Ruby.jruby?
-        ripper_requirements.push(Ruby.jruby_version >= '1.7.5')
-        # Ripper on JRuby 9.0.0.0.rc1 - 9.1.8.0 reports wrong line number
-        # or cannot parse source including `:if`.
-        ripper_requirements.push(!Ruby.jruby_version.between?('9.0.0.0.rc1', '9.1.8.0'))
-      end
-
-      if ripper_requirements.all?
-        def ripper_supported?
-          true
-        end
-      else
-        def ripper_supported?
-          false
-        end
-      end
-
-      if Ruby.mri?
-        def kw_args_supported?
-          RUBY_VERSION >= '2.0.0'
-        end
-
-        def required_kw_args_supported?
-          RUBY_VERSION >= '2.1.0'
-        end
-
-        def supports_rebinding_module_methods?
-          RUBY_VERSION.to_i >= 2
-        end
-      else
-        # RBX / JRuby et al support is unknown for keyword arguments
-        begin
-          eval("o = Object.new; def o.m(a: 1); end;"\
-               " raise SyntaxError unless o.method(:m).parameters.include?([:key, :a])")
-
-          def kw_args_supported?
-            true
-          end
-        rescue SyntaxError
-          def kw_args_supported?
-            false
-          end
-        end
-
-        begin
-          eval("o = Object.new; def o.m(a: ); end;"\
-               "raise SyntaxError unless o.method(:m).parameters.include?([:keyreq, :a])")
-
-          def required_kw_args_supported?
-            true
-          end
-        rescue SyntaxError
-          def required_kw_args_supported?
-            false
-          end
-        end
-
-        begin
-          Module.new { def foo; end }.instance_method(:foo).bind(Object.new)
-
-          def supports_rebinding_module_methods?
-            true
-          end
-        rescue TypeError
-          def supports_rebinding_module_methods?
-            false
-          end
-        end
-      end
-
-      def module_refinement_supported?
-        Module.method_defined?(:refine) || Module.private_method_defined?(:refine)
-      end
-
-      def module_prepends_supported?
-        Module.method_defined?(:prepend) || Module.private_method_defined?(:prepend)
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-module RSpec
-  module Support
-    class Source
-      # @private
-      # Represents a source location of node or token.
-      Location = Struct.new(:line, :column) do
-        include Comparable
-
-        def self.location?(array)
-          array.is_a?(Array) && array.size == 2 && array.all? { |e| e.is_a?(Integer) }
-        end
-
-        def <=>(other)
-          line_comparison = (line <=> other.line)
-          return line_comparison unless line_comparison == 0
-          column <=> other.column
-        end
-      end
-    end
-  end
-end