RubyGems - genkaio - Versions diffs - 0.0.1 → 0.0.2 - Mend

genkaio 0.0.1 → 0.0.2

Files changed (355) hide show

data/vendor/bundle/ruby/2.7.0/gems/diff-lcs-1.3/lib/diff/lcs/htmldiff.rb ADDED

@@ -0,0 +1,149 @@
+# -*- ruby encoding: utf-8 -*-
+require 'cgi'
+class Diff::LCS::HTMLDiff
+  class << self
+    attr_accessor :can_expand_tabs #:nodoc:
+  end
+  self.can_expand_tabs = true
+  class Callbacks
+    attr_accessor :output
+    attr_accessor :match_class
+    attr_accessor :only_a_class
+    attr_accessor :only_b_class
+    def initialize(output, options = {})
+      @output = output
+      options ||= {}
+      @match_class = options[:match_class] || "match"
+      @only_a_class = options[:only_a_class] || "only_a"
+      @only_b_class = options[:only_b_class] || "only_b"
+    end
+    def htmlize(element, css_class)
+      element = "&nbsp;" if element.empty?
+      %Q|<pre class="#{__send__(css_class)}">#{element}</pre>\n|
+    end
+    private :htmlize
+    # This will be called with both lines are the same
+    def match(event)
+      @output << htmlize(event.old_element, :match_class)
+    end
+    # This will be called when there is a line in A that isn't in B
+    def discard_a(event)
+      @output << htmlize(event.old_element, :only_a_class)
+    end
+    # This will be called when there is a line in B that isn't in A
+    def discard_b(event)
+      @output << htmlize(event.new_element, :only_b_class)
+    end
+  end
+  DEFAULT_OPTIONS = {
+    :expand_tabs => nil,
+    :output => nil,
+    :css => nil,
+    :title => nil,
+  }
+  DEFAULT_CSS = <<-CSS
+body { margin: 0; }
+.diff
+{
+  border: 1px solid black;
+  margin: 1em 2em;
+}
+p
+{
+  margin-left: 2em;
+}
+pre
+{
+  padding-left: 1em;
+  margin: 0;
+  font-family: Inconsolata, Consolas, Lucida, Courier, monospaced;
+	white-space: pre;
+}
+.match { }
+.only_a
+{
+  background-color: #fdd;
+  color: red;
+  text-decoration: line-through;
+}
+.only_b
+{
+  background-color: #ddf;
+  color: blue;
+  border-left: 3px solid blue
+}
+h1 { margin-left: 2em; }
+  CSS
+  def initialize(left, right, options = nil)
+    @left     = left
+    @right    = right
+    @options  = options
+    @options = DEFAULT_OPTIONS.dup if @options.nil?
+  end
+  def verify_options
+    @options[:expand_tabs] ||= 4
+    @options[:expand_tabs] = 4 if @options[:expand_tabs] < 0
+    @options[:output] ||= $stdout
+    @options[:css] ||= DEFAULT_CSS.dup
+    @options[:title] ||= "diff"
+  end
+  private :verify_options
+  attr_reader :options
+  def run
+    verify_options
+    if @options[:expand_tabs] > 0 && self.class.can_expand_tabs
+      formatter = Text::Format.new
+      formatter.tabstop = @options[:expand_tabs]
+      @left.map! { |line| formatter.expand(line.chomp) }
+      @right.map! { |line| formatter.expand(line.chomp) }
+    end
+    @left.map! { |line| CGI.escapeHTML(line.chomp) }
+    @right.map! { |line| CGI.escapeHTML(line.chomp) }
+    @options[:output] << <<-OUTPUT
+<html>
+  <head>
+    <title>#{@options[:title]}</title>
+    <style type="text/css">
+    #{@options[:css]}
+    </style>
+  </head>
+  <body>
+    <h1>#{@options[:title]}</h1>
+    <p>Legend: <span class="only_a">Only in Old</span>&nbsp;
+    <span class="only_b">Only in New</span></p>
+    <div class="diff">
+    OUTPUT
+    callbacks = Callbacks.new(@options[:output])
+    Diff::LCS.traverse_sequences(@left, @right, callbacks)
+    @options[:output] << <<-OUTPUT
+    </div>
+  </body>
+</html>
+    OUTPUT
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/diff-lcs-1.3/lib/diff/lcs/hunk.rb ADDED

