hatena_bookmark_client_for_ruby 0.1.0

data/vendor/bundle/ruby/2.6.0/gems/rspec-support-3.8.0/LICENSE.md

@@ -0,0 +1,23 @@
+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/vendor/bundle/ruby/2.6.0/gems/rspec-support-3.8.0/README.md

@@ -0,0 +1,40 @@
+# 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/vendor/bundle/ruby/2.6.0/gems/rspec-support-3.8.0/lib/rspec/support.rb

@@ -0,0 +1,149 @@
+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 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/vendor/bundle/ruby/2.6.0/gems/rspec-support-3.8.0/lib/rspec/support/caller_filter.rb

@@ -0,0 +1,83 @@
+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/vendor/bundle/ruby/2.6.0/gems/rspec-support-3.8.0/lib/rspec/support/comparable_version.rb

@@ -0,0 +1,46 @@
+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/vendor/bundle/ruby/2.6.0/gems/rspec-support-3.8.0/lib/rspec/support/differ.rb

@@ -0,0 +1,215 @@
+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 = ""
+
+        if actual && expected
+          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")
+          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