daff 1.2.6 → 1.3.1

data/lib/lib/coopy/cell_builder.rb

@@ -10,7 +10,7 @@ module Coopy
     def update(local,remote) puts "Abstract CellBuilder.update called" end
     def conflict(parent,local,remote) puts "Abstract CellBuilder.conflict called" end
     def marker(label) puts "Abstract CellBuilder.marker called" end
-    def links(unit) puts "Abstract CellBuilder.links called" end
+    def links(unit,row_like) puts "Abstract CellBuilder.links called" end
   haxe_me ["coopy", "CellBuilder"]
   end
 

data/lib/lib/coopy/cell_info.rb

@@ -19,11 +19,12 @@ module Coopy
     attr_accessor :pvalue
     attr_accessor :lvalue
     attr_accessor :rvalue
+    attr_accessor :meta
     
     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)
+      _hx_str(@pvalue) + "||" + _hx_str(@lvalue) + "::" + _hx_str(@rvalue)
     end
     
   haxe_me ["coopy", "CellInfo"]

data/lib/lib/coopy/column_change.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class ColumnChange 
+    
+    def initialize
+    end
+    
+    attr_accessor :prev_name
+    attr_accessor :name
+    attr_accessor :props
+  haxe_me ["coopy", "ColumnChange"]
+  end
+
+end

data/lib/lib/coopy/compare_flags.rb

@@ -17,6 +17,13 @@ module Coopy
       @ids = nil
       @columns_to_ignore = nil
       @allow_nested_cells = false
+      @warnings = nil
+      @diff_strategy = nil
+      @show_meta = true
+      @show_unchanged_meta = false
+      @tables = nil
+      @parent = nil
+      @count_like_a_spreadsheet = true
     end
     
     attr_accessor :ordered
@@ -30,7 +37,14 @@ module Coopy
     attr_accessor :acts
     attr_accessor :ids
     attr_accessor :columns_to_ignore
+    attr_accessor :tables
     attr_accessor :allow_nested_cells
+    attr_accessor :warnings
+    attr_accessor :diff_strategy
+    attr_accessor :show_meta
+    attr_accessor :show_unchanged_meta
+    attr_accessor :parent
+    attr_accessor :count_like_a_spreadsheet
     
     def filter(act,allow)
       if @acts == nil 
@@ -41,22 +55,22 @@ module Coopy
       end
       return false if !@acts.include?(act)
       @acts[act] = allow
-      return true
+      true
     end
     
     def allow_update 
       return true if @acts == nil
-      return @acts.include?("update")
+      @acts.include?("update")
     end
     
     def allow_insert 
       return true if @acts == nil
-      return @acts.include?("insert")
+      @acts.include?("insert")
     end
     
     def allow_delete 
       return true if @acts == nil
-      return @acts.include?("delete")
+      @acts.include?("delete")
     end
     
     def get_ignored_columns 
@@ -71,7 +85,7 @@ module Coopy
           ignore[@columns_to_ignore[i]] = true
         end
       end
-      return ignore
+      ignore
     end
     
     def add_primary_key(column)
@@ -84,6 +98,20 @@ module Coopy
       @columns_to_ignore.push(column)
     end
     
+    def add_table(table)
+      @tables = Array.new if @tables == nil
+      @tables.push(table)
+    end
+    
+    def add_warning(warn)
+      @warnings = Array.new if @warnings == nil
+      @warnings.push(warn)
+    end
+    
+    def get_warning 
+      @warnings.join("\n")
+    end
+    
   haxe_me ["coopy", "CompareFlags"]
   end
 

data/lib/lib/coopy/compare_table.rb

@@ -6,6 +6,9 @@ module Coopy
     
     def initialize(comp)
       @comp = comp
+      if comp.compare_flags != nil 
+        comp.p = comp.compare_flags.parent if comp.compare_flags.parent != nil
+      end
     end
     
     protected
@@ -16,11 +19,15 @@ module Coopy
     public
     
     def run 
+      if self.use_sql 
+        @comp.completed = true
+        return false
+      end
       more = self.compare_core
       while(more && @comp.run_to_completion) 
         more = self.compare_core
       end
