daff 1.1.2

data/lib/lib/coopy/bag.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class Bag 
+    def getItem(x) puts "Abstract Bag.getItem called" end
+    def getItemView() puts "Abstract Bag.getItemView called" end
+  end
+
+end

data/lib/lib/coopy/cell_info.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class CellInfo 
+    
+    def initialize
+    end
+    
+    attr_accessor :value
+    attr_accessor :pretty_value
+    attr_accessor :category
+    attr_accessor :category_given_tr
+    attr_accessor :separator
+    attr_accessor :updated
+    attr_accessor :conflicted
+    attr_accessor :pvalue
+    attr_accessor :lvalue
+    attr_accessor :rvalue
+    
+    def to_s 
+      return @value if !@updated
+      return _hx_str(@lvalue) + "::" + _hx_str(@rvalue) if !@conflicted
+      return _hx_str(@pvalue) + "||" + _hx_str(@lvalue) + "::" + _hx_str(@rvalue)
+    end
+    
+  end
+
+end

data/lib/lib/coopy/change.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class Change 
+    
+    def initialize(txt = nil)
+      if txt != nil 
+        @mode = ::Coopy::ChangeType.note_change
+        @change = txt
+      else 
+        @mode = ::Coopy::ChangeType.no_change
+      end
+    end
+    
+    attr_accessor :change
+    attr_accessor :parent
+    attr_accessor :local
+    attr_accessor :remote
+    attr_accessor :mode
+    
+    def get_mode 
+      return "" + _hx_str(@mode.to_s)
+    end
+    
+    def to_s 
+      begin
+        _g = @mode
+        case(_g.index)
+        when 0
+          return "no change"
+        when 2
+          return "local change: " + _hx_str(@remote.to_s) + " -> " + _hx_str(@local.to_s)
+        when 1
+          return "remote change: " + _hx_str(@local.to_s) + " -> " + _hx_str(@remote.to_s)
+        when 3
+          return "conflicting change: " + _hx_str(@parent.to_s) + " -> " + _hx_str(@local.to_s) + " / " + _hx_str(@remote.to_s)
+        when 4
+          return "same change: " + _hx_str(@parent.to_s) + " -> " + _hx_str(@local.to_s) + " / " + _hx_str(@remote.to_s)
+        when 5
+          return @change
+        end
+      end
+    end
+    
+  end
+
+end

data/lib/lib/coopy/change_type.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class ChangeType
+    ISENUM__ = true
+    attr_accessor :tag
+    attr_accessor :index
+    attr_accessor :params
+    def initialize(t,index,p = nil ) @tag = t; @index = index; @params = p; end
+    
+    def ChangeType.both_change() ChangeType.new("BOTH_CHANGE",3) end
+    def ChangeType.local_change() ChangeType.new("LOCAL_CHANGE",2) end
+    def ChangeType.note_change() ChangeType.new("NOTE_CHANGE",5) end
+    def ChangeType.no_change() ChangeType.new("NO_CHANGE",0) end
+    def ChangeType.remote_change() ChangeType.new("REMOTE_CHANGE",1) end
+    def ChangeType.same_change() ChangeType.new("SAME_CHANGE",4) end
+    CONSTRUCTS__ = ["NO_CHANGE","REMOTE_CHANGE","LOCAL_CHANGE","BOTH_CHANGE","SAME_CHANGE","NOTE_CHANGE"]
+  end
+
+end

