jscop 0.1.2

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

@@ -0,0 +1,230 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Provides the implementation for `raise_error`.
+      # Not intended to be instantiated directly.
+      # rubocop:disable ClassLength
+      # rubocop:disable RescueException
+      class RaiseError
+        include Composable
+
+        def initialize(expected_error_or_message=nil, expected_message=nil, &block)
+          @block = block
+          @actual_error = nil
+          @warn_about_bare_error = expected_error_or_message.nil?
+
+          case expected_error_or_message
+          when nil
+            @expected_error = Exception
+            @expected_message = expected_message
+          when String
+            @expected_error = Exception
+            @expected_message = expected_error_or_message
+          else
+            @expected_error = expected_error_or_message
+            @expected_message = expected_message
+          end
+        end
+
+        # @api public
+        # Specifies the expected error message.
+        def with_message(expected_message)
+          raise_message_already_set if @expected_message
+          @warn_about_bare_error = false
+          @expected_message = expected_message
+          self
+        end
+
+        # rubocop:disable MethodLength
+        # @private
+        def matches?(given_proc, negative_expectation=false, &block)
+          @given_proc = given_proc
+          @block ||= block
+          @raised_expected_error = false
+          @with_expected_message = false
+          @eval_block = false
+          @eval_block_passed = false
+
+          return false unless Proc === given_proc
+
+          begin
+            given_proc.call
+          rescue Exception => @actual_error
+            if values_match?(@expected_error, @actual_error) ||
+               values_match?(@expected_error, @actual_error.message)
+              @raised_expected_error = true
+              @with_expected_message = verify_message
+            end
+          end
+
+          warn_about_bare_error if warning_about_bare_error && !negative_expectation
+          eval_block if !negative_expectation && ready_to_eval_block?
+
+          expectation_matched?
+        end
+        # rubocop:enable MethodLength
+
+        # @private
+        def does_not_match?(given_proc)
+          warn_for_false_positives
+          !matches?(given_proc, :negative_expectation) && Proc === given_proc
+        end
+
+        # @private
+        def supports_block_expectations?
+          true
+        end
+
+        def expects_call_stack_jump?
+          true
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message
+          @eval_block ? @actual_error.message : "expected #{expected_error}#{given_error}"
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          "expected no #{expected_error}#{given_error}"
+        end
+
+        # @api private
+        # @return [String]
+        def description
+          "raise #{expected_error}"
+        end
+
+      private
+
+        def expectation_matched?
+          error_and_message_match? && block_matches?
+        end
+
+        def error_and_message_match?
+          @raised_expected_error && @with_expected_message
+        end
+
+        def block_matches?
+          @eval_block ? @eval_block_passed : true
+        end
+
+        def ready_to_eval_block?
+          @raised_expected_error && @with_expected_message && @block
+        end
+
+        def eval_block
+          @eval_block = true
+          begin
+            @block[@actual_error]
+            @eval_block_passed = true
+          rescue Exception => err
+            @actual_error = err
+          end
+        end
+
+        def verify_message
+          return true if @expected_message.nil?
+          values_match?(@expected_message, @actual_error.message.to_s)
+        end
+
+        def warn_for_false_positives
+          expression = if expecting_specific_exception? && @expected_message
+                         "`expect { }.not_to raise_error(SpecificErrorClass, message)`"
+                       elsif expecting_specific_exception?
+                         "`expect { }.not_to raise_error(SpecificErrorClass)`"
+                       elsif @expected_message
+                         "`expect { }.not_to raise_error(message)`"
+                       end
+
+          return unless expression
+
+          warn_about_negative_false_positive expression
+        end
+
+        def handle_warning(message)
+          RSpec::Expectations.configuration.false_positives_handler.call(message)
+        end
+
+        def warning_about_bare_error
+          @warn_about_bare_error && @block.nil?
+        end
+
+        def warn_about_bare_error
+          handle_warning("Using the `raise_error` matcher without providing a specific " \
+                         "error or message risks false positives, since `raise_error` " \
+                         "will match when Ruby raises a `NoMethodError`, `NameError` or " \
+                         "`ArgumentError`, potentially allowing the expectation to pass " \
+                         "without even executing the method you are intending to call. " \
+                         "#{warning}"\
+                         "Instead consider providing a specific error class or message. " \
+                         "This message can be suppressed by setting: " \
+                         "`RSpec::Expectations.configuration.on_potential_false" \
+                         "_positives = :nothing`")
+        end
+
+        def warn_about_negative_false_positive(expression)
+          handle_warning("Using #{expression} risks false positives, since literally " \
+                         "any other error would cause the expectation to pass, " \
+                         "including those raised by Ruby (e.g. NoMethodError, NameError " \
+                         "and ArgumentError), meaning the code you are intending to test " \
+                         "may not even get reached. Instead consider using " \
+                         "`expect { }.not_to raise_error` or `expect { }.to raise_error" \
+                         "(DifferentSpecificErrorClass)`. This message can be suppressed by " \
+                         "setting: `RSpec::Expectations.configuration.on_potential_false" \
+                         "_positives = :nothing`")
+        end
+
+        def expected_error
+          case @expected_message
+          when nil
+            if RSpec::Support.is_a_matcher?(@expected_error)
+              "Exception with #{description_of(@expected_error)}"
+            else
+              description_of(@expected_error)
+            end
+          when Regexp
+            "#{@expected_error} with message matching #{description_of(@expected_message)}"
+          else
+            "#{@expected_error} with #{description_of(@expected_message)}"
+          end
+        end
+
+        def format_backtrace(backtrace)
+          formatter = Matchers.configuration.backtrace_formatter
+          formatter.format_backtrace(backtrace)
+        end
+
+        def given_error
+          return " but was not given a block" unless Proc === @given_proc
+          return " but nothing was raised" unless @actual_error
+
+          backtrace = format_backtrace(@actual_error.backtrace)
+          [
+            ", got #{description_of(@actual_error)} with backtrace:",
+            *backtrace
+          ].join("\n  # ")
+        end
+
+        def expecting_specific_exception?
+          @expected_error != Exception
+        end
+
+        def raise_message_already_set
+          raise "`expect { }.to raise_error(message).with_message(message)` is not valid. " \
+                'The matcher only allows the expected message to be specified once'
+        end
+
+        def warning
+          warning = "Actual error raised was #{description_of(@actual_error)}. "
+          warning if @actual_error
+        end
+      end
+      # rubocop:enable RescueException
+      # rubocop:enable ClassLength
+    end
+  end
+end

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

