qiita_org 0.1.35 → 0.1.37

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

@@ -1,73 +0,0 @@
-module RSpec
-  module Support
-    # On 1.8.7, it's in the stdlib.
-    # We don't want to load the stdlib, b/c this is a test tool, and can affect
-    # the test environment, causing tests to pass where they should fail.
-    #
-    # So we're transcribing/modifying it from
-    # https://github.com/ruby/ruby/blob/v1_8_7_374/lib/thread.rb#L56
-    # Some methods we don't need are deleted. Anything I don't
-    # understand (there's quite a bit, actually) is left in.
-    #
-    # Some formating changes are made to appease the robot overlord:
-    #   https://travis-ci.org/rspec/rspec-core/jobs/54410874
-    # @private
-    class Mutex
-      def initialize
-        @waiting = []
-        @locked = false
-        @waiting.taint
-        taint
-      end
-
-      # @private
-      def lock
-        while Thread.critical = true && @locked
-          @waiting.push Thread.current
-          Thread.stop
-        end
-        @locked = true
-        Thread.critical = false
-        self
-      end
-
-      # @private
-      def unlock
-        return unless @locked
-        Thread.critical = true
-        @locked = false
-        wakeup_and_run_waiting_thread
-        self
-      end
-
-      # @private
-      def synchronize
-        lock
-        begin
-          yield
-        ensure
-          unlock
-        end
-      end
-
-    private
-
-      def wakeup_and_run_waiting_thread
-        begin
-          t = @waiting.shift
-          t.wakeup if t
-        rescue ThreadError
-          retry
-        end
-        Thread.critical = false
-        begin
-          t.run if t
-        rescue ThreadError
-          :noop
-        end
-      end
-
-      # Avoid warnings for library wide checks spec
-    end unless defined?(::RSpec::Support::Mutex) || defined?(::Mutex)
-  end
-end

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

