qiita_org 0.1.32 → 0.1.38

data/.bandle/ruby/2.7.0/gems/rspec-support-3.9.3/LICENSE.md

@@ -1,23 +0,0 @@
-The MIT License (MIT)
-====================
-
-* Copyright © 2013 David Chelimsky, Myron Marston, Jon Rowe, Sam Phippen, Xavier Shay, Bradley Schaefer
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/.bandle/ruby/2.7.0/gems/rspec-support-3.9.3/README.md

@@ -1,40 +0,0 @@
-# RSpec::Support
-
-`RSpec::Support` provides common functionality to `RSpec::Core`,
-`RSpec::Expectations` and `RSpec::Mocks`. It is considered
-suitable for internal use only at this time.
-
-## Installation / Usage
-
-Install one or more of the `RSpec` gems.
-
-Want to run against the `master` branch? You'll need to include the dependent
-RSpec repos as well. Add the following to your `Gemfile`:
-
-```ruby
-%w[rspec-core rspec-expectations rspec-mocks rspec-support].each do |lib|
-  gem lib, :git => "https://github.com/rspec/#{lib}.git", :branch => 'master'
-end
-```
-
-## Contributing
-
-Once you've set up the environment, you'll need to cd into the working
-directory of whichever repo you want to work in. From there you can run the
-specs and cucumber features, and make patches.
-
-NOTE: You do not need to use rspec-dev to work on a specific RSpec repo. You
-can treat each RSpec repo as an independent project.
-
-- [Build details](BUILD_DETAIL.md)
-- [Code of Conduct](CODE_OF_CONDUCT.md)
-- [Detailed contributing guide](CONTRIBUTING.md)
-- [Development setup guide](DEVELOPMENT.md)
-
-## Patches
-
-Please submit a pull request or a github issue. If you submit an issue, please
-include a link to either of:
-
-* a gist (or equivalent) of the patch
-* a branch or commit in your github fork of the repo

data/.bandle/ruby/2.7.0/gems/rspec-support-3.9.3/lib/rspec/support.rb

@@ -1,149 +0,0 @@
-module RSpec
-  module Support
-    # @api private
-    #
-    # Defines a helper method that is optimized to require files from the
-    # named lib. The passed block MUST be `{ |f| require_relative f }`
-    # because for `require_relative` to work properly from within the named
-    # lib the line of code must be IN that lib.
-    #
-    # `require_relative` is preferred when available because it is always O(1),
-    # regardless of the number of dirs in $LOAD_PATH. `require`, on the other
-    # hand, does a linear O(N) search over the dirs in the $LOAD_PATH until
-    # it can resolve the file relative to one of the dirs.
-    def self.define_optimized_require_for_rspec(lib, &require_relative)
-      name = "require_rspec_#{lib}"
-
-      if Kernel.respond_to?(:require_relative)
-        (class << self; self; end).__send__(:define_method, name) do |f|
-          require_relative.call("#{lib}/#{f}")
-        end
-      else
-        (class << self; self; end).__send__(:define_method, name) do |f|
-          require "rspec/#{lib}/#{f}"
-        end
-      end
-    end
-
-    define_optimized_require_for_rspec(:support) { |f| require_relative(f) }
-    require_rspec_support "version"
-    require_rspec_support "ruby_features"
-
-    # @api private
-    KERNEL_METHOD_METHOD = ::Kernel.instance_method(:method)
-
-    # @api private
-    #
-    # Used internally to get a method handle for a particular object
-    # and method name.
-    #
-    # Includes handling for a few special cases:
-    #
-    #   - Objects that redefine #method (e.g. an HTTPRequest struct)
-    #   - BasicObject subclasses that mixin a Kernel dup (e.g. SimpleDelegator)
-    #   - Objects that undefine method and delegate everything to another
-    #     object (e.g. Mongoid association objects)
-    if RubyFeatures.supports_rebinding_module_methods?
-      def self.method_handle_for(object, method_name)
-        KERNEL_METHOD_METHOD.bind(object).call(method_name)
-      rescue NameError => original
-        begin
-          handle = object.method(method_name)
-          raise original unless handle.is_a? Method
-          handle
-        rescue Support::AllExceptionsExceptOnesWeMustNotRescue
-          raise original
-        end
-      end
-    else
-      def self.method_handle_for(object, method_name)
-        if ::Kernel === object
-          KERNEL_METHOD_METHOD.bind(object).call(method_name)
-        else
-          object.method(method_name)
-        end
-      rescue NameError => original
-        begin
-          handle = object.method(method_name)
-          raise original unless handle.is_a? Method
-          handle
-        rescue Support::AllExceptionsExceptOnesWeMustNotRescue
-          raise original
-        end
-      end
-    end
-
-    # @api private
-    #
-    # Used internally to get a class of a given object, even if it does not respond to #class.
-    def self.class_of(object)
-      object.class
-    rescue NoMethodError
-      singleton_class = class << object; self; end
-      singleton_class.ancestors.find { |ancestor| !ancestor.equal?(singleton_class) }
-    end
-
-    # A single thread local variable so we don't excessively pollute that namespace.
-    def self.thread_local_data
-      Thread.current[:__rspec] ||= {}
-    end
-
-    # @api private
-    def self.failure_notifier=(callable)
-      thread_local_data[:failure_notifier] = callable
-    end
-
-    # @private
-    DEFAULT_FAILURE_NOTIFIER = lambda { |failure, _opts| raise failure }
-
-    # @api private
-    def self.failure_notifier
-      thread_local_data[:failure_notifier] || DEFAULT_FAILURE_NOTIFIER
-    end
-
-    # @api private
-    def self.notify_failure(failure, options={})
-      failure_notifier.call(failure, options)
-    end
-
-    # @api private
-    def self.with_failure_notifier(callable)
-      orig_notifier = failure_notifier
-      self.failure_notifier = callable
-      yield
-    ensure
-      self.failure_notifier = orig_notifier
-    end
-
-    class << self
-      # @api private
-      attr_writer :warning_notifier
-    end
-
-    # @private
-    DEFAULT_WARNING_NOTIFIER = lambda { |warning| ::Kernel.warn warning }
-
-    # @api private
-    def self.warning_notifier
-      @warning_notifier ||= DEFAULT_WARNING_NOTIFIER
-    end
-
-    # @private
-    module AllExceptionsExceptOnesWeMustNotRescue
-      # These exceptions are dangerous to rescue as rescuing them
-      # would interfere with things we should not interfere with.
-      AVOID_RESCUING = [NoMemoryError, SignalException, Interrupt, SystemExit]
-
-      def self.===(exception)
-        AVOID_RESCUING.none? { |ar| ar === exception }
-      end
-    end
-
-    # The Differ is only needed when a spec fails with a diffable failure.
-    # In the more common case of all specs passing or the only failures being
-    # non-diffable, we can avoid the extra cost of loading the differ, diff-lcs,
-    # pp, etc by avoiding an unnecessary require. Instead, autoload will take
-    # care of loading the differ on first use.
-    autoload :Differ, "rspec/support/differ"
-  end
-end

