qiita_org 0.1.32 → 0.1.38

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

@@ -1,116 +0,0 @@
-module RSpec
-  module Matchers
-    # Decorator that wraps a matcher and overrides `description`
-    # using the provided block in order to support an alias
-    # of a matcher. This is intended for use when composing
-    # matchers, so that you can use an expression like
-    # `include( a_value_within(0.1).of(3) )` rather than
-    # `include( be_within(0.1).of(3) )`, and have the corresponding
-    # description read naturally.
-    #
-    # @api private
-    class AliasedMatcher < MatcherDelegator
-      def initialize(base_matcher, description_block)
-        @description_block = description_block
-        super(base_matcher)
-      end
-
-      # Forward messages on to the wrapped matcher.
-      # Since many matchers provide a fluent interface
-      # (e.g. `a_value_within(0.1).of(3)`), we need to wrap
-      # the returned value if it responds to `description`,
-      # so that our override can be applied when it is eventually
-      # used.
-      def method_missing(*)
-        return_val = super
-        return return_val unless RSpec::Matchers.is_a_matcher?(return_val)
-        self.class.new(return_val, @description_block)
-      end
-
-      # Provides the description of the aliased matcher. Aliased matchers
-      # are designed to behave identically to the original matcher except
-      # for the description and failure messages. The description is different
-      # to reflect the aliased name.
-      #
-      # @api private
-      def description
-        @description_block.call(super)
-      end
-
-      # Provides the failure_message of the aliased matcher. Aliased matchers
-      # are designed to behave identically to the original matcher except
-      # for the description and failure messages. The failure_message is different
-      # to reflect the aliased name.
-      #
-      # @api private
-      def failure_message
-        @description_block.call(super)
-      end
-
-      # Provides the failure_message_when_negated of the aliased matcher. Aliased matchers
-      # are designed to behave identically to the original matcher except
-      # for the description and failure messages. The failure_message_when_negated is different
-      # to reflect the aliased name.
-      #
-      # @api private
-      def failure_message_when_negated
-        @description_block.call(super)
-      end
-    end
-
-    # Decorator used for matchers that have special implementations of
-    # operators like `==` and `===`.
-    # @private
-    class AliasedMatcherWithOperatorSupport < AliasedMatcher
-      # We undef these so that they get delegated via `method_missing`.
-      undef ==
-      undef ===
-    end
-
-    # @private
-    class AliasedNegatedMatcher < AliasedMatcher
-      def matches?(*args, &block)
-        if @base_matcher.respond_to?(:does_not_match?)
-          @base_matcher.does_not_match?(*args, &block)
-        else
-          !super
-        end
-      end
-
-      def does_not_match?(*args, &block)
-        @base_matcher.matches?(*args, &block)
-      end
-
-      def failure_message
-        optimal_failure_message(__method__, :failure_message_when_negated)
-      end
-
-      def failure_message_when_negated
-        optimal_failure_message(__method__, :failure_message)
-      end
-
-    private
-
-      DefaultFailureMessages = BuiltIn::BaseMatcher::DefaultFailureMessages
-
-      # For a matcher that uses the default failure messages, we prefer to
-      # use the override provided by the `description_block`, because it
-      # includes the phrasing that the user has expressed a preference for
-      # by going through the effort of defining a negated matcher.
-      #
-      # However, if the override didn't actually change anything, then we
-      # should return the opposite failure message instead -- the overriden
-      # message is going to be confusing if we return it as-is, as it represents
-      # the non-negated failure message for a negated match (or vice versa).
-      def optimal_failure_message(same, inverted)
-        if DefaultFailureMessages.has_default_failure_messages?(@base_matcher)
-          base_message = @base_matcher.__send__(same)
-          overriden    = @description_block.call(base_message)
-          return overriden if overriden != base_message
-        end
-
-        @base_matcher.__send__(inverted)
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-RSpec::Support.require_rspec_matchers "built_in/base_matcher"
-
-module RSpec
-  module Matchers
-    # Container module for all built-in matchers. The matcher classes are here
-    # (rather than directly under `RSpec::Matchers`) in order to prevent name
-    # collisions, since `RSpec::Matchers` gets included into the user's namespace.
-    #
-    # Autoloading is used to delay when the matcher classes get loaded, allowing
-    # rspec-matchers to boot faster, and avoiding loading matchers the user is
-    # not using.
-    module BuiltIn
-      autoload :BeAKindOf,               'rspec/matchers/built_in/be_kind_of'
-      autoload :BeAnInstanceOf,          'rspec/matchers/built_in/be_instance_of'
-      autoload :BeBetween,               'rspec/matchers/built_in/be_between'
-      autoload :Be,                      'rspec/matchers/built_in/be'
-      autoload :BeComparedTo,            'rspec/matchers/built_in/be'
-      autoload :BeFalsey,                'rspec/matchers/built_in/be'
-      autoload :BeNil,                   'rspec/matchers/built_in/be'
-      autoload :BePredicate,             'rspec/matchers/built_in/be'
-      autoload :BeTruthy,                'rspec/matchers/built_in/be'
-      autoload :BeWithin,                'rspec/matchers/built_in/be_within'
-      autoload :Change,                  'rspec/matchers/built_in/change'
-      autoload :Compound,                'rspec/matchers/built_in/compound'
-      autoload :ContainExactly,          'rspec/matchers/built_in/contain_exactly'
-      autoload :Cover,                   'rspec/matchers/built_in/cover'
-      autoload :EndWith,                 'rspec/matchers/built_in/start_or_end_with'
-      autoload :Eq,                      'rspec/matchers/built_in/eq'
-      autoload :Eql,                     'rspec/matchers/built_in/eql'
-      autoload :Equal,                   'rspec/matchers/built_in/equal'
-      autoload :Exist,                   'rspec/matchers/built_in/exist'
-      autoload :Has,                     'rspec/matchers/built_in/has'
-      autoload :HaveAttributes,          'rspec/matchers/built_in/have_attributes'
-      autoload :Include,                 'rspec/matchers/built_in/include'
-      autoload :All,                     'rspec/matchers/built_in/all'
-      autoload :Match,                   'rspec/matchers/built_in/match'
-      autoload :NegativeOperatorMatcher, 'rspec/matchers/built_in/operators'
-      autoload :OperatorMatcher,         'rspec/matchers/built_in/operators'
-      autoload :Output,                  'rspec/matchers/built_in/output'
-      autoload :PositiveOperatorMatcher, 'rspec/matchers/built_in/operators'
-      autoload :RaiseError,              'rspec/matchers/built_in/raise_error'
-      autoload :RespondTo,               'rspec/matchers/built_in/respond_to'
-      autoload :Satisfy,                 'rspec/matchers/built_in/satisfy'
-      autoload :StartWith,               'rspec/matchers/built_in/start_or_end_with'
-      autoload :ThrowSymbol,             'rspec/matchers/built_in/throw_symbol'
-      autoload :YieldControl,            'rspec/matchers/built_in/yield'
-      autoload :YieldSuccessiveArgs,     'rspec/matchers/built_in/yield'
-      autoload :YieldWithArgs,           'rspec/matchers/built_in/yield'
-      autoload :YieldWithNoArgs,         'rspec/matchers/built_in/yield'
-    end
-  end
-end

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