@@ -1,275 +0,0 @@
-RSpec::Support.require_rspec_support 'matcher_definition'
-
-module RSpec
-  module Support
-    # Provide additional output details beyond what `inspect` provides when
-    # printing Time, DateTime, or BigDecimal
-    # @api private
-    class ObjectFormatter # rubocop:disable Metrics/ClassLength
-      ELLIPSIS = "..."
-
-      attr_accessor :max_formatted_output_length
-
-      # Methods are deferred to a default instance of the class to maintain the interface
-      # For example, calling ObjectFormatter.format is still possible
-      def self.default_instance
-        @default_instance ||= new
-      end
-
-      def self.format(object)
-        default_instance.format(object)
-      end
-
-      def self.prepare_for_inspection(object)
-        default_instance.prepare_for_inspection(object)
-      end
-
-      def initialize(max_formatted_output_length=200)
-        @max_formatted_output_length = max_formatted_output_length
-        @current_structure_stack = []
-      end
-
-      def format(object)
-        if max_formatted_output_length.nil?
-          prepare_for_inspection(object).inspect
-        else
-          formatted_object = prepare_for_inspection(object).inspect
-          if formatted_object.length < max_formatted_output_length
-            formatted_object
-          else
-            beginning = truncate_string formatted_object, 0, max_formatted_output_length / 2
-            ending = truncate_string formatted_object, -max_formatted_output_length / 2, -1
-            beginning + ELLIPSIS + ending
-          end
-        end
-      end
-
-      # Prepares the provided object to be formatted by wrapping it as needed
-      # in something that, when `inspect` is called on it, will produce the
-      # desired output.
-      #
-      # This allows us to apply the desired formatting to hash/array data structures
-      # at any level of nesting, simply by walking that structure and replacing items
-      # with custom items that have `inspect` defined to return the desired output
-      # for that item. Then we can just use `Array#inspect` or `Hash#inspect` to
-      # format the entire thing.
-      def prepare_for_inspection(object)
-        case object
-        when Array
-          prepare_array(object)
-        when Hash
-          prepare_hash(object)
-        else
-          inspector_class = INSPECTOR_CLASSES.find { |inspector| inspector.can_inspect?(object) }
-          inspector_class.new(object, self)
-        end
-      end
-
-      def prepare_array(array)
-        with_entering_structure(array) do
-          array.map { |element| prepare_element(element) }
-        end
-      end
-
-      def prepare_hash(input_hash)
-        with_entering_structure(input_hash) do
-          sort_hash_keys(input_hash).inject({}) do |output_hash, key_and_value|
-            key, value = key_and_value.map { |element| prepare_element(element) }
-            output_hash[key] = value
-            output_hash
-          end
-        end
-      end
-
-      def sort_hash_keys(input_hash)
-        if input_hash.keys.all? { |k| k.is_a?(String) || k.is_a?(Symbol) }
-          Hash[input_hash.sort_by { |k, _v| k.to_s }]
-        else
-          input_hash
-        end
-      end
-
-      def prepare_element(element)
-        if recursive_structure?(element)
-          case element
-          when Array then InspectableItem.new('[...]')
-          when Hash then InspectableItem.new('{...}')
-          else raise # This won't happen
-          end
-        else
-          prepare_for_inspection(element)
-        end
-      end
-
-      def with_entering_structure(structure)
-        @current_structure_stack.push(structure)
-        return_value = yield
-        @current_structure_stack.pop
-        return_value
-      end
-
-      def recursive_structure?(object)
-        @current_structure_stack.any? { |seen_structure| seen_structure.equal?(object) }
-      end
-
-      InspectableItem = Struct.new(:text) do
-        def inspect
-          text
-        end
-
-        def pretty_print(pp)
-          pp.text(text)
-        end
-      end
-
-      BaseInspector = Struct.new(:object, :formatter) do
-        def self.can_inspect?(_object)
-          raise NotImplementedError
-        end
-
-        def inspect
-          raise NotImplementedError
-        end
-
-        def pretty_print(pp)
-          pp.text(inspect)
-        end
-      end
-
-      class TimeInspector < BaseInspector
-        FORMAT = "%Y-%m-%d %H:%M:%S"
-
-        def self.can_inspect?(object)
-          Time === object
-        end
-
-        if Time.method_defined?(:nsec)
-          def inspect
-            object.strftime("#{FORMAT}.#{"%09d" % object.nsec} %z")
-          end
-        else # for 1.8.7
-          def inspect
-            object.strftime("#{FORMAT}.#{"%06d" % object.usec} %z")
-          end
-        end
-      end
-
-      class DateTimeInspector < BaseInspector
-        FORMAT = "%a, %d %b %Y %H:%M:%S.%N %z"
-
-        def self.can_inspect?(object)
-          defined?(DateTime) && DateTime === object
-        end
-
-        # ActiveSupport sometimes overrides inspect. If `ActiveSupport` is
-        # defined use a custom format string that includes more time precision.
-        def inspect
-          if defined?(ActiveSupport)
-            object.strftime(FORMAT)
-          else
-            object.inspect
-          end
-        end
-      end
-
-      class BigDecimalInspector < BaseInspector
-        def self.can_inspect?(object)
-          defined?(BigDecimal) && BigDecimal === object
-        end
-
-        def inspect
-          "#{object.to_s('F')} (#{object.inspect})"
-        end
-      end
-
-      class DescribableMatcherInspector < BaseInspector
-        def self.can_inspect?(object)
-          Support.is_a_matcher?(object) && object.respond_to?(:description)
-        end
-
-        def inspect
-          object.description
-        end
-      end
-
-      class UninspectableObjectInspector < BaseInspector
-        OBJECT_ID_FORMAT = '%#016x'
-
-        def self.can_inspect?(object)
-          object.inspect
-          false
-        rescue NoMethodError
-          true
-        end
-
-        def inspect
-          "#<#{klass}:#{native_object_id}>"
-        end
-
-        def klass
-          Support.class_of(object)
-        end
-
-        # http://stackoverflow.com/a/2818916
-        def native_object_id
-          OBJECT_ID_FORMAT % (object.__id__ << 1)
-        rescue NoMethodError
-          # In Ruby 1.9.2, BasicObject responds to none of #__id__, #object_id, #id...
-          '-'
-        end
-      end
-
-      class DelegatorInspector < BaseInspector
-        def self.can_inspect?(object)
-          defined?(Delegator) && Delegator === object
-        end
-
-        def inspect
-          "#<#{object.class}(#{formatter.format(object.send(:__getobj__))})>"
-        end
-      end
-
-      class InspectableObjectInspector < BaseInspector
-        def self.can_inspect?(object)
-          object.inspect
-          true
-        rescue NoMethodError
-          false
-        end
-
-        def inspect
-          object.inspect
-        end
-      end
-
-      INSPECTOR_CLASSES = [
-        TimeInspector,
-        DateTimeInspector,
-        BigDecimalInspector,
-        UninspectableObjectInspector,
-        DescribableMatcherInspector,
-        DelegatorInspector,
-        InspectableObjectInspector
-      ].tap do |classes|
-        # 2.4 has improved BigDecimal formatting so we do not need
-        # to provide our own.
-        # https://github.com/ruby/bigdecimal/pull/42
-        classes.delete(BigDecimalInspector) if RUBY_VERSION >= '2.4'
-      end
-
-    private
-
-      # Returns the substring defined by the start_index and end_index
-      # If the string ends with a partial ANSI code code then that
-      # will be removed as printing partial ANSI
-      # codes to the terminal can lead to corruption
-      def truncate_string(str, start_index, end_index)
-        cut_str = str[start_index..end_index]
-
-        # ANSI color codes are like: \e[33m so anything with \e[ and a
-        # number without a 'm' is an incomplete color code
-        cut_str.sub(/\e\[\d+$/, '')
-      end
-    end
-  end
-end

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

@@ -1,76 +0,0 @@
-module RSpec
-  module Support
-    # Provides recursive constant lookup methods useful for
-    # constant stubbing.
-    module RecursiveConstMethods
-      # We only want to consider constants that are defined directly on a
-      # particular module, and not include top-level/inherited constants.
-      # Unfortunately, the constant API changed between 1.8 and 1.9, so
-      # we need to conditionally define methods to ignore the top-level/inherited
-      # constants.
-      #
-      # Given:
-      #   class A; B = 1; end
-      #   class C < A; end
-      #
-      # On 1.8:
-      #   - C.const_get("Hash") # => ::Hash
-      #   - C.const_defined?("Hash") # => false
-      #   - C.constants # => ["B"]
-      #   - None of these methods accept the extra `inherit` argument
-      # On 1.9:
-      #   - C.const_get("Hash") # => ::Hash
-      #   - C.const_defined?("Hash") # => true
-      #   - C.const_get("Hash", false) # => raises NameError
-      #   - C.const_defined?("Hash", false) # => false
-      #   - C.constants # => [:B]
-      #   - C.constants(false) #=> []
-      if Module.method(:const_defined?).arity == 1
-        def const_defined_on?(mod, const_name)
-          mod.const_defined?(const_name)
-        end
-
-        def get_const_defined_on(mod, const_name)
-          return mod.const_get(const_name) if const_defined_on?(mod, const_name)
-
-          raise NameError, "uninitialized constant #{mod.name}::#{const_name}"
-        end
-
-        def constants_defined_on(mod)
-          mod.constants.select { |c| const_defined_on?(mod, c) }
-        end
-      else
-        def const_defined_on?(mod, const_name)
-          mod.const_defined?(const_name, false)
-        end
-
-        def get_const_defined_on(mod, const_name)
-          mod.const_get(const_name, false)
-        end
-
-        def constants_defined_on(mod)
-          mod.constants(false)
-        end
-      end
-
-      def recursive_const_get(const_name)
-        normalize_const_name(const_name).split('::').inject(Object) do |mod, name|
-          get_const_defined_on(mod, name)
-        end
-      end
-
-      def recursive_const_defined?(const_name)
-        parts = normalize_const_name(const_name).split('::')
-        parts.inject([Object, '']) do |(mod, full_name), name|
-          yield(full_name, name) if block_given? && !(Module === mod)
-          return false unless const_defined_on?(mod, name)
-          [get_const_defined_on(mod, name), [mod.name, name].join('::')]
-        end
-      end
-
-      def normalize_const_name(const_name)
-        const_name.sub(/\A::/, '')
-      end
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-module RSpec
-  module Support
-    # Allows a thread to lock out other threads from a critical section of code,
-    # while allowing the thread with the lock to reenter that section.
-    #
-    # Based on Monitor as of 2.2 -
-    # https://github.com/ruby/ruby/blob/eb7ddaa3a47bf48045d26c72eb0f263a53524ebc/lib/monitor.rb#L9
-    #
-    # Depends on Mutex, but Mutex is only available as part of core since 1.9.1:
-    #   exists - http://ruby-doc.org/core-1.9.1/Mutex.html
-    #   dne    - http://ruby-doc.org/core-1.9.0/Mutex.html
-    #
-    # @private
-    class ReentrantMutex
-      def initialize
-        @owner = nil
-        @count = 0
-        @mutex = Mutex.new
-      end
-
-      def synchronize
-        enter
-        yield
-      ensure
-        exit
-      end
-
-    private
-
-      def enter
-        @mutex.lock if @owner != Thread.current
-        @owner = Thread.current
-        @count += 1
-      end
-
-      def exit
-        @count -= 1
-        return unless @count == 0
-        @owner = nil
-        @mutex.unlock
-      end
-    end
-
-    if defined? ::Mutex
-      # On 1.9 and up, this is in core, so we just use the real one
-      class Mutex < ::Mutex
-        # If you mock Mutex.new you break our usage of Mutex, so
-        # instead we capture the original method to return Mutexs.
-        NEW_MUTEX_METHOD = Mutex.method(:new)
-
-        def self.new
-          NEW_MUTEX_METHOD.call
-        end
-      end
-    else # For 1.8.7
-      # :nocov:
-      RSpec::Support.require_rspec_support "mutex"
-      # :nocov:
-    end
-  end
-end