docdiff 0.5.0

data/lib/docdiff/diff/editscript.rb

@@ -0,0 +1,148 @@
+require 'docdiff/diff/rcsdiff'
+require 'docdiff/diff/unidiff'
+
+class Diff
+  class EditScript
+    def initialize
+      @chunk_common = nil
+      @chunk_add = []
+      @chunk_del = []
+      @list = []
+      @list << @chunk_del
+      @list << @chunk_add
+
+      @cs = Subsequence.new
+      @count_a = 0
+      @count_b = 0
+      @additions = 0
+      @deletions = 0
+    end
+
+    attr_reader :count_a, :additions
+    attr_reader :count_b, :deletions
+
+    def commonsubsequence
+      return @cs
+    end
+
+    def del(seq_or_len)
+      unless @chunk_del
+	@chunk_add = []
+	@chunk_del = []
+	@chunk_common = nil
+        @list << @chunk_del
+        @list << @chunk_add
+      end
+      if Array === seq_or_len
+	len = seq_or_len.length
+	mark = :del_elt
+      else
+	len = seq_or_len
+	mark = :del_num
+      end
+      if !@chunk_del.empty? && @chunk_del.last[0] == mark
+	@chunk_del.last[1] += seq_or_len
+      else
+	@chunk_del << [mark, seq_or_len, nil]
+      end
+      @count_a += len
+      @deletions += len
+    end
+
+    def add(seq_or_len)
+      unless @chunk_add
+	@chunk_add = []
+	@chunk_del = []
+	@chunk_common = nil
+        @list << @chunk_del
+        @list << @chunk_add
+      end
+      if Array === seq_or_len
+	len = seq_or_len.length
+	mark = :add_elt
+      else
+	len = seq_or_len
+	mark = :add_num
+      end
+      if !@chunk_add.empty? && @chunk_add.last[0] == mark
+	@chunk_add.last[2] += seq_or_len
+      else
+	@chunk_add << [mark, nil, seq_or_len]
+      end
+      @count_b += len
+      @additions += len
+    end
+
+    def common(seq_or_len_a, seq_or_len_b=seq_or_len_a)
+      unless @chunk_common
+	@list.pop
+	@list.pop
+	@list << @chunk_del unless @chunk_del.empty?
+	@list << @chunk_add unless @chunk_add.empty?
+	@chunk_add = nil
+	@chunk_del = nil
+	@chunk_common = []
+        @list << @chunk_common
+      end
+
+      len_a = Array === seq_or_len_a ? seq_or_len_a.length : seq_or_len_a
+      len_b = Array === seq_or_len_b ? seq_or_len_b.length : seq_or_len_b
+      raise ArgumentError.new("length not equal: #{len_a} != #{len_b}") if len_a != len_b
+      len = len_a
+
+      mark = ((Array === seq_or_len_a) ?
+              (Array === seq_or_len_b ? :common_elt_elt : :common_elt_num) :
+	      (Array === seq_or_len_b ? :common_num_elt : :common_num_num))
+
+      if !@chunk_common.empty? && @chunk_common.last[0] == mark
+	@chunk_common.last[1] += seq_or_len_a
+	@chunk_common.last[2] += seq_or_len_b
+      else
+	@chunk_common << [mark, seq_or_len_a, seq_or_len_b]
+      end
+
+      @cs.add @count_a, @count_b, len
+      @count_a += len
+      @count_b += len
+    end
+
+    def each
+      @list.each {|chunk|
+        chunk.each {|mark_del_add|
+	  yield mark_del_add
+	}
+      }
+    end
+
+    def apply(src)
+      l = 0
+      dst = []
+      each {|mark, del, add|
+        case mark
+	when :add_elt
+	  dst.concat add
+	when :add_num
+	  raise ArgumentError.new("additionnal lines are not known.")
+	when :common_elt_elt
+	  dst.concat add
+	  l += del.length
+	when :common_elt_num
+	  dst.concat src[l, del]
+	  l += del
+	when :common_num_elt
+	  dst.concat add
+	  l += add
+	when :common_num_num
+	  dst.concat src[l, del]
+	  l += del
+	when :del_elt
+	  l += del.length
+	when :del_num
+	  l += del
+	end
+      }
+      dst.concat src[l..-1]
+      return dst
+    end
+  end
+end

data/lib/docdiff/diff/rcsdiff.rb

