daff 1.1.2

data/lib/lib/coopy/highlight_patch_unit.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class HighlightPatchUnit 
+    
+    def initialize
+      @add = false
+      @rem = false
+      @update = false
+      @source_row = -1
+      @source_row_offset = 0
+      @source_prev_row = -1
+      @source_next_row = -1
+      @dest_row = -1
+      @patch_row = -1
+      @code = ""
+    end
+    
+    attr_accessor :add
+    attr_accessor :rem
+    attr_accessor :update
+    attr_accessor :code
+    attr_accessor :source_row
+    attr_accessor :source_row_offset
+    attr_accessor :source_prev_row
+    attr_accessor :source_next_row
+    attr_accessor :dest_row
+    attr_accessor :patch_row
+    
+    def to_s 
+      return _hx_str(@code) + " patchRow " + _hx_str(@patch_row) + " sourceRows " + _hx_str(@source_prev_row) + "," + _hx_str(@source_row) + "," + _hx_str(@source_next_row) + " destRow " + _hx_str(@dest_row)
+    end
+    
+  end
+
+end

data/lib/lib/coopy/index.rb

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class Index 
+    
+    def initialize
+      @items = {}
+      @cols = Array.new
+      @keys = Array.new
+      @top_freq = 0
+      @height = 0
+    end
+    
+    attr_accessor :items
+    attr_accessor :keys
+    attr_accessor :top_freq
+    attr_accessor :height
+    
+    protected
+    
+    attr_accessor :cols
+    attr_accessor :v
+    attr_accessor :indexed_table
+    
+    public
+    
+    def add_column(i)
+      @cols.push(i)
+    end
+    
+    def index_table(t)
+      @indexed_table = t
+      begin
+        _g1 = 0
+        _g = t.get_height
+        while(_g1 < _g) 
+          i = _g1
+          _g1+=1
+          key = nil
+          if @keys.length > i 
+            key = @keys[i]
+          else 
+            key = self.to_key(t,i)
+            @keys.push(key)
+          end
+          item = @items[key]
+          if item == nil 
+            item = ::Coopy::IndexItem.new
+            @items[key] = item
+          end
+          ct = item.add(i)
+          @top_freq = ct if ct > @top_freq
+        end
+      end
+      @height = t.get_height
+    end
+    
+    def to_key(t,i)
+      wide = ""
+      @v = t.get_cell_view if @v == nil
+      begin
+        _g1 = 0
+        _g = @cols.length
+        while(_g1 < _g) 
+          k = _g1
+          _g1+=1
+          d = t.get_cell(@cols[k],i)
+          txt = @v.to_s(d)
+          next if txt == nil || txt == "" || txt == "null" || txt == "undefined"
+          wide += " // " if k > 0
+          wide += txt
+        end
+      end
+      return wide
+    end
+    
+    def to_key_by_content(row)
+      wide = ""
+      begin
+        _g1 = 0
+        _g = @cols.length
+        while(_g1 < _g) 
+          k = _g1
+          _g1+=1
+          txt = row.get_row_string(@cols[k])
+          next if txt == nil || txt == "" || txt == "null" || txt == "undefined"
+          wide += " // " if k > 0
+          wide += txt
+        end
+      end
+      return wide
+    end
+    
+    def get_table 
+      return @indexed_table
+    end
+    
+  end
+
+end

data/lib/lib/coopy/index_item.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class IndexItem 
+    
+    def initialize
+    end
+    
+    attr_accessor :lst
+    
+    def add(i)
+      @lst = Array.new if @lst == nil
+      @lst.push(i)
+      return @lst.length
+    end
+    
+  end
+
+end