@@ -0,0 +1,276 @@
+# -*- ruby encoding: utf-8 -*-
+require 'diff/lcs/block'
+# A Hunk is a group of Blocks which overlap because of the context
+# surrounding each block. (So if we're not using context, every hunk will
+# contain one block.) Used in the diff program (bin/diff).
+class Diff::LCS::Hunk
+  # Create a hunk using references to both the old and new data, as well as
+  # the piece of data.
+  def initialize(data_old, data_new, piece, flag_context, file_length_difference)
+    # At first, a hunk will have just one Block in it
+    @blocks = [ Diff::LCS::Block.new(piece) ]
+    if String.method_defined?(:encoding)
+      @preferred_data_encoding = data_old.fetch(0, data_new.fetch(0,'') ).encoding
+    end
+    @data_old = data_old
+    @data_new = data_new
+    before = after = file_length_difference
+    after += @blocks[0].diff_size
+    @file_length_difference = after # The caller must get this manually
+    # Save the start & end of each array. If the array doesn't exist (e.g.,
+    # we're only adding items in this block), then figure out the line
+    # number based on the line number of the other file and the current
+    # difference in file lengths.
+    if @blocks[0].remove.empty?
+      a1 = a2 = nil
+    else
+      a1 = @blocks[0].remove[0].position
+      a2 = @blocks[0].remove[-1].position
+    end
+    if @blocks[0].insert.empty?
+      b1 = b2 = nil
+    else
+      b1 = @blocks[0].insert[0].position
+      b2 = @blocks[0].insert[-1].position
+    end
+    @start_old = a1 || (b1 - before)
+    @start_new = b1 || (a1 + before)
+    @end_old   = a2 || (b2 - after)
+    @end_new   = b2 || (a2 + after)
+    self.flag_context = flag_context
+  end
+  attr_reader :blocks
+  attr_reader :start_old, :start_new
+  attr_reader :end_old, :end_new
+  attr_reader :file_length_difference
+  # Change the "start" and "end" fields to note that context should be added
+  # to this hunk.
+  attr_accessor :flag_context
+  undef :flag_context=;
+  def flag_context=(context) #:nodoc:
+    return if context.nil? or context.zero?
+    add_start = (context > @start_old) ? @start_old : context
+    @start_old -= add_start
+    @start_new -= add_start
+    if (@end_old + context) > @data_old.size
+      add_end = @data_old.size - @end_old
+    else
+      add_end = context
+    end
+    @end_old += add_end
+    @end_new += add_end
+  end
+  # Merges this hunk and the provided hunk together if they overlap. Returns
+  # a truthy value so that if there is no overlap, you can know the merge
+  # was skipped.
+  def merge(hunk)
+    if overlaps?(hunk)
+      @start_old = hunk.start_old
+      @start_new = hunk.start_new
+      blocks.unshift(*hunk.blocks)
+    else
+      nil
+    end
+  end
+  alias_method :unshift, :merge
+  # Determines whether there is an overlap between this hunk and the
+  # provided hunk. This will be true if the difference between the two hunks
+  # start or end positions is within one position of each other.
+  def overlaps?(hunk)
+    hunk and (((@start_old - hunk.end_old) <= 1) or
+              ((@start_new - hunk.end_new) <= 1))
+  end
+  # Returns a diff string based on a format.
+  def diff(format)
+    case format
+    when :old
+      old_diff
+    when :unified
+      unified_diff
+    when :context
+      context_diff
+    when :ed
+      self
+    when :reverse_ed, :ed_finish
+      ed_diff(format)
+    else
+      raise "Unknown diff format #{format}."
+    end
+  end
+  # Note that an old diff can't have any context. Therefore, we know that
+  # there's only one block in the hunk.
+  def old_diff
+    warn "Expecting only one block in an old diff hunk!" if @blocks.size > 1
+    op_act = { "+" => 'a', "-" => 'd', "!" => "c" }
+    block = @blocks[0]
+    # Calculate item number range. Old diff range is just like a context
+    # diff range, except the ranges are on one line with the action between
+    # them.
+    s = encode("#{context_range(:old)}#{op_act[block.op]}#{context_range(:new)}\n")
+    # If removing anything, just print out all the remove lines in the hunk
+    # which is just all the remove lines in the block.
+    @data_old[@start_old .. @end_old].each { |e| s << encode("< ") + e + encode("\n") } unless block.remove.empty?
+    s << encode("---\n") if block.op == "!"
+    @data_new[@start_new .. @end_new].each { |e| s << encode("> ") + e + encode("\n") } unless block.insert.empty?
+    s
+  end
+  private :old_diff
+  def unified_diff
+    # Calculate item number range.
+    s = encode("@@ -#{unified_range(:old)} +#{unified_range(:new)} @@\n")
+    # Outlist starts containing the hunk of the old file. Removing an item
+    # just means putting a '-' in front of it. Inserting an item requires
+    # getting it from the new file and splicing it in. We splice in
+    # +num_added+ items. Remove blocks use +num_added+ because splicing
+    # changed the length of outlist.
+    #
+    # We remove +num_removed+ items. Insert blocks use +num_removed+
+    # because their item numbers -- corresponding to positions in the NEW
+    # file -- don't take removed items into account.
+    lo, hi, num_added, num_removed = @start_old, @end_old, 0, 0
+    outlist = @data_old[lo .. hi].map { |e| e.insert(0, encode(' ')) }
+    @blocks.each do |block|
+      block.remove.each do |item|
+        op     = item.action.to_s # -
+        offset = item.position - lo + num_added
+        outlist[offset][0, 1] = encode(op)
+        num_removed += 1
+      end
+      block.insert.each do |item|
+        op     = item.action.to_s # +
+        offset = item.position - @start_new + num_removed
+        outlist[offset, 0] = encode(op) + @data_new[item.position]
+        num_added += 1
+      end
+    end
+    s << outlist.join(encode("\n"))
+  end
+  private :unified_diff
+  def context_diff
+    s = encode("***************\n")
+    s << encode("*** #{context_range(:old)} ****\n")
+    r = context_range(:new)
+    # Print out file 1 part for each block in context diff format if there
+    # are any blocks that remove items
+    lo, hi = @start_old, @end_old
+    removes = @blocks.select { |e| not e.remove.empty? }
+    if removes
+      outlist = @data_old[lo .. hi].map { |e| e.insert(0, encode(' ')) }
+      removes.each do |block|
+        block.remove.each do |item|
+          outlist[item.position - lo][0, 1] = encode(block.op) # - or !
+        end
+      end
+      s << outlist.join("\n")
+    end
+    s << encode("\n--- #{r} ----\n")
+    lo, hi = @start_new, @end_new
+    inserts = @blocks.select { |e| not e.insert.empty? }
+    if inserts
+      outlist = @data_new[lo .. hi].collect { |e| e.insert(0, encode(' ')) }
+      inserts.each do |block|
+        block.insert.each do |item|
+          outlist[item.position - lo][0, 1] = encode(block.op) # + or !
+        end
+      end
+      s << outlist.join("\n")
+    end
+    s
+  end
+  private :context_diff
+  def ed_diff(format)
+    op_act = { "+" => 'a', "-" => 'd', "!" => "c" }
+    warn "Expecting only one block in an old diff hunk!" if @blocks.size > 1
+    if format == :reverse_ed
+      s = encode("#{op_act[@blocks[0].op]}#{context_range(:old)}\n")
+    else
+      s = encode("#{context_range(:old, ' ')}#{op_act[@blocks[0].op]}\n")
+    end
+    unless @blocks[0].insert.empty?
+      @data_new[@start_new .. @end_new].each { |e| s << e + encode("\n") }
+      s << encode(".\n")
+    end
+    s
+  end
+  private :ed_diff
+  # Generate a range of item numbers to print. Only print 1 number if the
+  # range has only one item in it. Otherwise, it's 'start,end'
+  def context_range(mode, op = ',')
+    case mode
+    when :old
+      s, e = (@start_old + 1), (@end_old + 1)
+    when :new
+      s, e = (@start_new + 1), (@end_new + 1)
+    end
+    (s < e) ? "#{s}#{op}#{e}" : "#{e}"
+  end
+  private :context_range
+  # Generate a range of item numbers to print for unified diff. Print number
+  # where block starts, followed by number of lines in the block
+  # (don't print number of lines if it's 1)
+  def unified_range(mode)
+    case mode
+    when :old
+      s, e = (@start_old + 1), (@end_old + 1)
+    when :new
+      s, e = (@start_new + 1), (@end_new + 1)
+    end
+    length = e - s + 1
+    first = (length < 2) ? e : s # "strange, but correct"
+    (length == 1) ? "#{first}" : "#{first},#{length}"
+  end
+  private :unified_range
+  if String.method_defined?(:encoding)
+    def encode(literal, target_encoding = @preferred_data_encoding)
+      literal.encode target_encoding
+    end
+    def encode_as(string, *args)
+      args.map { |arg| arg.encode(string.encoding) }
+    end
+  else
+    def encode(literal, target_encoding = nil)
+      literal
+    end
+    def encode_as(string, *args)
+      args
+    end
+  end
+  private :encode
+  private :encode_as
+end