@@ -0,0 +1,107 @@
+class Diff
+  def Diff.rcsdiff(a, b)
+    al = []
+    a.each_line {|l| al << l}
+    bl = []
+    b.each_line {|l| bl << l}
+    return Diff.new(al, bl).ses.rcsdiff
+  end
+
+  class EditScript
+    def EditScript.parse_rcsdiff(input)
+      ses = EditScript.new
+      l = 1
+      scan_rcsdiff(input) {|mark, beg, len, lines|
+        if mark == :del
+	  ses.common beg - l if l < beg
+	  ses.del len
+	  l = beg + len
+	else
+	  ses.add lines
+	end
+      }
+      return ses
+    end
+
+    def EditScript.scan_rcsdiff(input)
+      state = :command
+      beg = len = nil
+      adds = nil
+      input.each_line("\n") {|line|
+	case state
+	when :command
+	  case line
+	  when /\Aa(\d+)\s+(\d+)/
+	    beg = $1.to_i
+	    len = $2.to_i
+	    adds = []
+	    state = :add
+	  when /\Ad(\d+)\s+(\d+)/
+	    beg = $1.to_i
+	    len = $2.to_i
+	    yield :del, beg, len, nil
+	    state = :command
+	  else
+	    raise InvalidRCSDiffFormat.new(line)
+	  end
+	when :add
+	  adds << line
+	  if adds.length == len
+	    yield :add, beg, len, adds
+	    adds = nil
+	    state = :command
+	  end
+	else
+	  raise StandardError.new("unknown state")
+	end
+      }
+    end
+
+    def rcsdiff(out='')
+      state = :lines
+      l = 1
+      each {|mark, del, add|
+        case mark
+        when :add_elt
+	  out << "a#{l - 1} #{add.length}\n"
+	  add.each {|line|
+	    case state
+	    when :lines
+	      case line
+	      when /\A.*\n\z/
+	      when /\A.*\z/
+	        state = :after_last_line
+	      else
+		raise ArgumentError.new("additional element is not line")
+	      end
+	    when :after_last_line
+	      raise ArgumentError.new("additional elements after last incomplete line")
+	    end
+	    out << line
+	  }
+        when :add_num
+	  raise ArgumentError.new("additionnal lines are not known.")
+        when :common_elt_elt
+	  l += del.length
+        when :common_elt_num
+	  l += add
+        when :common_num_elt
+	  l += del
+        when :common_num_num
+	  l += del
+        when :del_elt
+	  del = del.length
+	  out << "d#{l} #{del}\n"
+	  l += del
+        when :del_num
+	  out << "d#{l} #{del}\n"
+	  l += del
+	end
+      }
+      return out
+    end
+
+    class InvalidRCSDiffFormat < StandardError
+    end
+  end
+end

data/lib/docdiff/diff/shortestpath.rb