@@ -1,86 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `all`.
-      # Not intended to be instantiated directly.
-      class All < BaseMatcher
-        # @private
-        attr_reader :matcher, :failed_objects
-
-        def initialize(matcher)
-          @matcher = matcher
-          @failed_objects = {}
-        end
-
-        # @private
-        def does_not_match?(_actual)
-          raise NotImplementedError, '`expect().not_to all( matcher )` is not supported.'
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          unless iterable?
-            return "#{improve_hash_formatting(super)}, but was not iterable"
-          end
-
-          all_messages = [improve_hash_formatting(super)]
-          failed_objects.each do |index, matcher_failure_message|
-            all_messages << failure_message_for_item(index, matcher_failure_message)
-          end
-          all_messages.join("\n\n")
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          improve_hash_formatting "all #{description_of matcher}"
-        end
-
-      private
-
-        def match(_expected, _actual)
-          return false unless iterable?
-
-          index_failed_objects
-          failed_objects.empty?
-        end
-
-        def index_failed_objects
-          actual.each_with_index do |actual_item, index|
-            cloned_matcher = matcher.clone
-            matches = cloned_matcher.matches?(actual_item)
-            failed_objects[index] = cloned_matcher.failure_message unless matches
-          end
-        end
-
-        def failure_message_for_item(index, failure_message)
-          failure_message = indent_multiline_message(add_new_line_if_needed(failure_message))
-          indent_multiline_message("object at index #{index} failed to match:#{failure_message}")
-        end
-
-        def add_new_line_if_needed(message)
-          message.start_with?("\n") ? message : "\n#{message}"
-        end
-
-        def indent_multiline_message(message)
-          message = message.sub(/\n+\z/, '')
-          message.lines.map do |line|
-            line =~ /\S/ ? '   ' + line : line
-          end.join
-        end
-
-        def initialize_copy(other)
-          @matcher = @matcher.clone
-          @failed_objects = @failed_objects.clone
-          super
-        end
-
-        def iterable?
-          @actual.respond_to?(:each_with_index)
-        end
-      end
-    end
-  end
-end

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

