honeybadger 5.4.0 → 5.4.1

data/vendor/bundle/ruby/3.2.0/gems/hashdiff-1.0.1/lib/hashdiff/diff.rb

@@ -1,177 +0,0 @@
-# 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/ruby/3.2.0/gems/hashdiff-1.0.1/lib/hashdiff/lcs.rb

@@ -1,66 +0,0 @@
-# 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/ruby/3.2.0/gems/hashdiff-1.0.1/lib/hashdiff/lcs_compare_arrays.rb

@@ -1,32 +0,0 @@
-# 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/ruby/3.2.0/gems/hashdiff-1.0.1/lib/hashdiff/linear_compare_array.rb

@@ -1,159 +0,0 @@
-# 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

data/vendor/bundle/ruby/3.2.0/gems/hashdiff-1.0.1/lib/hashdiff/patch.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-#
-# This module provides methods to diff two hash, patch and unpatch hash
-#
-module Hashdiff
-  # Apply patch to object
-  #
-  # @param [Hash, Array] obj the object to be patched, can be an Array or a Hash
-  # @param [Array] changes e.g. [[ '+', 'a.b', '45' ], [ '-', 'a.c', '5' ], [ '~', 'a.x', '45', '63']]
-  # @param [Hash] options supports following keys:
-  #   * :delimiter (String) ['.'] delimiter string for representing nested keys in changes array
-  #
-  # @return the object after patch
-  #
-  # @since 0.0.1
-  def self.patch!(obj, changes, options = {})
-    delimiter = options[:delimiter] || '.'
-
-    changes.each do |change|
-      parts = change[1]
-      parts = decode_property_path(parts, delimiter) unless parts.is_a?(Array)
-
-      last_part = parts.last
-
-      parent_node = node(obj, parts[0, parts.size - 1])
-
-      if change[0] == '+'
-        if parent_node.is_a?(Array)
-          parent_node.insert(last_part, change[2])
-        else
-          parent_node[last_part] = change[2]
-        end
-      elsif change[0] == '-'
-        if parent_node.is_a?(Array)
-          parent_node.delete_at(last_part)
-        else
-          parent_node.delete(last_part)
-        end
-      elsif change[0] == '~'
-        parent_node[last_part] = change[3]
-      end
-    end
-
-    obj
-  end
-
-  # Unpatch an object
-  #
-  # @param [Hash, Array] obj the object to be unpatched, can be an Array or a Hash
-  # @param [Array] changes e.g. [[ '+', 'a.b', '45' ], [ '-', 'a.c', '5' ], [ '~', 'a.x', '45', '63']]
-  # @param [Hash] options supports following keys:
-  #   * :delimiter (String) ['.'] delimiter string for representing nested keys in changes array
-  #
-  # @return the object after unpatch
-  #
-  # @since 0.0.1
-  def self.unpatch!(obj, changes, options = {})
-    delimiter = options[:delimiter] || '.'
-
-    changes.reverse_each do |change|
-      parts = change[1]
-      parts = decode_property_path(parts, delimiter) unless parts.is_a?(Array)
-
-      last_part = parts.last
-
-      parent_node = node(obj, parts[0, parts.size - 1])
-
-      if change[0] == '+'
-        if parent_node.is_a?(Array)
-          parent_node.delete_at(last_part)
-        else
-          parent_node.delete(last_part)
-        end
-      elsif change[0] == '-'
-        if parent_node.is_a?(Array)
-          parent_node.insert(last_part, change[2])
-        else
-          parent_node[last_part] = change[2]
-        end
-      elsif change[0] == '~'
-        parent_node[last_part] = change[2]
-      end
-    end
-
-    obj
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/hashdiff-1.0.1/lib/hashdiff/util.rb

