jscop 0.1.2 → 0.1.3

data/vendor/cache/ruby/2.6.0/gems/rspec-expectations-3.9.1/lib/rspec/matchers/built_in/have_attributes.rb

@@ -1,114 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `have_attributes`.
-      # Not intended to be instantiated directly.
-      class HaveAttributes < BaseMatcher
-        # @private
-        attr_reader :respond_to_failed
-
-        def initialize(expected)
-          @expected = expected
-          @values = {}
-          @respond_to_failed = false
-          @negated = false
-        end
-
-        # @private
-        def actual
-          @values
-        end
-
-        # @api private
-        # @return [Boolean]
-        def matches?(actual)
-          @actual = actual
-          @negated = false
-          return false unless respond_to_attributes?
-          perform_match(:all?)
-        end
-
-        # @api private
-        # @return [Boolean]
-        def does_not_match?(actual)
-          @actual = actual
-          @negated = true
-          return false unless respond_to_attributes?
-          perform_match(:none?)
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          described_items = surface_descriptions_in(expected)
-          improve_hash_formatting "have attributes #{RSpec::Support::ObjectFormatter.format(described_items)}"
-        end
-
-        # @api private
-        # @return [Boolean]
-        def diffable?
-          !@respond_to_failed && !@negated
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          respond_to_failure_message_or do
-            "expected #{actual_formatted} to #{description} but had attributes #{ formatted_values }"
-          end
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          respond_to_failure_message_or { "expected #{actual_formatted} not to #{description}" }
-        end
-
-      private
-
-        def cache_all_values
-          @values = {}
-          expected.each do |attribute_key, _attribute_value|
-            actual_value = @actual.__send__(attribute_key)
-            @values[attribute_key] = actual_value
-          end
-        end
-
-        def perform_match(predicate)
-          cache_all_values
-          expected.__send__(predicate) do |attribute_key, attribute_value|
-            actual_has_attribute?(attribute_key, attribute_value)
-          end
-        end
-
-        def actual_has_attribute?(attribute_key, attribute_value)
-          values_match?(attribute_value, @values.fetch(attribute_key))
-        end
-
-        def respond_to_attributes?
-          matches = respond_to_matcher.matches?(@actual)
-          @respond_to_failed = !matches
-          matches
-        end
-
-        def respond_to_matcher
-          @respond_to_matcher ||= RespondTo.new(*expected.keys).with(0).arguments.tap { |m| m.ignoring_method_signature_failure! }
-        end
-
-        def respond_to_failure_message_or
-          if respond_to_failed
-            respond_to_matcher.failure_message
-          else
-            improve_hash_formatting(yield)
-          end
-        end
-
-        def formatted_values
-          values = RSpec::Support::ObjectFormatter.format(@values)
-          improve_hash_formatting(values)
-        end
-      end
-    end
-  end
-end

data/vendor/cache/ruby/2.6.0/gems/rspec-expectations-3.9.1/lib/rspec/matchers/built_in/include.rb

