bibtex_to_scrapbox 0.1.0

data/gems/gems/rspec-support-3.6.0/lib/rspec/support/mutex.rb

@@ -0,0 +1,73 @@
+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/gems/gems/rspec-support-3.6.0/lib/rspec/support/object_formatter.rb

@@ -0,0 +1,268 @@
+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 Style/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?
+          return prepare_for_inspection(object).inspect
+        else
+          formatted_object = prepare_for_inspection(object).inspect
+          if formatted_object.length < max_formatted_output_length
+            return 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
+            return 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
+          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 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
+          singleton_class = class << object; self; end
+          singleton_class.ancestors.find { |ancestor| !ancestor.equal?(singleton_class) }
+        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.__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/gems/gems/rspec-support-3.6.0/lib/rspec/support/recursive_const_methods.rb

@@ -0,0 +1,76 @@
+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].join('::')]
+        end
+      end
+
+      def normalize_const_name(const_name)
+        const_name.sub(/\A::/, '')
+      end
+    end
+  end
+end

data/gems/gems/rspec-support-3.6.0/lib/rspec/support/reentrant_mutex.rb

@@ -0,0 +1,53 @@
+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
+      Mutex = ::Mutex
+    else # For 1.8.7
+      # :nocov:
+      RSpec::Support.require_rspec_support "mutex"
+      # :nocov:
+    end
+  end
+end