daff 1.1.9 → 1.1.11

data/README.md

@@ -2,6 +2,7 @@
 [![NPM version](https://badge.fury.io/js/daff.svg)](http://badge.fury.io/js/daff)
 [![Gem Version](https://badge.fury.io/rb/daff.svg)](http://badge.fury.io/rb/daff)
 [![PyPI version](https://badge.fury.io/py/daff.svg)](http://badge.fury.io/py/daff)
+[![PHP version](https://badge.fury.io/ph/paulfitz%2Fdaff-php.svg)](http://badge.fury.io/ph/paulfitz%2Fdaff-php)
 
 daff: data diff
 ===============

data/lib/lib/coopy/compare_flags.rb

@@ -14,6 +14,7 @@ module Coopy
       @unchanged_column_context = 1
       @always_show_header = true
       @acts = nil
+      @ids = nil
     end
     
     attr_accessor :ordered
@@ -25,6 +26,7 @@ module Coopy
     attr_accessor :unchanged_column_context
     attr_accessor :always_show_header
     attr_accessor :acts
+    attr_accessor :ids
     
     def allow_update 
       return true if @acts == nil

data/lib/lib/coopy/compare_table.rb

@@ -67,137 +67,182 @@ module Coopy
       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
+      ids = nil
+      ids = @comp.compare_flags.ids if @comp.compare_flags != nil
+      if ids != nil 
+        index = ::Coopy::IndexPair.new
+        ids_as_map = {}
         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
+          _g2 = 0
+          while(_g2 < ids.length) 
+            id = ids[_g2]
+            _g2+=1
             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
+              ids_as_map[id] = true
+              true
             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]]
+        begin
+          _g3 = 0
+          while(_g3 < common_units.length) 
+            unit1 = common_units[_g3]
+            _g3+=1
+            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)
               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)
+        end
+        index.index_tables(a,b)
+        @indexes.push(index) if @indexes != nil
+        begin
+          _g4 = 0
+          while(_g4 < ha) 
+            j = _g4
+            _g4+=1
+            cross = index.query_local(j)
             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])
+            align.link(j,cross.item_b.lst[0])
           end
+        end
+      else 
+        n = 5
+        columns = Array.new
+        if common_units.length > n 
+          columns_eval = Array.new
           begin
-            _g24 = 0
-            _g14 = fixed.length
-            while(_g24 < _g14) 
-              j4 = _g24
-              _g24+=1
-              pending.delete(fixed[j4])
-              pending_ct-=1
+            _g11 = 0
+            _g5 = common_units.length
+            while(_g11 < _g5) 
+              i = _g11
+              _g11+=1
+              ct = 0
+              mem = {}
+              mem2 = {}
+              ca = common_units[i].l
+              cb = common_units[i].r
+              begin
+                _g21 = 0
+                while(_g21 < ha) 
+                  j1 = _g21
+                  _g21+=1
+                  key = av.to_s(a.get_cell(ca,j1))
+                  if !mem.include?(key) 
+                    mem[key] = 1
+                    ct+=1
+                  end
+                end
+              end
+              begin
+                _g22 = 0
+                while(_g22 < hb) 
+                  j2 = _g22
+                  _g22+=1
+                  key1 = av.to_s(b.get_cell(cb,j2))
+                  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
+          _g6 = common_units.length
+          while(_g12 < _g6) 
+            i1 = _g12
+            _g12+=1
+            columns.push(i1)
+          end
+        end
+        top = nil
+        begin
+          v1 = 2 ** columns.length
+          top = v1.round
+        end
+        pending = {}
+        begin
+          _g7 = 0
+          while(_g7 < ha) 
+            j3 = _g7
+            _g7+=1
+            pending[j3] = j3
+          end
+        end
+        pending_ct = ha
+        begin
+          _g8 = 0
+          while(_g8 < top) 
+            k = _g8
+            _g8+=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
+            index1 = ::Coopy::IndexPair.new
+            begin
+              _g23 = 0
+              _g13 = active_columns.length
+              while(_g23 < _g13) 
+                k1 = _g23
+                _g23+=1
+                unit2 = common_units[active_columns[k1]]
+                index1.add_columns(unit2.l,unit2.r)
+                align.add_index_columns(unit2)
+              end
+            end
+            index1.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 = index1.get_top_freq
+            ratio = wide_top_freq
+            ratio /= h + 20
+            next if ratio >= 0.1
+            @indexes.push(index1) 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)
+              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])
+            end
+            begin
+              _g24 = 0
+              _g14 = fixed.length
+              while(_g24 < _g14) 
+                j5 = _g24
+                _g24+=1
+                pending.delete(fixed[j5])
+                pending_ct-=1
+              end
             end
           end
         end