data/lib/lib/coopy/compare.rb

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class Compare 
+    
+    def initialize
+    end
+    
+    def compare(parent,local,remote,report)
+      ws = ::Coopy::Workspace.new
+      ws.parent = parent
+      ws.local = local
+      ws.remote = remote
+      ws.report = report
+      report.clear
+      if parent == nil || local == nil || remote == nil 
+        report.changes.push(::Coopy::Change.new("only 3-way comparison allowed right now"))
+        return false
+      end
+      return self.compare_structured(ws) if parent.has_structure || local.has_structure || remote.has_structure
+      return self.compare_primitive(ws)
+    end
+    
+    protected
+    
+    def compare_structured(ws)
+      ws.tparent = ws.parent.get_table
+      ws.tlocal = ws.local.get_table
+      ws.tremote = ws.remote.get_table
+      if ws.tparent == nil || ws.tlocal == nil || ws.tremote == nil 
+        ws.report.changes.push(::Coopy::Change.new("structured comparisons that include non-tables are not available yet"))
+        return false
+      end
+      return self.compare_table(ws)
+    end
+    
+    def compare_table(ws)
+      ws.p2l = ::Coopy::TableComparisonState.new
+      ws.p2r = ::Coopy::TableComparisonState.new
+      ws.p2l.a = ws.tparent
+      ws.p2l.b = ws.tlocal
+      ws.p2r.a = ws.tparent
+      ws.p2r.b = ws.tremote
+      cmp = ::Coopy::CompareTable.new
+      cmp.attach(ws.p2l)
+      cmp.attach(ws.p2r)
+      c = ::Coopy::Change.new
+      c.parent = ws.parent
+      c.local = ws.local
+      c.remote = ws.remote
+      if ws.p2l.is_equal && !ws.p2r.is_equal 
+        c.mode = ::Coopy::ChangeType.remote_change
+      elsif !ws.p2l.is_equal && ws.p2r.is_equal 
+        c.mode = ::Coopy::ChangeType.local_change
+      elsif !ws.p2l.is_equal && !ws.p2r.is_equal 
+        ws.l2r = ::Coopy::TableComparisonState.new
+        ws.l2r.a = ws.tlocal
+        ws.l2r.b = ws.tremote
+        cmp.attach(ws.l2r)
+        if ws.l2r.is_equal 
+          c.mode = ::Coopy::ChangeType.same_change
+        else 
+          c.mode = ::Coopy::ChangeType.both_change
+        end
+      else 
+        c.mode = ::Coopy::ChangeType.no_change
+      end
+      ws.report.changes.push(c) if c.mode != ::Coopy::ChangeType.no_change
+      return true
+    end
+    
+    def compare_primitive(ws)
+      sparent = ws.parent.to_s
+      slocal = ws.local.to_s
+      sremote = ws.remote.to_s
+      c = ::Coopy::Change.new
+      c.parent = ws.parent
+      c.local = ws.local
+      c.remote = ws.remote
+      if sparent == slocal && sparent != sremote 
+        c.mode = ::Coopy::ChangeType.remote_change
+      elsif sparent == sremote && sparent != slocal 
+        c.mode = ::Coopy::ChangeType.local_change
+      elsif slocal == sremote && sparent != slocal 
+        c.mode = ::Coopy::ChangeType.same_change
+      elsif sparent != slocal && sparent != sremote 
+        c.mode = ::Coopy::ChangeType.both_change
+      else 
+        c.mode = ::Coopy::ChangeType.no_change
+      end
+      ws.report.changes.push(c) if c.mode != ::Coopy::ChangeType.no_change
+      return true
+    end
+    
+  end
+
+end

data/lib/lib/coopy/compare_flags.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class CompareFlags 
+    
+    def initialize
+      @ordered = true
+      @show_unchanged = false
+      @unchanged_context = 1
+      @always_show_order = false
+      @never_show_order = true
+      @show_unchanged_columns = false
+      @unchanged_column_context = 1
+      @always_show_header = true
+      @acts = nil
+    end
+    
+    attr_accessor :ordered
+    attr_accessor :show_unchanged
+    attr_accessor :unchanged_context
+    attr_accessor :always_show_order
+    attr_accessor :never_show_order
+    attr_accessor :show_unchanged_columns
+    attr_accessor :unchanged_column_context
+    attr_accessor :always_show_header
+    attr_accessor :acts
+    
+    def allow_update 
+      return true if @acts == nil
+      return @acts.include?("update")
+    end
+    
+    def allow_insert 
+      return true if @acts == nil
+      return @acts.include?("insert")
+    end
+    
+    def allow_delete 
+      return true if @acts == nil
+      return @acts.include?("delete")
+    end
+    
+  end
+
+end

data/lib/lib/coopy/compare_table.rb