@@ -0,0 +1,199 @@
+RSpec::Support.require_rspec_support "method_signature_verifier"
+
+# TODO: Refactor this file to be under our class length
+# rubocop:disable ClassLength
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Provides the implementation for `respond_to`.
+      # Not intended to be instantiated directly.
+      class RespondTo < BaseMatcher
+        def initialize(*names)
+          @names = names
+          @expected_arity = nil
+          @expected_keywords = []
+          @ignoring_method_signature_failure = false
+          @unlimited_arguments = nil
+          @arbitrary_keywords = nil
+        end
+
+        # @api public
+        # Specifies the number of expected arguments.
+        #
+        # @example
+        #   expect(obj).to respond_to(:message).with(3).arguments
+        def with(n)
+          @expected_arity = n
+          self
+        end
+
+        # @api public
+        # Specifies keyword arguments, if any.
+        #
+        # @example
+        #   expect(obj).to respond_to(:message).with_keywords(:color, :shape)
+        # @example with an expected number of arguments
+        #   expect(obj).to respond_to(:message).with(3).arguments.and_keywords(:color, :shape)
+        def with_keywords(*keywords)
+          @expected_keywords = keywords
+          self
+        end
+        alias :and_keywords :with_keywords
+
+        # @api public
+        # Specifies that the method accepts any keyword, i.e. the method has
+        #   a splatted keyword parameter of the form **kw_args.
+        #
+        # @example
+        #   expect(obj).to respond_to(:message).with_any_keywords
+        def with_any_keywords
+          @arbitrary_keywords = true
+          self
+        end
+        alias :and_any_keywords :with_any_keywords
+
+        # @api public
+        # Specifies that the number of arguments has no upper limit, i.e. the
+        #   method has a splatted parameter of the form *args.
+        #
+        # @example
+        #   expect(obj).to respond_to(:message).with_unlimited_arguments
+        def with_unlimited_arguments
+          @unlimited_arguments = true
+          self
+        end
+        alias :and_unlimited_arguments :with_unlimited_arguments
+
+        # @api public
+        # No-op. Intended to be used as syntactic sugar when using `with`.
+        #
+        # @example
+        #   expect(obj).to respond_to(:message).with(3).arguments
+        def argument
+          self
+        end
+        alias :arguments :argument
+
+        # @private
+        def matches?(actual)
+          find_failing_method_names(actual, :reject).empty?
+        end
+
+        # @private
+        def does_not_match?(actual)
+          find_failing_method_names(actual, :select).empty?
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message
+          "expected #{actual_formatted} to respond to #{@failing_method_names.map { |name| description_of(name) }.join(', ')}#{with_arity}"
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          failure_message.sub(/to respond to/, 'not to respond to')
+        end
+
+        # @api private
+        # @return [String]
+        def description
+          "respond to #{pp_names}#{with_arity}"
+        end
+
+        # @api private
+        # Used by other matchers to suppress a check
+        def ignoring_method_signature_failure!
+          @ignoring_method_signature_failure = true
+        end
+
+      private
+
+        def find_failing_method_names(actual, filter_method)
+          @actual = actual
+          @failing_method_names = @names.__send__(filter_method) do |name|
+            @actual.respond_to?(name) && matches_arity?(actual, name)
+          end
+        end
+
+        def setup_method_signature_expectation
+          expectation = Support::MethodSignatureExpectation.new
+
+          if @expected_arity.is_a?(Range)
+            expectation.min_count = @expected_arity.min
+            expectation.max_count = @expected_arity.max
+          else
+            expectation.min_count = @expected_arity
+          end
+
+          expectation.keywords = @expected_keywords
+          expectation.expect_unlimited_arguments = @unlimited_arguments
+          expectation.expect_arbitrary_keywords  = @arbitrary_keywords
+
+          expectation
+        end
+
+        def matches_arity?(actual, name)
+          expectation = setup_method_signature_expectation
+
+          return true if expectation.empty?
+
+          begin
+            Support::StrictSignatureVerifier.new(method_signature_for(actual, name)).
+              with_expectation(expectation).valid?
+          rescue NameError
+            return true if @ignoring_method_signature_failure
+            raise ArgumentError, "The #{matcher_name} matcher requires that " \
+                                 "the actual object define the method(s) in " \
+                                 "order to check arity, but the method " \
+                                 "`#{name}` is not defined. Remove the arity " \
+                                 "check or define the method to continue."
+          end
+        end
+
+        def method_signature_for(actual, name)
+          method_handle = Support.method_handle_for(actual, name)
+
+          if name == :new && method_handle.owner === ::Class && ::Class === actual
+            Support::MethodSignature.new(actual.instance_method(:initialize))
+          else
+            Support::MethodSignature.new(method_handle)
+          end
+        end
+
+        def with_arity
+          str = ''.dup
+          str << " with #{with_arity_string}" if @expected_arity
+          str << " #{str.length == 0 ? 'with' : 'and'} #{with_keywords_string}" if @expected_keywords && @expected_keywords.count > 0
+          str << " #{str.length == 0 ? 'with' : 'and'} unlimited arguments" if @unlimited_arguments
+          str << " #{str.length == 0 ? 'with' : 'and'} any keywords" if @arbitrary_keywords
+          str
+        end
+
+        def with_arity_string
+          "#{@expected_arity} argument#{@expected_arity == 1 ? '' : 's'}"
+        end
+
+        def with_keywords_string
+          kw_str = case @expected_keywords.count
+                   when 1
+                     @expected_keywords.first.inspect
+                   when 2
+                     @expected_keywords.map(&:inspect).join(' and ')
+                   else
+                     "#{@expected_keywords[0...-1].map(&:inspect).join(', ')}, and #{@expected_keywords.last.inspect}"
+                   end
+
+          "keyword#{@expected_keywords.count == 1 ? '' : 's'} #{kw_str}"
+        end
+
+        def pp_names
+          @names.length == 1 ? "##{@names.first}" : description_of(@names)
+        end
+      end
+    end
+  end
+end
+# rubocop:enable ClassLength

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