data/.bandle/ruby/2.7.0/gems/rspec-support-3.9.3/lib/rspec/support/caller_filter.rb

@@ -1,83 +0,0 @@
-RSpec::Support.require_rspec_support "ruby_features"
-
-module RSpec
-  # Consistent implementation for "cleaning" the caller method to strip out
-  # non-rspec lines. This enables errors to be reported at the call site in
-  # the code using the library, which is far more useful than the particular
-  # internal method that raised an error.
-  class CallerFilter
-    RSPEC_LIBS = %w[
-      core
-      mocks
-      expectations
-      support
-      matchers
-      rails
-    ]
-
-    ADDITIONAL_TOP_LEVEL_FILES = %w[ autorun ]
-
-    LIB_REGEX = %r{/lib/rspec/(#{(RSPEC_LIBS + ADDITIONAL_TOP_LEVEL_FILES).join('|')})(\.rb|/)}
-
-    # rubygems/core_ext/kernel_require.rb isn't actually part of rspec (obviously) but we want
-    # it ignored when we are looking for the first meaningful line of the backtrace outside
-    # of RSpec. It can show up in the backtrace as the immediate first caller
-    # when `CallerFilter.first_non_rspec_line` is called from the top level of a required
-    # file, but it depends on if rubygems is loaded or not. We don't want to have to deal
-    # with this complexity in our `RSpec.deprecate` calls, so we ignore it here.
-    IGNORE_REGEX = Regexp.union(LIB_REGEX, "rubygems/core_ext/kernel_require.rb")
-
-    if RSpec::Support::RubyFeatures.caller_locations_supported?
-      # This supports args because it's more efficient when the caller specifies
-      # these. It allows us to skip frames the caller knows are part of RSpec,
-      # and to decrease the increment size if the caller is confident the line will
-      # be found in a small number of stack frames from `skip_frames`.
-      #
-      # Note that there is a risk to passing a `skip_frames` value that is too high:
-      # If it skippped the first non-rspec line, then this method would return the
-      # 2nd or 3rd (or whatever) non-rspec line. Thus, you generally shouldn't pass
-      # values for these parameters, particularly since most places that use this are
-      # not hot spots (generally it gets used for deprecation warnings). However,
-      # if you do have a hot spot that calls this, passing `skip_frames` can make
-      # a significant difference. Just make sure that that particular use is tested
-      # so that if the provided `skip_frames` changes to no longer be accurate in
-      # such a way that would return the wrong stack frame, a test will fail to tell you.
-      #
-      # See benchmarks/skip_frames_for_caller_filter.rb for measurements.
-      def self.first_non_rspec_line(skip_frames=3, increment=5)
-        # Why a default `skip_frames` of 3?
-        # By the time `caller_locations` is called below, the first 3 frames are:
-        #   lib/rspec/support/caller_filter.rb:63:in `block in first_non_rspec_line'
-        #   lib/rspec/support/caller_filter.rb:62:in `loop'
-        #   lib/rspec/support/caller_filter.rb:62:in `first_non_rspec_line'
-
-        # `caller` is an expensive method that scales linearly with the size of
-        # the stack. The performance hit for fetching it in chunks is small,
-        # and since the target line is probably near the top of the stack, the
-        # overall improvement of a chunked search like this is significant.
-        #
-        # See benchmarks/caller.rb for measurements.
-
-        # The default increment of 5 for this method are mostly arbitrary, but
-        # is chosen to give good performance on the common case of creating a double.
-
-        loop do
-          stack = caller_locations(skip_frames, increment)
-          raise "No non-lib lines in stack" unless stack
-
-          line = stack.find { |l| l.path !~ IGNORE_REGEX }
-          return line.to_s if line
-
-          skip_frames += increment
-          increment   *= 2 # The choice of two here is arbitrary.
-        end
-      end
-    else
-      # Earlier rubies do not support the two argument form of `caller`. This
-      # fallback is logically the same, but slower.
-      def self.first_non_rspec_line(*)
-        caller.find { |line| line !~ IGNORE_REGEX }
-      end
-    end
-  end
-end

data/.bandle/ruby/2.7.0/gems/rspec-support-3.9.3/lib/rspec/support/comparable_version.rb

@@ -1,46 +0,0 @@
-module RSpec
-  module Support
-    # @private
-    class ComparableVersion
-      include Comparable
-
-      attr_reader :string
-
-      def initialize(string)
-        @string = string
-      end
-
-      def <=>(other)
-        other = self.class.new(other) unless other.is_a?(self.class)
-
-        return 0 if string == other.string
-
-        longer_segment_count = [self, other].map { |version| version.segments.count }.max
-
-        longer_segment_count.times do |index|
-          self_segment = segments[index] || 0
-          other_segment = other.segments[index] || 0
-
-          if self_segment.class == other_segment.class
-            result = self_segment <=> other_segment
-            return result unless result == 0
-          else
-            return self_segment.is_a?(String) ? -1 : 1
-          end
-        end
-
-        0
-      end
-
-      def segments
-        @segments ||= string.scan(/[a-z]+|\d+/i).map do |segment|
-          if segment =~ /\A\d+\z/
-            segment.to_i
-          else
-            segment
-          end
-        end
-      end
-    end
-  end
-end

data/.bandle/ruby/2.7.0/gems/rspec-support-3.9.3/lib/rspec/support/differ.rb

@@ -1,215 +0,0 @@
-RSpec::Support.require_rspec_support 'encoded_string'
-RSpec::Support.require_rspec_support 'hunk_generator'
-RSpec::Support.require_rspec_support "object_formatter"
-
-require 'pp'
-
-module RSpec
-  module Support
-    # rubocop:disable ClassLength
-    class Differ
-      def diff(actual, expected)
-        diff = ""
-
-        unless actual.nil? || expected.nil?
-          if all_strings?(actual, expected)
-            if any_multiline_strings?(actual, expected)
-              diff = diff_as_string(coerce_to_string(actual), coerce_to_string(expected))
-            end
-          elsif no_procs?(actual, expected) && no_numbers?(actual, expected)
-            diff = diff_as_object(actual, expected)
-          end
-        end
-
-        diff.to_s
-      end
-
-      # rubocop:disable MethodLength
-      def diff_as_string(actual, expected)
-        encoding = EncodedString.pick_encoding(actual, expected)
-
-        actual   = EncodedString.new(actual, encoding)
-        expected = EncodedString.new(expected, encoding)
-
-        output = EncodedString.new("\n", encoding)
-        hunks = build_hunks(actual, expected)
-
-        hunks.each_cons(2) do |prev_hunk, current_hunk|
-          begin
-            if current_hunk.overlaps?(prev_hunk)
-              add_old_hunk_to_hunk(current_hunk, prev_hunk)
-            else
-              add_to_output(output, prev_hunk.diff(format_type).to_s)
-            end
-          ensure
-            add_to_output(output, "\n")
-          end
-        end
-
-        finalize_output(output, hunks.last.diff(format_type).to_s) if hunks.last
-
-        color_diff output
-      rescue Encoding::CompatibilityError
-        handle_encoding_errors(actual, expected)
-      end
-      # rubocop:enable MethodLength
-
-      def diff_as_object(actual, expected)
-        actual_as_string = object_to_string(actual)
-        expected_as_string = object_to_string(expected)
-        diff_as_string(actual_as_string, expected_as_string)
-      end
-
-      def color?
-        @color
-      end
-
-      def initialize(opts={})
-        @color = opts.fetch(:color, false)
-        @object_preparer = opts.fetch(:object_preparer, lambda { |string| string })
-      end
-
-    private
-
-      def no_procs?(*args)
-        safely_flatten(args).none? { |a| Proc === a }
-      end
-
-      def all_strings?(*args)
-        safely_flatten(args).all? { |a| String === a }
-      end
-
-      def any_multiline_strings?(*args)
-        all_strings?(*args) && safely_flatten(args).any? { |a| multiline?(a) }
-      end
-
-      def no_numbers?(*args)
-        safely_flatten(args).none? { |a| Numeric === a }
-      end
-
-      def coerce_to_string(string_or_array)
-        return string_or_array unless Array === string_or_array
-        diffably_stringify(string_or_array).join("\n")
-      end
-
-      def diffably_stringify(array)
-        array.map do |entry|
-          if Array === entry
-            entry.inspect
-          else
-            entry.to_s.gsub("\n", "\\n").gsub("\r", "\\r")
-          end
-        end
-      end
-
-      if String.method_defined?(:encoding)
-        def multiline?(string)
-          string.include?("\n".encode(string.encoding))
-        end
-      else
-        def multiline?(string)
-          string.include?("\n")
-        end
-      end
-
-      def build_hunks(actual, expected)
-        HunkGenerator.new(actual, expected).hunks
-      end
-
-      def finalize_output(output, final_line)
-        add_to_output(output, final_line)
-        add_to_output(output, "\n")
-      end
-
-      def add_to_output(output, string)
-        output << string
-      end
-
-      def add_old_hunk_to_hunk(hunk, oldhunk)
-        hunk.merge(oldhunk)
-      end
-
-      def safely_flatten(array)
-        array = array.flatten(1) until (array == array.flatten(1))
-        array
-      end
-
-      def format_type
-        :unified
-      end
-
-      def color(text, color_code)
-        "\e[#{color_code}m#{text}\e[0m"
-      end
-
-      def red(text)
-        color(text, 31)
-      end
-
-      def green(text)
-        color(text, 32)
-      end
-
-      def blue(text)
-        color(text, 34)
-      end
-
-      def normal(text)
-        color(text, 0)
-      end
-
-      def color_diff(diff)
-        return diff unless color?
-
-        diff.lines.map do |line|
-          case line[0].chr
-          when "+"
-            green line
-          when "-"
-            red line
-          when "@"
-            line[1].chr == "@" ? blue(line) : normal(line)
-          else
-            normal(line)
-          end
-        end.join
-      end
-
-      def object_to_string(object)
-        object = @object_preparer.call(object)
-        case object
-        when Hash
-          hash_to_string(object)
-        when Array
-          PP.pp(ObjectFormatter.prepare_for_inspection(object), "".dup)
-        when String
-          object =~ /\n/ ? object : object.inspect
-        else
-          PP.pp(object, "".dup)
-        end
-      end
-
-      def hash_to_string(hash)
-        formatted_hash = ObjectFormatter.prepare_for_inspection(hash)
-        formatted_hash.keys.sort_by { |k| k.to_s }.map do |key|
-          pp_key   = PP.singleline_pp(key, "".dup)
-          pp_value = PP.singleline_pp(formatted_hash[key], "".dup)
-
-          "#{pp_key} => #{pp_value},"
-        end.join("\n")
-      end
-
-      def handle_encoding_errors(actual, expected)
-        if actual.source_encoding != expected.source_encoding
-          "Could not produce a diff because the encoding of the actual string " \
-          "(#{actual.source_encoding}) differs from the encoding of the expected " \
-          "string (#{expected.source_encoding})"
-        else
-          "Could not produce a diff because of the encoding of the string " \
-          "(#{expected.source_encoding})"
-        end
-      end
-    end
-    # rubocop:enable ClassLength
-  end
-end