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/respond_to.rb

@@ -1,199 +0,0 @@
-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/.bandle/ruby/2.7.0/gems/rspec-expectations-3.9.2/lib/rspec/matchers/built_in/satisfy.rb

@@ -1,60 +0,0 @@
-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/.bandle/ruby/2.7.0/gems/rspec-expectations-3.9.2/lib/rspec/matchers/built_in/start_or_end_with.rb

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

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

@@ -1,132 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `throw_symbol`.
-      # Not intended to be instantiated directly.
-      class ThrowSymbol
-        include Composable
-
-        def initialize(expected_symbol=nil, expected_arg=nil)
-          @expected_symbol = expected_symbol
-          @expected_arg = expected_arg
-          @caught_symbol = @caught_arg = nil
-        end
-
-        # rubocop:disable MethodLength
-        # @private
-        def matches?(given_proc)
-          @block = given_proc
-          return false unless Proc === given_proc
-
-          begin
-            if @expected_symbol.nil?
-              given_proc.call
-            else
-              @caught_arg = catch :proc_did_not_throw_anything do
-                catch @expected_symbol do
-                  given_proc.call
-                  throw :proc_did_not_throw_anything, :nothing_thrown
-                end
-              end
-
-              if @caught_arg == :nothing_thrown
-                @caught_arg = nil
-              else
-                @caught_symbol = @expected_symbol
-              end
-            end
-
-            # Ruby 1.8 uses NameError with `symbol'
-            # Ruby 1.9 uses ArgumentError with :symbol
-          rescue NameError, ArgumentError => e
-            unless (match_data = e.message.match(/uncaught throw (`|\:)([a-zA-Z0-9_]*)(')?/))
-              other_exception = e
-              raise
-            end
-            @caught_symbol = match_data.captures[1].to_sym
-          rescue => other_exception
-            raise
-          ensure
-            # rubocop:disable EnsureReturn
-            unless other_exception
-              if @expected_symbol.nil?
-                return !!@caught_symbol
-              else
-                if @expected_arg.nil?
-                  return @caught_symbol == @expected_symbol
-                else
-                  return (@caught_symbol == @expected_symbol) && values_match?(@expected_arg, @caught_arg)
-                end
-              end
-            end
-            # rubocop:enable EnsureReturn
-          end
-        end
-        # rubocop:enable MethodLength
-
-        def does_not_match?(given_proc)
-          !matches?(given_proc) && Proc === given_proc
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          "expected #{expected} to be thrown, #{actual_result}"
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          "expected #{expected('no Symbol')}#{' not' if @expected_symbol} to be thrown, #{actual_result}"
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          "throw #{expected}"
-        end
-
-        # @api private
-        # Indicates this matcher matches against a block.
-        # @return [True]
-        def supports_block_expectations?
-          true
-        end
-
-        def expects_call_stack_jump?
-          true
-        end
-
-      private
-
-        def actual_result
-          return "but was not a block" unless Proc === @block
-          "got #{caught}"
-        end
-
-        def expected(symbol_desc='a Symbol')
-          throw_description(@expected_symbol || symbol_desc, @expected_arg)
-        end
-
-        def caught
-          throw_description(@caught_symbol || 'nothing', @caught_arg)
-        end
-
-        def throw_description(symbol, arg)
-          symbol_description = symbol.is_a?(String) ? symbol : description_of(symbol)
-
-          arg_description = if arg
-                              " with #{description_of arg}"
-                            elsif @expected_arg && @caught_symbol == @expected_symbol
-                              " with no argument"
-                            else
-                              ""
-                            end
-
-          symbol_description + arg_description
-        end
-      end
-    end
-  end
-end