data/lib/lib/coopy/coopy.rb

@@ -378,6 +378,12 @@ module Coopy
               @output_format = args[i + 1]
               args.slice!(i,2)
               break
+            elsif tag == "--id" 
+              more = true
+              flags.ids = Array.new if flags.ids == nil
+              flags.ids.push(args[i + 1])
+              args.slice!(i,2)
+              break
             end
           end
         end
@@ -429,6 +435,7 @@ module Coopy
         io.write_stderr("\n")
         io.write_stderr("If you need more control, here is the full list of flags:\n")
         io.write_stderr("  daff diff [--output OUTPUT.csv] [--context NUM] [--all] [--act ACT] a.csv b.csv\n")
+        io.write_stderr("     --id:          specify column to use as primary key (repeat for multi-column key)\n")
         io.write_stderr("     --color:       highlight changes with terminal colors\n")
         io.write_stderr("     --context NUM: show NUM rows of context\n")
         io.write_stderr("     --all:         do not prune unchanged rows\n")
@@ -499,7 +506,7 @@ module Coopy
       output = "-" if output == nil
       ok = true
       if cmd1 == "diff" 
-        ct1 = ::Coopy::Coopy.compare_tables3(parent,a,b)
+        ct1 = ::Coopy::Coopy.compare_tables3(parent,a,b,flags)
         align = ct1.align
         td = ::Coopy::TableDiff.new(align,flags)
         o = ::Coopy::SimpleTable.new(0,0)
@@ -543,23 +550,25 @@ module Coopy
     class << self
     attr_accessor :version
     end
-    @version = "1.1.8"
+    @version = "1.1.11"
     
-    def Coopy.compare_tables(local,remote)
+    def Coopy.compare_tables(local,remote,flags = nil)
       ct = ::Coopy::CompareTable.new
       comp = ::Coopy::TableComparisonState.new
       comp.a = local
       comp.b = remote
+      comp.compare_flags = flags
       ct.attach(comp)
       return ct
     end
     
-    def Coopy.compare_tables3(parent,local,remote)
+    def Coopy.compare_tables3(parent,local,remote,flags = nil)
       ct = ::Coopy::CompareTable.new
       comp = ::Coopy::TableComparisonState.new
       comp.p = parent
       comp.a = local
       comp.b = remote
+      comp.compare_flags = flags
       ct.attach(comp)
       return ct
     end
@@ -569,35 +578,35 @@ module Coopy
     def Coopy.random_tests 
       st = ::Coopy::SimpleTable.new(15,6)
       tab = st
-      ::Haxe::Log._trace.call("table size is " + _hx_str(tab.get_width) + "x" + _hx_str(tab.get_height),{ file_name: "Coopy.hx", line_number: 51, class_name: "coopy.Coopy", method_name: "randomTests"})
+      ::Haxe::Log._trace.call("table size is " + _hx_str(tab.get_width) + "x" + _hx_str(tab.get_height),{ file_name: "Coopy.hx", line_number: 53, class_name: "coopy.Coopy", method_name: "randomTests"})
       tab.set_cell(3,4,::Coopy::SimpleCell.new(33))
       ::Haxe::Log._trace.call("element is " + _hx_str(lambda{ s = tab.get_cell(3,4)
-      _r = s.to_s}.call()),{ file_name: "Coopy.hx", line_number: 53, class_name: "coopy.Coopy", method_name: "randomTests"})
+      _r = s.to_s}.call()),{ file_name: "Coopy.hx", line_number: 55, class_name: "coopy.Coopy", method_name: "randomTests"})
       compare = ::Coopy::Compare.new
       d1 = ::Coopy::ViewedDatum.get_simple_view(::Coopy::SimpleCell.new(10))
       d2 = ::Coopy::ViewedDatum.get_simple_view(::Coopy::SimpleCell.new(10))
       d3 = ::Coopy::ViewedDatum.get_simple_view(::Coopy::SimpleCell.new(20))
       report = ::Coopy::Report.new
       compare.compare(d1,d2,d3,report)