@@ -0,0 +1,60 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Provides the implementation for `satisfy`.
+      # Not intended to be instantiated directly.
+      class Satisfy < BaseMatcher
+        def initialize(description=nil, &block)
+          @description = description
+          @block = block
+        end
+
+        # @private
+        def matches?(actual, &block)
+          @block = block if block
+          @actual = actual
+          @block.call(actual)
+        end
+
+        # @private
+        def description
+          @description ||= "satisfy #{block_representation}"
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message
+          "expected #{actual_formatted} to #{description}"
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          "expected #{actual_formatted} not to #{description}"
+        end
+
+      private
+
+        if RSpec::Support::RubyFeatures.ripper_supported?
+          def block_representation
+            if (block_snippet = extract_block_snippet)
+              "expression `#{block_snippet}`"
+            else
+              'block'
+            end
+          end
+
+          def extract_block_snippet
+            return nil unless @block
+            Expectations::BlockSnippetExtractor.try_extracting_single_line_body_of(@block, matcher_name)
+          end
+        else
+          def block_representation
+            'block'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Base class for the `end_with` and `start_with` matchers.
+      # Not intended to be instantiated directly.
+      class StartOrEndWith < BaseMatcher
+        def initialize(*expected)
+          @actual_does_not_have_ordered_elements = false
+          @expected = expected.length == 1 ? expected.first : expected
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message
+          super.tap do |msg|
+            if @actual_does_not_have_ordered_elements
+              msg << ", but it does not have ordered elements"
+            elsif !actual.respond_to?(:[])
+              msg << ", but it cannot be indexed using #[]"
+            end
+          end
+        end
+
+        # @api private
+        # @return [String]
+        def description
+          return super unless Hash === expected
+          english_name = EnglishPhrasing.split_words(self.class.matcher_name)
+          description_of_expected = surface_descriptions_in(expected).inspect
+          "#{english_name} #{description_of_expected}"
+        end
+
+      private
+
+        def match(_expected, actual)
+          return false unless actual.respond_to?(:[])
+
+          begin
+            return true if subsets_comparable? && subset_matches?
+            element_matches?
+          rescue ArgumentError
+            @actual_does_not_have_ordered_elements = true
+            return false
+          end
+        end
+
+        def subsets_comparable?
+          # Structs support the Enumerable interface but don't really have
+          # the semantics of a subset of a larger set...
+          return false if Struct === expected
+
+          expected.respond_to?(:length)
+        end
+      end
+
+      # For RSpec 3.1, the base class was named `StartAndEndWith`. For SemVer reasons,
+      # we still provide this constant until 4.0.
+      # @deprecated Use StartOrEndWith instead.
+      # @private
+      StartAndEndWith = StartOrEndWith
+
+      # @api private
+      # Provides the implementation for `start_with`.
+      # Not intended to be instantiated directly.
+      class StartWith < StartOrEndWith
+      private
+
+        def subset_matches?
+          values_match?(expected, actual[0, expected.length])
+        end
+
+        def element_matches?
+          values_match?(expected, actual[0])
+        end
+      end
+
+      # @api private
+      # Provides the implementation for `end_with`.
+      # Not intended to be instantiated directly.
+      class EndWith < StartOrEndWith
+      private
+
+        def subset_matches?
+          values_match?(expected, actual[-expected.length, expected.length])
+        end
+
+        def element_matches?
+          values_match?(expected, actual[-1])
+        end
+      end
+    end
+  end
+end