@@ -1,149 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `include`.
-      # Not intended to be instantiated directly.
-      class Include < BaseMatcher
-        # @private
-        attr_reader :expecteds
-
-        def initialize(*expecteds)
-          @expecteds = expecteds
-        end
-
-        # @api private
-        # @return [Boolean]
-        def matches?(actual)
-          actual = actual.to_hash if convert_to_hash?(actual)
-          perform_match(actual) { |v| v }
-        end
-
-        # @api private
-        # @return [Boolean]
-        def does_not_match?(actual)
-          actual = actual.to_hash if convert_to_hash?(actual)
-          perform_match(actual) { |v| !v }
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          improve_hash_formatting("include#{readable_list_of(expecteds)}")
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          format_failure_message("to") { super }
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          format_failure_message("not to") { super }
-        end
-
-        # @api private
-        # @return [Boolean]
-        def diffable?
-          !diff_would_wrongly_highlight_matched_item?
-        end
-
-        # @api private
-        # @return [Array, Hash]
-        def expected
-          if expecteds.one? && Hash === expecteds.first
-            expecteds.first
-          else
-            expecteds
-          end
-        end
-
-      private
-
-        def format_failure_message(preposition)
-          if actual.respond_to?(:include?)
-            improve_hash_formatting("expected #{description_of @actual} #{preposition} include#{readable_list_of @divergent_items}")
-          else
-            improve_hash_formatting(yield) + ", but it does not respond to `include?`"
-          end
-        end
-
-        def readable_list_of(items)
-          described_items = surface_descriptions_in(items)
-          if described_items.all? { |item| item.is_a?(Hash) }
-            " #{described_items.inject(:merge).inspect}"
-          else
-            EnglishPhrasing.list(described_items)
-          end
-        end
-
-        def perform_match(actual, &block)
-          @actual = actual
-          @divergent_items = excluded_from_actual(&block)
-          actual.respond_to?(:include?) && @divergent_items.empty?
-        end
-
-        def excluded_from_actual
-          return [] unless @actual.respond_to?(:include?)
-
-          expecteds.inject([]) do |memo, expected_item|
-            if comparing_hash_to_a_subset?(expected_item)
-              expected_item.each do |(key, value)|
-                memo << { key => value } unless yield actual_hash_includes?(key, value)
-              end
-            elsif comparing_hash_keys?(expected_item)
-              memo << expected_item unless yield actual_hash_has_key?(expected_item)
-            else
-              memo << expected_item unless yield actual_collection_includes?(expected_item)
-            end
-            memo
-          end
-        end
-
-        def comparing_hash_to_a_subset?(expected_item)
-          actual.is_a?(Hash) && expected_item.is_a?(Hash)
-        end
-
-        def actual_hash_includes?(expected_key, expected_value)
-          actual_value = actual.fetch(expected_key) { return false }
-          values_match?(expected_value, actual_value)
-        end
-
-        def comparing_hash_keys?(expected_item)
-          actual.is_a?(Hash) && !expected_item.is_a?(Hash)
-        end
-
-        def actual_hash_has_key?(expected_key)
-          # We check `key?` first for perf:
-          # `key?` is O(1), but `any?` is O(N).
-          actual.key?(expected_key) ||
-          actual.keys.any? { |key| values_match?(expected_key, key) }
-        end
-
-        def actual_collection_includes?(expected_item)
-          return true if actual.include?(expected_item)
-
-          # String lacks an `any?` method...
-          return false unless actual.respond_to?(:any?)
-
-          actual.any? { |value| values_match?(expected_item, value) }
-        end
-
-        def diff_would_wrongly_highlight_matched_item?
-          return false unless actual.is_a?(String) && expected.is_a?(Array)
-
-          lines = actual.split("\n")
-          expected.any? do |str|
-            actual.include?(str) && lines.none? { |line| line == str }
-          end
-        end
-
-        def convert_to_hash?(obj)
-          !obj.respond_to?(:include?) && obj.respond_to?(:to_hash)
-        end
-      end
-    end
-  end
-end

data/vendor/cache/ruby/2.6.0/gems/rspec-expectations-3.9.1/lib/rspec/matchers/built_in/match.rb

@@ -1,106 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `match`.
-      # Not intended to be instantiated directly.
-      class Match < BaseMatcher
-        def initialize(expected)
-          super(expected)
-
-          @expected_captures = nil
-        end
-        # @api private
-        # @return [String]
-        def description
-          if @expected_captures && @expected.match(actual)
-            "match #{surface_descriptions_in(expected).inspect} with captures #{surface_descriptions_in(@expected_captures).inspect}"
-          else
-            "match #{surface_descriptions_in(expected).inspect}"
-          end
-        end
-
-        # @api private
-        # @return [Boolean]
-        def diffable?
-          true
-        end
-
-        # Used to specify the captures we match against
-        # @return [self]
-        def with_captures(*captures)
-          @expected_captures = captures
-          self
-        end
-
-      private
-
-        def match(expected, actual)
-          return match_captures(expected, actual) if @expected_captures
-          return true if values_match?(expected, actual)
-          return false unless can_safely_call_match?(expected, actual)
-          actual.match(expected)
-        end
-
-        def can_safely_call_match?(expected, actual)
-          return false unless actual.respond_to?(:match)
-
-          !(RSpec::Matchers.is_a_matcher?(expected) &&
-            (String === actual || Regexp === actual))
-        end
-
-        def match_captures(expected, actual)
-          match = actual.match(expected)
-          if match
-            match = ReliableMatchData.new(match)
-            if match.names.empty?
-              values_match?(@expected_captures, match.captures)
-            else
-              expected_matcher = @expected_captures.last
-              values_match?(expected_matcher, Hash[match.names.zip(match.captures)]) ||
-                values_match?(expected_matcher, Hash[match.names.map(&:to_sym).zip(match.captures)]) ||
-                values_match?(@expected_captures, match.captures)
-            end
-          else
-            false
-          end
-        end
-      end
-
-      # @api private
-      # Used to wrap match data and make it reliable for 1.8.7
-      class ReliableMatchData
-        def initialize(match_data)
-          @match_data = match_data
-        end
-
-        if RUBY_VERSION == "1.8.7"
-          # @api private
-          # Returns match data names for named captures
-          # @return Array
-          def names
-            []
-          end
-        else
-          # @api private
-          # Returns match data names for named captures
-          # @return Array
-          def names
-            match_data.names
-          end
-        end
-
-        # @api private
-        # returns an array of captures from the match data
-        # @return Array
-        def captures
-          match_data.captures
-        end
-
-      protected
-
-        attr_reader :match_data
-      end
-    end
-  end
-end