@@ -1,155 +0,0 @@
-# frozen_string_literal: true
-
-module Hashdiff
-  # @private
-  #
-  # judge whether two objects are similar
-  def self.similar?(obja, objb, options = {})
-    return compare_values(obja, objb, options) if !options[:comparison] && !any_hash_or_array?(obja, objb)
-
-    count_a = count_nodes(obja)
-    count_b = count_nodes(objb)
-
-    return true if (count_a + count_b).zero?
-
-    opts = { similarity: 0.8 }.merge!(options)
-
-    diffs = count_diff diff(obja, objb, opts)
-
-    (1 - diffs / (count_a + count_b).to_f) >= opts[:similarity]
-  end
-
-  # @private
-  #
-  # count node differences
-  def self.count_diff(diffs)
-    diffs.inject(0) do |sum, item|
-      old_change_count = count_nodes(item[2])
-      new_change_count = count_nodes(item[3])
-      sum + (old_change_count + new_change_count)
-    end
-  end
-
-  # @private
-  #
-  # count total nodes for an object
-  def self.count_nodes(obj)
-    return 0 unless obj
-
-    count = 0
-    if obj.is_a?(Array)
-      obj.each { |e| count += count_nodes(e) }
-    elsif obj.is_a?(Hash)
-      obj.each_value { |v| count += count_nodes(v) }
-    else
-      return 1
-    end
-
-    count
-  end
-
-  # @private
-  #
-  # decode property path into an array
-  # @param [String] path Property-string
-  # @param [String] delimiter Property-string delimiter
-  #
-  # e.g. "a.b[3].c" => ['a', 'b', 3, 'c']
-  def self.decode_property_path(path, delimiter = '.')
-    path.split(delimiter).inject([]) do |memo, part|
-      if part =~ /^(.*)\[(\d+)\]$/
-        if !Regexp.last_match(1).empty?
-          memo + [Regexp.last_match(1), Regexp.last_match(2).to_i]
-        else
-          memo + [Regexp.last_match(2).to_i]
-        end
-      else
-        memo + [part]
-      end
-    end
-  end
-
-  # @private
-  #
-  # get the node of hash by given path parts
-  def self.node(hash, parts)
-    temp = hash
-    parts.each do |part|
-      temp = temp[part]
-    end
-    temp
-  end
-
-  # @private
-  #
-  # check for equality or "closeness" within given tolerance
-  def self.compare_values(obj1, obj2, options = {})
-    if options[:numeric_tolerance].is_a?(Numeric) &&
-       obj1.is_a?(Numeric) && obj2.is_a?(Numeric)
-      return (obj1 - obj2).abs <= options[:numeric_tolerance]
-    end
-
-    if options[:strip] == true
-      obj1 = obj1.strip if obj1.respond_to?(:strip)
-      obj2 = obj2.strip if obj2.respond_to?(:strip)
-    end
-
-    if options[:case_insensitive] == true
-      obj1 = obj1.downcase if obj1.respond_to?(:downcase)
-      obj2 = obj2.downcase if obj2.respond_to?(:downcase)
-    end
-
-    obj1 == obj2
-  end
-
-  # @private
-  #
-  # check if objects are comparable
-  def self.comparable?(obj1, obj2, strict = true)
-    return true if (obj1.is_a?(Array) || obj1.is_a?(Hash)) && obj2.is_a?(obj1.class)
-    return true if (obj2.is_a?(Array) || obj2.is_a?(Hash)) && obj1.is_a?(obj2.class)
-    return true if !strict && obj1.is_a?(Numeric) && obj2.is_a?(Numeric)
-
-    obj1.is_a?(obj2.class) && obj2.is_a?(obj1.class)
-  end
-
-  # @private
-  #
-  # try custom comparison
-  def self.custom_compare(method, key, obj1, obj2)
-    return unless method
-
-    res = method.call(key, obj1, obj2)
-
-    # nil != false here
-    return [['~', key, obj1, obj2]] if res == false
-    return [] if res == true
-  end
-
-  def self.prefix_append_key(prefix, key, opts)
-    if opts[:array_path]
-      prefix + [key]
-    else
-      prefix.empty? ? key.to_s : "#{prefix}#{opts[:delimiter]}#{key}"
-    end
-  end
-
-  def self.prefix_append_array_index(prefix, array_index, opts)
-    if opts[:array_path]
-      prefix + [array_index]
-    else
-      "#{prefix}[#{array_index}]"
-    end
-  end
-
-  class << self
-    private
-
-    # @private
-    #
-    # checks if both objects are Arrays or Hashes
-    def any_hash_or_array?(obja, objb)
-      obja.is_a?(Array) || obja.is_a?(Hash) || objb.is_a?(Array) || objb.is_a?(Hash)
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/hashdiff-1.0.1/lib/hashdiff/version.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module Hashdiff
-  VERSION = '1.0.1'.freeze
-end

data/vendor/bundle/ruby/3.2.0/gems/hashdiff-1.0.1/lib/hashdiff.rb

@@ -1,10 +0,0 @@
-# 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'