-      ::Haxe::Log._trace.call("report is " + _hx_str(report.to_s),{ file_name: "Coopy.hx", line_number: 61, class_name: "coopy.Coopy", method_name: "randomTests"})
+      ::Haxe::Log._trace.call("report is " + _hx_str(report.to_s),{ file_name: "Coopy.hx", line_number: 63, class_name: "coopy.Coopy", method_name: "randomTests"})
       d2 = ::Coopy::ViewedDatum.get_simple_view(::Coopy::SimpleCell.new(50))
       report.clear
       compare.compare(d1,d2,d3,report)
-      ::Haxe::Log._trace.call("report is " + _hx_str(report.to_s),{ file_name: "Coopy.hx", line_number: 65, class_name: "coopy.Coopy", method_name: "randomTests"})
+      ::Haxe::Log._trace.call("report is " + _hx_str(report.to_s),{ file_name: "Coopy.hx", line_number: 67, class_name: "coopy.Coopy", method_name: "randomTests"})
       d2 = ::Coopy::ViewedDatum.get_simple_view(::Coopy::SimpleCell.new(20))
       report.clear
       compare.compare(d1,d2,d3,report)
-      ::Haxe::Log._trace.call("report is " + _hx_str(report.to_s),{ file_name: "Coopy.hx", line_number: 69, class_name: "coopy.Coopy", method_name: "randomTests"})
+      ::Haxe::Log._trace.call("report is " + _hx_str(report.to_s),{ file_name: "Coopy.hx", line_number: 71, class_name: "coopy.Coopy", method_name: "randomTests"})
       d1 = ::Coopy::ViewedDatum.get_simple_view(::Coopy::SimpleCell.new(20))
       report.clear
       compare.compare(d1,d2,d3,report)
-      ::Haxe::Log._trace.call("report is " + _hx_str(report.to_s),{ file_name: "Coopy.hx", line_number: 73, class_name: "coopy.Coopy", method_name: "randomTests"})
+      ::Haxe::Log._trace.call("report is " + _hx_str(report.to_s),{ file_name: "Coopy.hx", line_number: 75, class_name: "coopy.Coopy", method_name: "randomTests"})
       comp = ::Coopy::TableComparisonState.new
       ct = ::Coopy::CompareTable.new
       comp.a = st
       comp.b = st
       ct.attach(comp)
-      ::Haxe::Log._trace.call("comparing tables",{ file_name: "Coopy.hx", line_number: 81, class_name: "coopy.Coopy", method_name: "randomTests"})
+      ::Haxe::Log._trace.call("comparing tables",{ file_name: "Coopy.hx", line_number: 83, class_name: "coopy.Coopy", method_name: "randomTests"})
       t1 = ::Coopy::SimpleTable.new(3,2)
       t2 = ::Coopy::SimpleTable.new(3,2)
       t3 = ::Coopy::SimpleTable.new(3,2)
@@ -605,13 +614,13 @@ module Coopy
       dt2 = ::Coopy::ViewedDatum.new(t2,::Coopy::SimpleView.new)
       dt3 = ::Coopy::ViewedDatum.new(t3,::Coopy::SimpleView.new)
       compare.compare(dt1,dt2,dt3,report)
-      ::Haxe::Log._trace.call("report is " + _hx_str(report.to_s),{ file_name: "Coopy.hx", line_number: 89, class_name: "coopy.Coopy", method_name: "randomTests"})
+      ::Haxe::Log._trace.call("report is " + _hx_str(report.to_s),{ file_name: "Coopy.hx", line_number: 91, class_name: "coopy.Coopy", method_name: "randomTests"})
       t3.set_cell(1,1,::Coopy::SimpleCell.new("hello"))
       compare.compare(dt1,dt2,dt3,report)
