diff-lcs 1.1.3 → 1.2.0

data/lib/diff/lcs/change.rb

@@ -1,59 +1,58 @@
-#! /usr/env/bin ruby
-#--
-# Copyright 2004 Austin Ziegler <diff-lcs@halostatue.ca>
-#   adapted from:
-#     Algorithm::Diff (Perl) by Ned Konz <perl@bike-nomad.com>
-#     Smalltalk by Mario I. Wolczko <mario@wolczko.com>
-#   implements McIlroy-Hunt diff algorithm
-#
-# 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
-# Ruby licence.
-# 
-# $Id$
-#++
-# Provides Diff::LCS::Change and Diff::LCS::ContextChange.
-
-  # Centralises the change test code in Diff::LCS::Change and
-  # Diff::LCS::ContextChange, since it's the same for both classes.
-module Diff::LCS::ChangeTypeTests
-  def deleting?
-    @action == '-'
-  end
+# -*- ruby encoding: utf-8 -*-
 
-  def adding?
-    @action == '+'
-  end
+# Represents a simplistic (non-contextual) change. Represents the removal or
+# addition of an element from either the old or the new sequenced
+# enumerable.
+class Diff::LCS::Change
+  # The only actions valid for changes are '+' (add), '-' (delete), '='
+  # (no change), '!' (changed), '<' (tail changes from first sequence), or
+  # '>' (tail changes from second sequence). The last two ('<>') are only
+  # found with Diff::LCS::diff and Diff::LCS::sdiff.
+  VALID_ACTIONS = %W(+ - = ! > <)
 
-  def unchanged?
-    @action == '='
+  def self.valid_action?(action)
+    VALID_ACTIONS.include? action
   end
 
-  def changed?
-    @changed == '!'
+  # Returns the action this Change represents.
+  attr_reader :action
+
+  # Returns the position of the Change.
+  attr_reader :position
+  # Returns the sequence element of the Change.
+  attr_reader :element
+
+  def initialize(*args)
+    @action, @position, @element = *args
+
+    unless Diff::LCS::Change.valid_action?(@action)
+      raise "Invalid Change Action '#{@action}'"
+    end
+    raise "Invalid Position Type" unless @position.kind_of? Fixnum
   end
 
-  def finished_a?
-    @changed == '>'
+  def inspect
+    to_a.inspect
   end
 
-  def finished_b?
-    @changed == '<'
+  def to_a
+    [ @action, @position, @element ]
   end
-end
 
-  # Represents a simplistic (non-contextual) change. Represents the removal or
-  # addition of an element from either the old or the new sequenced enumerable.
-class Diff::LCS::Change
-    # Returns the action this Change represents. Can be '+' (#adding?), '-'
-    # (#deleting?), '=' (#unchanged?), # or '!' (#changed?). When created by
-    # Diff::LCS#diff or Diff::LCS#sdiff, it may also be '>' (#finished_a?) or
-    # '<' (#finished_b?).
-  attr_reader :action
-  attr_reader :position
-  attr_reader :element
+  def self.from_a(arr)
+    arr = arr.flatten
+    case arr.size
+    when 5
+      Diff::LCS::ContextChange.new(*(arr[0...5]))
+    when 3
+      Diff::LCS::Change.new(*(arr[0...3]))
+    else
+      raise "Invalid change array format provided."
+    end
+  end
 
   include Comparable
+
   def ==(other)
     (self.action == other.action) and
     (self.position == other.position) and
@@ -67,85 +66,79 @@ class Diff::LCS::Change
     r
   end
 
-  def initialize(action, position, element)
-    @action = action
-    @position = position
-    @element = element
+  def adding?
+    @action == '+'
   end
 
-    # Creates a Change from an array produced by Change#to_a.
-  def to_a
-    [@action, @position, @element]
+  def deleting?
+    @action == '-'
   end
 
-  def self.from_a(arr)
-    Diff::LCS::Change.new(arr[0], arr[1], arr[2])
+  def unchanged?
+    @action == '='
+  end
+
+  def changed?
+    @action == '!'
   end
 