@@ -0,0 +1,402 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class CompareTable 
+    
+    def initialize
+    end
+    
+    protected
+    
+    attr_accessor :comp
+    attr_accessor :indexes
+    
+    public
+    
+    def attach(comp)
+      @comp = comp
+      more = self.compare_core
+      while(more && comp.run_to_completion) 
+        more = self.compare_core
+      end
+      return !more
+    end
+    
+    def align 
+      alignment = ::Coopy::Alignment.new
+      self.align_core(alignment)
+      return alignment
+    end
+    
+    def get_comparison_state 
+      return @comp
+    end
+    
+    protected
+    
+    def align_core(align)
+      if @comp.p == nil 
+        self.align_core2(align,@comp.a,@comp.b)
+        return
+      end
+      align.reference = ::Coopy::Alignment.new
+      self.align_core2(align,@comp.p,@comp.b)
+      self.align_core2(align.reference,@comp.p,@comp.a)
+      align.meta.reference = align.reference.meta
+    end
+    
+    def align_core2(align,a,b)
+      align.meta = ::Coopy::Alignment.new if align.meta == nil
+      self.align_columns(align.meta,a,b)
+      column_order = align.meta.to_order_pruned(false)
+      common_units = Array.new
+      begin
+        _g = 0
+        _g1 = column_order.get_list
+        while(_g < _g1.length) 
+          unit = _g1[_g]
+          _g+=1
+          common_units.push(unit) if unit.l >= 0 && unit.r >= 0 && unit.p != -1
+        end
+      end
+      align.range(a.get_height,b.get_height)
+      align.tables(a,b)
+      align.set_rowlike(true)
+      w = a.get_width
+      ha = a.get_height
+      hb = b.get_height
+      av = a.get_cell_view
+      n = 5
+      columns = Array.new
+      if common_units.length > n 
+        columns_eval = Array.new
+        begin
+          _g11 = 0
+          _g2 = common_units.length
+          while(_g11 < _g2) 
+            i = _g11
+            _g11+=1
+            ct = 0
+            mem = {}
+            mem2 = {}
+            ca = common_units[i].l
+            cb = common_units[i].r
+            begin
+              _g21 = 0
+              while(_g21 < ha) 
+                j = _g21
+                _g21+=1
+                key = av.to_s(a.get_cell(ca,j))
+                if !mem.include?(key) 
+                  mem[key] = 1
+                  ct+=1
+                end
+              end
+            end
+            begin
+              _g22 = 0
+              while(_g22 < hb) 
+                j1 = _g22
+                _g22+=1
+                key1 = av.to_s(b.get_cell(cb,j1))
+                if !mem2.include?(key1) 
+                  mem2[key1] = 1
+                  ct+=1
+                end
+              end
+            end
+            columns_eval.push([i,ct])
+          end
+        end
+        sorter = lambda {|a1,b1|
+          return 1 if a1[1] < b1[1]
+          return -1 if a1[1] > b1[1]
+          return 0
+        }
+        columns_eval.sort{|a,b| sorter.call(a,b)}
+        columns = Lambda.array(Lambda.map(columns_eval,lambda {|v|
+          return v[0]
+        }))
+        columns = columns.slice(0,n - 1)
+      else 
+        _g12 = 0
+        _g3 = common_units.length
+        while(_g12 < _g3) 
+          i1 = _g12
+          _g12+=1
+          columns.push(i1)
+        end
+      end
+      top = nil
+      begin
+        v1 = 2 ** columns.length
+        top = v1.round
+      end
+      pending = {}
+      begin
+        _g4 = 0
+        while(_g4 < ha) 
+          j2 = _g4
+          _g4+=1
+          pending[j2] = j2
+        end
+      end
+      pending_ct = ha
+      begin
+        _g5 = 0
+        while(_g5 < top) 
+          k = _g5
+          _g5+=1
+          next if k == 0
+          break if pending_ct == 0
+          active_columns = Array.new
+          kk = k
+          at = 0
+          while(kk > 0) 
+            active_columns.push(columns[at]) if kk.remainder(2) == 1
+            kk >>= 1
+            at+=1
+          end
+          index = ::Coopy::IndexPair.new
+          begin
+            _g23 = 0
+            _g13 = active_columns.length
+            while(_g23 < _g13) 
+              k1 = _g23
+              _g23+=1
+              unit1 = common_units[active_columns[k1]]
+              index.add_columns(unit1.l,unit1.r)
+              align.add_index_columns(unit1)
+            end
+          end
+          index.index_tables(a,b)
+          h = a.get_height
+          h = b.get_height if b.get_height > h
+          h = 1 if h < 1
+          wide_top_freq = index.get_top_freq
+          ratio = wide_top_freq
+          ratio /= h + 20
+          next if ratio >= 0.1
+          @indexes.push(index) if @indexes != nil
+          fixed = Array.new
+          _it = ::Rb::RubyIterator.new(pending.keys)
+          while(_it.has_next) do
+            j3 = _it._next
+            cross = index.query_local(j3)
+            spot_a = cross.spot_a
+            spot_b = cross.spot_b
+            next if spot_a != 1 || spot_b != 1
+            fixed.push(j3)
+            align.link(j3,cross.item_b.lst[0])
+          end
+          begin
+            _g24 = 0
+            _g14 = fixed.length
+            while(_g24 < _g14) 
+              j4 = _g24
+              _g24+=1
+              pending.delete(fixed[j4])
+              pending_ct-=1
+            end
+          end
+        end
+      end
+      align.link(0,0)
+    end
+    
+    def align_columns(align,a,b)
+      align.range(a.get_width,b.get_width)
+      align.tables(a,b)
+      align.set_rowlike(false)
+      slop = 5
+      va = a.get_cell_view
+      vb = b.get_cell_view
+      ra_best = 0
+      rb_best = 0
+      ct_best = -1
+      ma_best = nil
+      mb_best = nil
+      ra_header = 0
+      rb_header = 0
+      ra_uniques = 0
+      rb_uniques = 0
+      begin
+        _g = 0
+        while(_g < slop) 
+          ra = _g
+          _g+=1
+          break if ra >= a.get_height
+          begin
+            _g1 = 0
+            while(_g1 < slop) 
+              rb1 = _g1
+              _g1+=1
+              break if rb1 >= b.get_height
+              ma = {}
+              mb = {}
+              ct = 0
+              uniques = 0
+              begin
+                _g3 = 0
+                _g2 = a.get_width
+                while(_g3 < _g2) 
+                  ca = _g3
+                  _g3+=1
+                  key = va.to_s(a.get_cell(ca,ra))
+                  if ma.include?(key) 
+                    ma[key] = -1
+                    uniques-=1
+                  else 
+                    ma[key] = ca
+                    uniques+=1
+                  end
+                end
+              end
+              if uniques > ra_uniques 
+                ra_header = ra
+                ra_uniques = uniques
+              end
+              uniques = 0
+              begin
+                _g31 = 0
+                _g21 = b.get_width
+                while(_g31 < _g21) 
+                  cb = _g31
+                  _g31+=1
+                  key1 = vb.to_s(b.get_cell(cb,rb1))
+                  if mb.include?(key1) 
+                    mb[key1] = -1
+                    uniques-=1
+                  else 
+                    mb[key1] = cb
+                    uniques+=1
+                  end
+                end
+              end
+              if uniques > rb_uniques 
+                rb_header = rb1
+                rb_uniques = uniques
+              end
+              _it = ::Rb::RubyIterator.new(ma.keys)
+              while(_it.has_next) do
+                key2 = _it._next
+                i0 = ma[key2]
+                i1 = mb[key2]
+                if i1 != nil 
+                  ct+=1 if i1 >= 0 && i0 >= 0
+                end
+              end
+              if ct > ct_best 
+                ct_best = ct
+                ma_best = ma
+                mb_best = mb
+                ra_best = ra
+                rb_best = rb1
+              end
+            end
+          end
+        end
+      end
+      return if ma_best == nil
+      _it2 = ::Rb::RubyIterator.new(ma_best.keys)
+      while(_it2.has_next) do
+        key3 = _it2._next
+        i01 = ma_best[key3]
+        i11 = mb_best[key3]
+        align.link(i01,i11) if i11 != nil && i01 != nil
+      end
+      align.headers(ra_header,rb_header)
+    end
+    
+    def test_has_same_columns 
+      p = @comp.p
+      a = @comp.a
+      b = @comp.b
+      eq = self.has_same_columns2(a,b)
+      eq = self.has_same_columns2(p,a) if eq && p != nil
+      @comp.has_same_columns = eq
+      @comp.has_same_columns_known = true
+      return true
+    end
+    
+    def has_same_columns2(a,b)
+      return false if a.get_width != b.get_width
+      return true if a.get_height == 0 || b.get_height == 0
+      av = a.get_cell_view
+      begin
+        _g1 = 0
+        _g = a.get_width
+        while(_g1 < _g) 
+          i = _g1
+          _g1+=1
+          begin
+            _g3 = i + 1
+            _g2 = a.get_width
+            while(_g3 < _g2) 
+              j = _g3
+              _g3+=1
+              return false if av.equals(a.get_cell(i,0),a.get_cell(j,0))
+            end
+          end
+          return false if !av.equals(a.get_cell(i,0),b.get_cell(i,0))
+        end
+      end
+      return true
+    end
+    
+    def test_is_equal 
+      p = @comp.p
+      a = @comp.a
+      b = @comp.b
+      eq = self.is_equal2(a,b)
+      eq = self.is_equal2(p,a) if eq && p != nil
+      @comp.is_equal = eq
+      @comp.is_equal_known = true
+      return true
+    end
+    
+    def is_equal2(a,b)
+      return false if a.get_width != b.get_width || a.get_height != b.get_height
+      av = a.get_cell_view
+      begin
+        _g1 = 0
+        _g = a.get_height
+        while(_g1 < _g) 
+          i = _g1
+          _g1+=1
+          begin
+            _g3 = 0
+            _g2 = a.get_width
+            while(_g3 < _g2) 
+              j = _g3
+              _g3+=1
+              return false if !av.equals(a.get_cell(j,i),b.get_cell(j,i))
+            end
+          end
+        end
+      end
+      return true
+    end
+    
+    def compare_core 
+      return false if @comp.completed
+      return self.test_is_equal if !@comp.is_equal_known
+      return self.test_has_same_columns if !@comp.has_same_columns_known
+      @comp.completed = true
+      return false
+    end
+    
+    public
+    
+    def store_indexes 
+      @indexes = Array.new
+    end
+    
+    def get_indexes 
+      return @indexes
+    end
+    
+  end
+
+end