data/lib/lib/coopy/index_pair.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class IndexPair 
+    
+    def initialize
+      @ia = ::Coopy::Index.new
+      @ib = ::Coopy::Index.new
+      @quality = 0
+    end
+    
+    protected
+    
+    attr_accessor :ia
+    attr_accessor :ib
+    attr_accessor :quality
+    
+    public
+    
+    def add_column(i)
+      @ia.add_column(i)
+      @ib.add_column(i)
+    end
+    
+    def add_columns(ca,cb)
+      @ia.add_column(ca)
+      @ib.add_column(cb)
+    end
+    
+    def index_tables(a,b)
+      @ia.index_table(a)
+      @ib.index_table(b)
+      good = 0
+      _it = ::Rb::RubyIterator.new(@ia.items.keys)
+      while(_it.has_next) do
+        key = _it._next
+        item_a = @ia.items[key]
+        spot_a = item_a.lst.length
+        item_b = @ib.items[key]
+        spot_b = 0
+        spot_b = item_b.lst.length if item_b != nil
+        good+=1 if spot_a == 1 && spot_b == 1
+      end
+      @quality = good / lambda{|_this_| b1 = a.get_height
+      _r2 = [1.0,b1].max}.call(self)
+    end
+    
+    protected
+    
+    def query_by_key(ka)
+      result = ::Coopy::CrossMatch.new
+      result.item_a = @ia.items[ka]
+      result.item_b = @ib.items[ka]
+      result.spot_a = result.spot_b = 0
+      if ka != "" 
+        result.spot_a = result.item_a.lst.length if result.item_a != nil
+        result.spot_b = result.item_b.lst.length if result.item_b != nil
+      end
+      return result
+    end
+    
+    public
+    
+    def query_by_content(row)
+      result = ::Coopy::CrossMatch.new
+      ka = @ia.to_key_by_content(row)
+      return self.query_by_key(ka)
+    end
+    
+    def query_local(row)
+      ka = @ia.to_key(@ia.get_table,row)
+      return self.query_by_key(ka)
+    end
+    
+    def get_top_freq 
+      return @ib.top_freq if @ib.top_freq > @ia.top_freq
+      return @ia.top_freq
+    end
+    
+    def get_quality 
+      return @quality
+    end
+    
+  end
+
+end

data/lib/lib/coopy/mover.rb