-  include Diff::LCS::ChangeTypeTests
+  def finished_a?
+    @action == '>'
+  end
+
+  def finished_b?
+    @action == '<'
+  end
 end
 
-  # Represents a contextual change. Contains the position and values of the
-  # elements in the old and the new sequenced enumerables as well as the action
-  # taken.
-class Diff::LCS::ContextChange
-    # Returns the action this Change represents. Can be '+' (#adding?), '-'
-    # (#deleting?), '=' (#unchanged?), # or '!' (#changed?). When
-    # created by Diff::LCS#diff or Diff::LCS#sdiff, it may also be '>'
-    # (#finished_a?) or '<' (#finished_b?).
-  attr_reader :action
+# Represents a contextual change. Contains the position and values of the
+# elements in the old and the new sequenced enumerables as well as the action
+# taken.
+class Diff::LCS::ContextChange < Diff::LCS::Change
+  # We don't need these two values.
+  undef :position
+  undef :element
+
+  # Returns the old position being changed.
   attr_reader :old_position
-  attr_reader :old_element
+  # Returns the new position being changed.
   attr_reader :new_position
+  # Returns the old element being changed.
+  attr_reader :old_element
+  # Returns the new element being changed.
   attr_reader :new_element
 
-  include Comparable
-
-  def ==(other)
-    (@action == other.action) and
-    (@old_position == other.old_position) and
-    (@new_position == other.new_position) and
-    (@old_element == other.old_element) and
-    (@new_element == other.new_element)
-  end
+  def initialize(*args)
+    @action, @old_position, @old_element, @new_position, @new_element = *args
 