data/vendor/cache/ruby/2.6.0/gems/rspec-expectations-3.9.1/lib/rspec/matchers/built_in/operators.rb

@@ -1,128 +0,0 @@
-require 'rspec/support'
-
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for operator matchers.
-      # Not intended to be instantiated directly.
-      # Only available for use with `should`.
-      class OperatorMatcher
-        class << self
-          # @private
-          def registry
-            @registry ||= {}
-          end
-
-          # @private
-          def register(klass, operator, matcher)
-            registry[klass] ||= {}
-            registry[klass][operator] = matcher
-          end
-
-          # @private
-          def unregister(klass, operator)
-            registry[klass] && registry[klass].delete(operator)
-          end
-
-          # @private
-          def get(klass, operator)
-            klass.ancestors.each do |ancestor|
-              matcher = registry[ancestor] && registry[ancestor][operator]
-              return matcher if matcher
-            end
-
-            nil
-          end
-        end
-
-        register Enumerable, '=~', BuiltIn::ContainExactly
-
-        def initialize(actual)
-          @actual = actual
-        end
-
-        # @private
-        def self.use_custom_matcher_or_delegate(operator)
-          define_method(operator) do |expected|
-            if !has_non_generic_implementation_of?(operator) && (matcher = OperatorMatcher.get(@actual.class, operator))
-              @actual.__send__(::RSpec::Matchers.last_expectation_handler.should_method, matcher.new(expected))
-            else
-              eval_match(@actual, operator, expected)
-            end
-          end
-
-          negative_operator = operator.sub(/^=/, '!')
-          if negative_operator != operator && respond_to?(negative_operator)
-            define_method(negative_operator) do |_expected|
-              opposite_should = ::RSpec::Matchers.last_expectation_handler.opposite_should_method
-              raise "RSpec does not support `#{::RSpec::Matchers.last_expectation_handler.should_method} #{negative_operator} expected`.  " \
-                "Use `#{opposite_should} #{operator} expected` instead."
-            end
-          end
-        end
-
-        ['==', '===', '=~', '>', '>=', '<', '<='].each do |operator|
-          use_custom_matcher_or_delegate operator
-        end
-
-        # @private
-        def fail_with_message(message)
-          RSpec::Expectations.fail_with(message, @expected, @actual)
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          "#{@operator} #{RSpec::Support::ObjectFormatter.format(@expected)}"
-        end
-
-      private
-
-        def has_non_generic_implementation_of?(op)
-          Support.method_handle_for(@actual, op).owner != ::Kernel
-        rescue NameError
-          false
-        end
-
-        def eval_match(actual, operator, expected)
-          ::RSpec::Matchers.last_matcher = self
-          @operator, @expected = operator, expected
-          __delegate_operator(actual, operator, expected)
-        end
-      end
-
-      # @private
-      # Handles operator matcher for `should`.
-      class PositiveOperatorMatcher < OperatorMatcher
-        def __delegate_operator(actual, operator, expected)
-          if actual.__send__(operator, expected)
-            true
-          else
-            expected_formatted = RSpec::Support::ObjectFormatter.format(expected)
-            actual_formatted   = RSpec::Support::ObjectFormatter.format(actual)
-
-            if ['==', '===', '=~'].include?(operator)
-              fail_with_message("expected: #{expected_formatted}\n     got: #{actual_formatted} (using #{operator})")
-            else
-              fail_with_message("expected: #{operator} #{expected_formatted}\n     got: #{operator.gsub(/./, ' ')} #{actual_formatted}")
-            end
-          end
-        end
-      end
-
-      # @private
-      # Handles operator matcher for `should_not`.
-      class NegativeOperatorMatcher < OperatorMatcher
-        def __delegate_operator(actual, operator, expected)
-          return false unless actual.__send__(operator, expected)
-
-          expected_formatted = RSpec::Support::ObjectFormatter.format(expected)
-          actual_formatted   = RSpec::Support::ObjectFormatter.format(actual)
-
-          fail_with_message("expected not: #{operator} #{expected_formatted}\n         got: #{operator.gsub(/./, ' ')} #{actual_formatted}")
-        end
-      end
-    end
-  end
-end

