logstash-output-scalyr 0.1.9 → 0.1.14.beta

data/vendor/bundle/jruby/2.5.0/gems/hashdiff-1.0.1/lib/hashdiff.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'hashdiff/util'
+require 'hashdiff/compare_hashes'
+require 'hashdiff/lcs'
+require 'hashdiff/lcs_compare_arrays'
+require 'hashdiff/linear_compare_array'
+require 'hashdiff/diff'
+require 'hashdiff/patch'
+require 'hashdiff/version'

data/vendor/bundle/jruby/2.5.0/gems/hashdiff-1.0.1/lib/hashdiff/compare_hashes.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Hashdiff
+  # @private
+  # Used to compare hashes
+  class CompareHashes
+    class << self
+      def call(obj1, obj2, opts = {})
+        return [] if obj1.empty? && obj2.empty?
+
+        obj1_keys = obj1.keys
+        obj2_keys = obj2.keys
+        obj1_lookup = {}
+        obj2_lookup = {}
+
+        if opts[:indifferent]
+          obj1_lookup = obj1_keys.each_with_object({}) { |k, h| h[k.to_s] = k }
+          obj2_lookup = obj2_keys.each_with_object({}) { |k, h| h[k.to_s] = k }
+          obj1_keys = obj1_keys.map { |k| k.is_a?(Symbol) ? k.to_s : k }
+          obj2_keys = obj2_keys.map { |k| k.is_a?(Symbol) ? k.to_s : k }
+        end
+
+        added_keys = (obj2_keys - obj1_keys).sort_by(&:to_s)
+        common_keys = (obj1_keys & obj2_keys).sort_by(&:to_s)
+        deleted_keys = (obj1_keys - obj2_keys).sort_by(&:to_s)
+
+        result = []
+
+        # add deleted properties
+        deleted_keys.each do |k|
+          k = opts[:indifferent] ? obj1_lookup[k] : k
+          change_key = Hashdiff.prefix_append_key(opts[:prefix], k, opts)
+          custom_result = Hashdiff.custom_compare(opts[:comparison], change_key, obj1[k], nil)
+
+          if custom_result
+            result.concat(custom_result)
+          else
+            result << ['-', change_key, obj1[k]]
+          end
+        end
+
+        # recursive comparison for common keys
+        common_keys.each do |k|
+          prefix = Hashdiff.prefix_append_key(opts[:prefix], k, opts)
+
+          k1 = opts[:indifferent] ? obj1_lookup[k] : k
+          k2 = opts[:indifferent] ? obj2_lookup[k] : k
+          result.concat(Hashdiff.diff(obj1[k1], obj2[k2], opts.merge(prefix: prefix)))
+        end
+
+        # added properties
+        added_keys.each do |k|
+          change_key = Hashdiff.prefix_append_key(opts[:prefix], k, opts)
+
+          k = opts[:indifferent] ? obj2_lookup[k] : k
+          custom_result = Hashdiff.custom_compare(opts[:comparison], change_key, nil, obj2[k])
+
+          if custom_result
+            result.concat(custom_result)
+          else
+            result << ['+', change_key, obj2[k]]
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/vendor/bundle/jruby/2.5.0/gems/hashdiff-1.0.1/lib/hashdiff/diff.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Hashdiff
+  # Best diff two objects, which tries to generate the smallest change set using different similarity values.
+  #
+  # Hashdiff.best_diff is useful in case of comparing two objects which include similar hashes in arrays.
+  #
+  # @param [Array, Hash] obj1
+  # @param [Array, Hash] obj2
+  # @param [Hash] options the options to use when comparing
+  #   * :strict (Boolean) [true] whether numeric values will be compared on type as well as value.  Set to false to allow comparing Integer, Float, BigDecimal to each other
+  #   * :indifferent (Boolean) [false] whether to treat hash keys indifferently.  Set to true to ignore differences between symbol keys (ie. {a: 1} ~= {'a' => 1})
+  #   * :delimiter (String) ['.'] the delimiter used when returning nested key references
+  #   * :numeric_tolerance (Numeric) [0] should be a positive numeric value.  Value by which numeric differences must be greater than.  By default, numeric values are compared exactly; with the :tolerance option, the difference between numeric values must be greater than the given value.
+  #   * :strip (Boolean) [false] whether or not to call #strip on strings before comparing
+  #   * :array_path (Boolean) [false] whether to return the path references for nested values in an array, can be used for patch compatibility with non string keys.
+  #   * :use_lcs (Boolean) [true] whether or not to use an implementation of the Longest common subsequence algorithm for comparing arrays, produces better diffs but is slower.
+  #
+  # @yield [path, value1, value2] Optional block is used to compare each value, instead of default #==. If the block returns value other than true of false, then other specified comparison options will be used to do the comparison.
+  #
+  # @return [Array] an array of changes.
+  #   e.g. [[ '+', 'a.b', '45' ], [ '-', 'a.c', '5' ], [ '~', 'a.x', '45', '63']]
+  #
+  # @example
+  #   a = {'x' => [{'a' => 1, 'c' => 3, 'e' => 5}, {'y' => 3}]}
+  #   b = {'x' => [{'a' => 1, 'b' => 2, 'e' => 5}] }
+  #   diff = Hashdiff.best_diff(a, b)
+  #   diff.should == [['-', 'x[0].c', 3], ['+', 'x[0].b', 2], ['-', 'x[1].y', 3], ['-', 'x[1]', {}]]
+  #
+  # @since 0.0.1
+  def self.best_diff(obj1, obj2, options = {}, &block)
+    options[:comparison] = block if block_given?
+
+    opts = { similarity: 0.3 }.merge!(options)
+    diffs1 = diff(obj1, obj2, opts)
+    count1 = count_diff diffs1
+
+    opts = { similarity: 0.5 }.merge!(options)
+    diffs2 = diff(obj1, obj2, opts)
+    count2 = count_diff diffs2
+
+    opts = { similarity: 0.8 }.merge!(options)
+    diffs3 = diff(obj1, obj2, opts)
+    count3 = count_diff diffs3
+
+    count, diffs = count1 < count2 ? [count1, diffs1] : [count2, diffs2]
+    count < count3 ? diffs : diffs3
+  end
+
+  # Compute the diff of two hashes or arrays
+  #
+  # @param [Array, Hash] obj1
+  # @param [Array, Hash] obj2
+  # @param [Hash] options the options to use when comparing
+  #   * :strict (Boolean) [true] whether numeric values will be compared on type as well as value.  Set to false to allow comparing Integer, Float, BigDecimal to each other
+  #   * :indifferent (Boolean) [false] whether to treat hash keys indifferently.  Set to true to ignore differences between symbol keys (ie. {a: 1} ~= {'a' => 1})
+  #   * :similarity (Numeric) [0.8] should be between (0, 1]. Meaningful if there are similar hashes in arrays. See {best_diff}.
+  #   * :delimiter (String) ['.'] the delimiter used when returning nested key references
+  #   * :numeric_tolerance (Numeric) [0] should be a positive numeric value.  Value by which numeric differences must be greater than.  By default, numeric values are compared exactly; with the :tolerance option, the difference between numeric values must be greater than the given value.
+  #   * :strip (Boolean) [false] whether or not to call #strip on strings before comparing
+  #   * :array_path (Boolean) [false] whether to return the path references for nested values in an array, can be used for patch compatibility with non string keys.
+  #   * :use_lcs (Boolean) [true] whether or not to use an implementation of the Longest common subsequence algorithm for comparing arrays, produces better diffs but is slower.
+  #
+  #
+  # @yield [path, value1, value2] Optional block is used to compare each value, instead of default #==. If the block returns value other than true of false, then other specified comparison options will be used to do the comparison.
+  #
+  # @return [Array] an array of changes.
+  #   e.g. [[ '+', 'a.b', '45' ], [ '-', 'a.c', '5' ], [ '~', 'a.x', '45', '63']]
+  #
+  # @example
+  #   a = {"a" => 1, "b" => {"b1" => 1, "b2" =>2}}
+  #   b = {"a" => 1, "b" => {}}
+  #
+  #   diff = Hashdiff.diff(a, b)
+  #   diff.should == [['-', 'b.b1', 1], ['-', 'b.b2', 2]]
+  #
+  # @since 0.0.1
+  def self.diff(obj1, obj2, options = {}, &block)
+    opts = {
+      prefix: '',
+      similarity: 0.8,
+      delimiter: '.',
+      strict: true,
+      indifferent: false,
+      strip: false,
+      numeric_tolerance: 0,
+      array_path: false,
+      use_lcs: true
+    }.merge!(options)
+
+    opts[:prefix] = [] if opts[:array_path] && opts[:prefix] == ''
+
+    opts[:comparison] = block if block_given?
+
+    # prefer to compare with provided block
+    result = custom_compare(opts[:comparison], opts[:prefix], obj1, obj2)
+    return result if result
+
+    return [] if obj1.nil? && obj2.nil?
+
+    return [['~', opts[:prefix], obj1, obj2]] if obj1.nil? || obj2.nil?
+
+    return [['~', opts[:prefix], obj1, obj2]] unless comparable?(obj1, obj2, opts[:strict])
+
+    return LcsCompareArrays.call(obj1, obj2, opts) if obj1.is_a?(Array) && opts[:use_lcs]
+
+    return LinearCompareArray.call(obj1, obj2, opts) if obj1.is_a?(Array) && !opts[:use_lcs]
+
+    return CompareHashes.call(obj1, obj2, opts) if obj1.is_a?(Hash)
+
+    return [] if compare_values(obj1, obj2, opts)
+
+    [['~', opts[:prefix], obj1, obj2]]
+  end
+
+  # @private
+  #
+  # diff array using LCS algorithm
+  def self.diff_array_lcs(arraya, arrayb, options = {})
+    return [] if arraya.empty? && arrayb.empty?
+
+    change_set = []
+
+    if arraya.empty?
+      arrayb.each_index do |index|
+        change_set << ['+', index, arrayb[index]]
+      end
+
+      return change_set
+    end
+
+    if arrayb.empty?
+      arraya.each_index do |index|
+        i = arraya.size - index - 1
+        change_set << ['-', i, arraya[i]]
+      end
+
+      return change_set
+    end
+
+    opts = {
+      prefix: '',
+      similarity: 0.8,
+      delimiter: '.'
+    }.merge!(options)
+
+    links = lcs(arraya, arrayb, opts)
+
+    # yield common
+    yield links if block_given?
+
+    # padding the end
+    links << [arraya.size, arrayb.size]
+
+    last_x = -1
+    last_y = -1
+    links.each do |pair|
+      x, y = pair
+
+      # remove from a, beginning from the end
+      (x > last_x + 1) && (x - last_x - 2).downto(0).each do |i|
+        change_set << ['-', last_y + i + 1, arraya[i + last_x + 1]]
+      end
+
+      # add from b, beginning from the head
+      (y > last_y + 1) && 0.upto(y - last_y - 2).each do |i|
+        change_set << ['+', last_y + i + 1, arrayb[i + last_y + 1]]
+      end
+
+      # update flags
+      last_x = x
+      last_y = y
+    end
+
+    change_set
+  end
+end