-      return !more
+      !more
     end
     
     def align 
@@ -29,16 +36,34 @@ module Coopy
       end
       alignment = ::Coopy::Alignment.new
       self.align_core(alignment)
-      return alignment
+      alignment
     end
     
     def get_comparison_state 
-      return @comp
+      @comp
     end
     
     protected
     
     def align_core(align)
+      if self.use_sql 
+        tab1 = nil
+        tab2 = nil
+        tab3 = nil
+        if @comp.p == nil 
+          tab1 = @comp.a
+          tab2 = @comp.b
+        else 
+          align.reference = ::Coopy::Alignment.new
+          tab1 = @comp.p
+          tab2 = @comp.b
+          tab3 = @comp.a
+        end
+        sc = ::Coopy::SqlCompare.new(tab1.get_database,tab1,tab2,tab3,align)
+        sc.apply
+        align.meta.reference = align.reference.meta if @comp.p != nil
+        return
+      end
       if @comp.p == nil 
         self.align_core2(align,@comp.a,@comp.b)
         return
@@ -90,8 +115,13 @@ module Coopy
           end
         end
       end
+      index_top = nil
+      pending_ct = ha
+      reverse_pending_ct = hb
+      used = {}
+      used_reverse = {}
       if ids != nil 
-        index = ::Coopy::IndexPair.new
+        index_top = ::Coopy::IndexPair.new
         ids_as_map = {}
         begin
           _g2 = 0
@@ -112,23 +142,27 @@ module Coopy
             na = av.to_s(a.get_cell(unit1.l,0))
             nb = av.to_s(b.get_cell(unit1.r,0))
             if ids_as_map.include?(na) || ids_as_map.include?(nb) 
-              index.add_columns(unit1.l,unit1.r)
+              index_top.add_columns(unit1.l,unit1.r)
               align.add_index_columns(unit1)
             end
           end
         end
-        index.index_tables(a,b)
-        @indexes.push(index) if @indexes != nil
+        index_top.index_tables(a,b,1)
+        @indexes.push(index_top) if @indexes != nil
         begin
           _g4 = 0
           while(_g4 < ha) 
             j = _g4
             _g4+=1
-            cross = index.query_local(j)
+            cross = index_top.query_local(j)
             spot_a = cross.spot_a
             spot_b = cross.spot_b
             next if spot_a != 1 || spot_b != 1
-            align.link(j,cross.item_b.lst[0])
+            jb = cross.item_b.lst[0]
+            align.link(j,jb)
+            used[jb] = 1
+            reverse_pending_ct-=1 if !used_reverse.include?(j)
+            used_reverse[j] = 1
           end
         end
       else 
@@ -179,11 +213,11 @@ module Coopy
             return -1 if a1[1] > b1[1]
             return 1 if a1[0] > b1[0]
             return -1 if a1[0] < b1[0]
-            return 0
+            0
           }
-          columns_eval.sort{|a,b| sorter.call(a,b)}
+          columns_eval.sort!{|a,b| sorter.call(a,b)}
           columns = Lambda.array(Lambda.map(columns_eval,lambda {|v|
-            return v[0]
+            v[0]
           }))
           columns = columns.slice(0,n - 1)
         else 
@@ -209,10 +243,8 @@ module Coopy
             pending[j3] = j3
           end
         end
-        pending_ct = ha
         added_columns = {}
         index_ct = 0
-        index_top = nil
         begin
           _g8 = 0
           while(_g8 < top) 
@@ -228,7 +260,7 @@ module Coopy
               kk >>= 1
               at+=1
             end
-            index1 = ::Coopy::IndexPair.new
+            index = ::Coopy::IndexPair.new
             begin
               _g23 = 0
               _g13 = active_columns.length
@@ -237,36 +269,42 @@ module Coopy
                 _g23+=1
                 col = active_columns[k1]
                 unit2 = common_units[col]
-                index1.add_columns(unit2.l,unit2.r)
+                index.add_columns(unit2.l,unit2.r)
                 if !added_columns.include?(col) 
                   align.add_index_columns(unit2)
                   added_columns[col] = true
                 end
               end
             end