data/vendor/bundle/ruby/2.7.0/gems/diff-lcs-1.3/lib/diff/lcs/internals.rb ADDED

@@ -0,0 +1,307 @@
+# -*- ruby encoding: utf-8 -*-
+class << Diff::LCS
+  def diff_traversal(method, seq1, seq2, callbacks, &block)
+    callbacks = callbacks_for(callbacks)
+    case method
+    when :diff
+      traverse_sequences(seq1, seq2, callbacks)
+    when :sdiff
+      traverse_balanced(seq1, seq2, callbacks)
+    end
+    callbacks.finish if callbacks.respond_to? :finish
+    if block
+      callbacks.diffs.map do |hunk|
+        if hunk.kind_of? Array
+          hunk.map { |hunk_block| block[hunk_block] }
+        else
+          block[hunk]
+        end
+      end
+    else
+      callbacks.diffs
+    end
+  end
+  private :diff_traversal
+end
+module Diff::LCS::Internals # :nodoc:
+end
+class << Diff::LCS::Internals
+  # Compute the longest common subsequence between the sequenced
+  # Enumerables +a+ and +b+. The result is an array whose contents is such
+  # that
+  #
+  #     result = Diff::LCS::Internals.lcs(a, b)
+  #     result.each_with_index do |e, i|
+  #       assert_equal(a[i], b[e]) unless e.nil?
+  #     end
+  def lcs(a, b)
+    a_start = b_start = 0
+    a_finish = a.size - 1
+    b_finish = b.size - 1
+    vector = []
+    # Prune off any common elements at the beginning...
+    while ((a_start <= a_finish) and (b_start <= b_finish) and
+           (a[a_start] == b[b_start]))
+      vector[a_start] = b_start
+      a_start += 1
+      b_start += 1
+    end
+    b_start = a_start
+    # Now the end...
+    while ((a_start <= a_finish) and (b_start <= b_finish) and
+           (a[a_finish] == b[b_finish]))
+      vector[a_finish] = b_finish
+      a_finish -= 1
+      b_finish -= 1
+    end
+    # Now, compute the equivalence classes of positions of elements.
+    b_matches = position_hash(b, b_start..b_finish)
+    thresh = []
+    links  = []
+    string = a.kind_of?(String)
+    (a_start .. a_finish).each do |i|
+      ai = string ? a[i, 1] : a[i]
+      bm = b_matches[ai]
+      k = nil
+      bm.reverse_each do |j|
+        if k and (thresh[k] > j) and (thresh[k - 1] < j)
+          thresh[k] = j
+        else
+          k = replace_next_larger(thresh, j, k)
+        end
+        links[k] = [ (k > 0) ? links[k - 1] : nil, i, j ] unless k.nil?
+      end
+    end
+    unless thresh.empty?
+      link = links[thresh.size - 1]
+      while not link.nil?
+        vector[link[1]] = link[2]
+        link = link[0]
+      end
+    end
+    vector
+  end
+  # This method will analyze the provided patchset to provide a
+  # single-pass normalization (conversion of the array form of
+  # Diff::LCS::Change objects to the object form of same) and detection of
+  # whether the patchset represents changes to be made.
+  def analyze_patchset(patchset, depth = 0)
+    raise "Patchset too complex" if depth > 1
+    has_changes = false
+    # Format:
+    # [ # patchset
+    #   # hunk (change)
+    #   [ # hunk
+    #     # change
+    #   ]
+    # ]
+    patchset = patchset.map do |hunk|
+      case hunk
+      when Diff::LCS::Change
+        has_changes ||= !hunk.unchanged?
+        hunk
+      when Array
+        # Detect if the 'hunk' is actually an array-format
+        # Change object.
+        if Diff::LCS::Change.valid_action? hunk[0]
+          hunk = Diff::LCS::Change.from_a(hunk)
+          has_changes ||= !hunk.unchanged?
+          hunk
+        else
+          with_changes, hunk = analyze_patchset(hunk, depth + 1)
+          has_changes ||= with_changes
+          hunk.flatten
+        end
+      else
+        raise ArgumentError, "Cannot normalise a hunk of class #{hunk.class}."
+      end
+    end
+    [ has_changes, patchset.flatten(1) ]
+  end
+  # Examine the patchset and the source to see in which direction the
+  # patch should be applied.
+  #
+  # WARNING: By default, this examines the whole patch, so this could take
+  # some time. This also works better with Diff::LCS::ContextChange or
+  # Diff::LCS::Change as its source, as an array will cause the creation
+  # of one of the above.
+  def intuit_diff_direction(src, patchset, limit = nil)
+    string = src.kind_of?(String)
+    count = left_match = left_miss = right_match = right_miss = 0
+    patchset.each do |change|
+      count += 1
+      case change
+      when Diff::LCS::ContextChange
+        le = string ? src[change.old_position, 1] : src[change.old_position]
+        re = string ? src[change.new_position, 1] : src[change.new_position]
+        case change.action
+        when '-' # Remove details from the old string
+          if le == change.old_element
+            left_match += 1
+          else
+            left_miss += 1
+          end
+        when '+'
+          if re == change.new_element
+            right_match += 1
+          else
+            right_miss += 1
+          end
+        when '='
+          left_miss += 1 if le != change.old_element
+          right_miss += 1 if re != change.new_element
+        when '!'
+          if le == change.old_element
+            left_match += 1
+          else
+            if re == change.new_element
+              right_match += 1
+            else
+              left_miss += 1
+              right_miss += 1
+            end
+          end
+        end
+      when Diff::LCS::Change
+        # With a simplistic change, we can't tell the difference between
+        # the left and right on '!' actions, so we ignore those. On '='
+        # actions, if there's a miss, we miss both left and right.
+        element = string ? src[change.position, 1] : src[change.position]
+        case change.action
+        when '-'
+          if element == change.element
+            left_match += 1
+          else
+            left_miss += 1
+          end
+        when '+'
+          if element == change.element
+            right_match += 1
+          else
+            right_miss += 1
+          end
+        when '='
+          if element != change.element
+            left_miss += 1
+            right_miss += 1
+          end
+        end
+      end
+      break if (not limit.nil?) && (count > limit)
+    end
+    no_left = (left_match == 0) && (left_miss > 0)
+    no_right = (right_match == 0) && (right_miss > 0)
+    case [ no_left, no_right ]
+    when [ false, true ]
+      :patch
+    when [ true, false ]
+      :unpatch
+    else
+      case left_match <=> right_match
+      when 1
+        if left_miss.zero?
+          :patch
+        else
+          :unpatch
+        end
+      when -1
+        if right_miss.zero?
+          :unpatch
+        else
+          :patch
+        end
+      else
+        raise "The provided patchset does not appear to apply to the provided enumerable as either source or destination value."
+      end
+    end
+  end
+  # Find the place at which +value+ would normally be inserted into the
+  # Enumerable. If that place is already occupied by +value+, do nothing
+  # and return +nil+. If the place does not exist (i.e., it is off the end
+  # of the Enumerable), add it to the end. Otherwise, replace the element
+  # at that point with +value+. It is assumed that the Enumerable's values
+  # are numeric.
+  #
+  # This operation preserves the sort order.
+  def replace_next_larger(enum, value, last_index = nil)
+    # Off the end?
+    if enum.empty? or (value > enum[-1])
+      enum << value
+      return enum.size - 1
+    end
+    # Binary search for the insertion point
+    last_index ||= enum.size
+    first_index = 0
+    while (first_index <= last_index)
+      i = (first_index + last_index) >> 1
+      found = enum[i]
+      if value == found
+        return nil
+      elsif value > found
+        first_index = i + 1
+      else
+        last_index = i - 1
+      end
+    end
+    # The insertion point is in first_index; overwrite the next larger
+    # value.
+    enum[first_index] = value
+    return first_index
+  end
+  private :replace_next_larger
+  # If +vector+ maps the matching elements of another collection onto this
+  # Enumerable, compute the inverse of +vector+ that maps this Enumerable
+  # onto the collection. (Currently unused.)
+  def inverse_vector(a, vector)
+    inverse = a.dup
+    (0...vector.size).each do |i|
+      inverse[vector[i]] = i unless vector[i].nil?
+    end
+    inverse
+  end
+  private :inverse_vector
+  # Returns a hash mapping each element of an Enumerable to the set of
+  # positions it occupies in the Enumerable, optionally restricted to the
+  # elements specified in the range of indexes specified by +interval+.
+  def position_hash(enum, interval)
+    string = enum.kind_of?(String)
+    hash = Hash.new { |h, k| h[k] = [] }
+    interval.each do |i|
+      k = string ? enum[i, 1] : enum[i]
+      hash[k] << i
+    end
+    hash
+  end
+  private :position_hash
+end