@@ -0,0 +1,195 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class Mover 
+    
+    def initialize
+    end
+    
+    def Mover.move_units(units)
+      isrc = Array.new
+      idest = Array.new
+      len = units.length
+      ltop = -1
+      rtop = -1
+      in_src = {}
+      in_dest = {}
+      begin
+        _g = 0
+        while(_g < len) 
+          i = _g
+          _g+=1
+          unit = units[i]
+          if unit.l >= 0 && unit.r >= 0 
+            ltop = unit.l if ltop < unit.l
+            rtop = unit.r if rtop < unit.r
+            begin
+              in_src[unit.l] = i
+              i
+            end
+            begin
+              in_dest[unit.r] = i
+              i
+            end
+          end
+        end
+      end
+      v = nil
+      begin
+        _g1 = 0
+        _g2 = ltop + 1
+        while(_g1 < _g2) 
+          i1 = _g1
+          _g1+=1
+          v = in_src[i1]
+          isrc.push(v) if v != nil
+        end
+      end
+      begin
+        _g11 = 0
+        _g3 = rtop + 1
+        while(_g11 < _g3) 
+          i2 = _g11
+          _g11+=1
+          v = in_dest[i2]
+          idest.push(v) if v != nil
+        end
+      end
+      return ::Coopy::Mover.move_without_extras(isrc,idest)
+    end
+    
+    def Mover.move_with_extras(isrc,idest)
+      len = isrc.length
+      len2 = idest.length
+      in_src = {}
+      in_dest = {}
+      begin
+        _g = 0
+        while(_g < len) 
+          i = _g
+          _g+=1
+          begin
+            in_src[isrc[i]] = i
+            i
+          end
+        end
+      end
+      begin
+        _g1 = 0
+        while(_g1 < len2) 
+          i1 = _g1
+          _g1+=1
+          begin
+            in_dest[idest[i1]] = i1
+            i1
+          end
+        end
+      end
+      src = Array.new
+      dest = Array.new
+      v = nil
+      begin
+        _g2 = 0
+        while(_g2 < len) 
+          i2 = _g2
+          _g2+=1
+          v = isrc[i2]
+          src.push(v) if in_dest.include?(v)
+        end
+      end
+      begin
+        _g3 = 0
+        while(_g3 < len2) 
+          i3 = _g3
+          _g3+=1
+          v = idest[i3]
+          dest.push(v) if in_src.include?(v)
+        end
+      end
+      return ::Coopy::Mover.move_without_extras(src,dest)
+    end
+    
+    def Mover.move_without_extras(src,dest)
+      return nil if src.length != dest.length
+      return [] if src.length <= 1
+      len = src.length
+      in_src = {}
+      blk_len = {}
+      blk_src_loc = {}
+      blk_dest_loc = {}
+      begin
+        _g = 0
+        while(_g < len) 
+          i = _g
+          _g+=1
+          begin
+            in_src[src[i]] = i
+            i
+          end
+        end
+      end
+      ct = 0
+      in_cursor = -2
+      out_cursor = 0
+      _next = nil
+      blk = -1
+      v = nil
+      while(out_cursor < len) 
+        v = dest[out_cursor]
+        _next = in_src[v]
+        if _next != in_cursor + 1 
+          blk = v
+          ct = 1
+          blk_src_loc[blk] = _next
+          blk_dest_loc[blk] = out_cursor
+        else 
+          ct+=1
+        end
+        blk_len[blk] = ct
+        in_cursor = _next
+        out_cursor+=1
+      end
+      blks = Array.new
+      _it = ::Rb::RubyIterator.new(blk_len.keys)
+      while(_it.has_next) do
+        k = _it._next
+        blks.push(k)
+      end
+      blks.sort {|a,b|
+        return blk_len[b] - blk_len[a]
+      }
+      moved = Array.new
+      while(blks.length > 0) 
+        blk1 = blks.shift
+        blen = blks.length
+        ref_src_loc = blk_src_loc[blk1]
+        ref_dest_loc = blk_dest_loc[blk1]
+        i1 = blen - 1
+        while(i1 >= 0) 
+          blki = blks[i1]
+          blki_src_loc = blk_src_loc[blki]
+          to_left_src = blki_src_loc < ref_src_loc
+          to_left_dest = blk_dest_loc[blki] < ref_dest_loc
+          if to_left_src != to_left_dest 
+            ct1 = blk_len[blki]
+            begin
+              _g1 = 0
+              while(_g1 < ct1) 
+                j = _g1
+                _g1+=1
+                moved.push(src[blki_src_loc])
+                blki_src_loc+=1
+              end
+            end
+            blks.slice!(i1,1)
+          end
+          i1-=1
+        end
+      end
+      return moved
+    end
+    
+  end
+
+end

data/lib/lib/coopy/ordering.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class Ordering 
+    
+    def initialize
+      @order = Array.new
+      @ignore_parent = false
+    end
+    
+    protected
+    
+    attr_accessor :order
+    attr_accessor :ignore_parent
+    
+    public
+    
+    def add(l,r,p = -2)
+      p = -2 if @ignore_parent
+      @order.push(::Coopy::Unit.new(l,r,p))
+    end
+    
+    def get_list 
+      return @order
+    end
+    
+    def to_s 
+      txt = ""
+      begin
+        _g1 = 0
+        _g = @order.length
+        while(_g1 < _g) 
+          i = _g1
+          _g1+=1
+          txt += ", " if i > 0
+          txt += @order[i].to_s
+        end
+      end
+      return txt
+    end
+    
+    def ignore_parent 
+      @ignore_parent = true
+    end
+    
+  end
+
+end