-            index1.index_tables(a,b)
-            index_top = index1 if k == top - 1
+            index.index_tables(a,b,1)
+            index_top = index if k == top - 1
             h = a.get_height
             h = b.get_height if b.get_height > h
             h = 1 if h < 1
-            wide_top_freq = index1.get_top_freq
+            wide_top_freq = index.get_top_freq
             ratio = wide_top_freq
             ratio /= h + 20
             if ratio >= 0.1 
               next if index_ct > 0 || k < top - 1
             end
             index_ct+=1
-            @indexes.push(index1) if @indexes != nil
+            @indexes.push(index) if @indexes != nil
             fixed = Array.new
             _it = ::Rb::RubyIterator.new(pending.keys)
             while(_it.has_next) do
               j4 = _it._next
-              cross1 = index1.query_local(j4)
+              cross1 = index.query_local(j4)
               spot_a1 = cross1.spot_a
               spot_b1 = cross1.spot_b
               next if spot_a1 != 1 || spot_b1 != 1
-              fixed.push(j4)
-              align.link(j4,cross1.item_b.lst[0])
+              val = cross1.item_b.lst[0]
+              if !used.include?(val) 
+                fixed.push(j4)
+                align.link(j4,val)
+                used[val] = 1
+                reverse_pending_ct-=1 if !used_reverse.include?(j4)
+                used_reverse[j4] = 1
+              end
             end
             begin
               _g24 = 0
@@ -280,47 +318,107 @@ module Coopy
             end
           end
         end
-        if index_top != nil 
-          offset = 0
-          scale = 1
-          begin
-            _g9 = 0
-            while(_g9 < 2) 
-              sgn = _g9
-              _g9+=1
-              if pending_ct > 0 
-                xb = nil
-                xb = hb - 1 if scale == -1 && hb > 0
-                begin
-                  _g15 = 0
-                  while(_g15 < ha) 
-                    xa0 = _g15
-                    _g15+=1
-                    xa = xa0 * scale + offset
-                    xb2 = align.a2b(xa)
-                    if xb2 != nil 
-                      xb = xb2 + scale
-                      break if xb >= hb || xb < 0
-                      next
-                    end
-                    next if xb == nil
-                    ka = index_top.local_key(xa)
-                    kb = index_top.remote_key(xb)
-                    next if ka != kb
-                    align.link(xa,xb)
-                    pending_ct-=1
-                    xb += scale
+      end
+      if index_top != nil 
+        offset = 0
+        scale = 1
+        begin
+          _g9 = 0
+          while(_g9 < 2) 
+            sgn = _g9
+            _g9+=1
+            if pending_ct > 0 
+              xb = nil
+              xb = hb - 1 if scale == -1 && hb > 0
+              begin
+                _g15 = 0
+                while(_g15 < ha) 
+                  xa0 = _g15
+                  _g15+=1
+                  xa = xa0 * scale + offset
+                  xb2 = align.a2b(xa)
+                  if xb2 != nil 
+                    xb = xb2 + scale
                     break if xb >= hb || xb < 0
-                    break if pending_ct == 0
+                    next
                   end
+                  next if xb == nil
+                  ka = index_top.local_key(xa)
+                  kb = index_top.remote_key(xb)
+                  next if ka != kb
+                  next if used.include?(xb)
+                  align.link(xa,xb)
+                  used[xb] = 1
+                  used_reverse[xa] = 1
+                  pending_ct-=1
+                  xb += scale
+                  break if xb >= hb || xb < 0
+                  break if pending_ct == 0
                 end
               end
-              offset = ha - 1
-              scale = -1
             end