-  def inspect(*args)
-    %Q(#<#{self.class.name}:#{__id__} @action=#{action} positions=#{old_position},#{new_position} elements=#{old_element.inspect},#{new_element.inspect}>)
-  end
-
-  def <=>(other)
-    r = @action <=> other.action
-    r = @old_position <=> other.old_position if r.zero?
-    r = @new_position <=> other.new_position if r.zero?
-    r = @old_element <=> other.old_element if r.zero?
-    r = @new_element <=> other.new_element if r.zero?
-    r
+    unless Diff::LCS::Change.valid_action?(@action)
+      raise "Invalid Change Action '#{@action}'"
+    end
+    unless @old_position.nil? or @old_position.kind_of? Fixnum
+      raise "Invalid (Old) Position Type"
+    end
+    unless @new_position.nil? or @new_position.kind_of? Fixnum
+      raise "Invalid (New) Position Type"
+    end
   end
 
-  def initialize(action, old_position, old_element, new_position, new_element)
-    @action = action
-    @old_position = old_position
-    @old_element = old_element
-    @new_position = new_position
-    @new_element = new_element
+  def to_a
+    [ @action,
+      [ @old_position, @old_element ],
+      [ @new_position, @new_element ]
+    ]
   end
 
-  def to_a
-    [@action, [@old_position, @old_element], [@new_position, @new_element]]
+  def inspect(*args)
+    to_a.inspect
   end
 
-    # Creates a ContextChange from an array produced by ContextChange#to_a.
   def self.from_a(arr)
-    if arr.size == 5
-      Diff::LCS::ContextChange.new(arr[0], arr[1], arr[2], arr[3], arr[4])
-    else
-      Diff::LCS::ContextChange.new(arr[0], arr[1][0], arr[1][1], arr[2][0],
-                                   arr[2][1])
-    end
+    Diff::LCS::Change.from_a(arr)
   end
 
-    # Simplifies a context change for use in some diff callbacks. '<' actions
-    # are converted to '-' and '>' actions are converted to '+'. 
+  # Simplifies a context change for use in some diff callbacks. '<' actions
+  # are converted to '-' and '>' actions are converted to '+'.
   def self.simplify(event)
     ea = event.to_a
 
@@ -165,5 +158,20 @@ class Diff::LCS::ContextChange
     Diff::LCS::ContextChange.from_a(ea)
   end
 
-  include Diff::LCS::ChangeTypeTests
+  def ==(other)
+    (@action == other.action) and
+    (@old_position == other.old_position) and
+    (@new_position == other.new_position) and
+    (@old_element == other.old_element) and
+    (@new_element == other.new_element)
+  end
+
+  def <=>(other)
+    r = @action <=> other.action
+    r = @old_position <=> other.old_position if r.zero?
+    r = @new_position <=> other.new_position if r.zero?
+    r = @old_element <=> other.old_element if r.zero?
+    r = @new_element <=> other.new_element if r.zero?
+    r
+  end
 end

data/lib/diff/lcs/htmldiff.rb

@@ -147,5 +147,3 @@ h1 { margin-left: 2em; }
     OUTPUT
   end
 end
-
-# vim: ft=ruby

data/lib/diff/lcs/hunk.rb

@@ -1,13 +1,15 @@
+# -*- 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).
+# 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, context, file_length_difference)
-      # At first, a hunk will have just one Block in it
+  # 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) ]
     @data_old = data_old
     @data_new = data_new
@@ -16,10 +18,10 @@ class Diff::LCS::Hunk
     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.
+    # 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
@@ -39,7 +41,7 @@ class Diff::LCS::Hunk
     @end_old   = a2 || (b2 - after)
     @end_new   = b2 || (a2 + after)
 
-    self.flag_context = context
+    self.flag_context = flag_context
   end
 
   attr_reader :blocks
@@ -47,10 +49,10 @@ class Diff::LCS::Hunk
   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
+  # Change the "start" and "end" fields to note that context should be added
+  # to this hunk.
   attr_accessor :flag_context
-  undef :flag_context=
+  undef :flag_context=;
   def flag_context=(context) #:nodoc:
     return if context.nil? or context.zero?
 
@@ -67,22 +69,28 @@ class Diff::LCS::Hunk
     @end_new += add_end
   end
 
-  def unshift(hunk)
-    @start_old = hunk.start_old
-    @start_new = hunk.start_new
-    blocks.unshift(*hunk.blocks)
+  # 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
 
-    # Is there an overlap between hunk arg0 and old hunk arg1? Note: if end
-    # of old hunk is one less than beginning of second, they overlap
-  def overlaps?(hunk = nil)
-    return nil if hunk.nil?
-
-    a = (@start_old - hunk.end_old) <= 1
-    b = (@start_new - hunk.end_new) <= 1
-    return (a or b)
+  # 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
@@ -100,44 +108,40 @@ class Diff::LCS::Hunk
     end
   end
 
-  def each_old(block)
-    @data_old[@start_old .. @end_old].each { |e| yield e }
-  end
-
-  private
-    # Note that an old diff can't have any context. Therefore, we know that
-    # there's only one block in the hunk.
+  # 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.
+    # 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 = "#{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.
+    # 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 << "< #{e}\n" } unless block.remove.empty?
     s << "---\n" if block.op == "!"
     @data_new[@start_new .. @end_new].each { |e| s << "> #{e}\n" } unless block.insert.empty?
     s
   end
+  private :old_diff
 
   def unified_diff
-      # Calculate item number range.
+    # Calculate item number range.
     s = "@@ -#{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.
+    # 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].collect { |e| e.gsub(/^/, ' ') }
@@ -159,14 +163,15 @@ class Diff::LCS::Hunk
 
     s << outlist.join("\n")
   end
+  private :unified_diff
 
   def context_diff
     s = "***************\n"
     s << "*** #{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
+    # 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
@@ -193,6 +198,7 @@ class Diff::LCS::Hunk
     end
     s
   end
+  private :context_diff
 
   def ed_diff(format)
     op_act = { "+" => 'a', "-" => 'd', "!" => "c" }
@@ -210,9 +216,10 @@ class Diff::LCS::Hunk
     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'
+  # 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)
     case mode
     when :old
@@ -223,10 +230,11 @@ class Diff::LCS::Hunk
 
     (s < e) ? "#{s},#{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)
+  # 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
@@ -239,4 +247,5 @@ class Diff::LCS::Hunk
     first = (length < 2) ? e : s # "strange, but correct"
     (length == 1) ? "#{first}" : "#{first},#{length}"
   end
+  private :unified_range
 end