data/vendor/bundle/jruby/2.5.0/gems/hashdiff-1.0.1/lib/hashdiff/lcs.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Hashdiff
+  # @private
+  #
+  # caculate array difference using LCS algorithm
+  # http://en.wikipedia.org/wiki/Longest_common_subsequence_problem
+  def self.lcs(arraya, arrayb, options = {})
+    return [] if arraya.empty? || arrayb.empty?
+
+    opts = { similarity: 0.8 }.merge!(options)
+
+    opts[:prefix] = prefix_append_array_index(opts[:prefix], '*', opts)
+
+    a_start = b_start = 0
+    a_finish = arraya.size - 1
+    b_finish = arrayb.size - 1
+    vector = []
+
+    lcs = []
+    (b_start..b_finish).each do |bi|
+      lcs[bi] = []
+      (a_start..a_finish).each do |ai|
+        if similar?(arraya[ai], arrayb[bi], opts)
+          topleft = (ai > 0) && (bi > 0) ? lcs[bi - 1][ai - 1][1] : 0
+          lcs[bi][ai] = [:topleft, topleft + 1]
+        elsif (top = bi > 0 ? lcs[bi - 1][ai][1] : 0)
+          left = ai > 0 ? lcs[bi][ai - 1][1] : 0
+          count = top > left ? top : left
+
+          direction = if top > left
+                        :top
+                      elsif top < left
+                        :left
+                      elsif bi.zero?
+                        :top
+                      elsif ai.zero?
+                        :left
+                      else
+                        :both
+                      end
+
+          lcs[bi][ai] = [direction, count]
+        end
+      end
+    end
+
+    x = a_finish
+    y = b_finish
+    while (x >= 0) && (y >= 0) && (lcs[y][x][1] > 0)
+      if lcs[y][x][0] == :both
+        x -= 1
+      elsif lcs[y][x][0] == :topleft
+        vector.insert(0, [x, y])
+        x -= 1
+        y -= 1
+      elsif lcs[y][x][0] == :top
+        y -= 1
+      elsif lcs[y][x][0] == :left
+        x -= 1
+      end
+    end
+
+    vector
+  end
+end

