qiita_org 0.1.31 → 0.1.37

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

@@ -1,304 +0,0 @@
-# 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/.bandle/ruby/2.7.0/gems/diff-lcs-1.4.4/lib/diff/lcs/ldiff.rb

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