+            offset = ha - 1
+            scale = -1
+          end
+        end
+        offset = 0
+        scale = 1
+        begin
+          _g10 = 0
+          while(_g10 < 2) 
+            sgn1 = _g10
+            _g10+=1
+            if reverse_pending_ct > 0 
+              xa1 = nil
+              xa1 = ha - 1 if scale == -1 && ha > 0
+              begin
+                _g16 = 0
+                while(_g16 < hb) 
+                  xb0 = _g16
+                  _g16+=1
+                  xb1 = xb0 * scale + offset
+                  xa2 = align.b2a(xb1)
+                  if xa2 != nil 
+                    xa1 = xa2 + scale
+                    break if xa1 >= ha || xa1 < 0
+                    next
+                  end
+                  next if xa1 == nil
+                  ka1 = index_top.local_key(xa1)
+                  kb1 = index_top.remote_key(xb1)
+                  next if ka1 != kb1
+                  next if used_reverse.include?(xa1)
+                  align.link(xa1,xb1)
+                  used[xb1] = 1
+                  used_reverse[xa1] = 1
+                  reverse_pending_ct-=1
+                  xa1 += scale
+                  break if xa1 >= ha || xa1 < 0
+                  break if reverse_pending_ct == 0
+                end
+              end
+            end
+            offset = hb - 1
+            scale = -1
           end
         end
       end
+      begin
+        _g17 = 1
+        while(_g17 < ha) 
+          i2 = _g17
+          _g17+=1
+          align.link(i2,-1) if !used_reverse.include?(i2)
+        end
+      end
+      begin
+        _g18 = 1
+        while(_g18 < hb) 
+          i3 = _g18
+          _g18+=1
+          align.link(-1,i3) if !used.include?(i3)
+        end
+      end
       align.link(0,0) if ha > 0 && hb > 0
     end
     
@@ -345,57 +443,59 @@ module Coopy
         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
+              if ra < a.get_height 
+                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
-              end
-              if uniques > ra_uniques 
-                ra_header = ra
-                ra_uniques = uniques
+                if uniques > ra_uniques 
+                  ra_header = ra
+                  ra_uniques = uniques
+                end
               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
+              if rb1 < b.get_height 
+                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
-              end
-              if uniques > rb_uniques 
-                rb_header = rb1
-                rb_uniques = uniques
+                if uniques > rb_uniques 
+                  rb_header = rb1
+                  rb_uniques = uniques
+                end
               end
               _it = ::Rb::RubyIterator.new(ma.keys)
               while(_it.has_next) do
@@ -430,7 +530,20 @@ module Coopy
         key3 = _it2._next
         i01 = ma_best[key3]
         i11 = mb_best[key3]
-        align.link(i01,i11) if i11 != nil && i01 != nil
+        if i01 != nil && i11 != nil 
+          align.link(i01,i11)
+        elsif i01 != nil 
+          align.link(i01,-1)
+        elsif i11 != nil 
+          align.link(-1,i11)
+        end
+      end
+      _it3 = ::Rb::RubyIterator.new(mb_best.keys)
+      while(_it3.has_next) do
+        key4 = _it3._next
+        i02 = ma_best[key4]
+        i12 = mb_best[key4]
+        align.link(-1,i12) if i02 == nil && i12 != nil
       end
       align.headers(ra_header,rb_header)
     end
@@ -443,7 +556,7 @@ module Coopy
       eq = self.has_same_columns2(p,a) if eq && p != nil
       @comp.has_same_columns = eq
       @comp.has_same_columns_known = true
-      return true
+      true
     end
     
     def has_same_columns2(a,b)
@@ -468,7 +581,7 @@ module Coopy
           return false if !av.equals(a.get_cell(i,0),b.get_cell(i,0))
         end
       end
-      return true
+      true
     end
     
     def test_is_equal 
@@ -479,7 +592,7 @@ module Coopy
       eq = self.is_equal2(p,a) if eq && p != nil
       @comp.is_equal = eq
       @comp.is_equal_known = true
-      return true
+      true
     end
     
     def is_equal2(a,b)
@@ -502,7 +615,7 @@ module Coopy
           end
         end
       end
-      return true
+      true
     end
     
     def compare_core 
@@ -510,7 +623,7 @@ module Coopy
       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
+      false
     end
     
     public
@@ -520,7 +633,14 @@ module Coopy
     end
     
     def get_indexes 
-      return @indexes
+      @indexes
+    end
+    
+    protected
+    
+    def use_sql 
+      return false if @comp.compare_flags == nil
+      @comp.compare_flags.diff_strategy == "sql"
     end
     
   haxe_me ["coopy", "CompareTable"]