data/vendor/bundle/jruby/2.5.0/gems/hashdiff-1.0.1/lib/hashdiff/lcs_compare_arrays.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Hashdiff
+  # @private
+  # Used to compare arrays using the lcs algorithm
+  class LcsCompareArrays
+    class << self
+      def call(obj1, obj2, opts = {})
+        result = []
+
+        changeset = Hashdiff.diff_array_lcs(obj1, obj2, opts) do |lcs|
+          # use a's index for similarity
+          lcs.each do |pair|
+            prefix = Hashdiff.prefix_append_array_index(opts[:prefix], pair[0], opts)
+
+            result.concat(Hashdiff.diff(obj1[pair[0]], obj2[pair[1]], opts.merge(prefix: prefix)))
+          end
+        end
+
+        changeset.each do |change|
+          next if change[0] != '-' && change[0] != '+'
+
+          change_key = Hashdiff.prefix_append_array_index(opts[:prefix], change[1], opts)
+
+          result << [change[0], change_key, change[2]]
+        end
+
+        result
+      end
+    end
+  end
+end

data/vendor/bundle/jruby/2.5.0/gems/hashdiff-1.0.1/lib/hashdiff/linear_compare_array.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Hashdiff
+  # @private
+  #
+  # Used to compare arrays in a linear complexity, which produces longer diffs
+  # than using the lcs algorithm but is considerably faster
+  class LinearCompareArray
+    def self.call(old_array, new_array, options = {})
+      instance = new(old_array, new_array, options)
+      instance.call
+    end
+
+    def call
+      return [] if old_array.empty? && new_array.empty?
+
+      self.old_index = 0
+      self.new_index = 0
+      # by comparing the array lengths we can expect that a number of items
+      # are either added or removed
+      self.expected_additions = new_array.length - old_array.length
+
+      loop do
+        if extra_items_in_old_array?
+          append_deletion(old_array[old_index], old_index)
+        elsif extra_items_in_new_array?
+          append_addition(new_array[new_index], new_index)
+        else
+          compare_at_index
+        end
+
+        self.old_index = old_index + 1
+        self.new_index = new_index + 1
+        break if iterated_through_both_arrays?
+      end
+
+      changes
+    end
+
+    private
+
+    attr_reader :old_array, :new_array, :options, :additions, :deletions, :differences
+    attr_accessor :old_index, :new_index, :expected_additions
+
+    def initialize(old_array, new_array, options)
+      @old_array = old_array
+      @new_array = new_array
+      @options = { prefix: '' }.merge!(options)
+
+      @additions = []
+      @deletions = []
+      @differences = []
+    end
+
+    def extra_items_in_old_array?
+      old_index < old_array.length && new_index >= new_array.length
+    end
+
+    def extra_items_in_new_array?
+      new_index < new_array.length && old_index >= old_array.length
+    end
+
+    def iterated_through_both_arrays?
+      old_index >= old_array.length && new_index >= new_array.length
+    end
+
+    def compare_at_index
+      difference = item_difference(old_array[old_index], new_array[new_index], old_index)
+      return if difference.empty?
+
+      index_after_additions = index_of_match_after_additions
+      append_addititions_before_match(index_after_additions)
+
+      index_after_deletions = index_of_match_after_deletions
+      append_deletions_before_match(index_after_deletions)
+
+      match = index_after_additions || index_after_deletions
+
+      append_differences(difference) unless match
+    end
+
+    def item_difference(old_item, new_item, item_index)
+      prefix = Hashdiff.prefix_append_array_index(options[:prefix], item_index, options)
+      Hashdiff.diff(old_item, new_item, options.merge(prefix: prefix))
+    end
+
+    # look ahead in the new array to see if the current item appears later
+    # thereby having new items added
+    def index_of_match_after_additions
+      return unless expected_additions > 0
+
+      (1..expected_additions).each do |i|
+        next_difference = item_difference(
+          old_array[old_index],
+          new_array[new_index + i],
+          old_index
+        )
+
+        return new_index + i if next_difference.empty?
+      end
+
+      nil
+    end
+
+    # look ahead in the old array to see if the current item appears later
+    # thereby having items removed
+    def index_of_match_after_deletions
+      return unless expected_additions < 0
+
+      (1..(expected_additions.abs)).each do |i|
+        next_difference = item_difference(
+          old_array[old_index + i],
+          new_array[new_index],
+          old_index
+        )
+
+        return old_index + i if next_difference.empty?
+      end
+
+      nil
+    end
+
+    def append_addititions_before_match(match_index)
+      return unless match_index
+
+      (new_index...match_index).each { |i| append_addition(new_array[i], i) }
+      self.expected_additions = expected_additions - (match_index - new_index)
+      self.new_index = match_index
+    end
+
+    def append_deletions_before_match(match_index)
+      return unless match_index
+
+      (old_index...match_index).each { |i| append_deletion(old_array[i], i) }
+      self.expected_additions = expected_additions + (match_index - new_index)
+      self.old_index = match_index
+    end
+
+    def append_addition(item, index)
+      key = Hashdiff.prefix_append_array_index(options[:prefix], index, options)
+      additions << ['+', key, item]
+    end
+
+    def append_deletion(item, index)
+      key = Hashdiff.prefix_append_array_index(options[:prefix], index, options)
+      deletions << ['-', key, item]
+    end
+
+    def append_differences(difference)
+      differences.concat(difference)
+    end
+
+    def changes
+      # this algorithm only allows there to be additions or deletions
+      # deletions are reverse so they don't change the index of earlier items
+      differences + additions + deletions.reverse
+    end
+  end
+end