-      ::Haxe::Log._trace.call("report is " + _hx_str(report.to_s),{ file_name: "Coopy.hx", line_number: 92, class_name: "coopy.Coopy", method_name: "randomTests"})
+      ::Haxe::Log._trace.call("report is " + _hx_str(report.to_s),{ file_name: "Coopy.hx", line_number: 94, class_name: "coopy.Coopy", method_name: "randomTests"})
       t1.set_cell(1,1,::Coopy::SimpleCell.new("hello"))
       compare.compare(dt1,dt2,dt3,report)
-      ::Haxe::Log._trace.call("report is " + _hx_str(report.to_s),{ file_name: "Coopy.hx", line_number: 95, class_name: "coopy.Coopy", method_name: "randomTests"})
+      ::Haxe::Log._trace.call("report is " + _hx_str(report.to_s),{ file_name: "Coopy.hx", line_number: 97, class_name: "coopy.Coopy", method_name: "randomTests"})
       v = ::Coopy::Viterbi.new
       td = ::Coopy::TableDiff.new(nil,nil)
       idx = ::Coopy::Index.new
@@ -717,7 +726,7 @@ module Coopy
           txt += "\n"
         end
       end
-      ::Haxe::Log._trace.call(txt,{ file_name: "Coopy.hx", line_number: 694, class_name: "coopy.Coopy", method_name: "show"})
+      ::Haxe::Log._trace.call(txt,{ file_name: "Coopy.hx", line_number: 705, class_name: "coopy.Coopy", method_name: "show"})
     end
     
     def Coopy.jsonify(t)

data/lib/lib/coopy/index.rb

@@ -31,19 +31,15 @@ module Coopy
     
     def index_table(t)
       @indexed_table = t
+      @keys[t.get_height - 1] = nil if @keys.length != t.get_height && t.get_height > 0
       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
+          key = @keys[i]
+          @keys[i] = key = self.to_key(t,i) if key == nil
           item = @items[key]
           if item == nil 
             item = ::Coopy::IndexItem.new

data/lib/lib/coopy/table_comparison_state.rb

@@ -17,6 +17,7 @@ module Coopy
     attr_accessor :is_equal_known
     attr_accessor :has_same_columns
     attr_accessor :has_same_columns_known
+    attr_accessor :compare_flags
     
     def reset 
       @completed = false
@@ -25,6 +26,7 @@ module Coopy
       @is_equal = false
       @has_same_columns = false
       @has_same_columns_known = false
+      @compare_flags = nil
     end
     
   end

data/lib/lib/coopy/table_diff.rb

@@ -293,7 +293,7 @@ module Coopy
         while(_g15 < _g6) 
           i2 = _g15
           _g15+=1
-          active[i2] = 0
+          active[units.length - 1 - i2] = 0
         end
       end
       allow_insert = @flags.allow_insert

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: daff
 version: !ruby/object:Gem::Version
-  version: 1.1.9
+  version: 1.1.11
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-29 00:00:00.000000000 Z
+date: 2014-09-03 00:00:00.000000000 Z
 dependencies: []
 description: Diff and patch tables
 email:
@@ -112,7 +112,8 @@ specification_version: 3
 summary: ! '[![Build Status](https://travis-ci.org/paulfitz/daff.svg?branch=master)](https://travis-ci.org/paulfitz/daff)
   [![NPM version](https://badge.fury.io/js/daff.svg)](http://badge.fury.io/js/daff)
   [![Gem Version](https://badge.fury.io/rb/daff.svg)](http://badge.fury.io/rb/daff)
-  [![PyPI version](https://badge.fury.io/py/daff.svg)](http://badge.fury.io/py/daff)  daff:
+  [![PyPI version](https://badge.fury.io/py/daff.svg)](http://badge.fury.io/py/daff)
+  [![PHP version](https://badge.fury.io/ph/paulfitz%2Fdaff-php.svg)](http://badge.fury.io/ph/paulfitz%2Fdaff-php)  daff:
   data diff ===============  This is a library for comparing tables, producing a summary
   of their differences, and using such a summary as a patch file.  It is optimized
   for comparing tables that share a common origin, in other words multiple versions