RubyGems - daff - Versions diffs - 1.1.9 → 1.1.11 - Mend

daff 1.1.9 → 1.1.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

data/README.md +1 -0
data/lib/lib/coopy/compare_flags.rb +2 -0
data/lib/lib/coopy/compare_table.rb +162 -117
data/lib/lib/coopy/coopy.rb +24 -15
data/lib/lib/coopy/index.rb +3 -7
data/lib/lib/coopy/table_comparison_state.rb +2 -0
data/lib/lib/coopy/table_diff.rb +1 -1
metadata +4 -3

data/README.md CHANGED

@@ -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 CHANGED

@@ -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 CHANGED

@@ -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 CHANGED

@@ -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 CHANGED

@@ -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 CHANGED

@@ -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 CHANGED

@@ -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 CHANGED

@@ -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