data/vendor/cache/ruby/2.6.0/gems/rspec-expectations-3.9.1/lib/rspec/matchers/built_in/output.rb

@@ -1,200 +0,0 @@
-require 'stringio'
-
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `output`.
-      # Not intended to be instantiated directly.
-      class Output < BaseMatcher
-        def initialize(expected)
-          @expected        = expected
-          @actual          = ""
-          @block           = nil
-          @stream_capturer = NullCapture
-        end
-
-        def matches?(block)
-          @block = block
-          return false unless Proc === block
-          @actual = @stream_capturer.capture(block)
-          @expected ? values_match?(@expected, @actual) : captured?
-        end
-
-        def does_not_match?(block)
-          !matches?(block) && Proc === block
-        end
-
-        # @api public
-        # Tells the matcher to match against stdout.
-        # Works only when the main Ruby process prints to stdout
-        def to_stdout
-          @stream_capturer = CaptureStdout
-          self
-        end
-
-        # @api public
-        # Tells the matcher to match against stderr.
-        # Works only when the main Ruby process prints to stderr
-        def to_stderr
-          @stream_capturer = CaptureStderr
-          self
-        end
-
-        # @api public
-        # Tells the matcher to match against stdout.
-        # Works when subprocesses print to stdout as well.
-        # This is significantly (~30x) slower than `to_stdout`
-        def to_stdout_from_any_process
-          @stream_capturer = CaptureStreamToTempfile.new("stdout", $stdout)
-          self
-        end
-
-        # @api public
-        # Tells the matcher to match against stderr.
-        # Works when subprocesses print to stderr as well.
-        # This is significantly (~30x) slower than `to_stderr`
-        def to_stderr_from_any_process
-          @stream_capturer = CaptureStreamToTempfile.new("stderr", $stderr)
-          self
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          "expected block to #{description}, but #{positive_failure_reason}"
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          "expected block to not #{description}, but #{negative_failure_reason}"
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          if @expected
-            "output #{description_of @expected} to #{@stream_capturer.name}"
-          else
-            "output to #{@stream_capturer.name}"
-          end
-        end
-
-        # @api private
-        # @return [Boolean]
-        def diffable?
-          true
-        end
-
-        # @api private
-        # Indicates this matcher matches against a block.
-        # @return [True]
-        def supports_block_expectations?
-          true
-        end
-
-      private
-
-        def captured?
-          @actual.length > 0
-        end
-
-        def positive_failure_reason
-          return "was not a block" unless Proc === @block
-          return "output #{actual_output_description}" if @expected
-          "did not"
-        end
-
-        def negative_failure_reason
-          return "was not a block" unless Proc === @block
-          "output #{actual_output_description}"
-        end
-
-        def actual_output_description
-          return "nothing" unless captured?
-          actual_formatted
-        end
-      end
-
-      # @private
-      module NullCapture
-        def self.name
-          "some stream"
-        end
-
-        def self.capture(_block)
-          raise "You must chain `to_stdout` or `to_stderr` off of the `output(...)` matcher."
-        end
-      end
-
-      # @private
-      module CaptureStdout
-        def self.name
-          'stdout'
-        end
-
-        def self.capture(block)
-          captured_stream = StringIO.new
-
-          original_stream = $stdout
-          $stdout = captured_stream
-
-          block.call
-
-          captured_stream.string
-        ensure
-          $stdout = original_stream
-        end
-      end
-
-      # @private
-      module CaptureStderr
-        def self.name
-          'stderr'
-        end
-
-        def self.capture(block)
-          captured_stream = StringIO.new
-
-          original_stream = $stderr
-          $stderr = captured_stream
-
-          block.call
-
-          captured_stream.string
-        ensure
-          $stderr = original_stream
-        end
-      end
-
-      # @private
-      class CaptureStreamToTempfile < Struct.new(:name, :stream)
-        def capture(block)
-          # We delay loading tempfile until it is actually needed because
-          # we want to minimize stdlibs loaded so that users who use a
-          # portion of the stdlib can't have passing specs while forgetting
-          # to load it themselves. `CaptureStreamToTempfile` is rarely used
-          # and `tempfile` pulls in a bunch of things (delegate, tmpdir,
-          # thread, fileutils, etc), so it's worth delaying it until this point.
-          require 'tempfile'
-
-          original_stream = stream.clone
-          captured_stream = Tempfile.new(name)
-
-          begin
-            captured_stream.sync = true
-            stream.reopen(captured_stream)
-            block.call
-            captured_stream.rewind
-            captured_stream.read
-          ensure
-            stream.reopen(original_stream)
-            captured_stream.close
-            captured_stream.unlink
-          end
-        end
-      end
-    end
-  end
-end