@@ -1,193 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      #
-      # Used _internally_ as a base class for matchers that ship with
-      # rspec-expectations and rspec-rails.
-      #
-      # ### Warning:
-      #
-      # This class is for internal use, and subject to change without notice.
-      # We strongly recommend that you do not base your custom matchers on this
-      # class. If/when this changes, we will announce it and remove this warning.
-      class BaseMatcher
-        include RSpec::Matchers::Composable
-
-        # @api private
-        # Used to detect when no arg is passed to `initialize`.
-        # `nil` cannot be used because it's a valid value to pass.
-        UNDEFINED = Object.new.freeze
-
-        # @private
-        attr_reader :actual, :expected, :rescued_exception
-
-        # @private
-        attr_writer :matcher_name
-
-        def initialize(expected=UNDEFINED)
-          @expected = expected unless UNDEFINED.equal?(expected)
-        end
-
-        # @api private
-        # Indicates if the match is successful. Delegates to `match`, which
-        # should be defined on a subclass. Takes care of consistently
-        # initializing the `actual` attribute.
-        def matches?(actual)
-          @actual = actual
-          match(expected, actual)
-        end
-
-        # @api private
-        # Used to wrap a block of code that will indicate failure by
-        # raising one of the named exceptions.
-        #
-        # This is used by rspec-rails for some of its matchers that
-        # wrap rails' assertions.
-        def match_unless_raises(*exceptions)
-          exceptions.unshift Exception if exceptions.empty?
-          begin
-            yield
-            true
-          rescue *exceptions => @rescued_exception
-            false
-          end
-        end
-
-        # @api private
-        # Generates a description using {EnglishPhrasing}.
-        # @return [String]
-        def description
-          desc = EnglishPhrasing.split_words(self.class.matcher_name)
-          desc << EnglishPhrasing.list(@expected) if defined?(@expected)
-          desc
-        end
-
-        # @api private
-        # Matchers are not diffable by default. Override this to make your
-        # subclass diffable.
-        def diffable?
-          false
-        end
-
-        # @api private
-        # Most matchers are value matchers (i.e. meant to work with `expect(value)`)
-        # rather than block matchers (i.e. meant to work with `expect { }`), so
-        # this defaults to false. Block matchers must override this to return true.
-        def supports_block_expectations?
-          false
-        end
-
-        # @api private
-        def expects_call_stack_jump?
-          false
-        end
-
-        # @private
-        def expected_formatted
-          RSpec::Support::ObjectFormatter.format(@expected)
-        end
-
-        # @private
-        def actual_formatted
-          RSpec::Support::ObjectFormatter.format(@actual)
-        end
-
-        # @private
-        def self.matcher_name
-          @matcher_name ||= underscore(name.split('::').last)
-        end
-
-        # @private
-        def matcher_name
-          if defined?(@matcher_name)
-            @matcher_name
-          else
-            self.class.matcher_name
-          end
-        end
-
-        # @private
-        # Borrowed from ActiveSupport.
-        def self.underscore(camel_cased_word)
-          word = camel_cased_word.to_s.dup
-          word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-          word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
-          word.tr!('-', '_')
-          word.downcase!
-          word
-        end
-        private_class_method :underscore
-
-      private
-
-        def assert_ivars(*expected_ivars)
-          return unless (expected_ivars - present_ivars).any?
-          ivar_list = EnglishPhrasing.list(expected_ivars)
-          raise "#{self.class.name} needs to supply#{ivar_list}"
-        end
-
-        if RUBY_VERSION.to_f < 1.9
-          # :nocov:
-          def present_ivars
-            instance_variables.map(&:to_sym)
-          end
-          # :nocov:
-        else
-          alias present_ivars instance_variables
-        end
-
-        # @private
-        module HashFormatting
-          # `{ :a => 5, :b => 2 }.inspect` produces:
-          #
-          #     {:a=>5, :b=>2}
-          #
-          # ...but it looks much better as:
-          #
-          #     {:a => 5, :b => 2}
-          #
-          # This is idempotent and safe to run on a string multiple times.
-          def improve_hash_formatting(inspect_string)
-            inspect_string.gsub(/(\S)=>(\S)/, '\1 => \2')
-          end
-          module_function :improve_hash_formatting
-        end
-
-        include HashFormatting
-
-        # @api private
-        # Provides default implementations of failure messages, based on the `description`.
-        module DefaultFailureMessages
-          # @api private
-          # Provides a good generic failure message. Based on `description`.
-          # When subclassing, if you are not satisfied with this failure message
-          # you often only need to override `description`.
-          # @return [String]
-          def failure_message
-            "expected #{description_of @actual} to #{description}".dup
-          end
-
-          # @api private
-          # Provides a good generic negative failure message. Based on `description`.
-          # When subclassing, if you are not satisfied with this failure message
-          # you often only need to override `description`.
-          # @return [String]
-          def failure_message_when_negated
-            "expected #{description_of @actual} not to #{description}".dup
-          end
-
-          # @private
-          def self.has_default_failure_messages?(matcher)
-            matcher.method(:failure_message).owner == self &&
-              matcher.method(:failure_message_when_negated).owner == self
-          rescue NameError
-            false
-          end
-        end
-
-        include DefaultFailureMessages
-      end
-    end
-  end
-end