qiita_org 0.1.35 → 0.1.41

data/.bandle/ruby/2.7.0/gems/rspec-expectations-3.9.2/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/.bandle/ruby/2.7.0/gems/rspec-expectations-3.9.2/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/.bandle/ruby/2.7.0/gems/rspec-expectations-3.9.2/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

data/.bandle/ruby/2.7.0/gems/rspec-expectations-3.9.2/lib/rspec/matchers/built_in/raise_error.rb

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