@@ -0,0 +1,93 @@
+=begin
+Diff::ShortestPath uses the algorithm described in following paper.
+
+[Wu1990] Sun Wu, Udi Manber, Gene Myers and Webb Miller,
+An O(NP) Sequence Comparison Algorithm,
+Information Processing Letters 35, 1990, 317-323
+=end
+
+class Diff
+  class ShortestPath
+    def initialize(a, b)
+      if a.length > b.length
+	@a = b
+	@b = a
+	@exchanged = true
+      else
+	@a = a
+	@b = b
+	@exchanged = false
+      end
+      @m = @a.length
+      @n = @b.length
+    end
+
+    def lcs(lcs=Subsequence.new)
+      d = @n - @m
+      fp = Array.new(@n+1+@m+1+1, -1)
+      fp_base = -(@m+1)
+      path = Array.new(fp.length)
+      p = -1
+      begin
+        p += 1
+	(-p).upto(d-1) {|k|
+	  a = fp[fp_base+k-1]+1
+	  b = fp[fp_base+k+1]
+	  if a < b
+	    y = fp[fp_base+k] = snake(k, b)
+	    path[fp_base+k] = path[fp_base+k+1]
+	    path[fp_base+k] = [y - k, y, y - b, path[fp_base+k]] if b < y
+	  else
+	    y = fp[fp_base+k] = snake(k, a)
+	    path[fp_base+k] = path[fp_base+k-1]
+	    path[fp_base+k] = [y - k, y, y - a, path[fp_base+k]] if a < y
+	  end
+	}
+	(d+p).downto(d+1) {|k|
+	  a = fp[fp_base+k-1]+1
+	  b = fp[fp_base+k+1]
+	  if a < b
+	    y = fp[fp_base+k] = snake(k, b)
+	    path[fp_base+k] = path[fp_base+k+1]
+	    path[fp_base+k] = [y - k, y, y - b, path[fp_base+k]] if b < y
+	  else
+	    y = fp[fp_base+k] = snake(k, a)
+	    path[fp_base+k] = path[fp_base+k-1]
+	    path[fp_base+k] = [y - k, y, y - a, path[fp_base+k]] if a < y
+	  end
+	}
+	a = fp[fp_base+d-1]+1
+	b = fp[fp_base+d+1]
+	if a < b
+	  y = fp[fp_base+d] = snake(d, b)
+	  path[fp_base+d] = path[fp_base+d+1]
+	  path[fp_base+d] = [y - d, y, y - b, path[fp_base+d]] if b < y
+	else
+	  y = fp[fp_base+d] = snake(d, a)
+	  path[fp_base+d] = path[fp_base+d-1]
+	  path[fp_base+d] = [y - d, y, y - a, path[fp_base+d]] if a < y
+	end
+      end until fp[fp_base+d] == @n
+      shortest_path = path[fp_base+d]
+      list = []
+      while shortest_path
+        x, y, l, shortest_path = shortest_path
+	list << [x - l, y - l, l]
+      end
+      if @exchanged
+	list.collect {|xyl| tmp = xyl[0]; xyl[0] = xyl[1]; xyl[1] = tmp}
+      end
+      list.reverse_each {|xyl| lcs.add(*xyl)}
+      return lcs
+    end
+
+    def snake(k, y)
+      x = y - k
+      while x < @m && y < @n && @a[x] == @b[y]
+        x += 1
+	y += 1
+      end
+      return y
+    end
+  end
+end

data/lib/docdiff/diff/speculative.rb

@@ -0,0 +1,40 @@
+require 'docdiff/diff/shortestpath'
+require 'docdiff/diff/contours'
+require 'thread'
+
+class Diff
+  class Speculative
+    def initialize(a, b)
+      @a = a
+      @b = b
+    end
+
+    def lcs
+      # Try speculative execution.
+      result = nil
+
+      tg = ThreadGroup.new
+
+      # Since ShortestPath is faster than Contours if two sequences are very similar,
+      # try it first.
+      tg.add(Thread.new {
+	#print "ShortestPath start.\n"
+	result = ShortestPath.new(@a, @b).lcs
+	Thread.exclusive {tg.list.each {|t| t.kill if t != Thread.current}}
+	#print "ShortestPath win.\n"
+      })
+
+      # start Contours unless ShortestPath is already ended with first quantum, 
+      tg.add(Thread.new {
+	#print "Contours start.\n"
+	result = Contours.new(@a, @b).lcs
+	Thread.exclusive {tg.list.each {|t| t.kill if t != Thread.current}}
+	#print "Contours win.\n"
+      }) unless tg.list.empty?
+
+      tg.list.each {|t| t.join}
+
+      return result
+    end
+  end
+end

data/lib/docdiff/diff/subsequence.rb

@@ -0,0 +1,39 @@
+class Diff
+  class Subsequence
+    def initialize
+      @list = []
+    end
+
+    def add(i, j, len=1)
+      raise ArgumentError.new("non-positive length: #{len}") if len <= 0
+
+      if @list.empty?
+        @list << [i, j, len]
+	return
+      end
+
+      i0, j0, len0 = @list.last
+
+      if i0 + len0 == i && j0 + len0 == j
+        @list.last[2] += len
+	return
+      end
+
+      if i0 + len0 > i || j0 + len0 > j
+	raise ArgumentError.new("additional common sequence overlapped.")
+      end
+
+      @list << [i, j, len]
+    end
+
+    def each(&block)
+      @list.each(&block)
+    end
+
+    def length
+      len = 0
+      each {|i, j, l| len += l}
+      return len
+    end
+  end
+end

data/lib/docdiff/diff/unidiff.rb

