qiita_org 0.1.0

data/gems/ruby/2.7.0/gems/diff-lcs-1.4.4/lib/diff/lcs/internals.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+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.positive? ? links[k - 1] : nil, i, j] unless k.nil?
+      end
+    end
+
+    unless thresh.empty?
+      link = links[thresh.size - 1]
+      until 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)
+    fail 'Patchset too complex' if depth > 1
+
+    has_changes = false
+    new_patchset = []
+
+    # Format:
+    # [ # patchset
+    #   # hunk (change)
+    #   [ # hunk
+    #     # change
+    #   ]
+    # ]
+
+    patchset.each do |hunk|
+      case hunk
+      when Diff::LCS::Change
+        has_changes ||= !hunk.unchanged?
+        new_patchset << 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?
+          new_patchset << hunk
+        else
+          with_changes, hunk = analyze_patchset(hunk, depth + 1)
+          has_changes ||= with_changes
+          new_patchset.concat(hunk)
+        end
+      else
+        fail ArgumentError, "Cannot normalise a hunk of class #{hunk.class}."
+      end
+    end
+
+    [has_changes, new_patchset]
+  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
+          elsif re == change.new_element
+            right_match += 1
+          else
+            left_miss += 1
+            right_miss += 1
+          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 !limit.nil? && (count > limit)
+    end
+
+    no_left = left_match.zero? && left_miss.positive?
+    no_right = right_match.zero? && right_miss.positive?
+
+    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
+        fail "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]
+
+      return nil if value == found
+
+      if 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
+    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

data/gems/ruby/2.7.0/gems/diff-lcs-1.4.4/lib/diff/lcs/ldiff.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'ostruct'
+require 'diff/lcs/hunk'
+
+module Diff::LCS::Ldiff #:nodoc:
+  BANNER = <<-COPYRIGHT
+ldiff #{Diff::LCS::VERSION}
+  Copyright 2004-2019 Austin Ziegler
+
+  Part of Diff::LCS.
+  https://github.com/halostatue/diff-lcs
+
+  This program is free software. It may be redistributed and/or modified under
+  the terms of the GPL version 2 (or later), the Perl Artistic licence, or the
+  MIT licence.
+  COPYRIGHT
+end
+
+class << Diff::LCS::Ldiff
+  attr_reader :format, :lines #:nodoc:
+  attr_reader :file_old, :file_new #:nodoc:
+  attr_reader :data_old, :data_new #:nodoc:
+
+  def run(args, _input = $stdin, output = $stdout, error = $stderr) #:nodoc:
+    @binary = nil
+
+    args.options do |o|
+      o.banner = "Usage: #{File.basename($0)} [options] oldfile newfile"
+      o.separator ''
+      o.on(
+        '-c', '-C', '--context [LINES]', Integer,
+        'Displays a context diff with LINES lines', 'of context. Default 3 lines.'
+      ) do |ctx|
+        @format = :context
+        @lines  = ctx || 3
+      end
+      o.on(
+        '-u', '-U', '--unified [LINES]', Integer,
+        'Displays a unified diff with LINES lines', 'of context. Default 3 lines.'
+      ) do |ctx|
+        @format = :unified
+        @lines  = ctx || 3
+      end
+      o.on('-e', 'Creates an \'ed\' script to change', 'oldfile to newfile.') do |_ctx|
+        @format = :ed
+      end
+      o.on('-f', 'Creates an \'ed\' script to change', 'oldfile to newfile in reverse order.') do |_ctx|
+        @format = :reverse_ed
+      end
+      o.on(
+        '-a', '--text',
+        'Treat the files as text and compare them', 'line-by-line, even if they do not seem', 'to be text.'
+      ) do |_txt|
+        @binary = false
+      end
+      o.on('--binary', 'Treats the files as binary.') do |_bin|
+        @binary = true
+      end
+      o.on('-q', '--brief', 'Report only whether or not the files', 'differ, not the details.') do |_ctx|
+        @format = :report
+      end
+      o.on_tail('--help', 'Shows this text.') do
+        error << o
+        return 0
+      end
+      o.on_tail('--version', 'Shows the version of Diff::LCS.') do
+        error << Diff::LCS::Ldiff::BANNER
+        return 0
+      end
+      o.on_tail ''
+      o.on_tail 'By default, runs produces an "old-style" diff, with output like UNIX diff.'
+      o.parse!
+    end
+
+    unless args.size == 2
+      error << args.options
+      return 127
+    end
+
+    # Defaults are for old-style diff
+    @format ||= :old
+    @lines  ||= 0
+
+    file_old, file_new = *ARGV
+
+    case @format
+    when :context
+      char_old = '*' * 3
+      char_new = '-' * 3
+    when :unified
+      char_old = '-' * 3
+      char_new = '+' * 3
+    end
+
+    # After we've read up to a certain point in each file, the number of
+    # items we've read from each file will differ by FLD (could be 0).
+    file_length_difference = 0
+
+    data_old = IO.read(file_old)
+    data_new = IO.read(file_new)
+
+    # Test binary status
+    if @binary.nil?
+      old_txt = data_old[0, 4096].scan(/\0/).empty?
+      new_txt = data_new[0, 4096].scan(/\0/).empty?
+      @binary = !old_txt || !new_txt
+    end
+
+    unless @binary
+      data_old = data_old.lines.to_a
+      data_new = data_new.lines.to_a
+    end
+
+    # diff yields lots of pieces, each of which is basically a Block object
+    if @binary
+      diffs = (data_old == data_new)
+    else
+      diffs = Diff::LCS.diff(data_old, data_new)
+      diffs = nil if diffs.empty?
+    end
+
+    return 0 unless diffs
+
+    if @format == :report
+      output << "Files #{file_old} and #{file_new} differ\n"
+      return 1
+    end
+
+    if (@format == :unified) or (@format == :context)
+      ft = File.stat(file_old).mtime.localtime.strftime('%Y-%m-%d %H:%M:%S.000000000 %z')
+      output << "#{char_old} #{file_old}\t#{ft}\n"
+      ft = File.stat(file_new).mtime.localtime.strftime('%Y-%m-%d %H:%M:%S.000000000 %z')
+      output << "#{char_new} #{file_new}\t#{ft}\n"
+    end
+
+    # Loop over hunks. If a hunk overlaps with the last hunk, join them.
+    # Otherwise, print out the old one.
+    oldhunk = hunk = nil
+
+    if @format == :ed
+      real_output = output
+      output = []
+    end
+
+    diffs.each do |piece|
+      begin # rubocop:disable Style/RedundantBegin
+        hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, @lines, file_length_difference)
+        file_length_difference = hunk.file_length_difference
+
+        next unless oldhunk
+        next if @lines.positive? and hunk.merge(oldhunk)
+
+        output << oldhunk.diff(@format)
+        output << "\n" if @format == :unified
+      ensure
+        oldhunk = hunk
+      end
+    end
+
+    last = oldhunk.diff(@format, true)
+    last << "\n" if last.respond_to?(:end_with?) && !last.end_with?("\n")
+
+    output << last
+
+    output.reverse_each { |e| real_output << e.diff(:ed_finish) } if @format == :ed
+
+    1
+  end
+end