qiita_org 0.1.31 → 0.1.37

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

@@ -1,90 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `exist`.
-      # Not intended to be instantiated directly.
-      class Exist < BaseMatcher
-        def initialize(*expected)
-          @expected = expected
-        end
-
-        # @api private
-        # @return [Boolean]
-        def matches?(actual)
-          @actual = actual
-          @test = ExistenceTest.new @actual, @expected
-          @test.valid_test? && @test.actual_exists?
-        end
-
-        # @api private
-        # @return [Boolean]
-        def does_not_match?(actual)
-          @actual = actual
-          @test = ExistenceTest.new @actual, @expected
-          @test.valid_test? && !@test.actual_exists?
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          "expected #{actual_formatted} to exist#{@test.validity_message}"
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          "expected #{actual_formatted} not to exist#{@test.validity_message}"
-        end
-
-        # @api private
-        # Simple class for memoizing actual/expected for this matcher
-        # and examining the match
-        class ExistenceTest < Struct.new(:actual, :expected)
-          # @api private
-          # @return [Boolean]
-          def valid_test?
-            uniq_truthy_values.size == 1
-          end
-
-          # @api private
-          # @return [Boolean]
-          def actual_exists?
-            existence_values.first
-          end
-
-          # @api private
-          # @return [String]
-          def validity_message
-            case uniq_truthy_values.size
-            when 0
-              " but it does not respond to either `exist?` or `exists?`"
-            when 2
-              " but `exist?` and `exists?` returned different values:\n\n"\
-              " exist?: #{existence_values.first}\n"\
-              "exists?: #{existence_values.last}"
-            end
-          end
-
-        private
-
-          def uniq_truthy_values
-            @uniq_truthy_values ||= existence_values.map { |v| !!v }.uniq
-          end
-
-          def existence_values
-            @existence_values ||= predicates.map { |p| actual.__send__(p, *expected) }
-          end
-
-          def predicates
-            @predicates ||= [:exist?, :exists?].select { |p| actual.respond_to?(p) && !deprecated(p, actual) }
-          end
-
-          def deprecated(predicate, actual)
-            predicate == :exists? && File == actual
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,103 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `has_<predicate>`.
-      # Not intended to be instantiated directly.
-      class Has < BaseMatcher
-        def initialize(method_name, *args, &block)
-          @method_name, @args, @block = method_name, args, block
-        end
-
-        # @private
-        def matches?(actual, &block)
-          @actual = actual
-          @block ||= block
-          predicate_accessible? && predicate_matches?
-        end
-
-        # @private
-        def does_not_match?(actual, &block)
-          @actual = actual
-          @block ||= block
-          predicate_accessible? && !predicate_matches?
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          validity_message || "expected ##{predicate}#{failure_message_args_description} to return true, got false"
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          validity_message || "expected ##{predicate}#{failure_message_args_description} to return false, got true"
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          [method_description, args_description].compact.join(' ')
-        end
-
-      private
-
-        def predicate_accessible?
-          !private_predicate? && predicate_exists?
-        end
-
-        # support 1.8.7, evaluate once at load time for performance
-        if String === methods.first
-          # :nocov:
-          def private_predicate?
-            @actual.private_methods.include? predicate.to_s
-          end
-          # :nocov:
-        else
-          def private_predicate?
-            @actual.private_methods.include? predicate
-          end
-        end
-
-        def predicate_exists?
-          @actual.respond_to? predicate
-        end
-
-        def predicate_matches?
-          @actual.__send__(predicate, *@args, &@block)
-        end
-
-        def predicate
-          # On 1.9, there appears to be a bug where String#match can return `false`
-          # rather than the match data object. Changing to Regex#match appears to
-          # work around this bug. For an example of this bug, see:
-          # https://travis-ci.org/rspec/rspec-expectations/jobs/27549635
-          @predicate ||= :"has_#{Matchers::HAS_REGEX.match(@method_name.to_s).captures.first}?"
-        end
-
-        def method_description
-          @method_name.to_s.tr('_', ' ')
-        end
-
-        def args_description
-          return nil if @args.empty?
-          @args.map { |arg| RSpec::Support::ObjectFormatter.format(arg) }.join(', ')
-        end
-
-        def failure_message_args_description
-          desc = args_description
-          "(#{desc})" if desc
-        end
-
-        def validity_message
-          if private_predicate?
-            "expected #{@actual} to respond to `#{predicate}` but `#{predicate}` is a private method"
-          elsif !predicate_exists?
-            "expected #{@actual} to respond to `#{predicate}`"
-          end
-        end
-      end
-    end
-  end
-end

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