@@ -0,0 +1,124 @@
+class Diff
+  def Diff.unidiff(a, b, algorithm=nil)
+    al = []
+    a.each_line {|l| al << l}
+    bl = []
+    b.each_line {|l| bl << l}
+    return Diff.new(al, bl).ses(algorithm).unidiff
+  end
+
+  class EditScript
+    def unidiff_hunk_header(l1, ll1, l2, ll2)
+      l1 = 0 if ll1 == 0
+      l2 = 0 if ll2 == 0
+      result = "@@ -#{l1}"
+      result << ",#{ll1}" if ll1 != 1
+      result << " +#{l2}"
+      result << ",#{ll2}" if ll2 != 1
+      result << " @@\n"
+    end
+
+    def unidiff(out='', context_lines=3)
+      state = :common
+      l1 = l2 = 1
+      hunk = []
+      hunk_l1 = hunk_l2 = 1
+      hunk_tail = 0
+      each {|mark, del, add|
+        case mark
+        when :add_elt
+	  unless hunk
+	    hunk = []
+	    hunk_l1 = l1
+	    hunk_l2 = l2
+	  end
+
+	  add.each {|line| hunk << '+' + line}
+	  hunk[-1] += "\n\\n" if /\n\z/ !~ hunk[-1]
+	  l2 += add.length
+	  hunk_tail = 0
+        when :add_num
+	  raise ArgumentError.new("additionnal lines are not known.")
+        when :common_elt_elt
+	  if hunk
+	    if hunk_tail + add.length <= context_lines * 2
+	      add.each {|line| hunk << ' ' + line}
+	      hunk[-1] += "\n\\n" if /\n\z/ !~ hunk[-1]
+	      l1 += add.length
+	      l2 += add.length
+	      hunk_tail += add.length
+	    else
+	      i = 0
+              if hunk_tail != hunk.length
+                while hunk_tail < context_lines
+                  hunk << ' ' + add[i]
+                  l1 += 1
+                  l2 += 1
+                  hunk_tail += 1
+                  i += 1
+                end
+                hunk[-1] += "\n\\n" if /\n\z/ !~ hunk[-1]
+
+                out << unidiff_hunk_header(hunk_l1, l1 - hunk_l1, hunk_l2, l2 - hunk_l1)
+                h = hunk.length - (hunk_tail - context_lines)
+                (0...h).each {|j| out << hunk[j]}
+                hunk[0, h] = []
+              end
+
+	      l1 += add.length - i
+	      l2 += add.length - i
+
+	      hunk_l1 = l1 - context_lines
+	      hunk_l2 = l2 - context_lines
+	      hunk = add[-context_lines..-1].collect {|line| ' ' + line}
+	      hunk[-1] += "\n\\n" if /\n\z/ !~ hunk[-1]
+	      hunk_tail = context_lines
+	    end
+	  else
+	    hunk_l1 = l1
+	    hunk_l2 = l2
+	    l1 += add.length
+	    l2 += add.length
+	    if context_lines <= add.length
+	      hunk = add[-context_lines..-1].collect {|line| ' ' + line}
+	    else
+	      hunk = add.collect {|line| ' ' + line}
+	    end
+	    hunk[-1] += "\n\\n" if /\n\z/ !~ hunk[-1]
+	    hunk_tail = hunk.length
+	  end
+        when :common_elt_num
+	  raise ArgumentError.new("deleted lines are not known.")
+        when :common_num_elt
+	  raise ArgumentError.new("additional lines are not known.")
+        when :common_num_num
+	  raise ArgumentError.new("deleted and additional lines are not known.")
+        when :del_elt
+	  if hunk_tail == hunk.length && context_lines < hunk_tail
+	    i = hunk_tail - context_lines
+	    hunk[0, i] = []
+	    hunk_l1 += i
+	    hunk_l2 += i
+	  end
+	  del.each {|line| hunk << '-' + line}
+	  hunk[-1] += "\n\\n" if /\n\z/ !~ hunk[-1]
+	  l1 += del.length
+	  hunk_tail = 0
+        when :del_num
+	  raise ArgumentError.new("deleted lines are not known.")
+	end
+      }
+      if hunk_tail != hunk.length
+	if context_lines < hunk_tail
+	  i = hunk_tail - context_lines
+	  hunk[-i..-1] = []
+	  l1 -= i
+	  l2 -= i
+	end
+	out << unidiff_hunk_header(hunk_l1, l1 - hunk_l1, hunk_l2, l2 - hunk_l1)
+	hunk.each {|line| out << line}
+      end
+      return out
+    end
+  end
+end