daff 1.1.12 → 1.1.13

data/README.md

@@ -23,6 +23,7 @@ For certain languages you can use the command-line:
 npm install daff -g  # node/javascript
 pip3 install daff    # python3
 gem install daff     # ruby
+composer require paulfitz/daff-php  # php
 ````
 
 Or use the library to view csv diffs on github via a chrome extension:

data/lib/lib/coopy/alignment.rb

@@ -85,12 +85,15 @@ module Coopy
       return "" + "not implemented yet"
     end
     
-    def to_order_pruned(rowlike)
-      return self.to_order_cached(true,rowlike)
-    end
-    
     def to_order 
-      return self.to_order_cached(false,false)
+      if @order_cache != nil 
+        if @reference != nil 
+          @order_cache = nil if !@order_cache_has_reference
+        end
+      end
+      @order_cache = self.to_order3 if @order_cache == nil
+      @order_cache_has_reference = true if @reference != nil
+      return @order_cache
     end
     
     def get_source 
@@ -111,119 +114,7 @@ module Coopy
     
     protected
     
-    def to_order_cached(prune,rowlike)
-      if @order_cache != nil 
-        if @reference != nil 
-          @order_cache = nil if !@order_cache_has_reference
-        end
-      end
-      @order_cache = self.to_order3(prune,rowlike) if @order_cache == nil
-      @order_cache_has_reference = true if @reference != nil
-      return @order_cache
-    end
-    
-    def prune_order(o,ref,rowlike)
-      tl = ref.tb
-      tr = @tb
-      if rowlike 
-        return if tl.get_width != tr.get_width
-      elsif tl.get_height != tr.get_height 
-        return
-      end
-      units = o.get_list
-      left_units = Array.new
-      left_locs = Array.new
-      right_units = Array.new
-      right_locs = Array.new
-      eliminate = Array.new
-      ct = 0
-      begin
-        _g1 = 0
-        _g = units.length
-        while(_g1 < _g) 
-          i = _g1
-          _g1+=1
-          unit = units[i]
-          if unit.l < 0 && unit.r >= 0 
-            right_units.push(unit)
-            right_locs.push(i)
-            ct+=1
-          elsif unit.r < 0 && unit.l >= 0 
-            left_units.push(unit)
-            left_locs.push(i)
-            ct+=1
-          elsif ct > 0 
-            left_units.slice!(0,left_units.length)
-            right_units.slice!(0,right_units.length)
-            left_locs.slice!(0,left_locs.length)
-            right_locs.slice!(0,right_locs.length)
-            ct = 0
-          end
-          while(left_locs.length > 0 && right_locs.length > 0) 
-            l = left_units[0].l
-            r = right_units[0].r
-            view = tl.get_cell_view
-            match = true
-            if rowlike 
-              w = tl.get_width
-              begin
-                _g2 = 0
-                while(_g2 < w) 
-                  j = _g2
-                  _g2+=1
-                  if !view.equals(tl.get_cell(j,l),tr.get_cell(j,r)) 
-                    match = false
-                    break
-                  end
-                end
-              end
-            else 
-              h = tl.get_height
-              begin
-                _g21 = 0
-                while(_g21 < h) 
-                  j1 = _g21
-                  _g21+=1
-                  if !view.equals(tl.get_cell(l,j1),tr.get_cell(r,j1)) 
-                    match = false
-                    break
-                  end
-                end
-              end
-            end
-            if match 
-              eliminate.push(left_locs[0])
-              eliminate.push(right_locs[0])
-            end
-            left_units.shift
-            right_units.shift
-            left_locs.shift
-            right_locs.shift
-            ct -= 2
-          end
-        end
-      end
-      if eliminate.length > 0 
-        eliminate.sort {|a,b|
-          return a - b
-        }
-        del = 0
-        begin
-          _g3 = 0
-          while(_g3 < eliminate.length) 
-            e = eliminate[_g3]
-            _g3+=1
-            begin
-              _this = o.get_list
-              _this.slice!(e - del,1)
-            end
-            del+=1
-          end
-        end
-      end
-    end
-    
-    def to_order3(prune,rowlike)
+    def to_order3 
       ref = @reference
       if ref == nil 
         ref = ::Coopy::Alignment.new
@@ -283,7 +174,7 @@ module Coopy
       while(ct_vp > 0 || ct_vl > 0 || ct_vr > 0) 
         ct+=1
         if ct > max_ct 
-          ::Haxe::Log._trace.call("Ordering took too long, something went wrong",{ file_name: "Alignment.hx", line_number: 241, class_name: "coopy.Alignment", method_name: "toOrder3"})
+          ::Haxe::Log._trace.call("Ordering took too long, something went wrong",{ file_name: "Alignment.hx", line_number: 153, class_name: "coopy.Alignment", method_name: "toOrder3"})
           break
         end
         xp = 0 if xp >= hp
@@ -400,7 +291,6 @@ module Coopy
         xl+=1
         xr+=1
       end
-      self.prune_order(order,ref,rowlike) if prune
       return order
     end
     

data/lib/lib/coopy/compare_table.rb

@@ -49,7 +49,7 @@ module Coopy
     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)
+      column_order = align.meta.to_order
       common_units = Array.new
       begin
         _g = 0
@@ -187,6 +187,9 @@ module Coopy
           end
         end
         pending_ct = ha
+        added_columns = {}
+        index_ct = 0
+        index_top = nil
         begin
           _g8 = 0
           while(_g8 < top) 
@@ -209,19 +212,27 @@ module Coopy
               while(_g23 < _g13) 
                 k1 = _g23
                 _g23+=1
-                unit2 = common_units[active_columns[k1]]
+                col = active_columns[k1]
+                unit2 = common_units[col]
                 index1.add_columns(unit2.l,unit2.r)
-                align.add_index_columns(unit2)
+                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
             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
+            if ratio >= 0.1 
+              next if index_ct > 0 || k < top - 1
+            end
+            index_ct+=1
             @indexes.push(index1) if @indexes != nil
             fixed = Array.new
             _it = ::Rb::RubyIterator.new(pending.keys)
@@ -246,6 +257,46 @@ 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
+                    break if xb >= hb || xb < 0
+                    break if pending_ct == 0
+                  end
+                end
+              end
+              offset = ha - 1
+              scale = -1
+            end
+          end
+        end
       end
       align.link(0,0)
     end

data/lib/lib/coopy/coopy.rb

@@ -550,7 +550,7 @@ module Coopy
     class << self
     attr_accessor :version
     end
-    @version = "1.1.12"
+    @version = "1.1.13"
     
     def Coopy.compare_tables(local,remote,flags = nil)
       ct = ::Coopy::CompareTable.new

data/lib/lib/coopy/index_pair.rb

@@ -73,6 +73,14 @@ module Coopy
       return self.query_by_key(ka)
     end
     
+    def local_key(row)
+      return @ia.to_key(@ia.get_table,row)
+    end
+    
+    def remote_key(row)
+      return @ib.to_key(@ib.get_table,row)
+    end
+    
     def get_top_freq 
       return @ib.top_freq if @ib.top_freq > @ia.top_freq
       return @ia.top_freq

data/lib/lib/coopy/merger.rb

@@ -100,9 +100,9 @@ module Coopy
       @conflicts = 0
       ct = ::Coopy::Coopy.compare_tables3(@parent,@local,@remote)
       align = ct.align
-      @order = align.to_order_pruned(true)
+      @order = align.to_order
       @units = @order.get_list
-      @column_order = align.meta.to_order_pruned(false)
+      @column_order = align.meta.to_order
       @column_units = @column_order.get_list
       allow_insert = @flags.allow_insert
       allow_delete = @flags.allow_delete

data/lib/lib/coopy/table_diff.rb

@@ -196,7 +196,7 @@ module Coopy
       output.clear
       row_map = {}
       col_map = {}
-      order = @align.to_order_pruned(true)
+      order = @align.to_order
       units = order.get_list
       has_parent = @align.reference != nil
       a = nil
@@ -250,7 +250,7 @@ module Coopy
           end
         end
       end
-      column_order = @align.meta.to_order_pruned(false)
+      column_order = @align.meta.to_order
       column_units = column_order.get_list
       show_rc_numbers = false
       row_moves = nil

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: daff
 version: !ruby/object:Gem::Version
-  version: 1.1.12
+  version: 1.1.13
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-08 00:00:00.000000000 Z
+date: 2014-10-14 00:00:00.000000000 Z
 dependencies: []
 description: Diff and patch tables
 email:
@@ -125,46 +125,47 @@ summary: ! '[![Build Status](https://travis-ci.org/paulfitz/daff.svg?branch=mast
   of the "same" table.  For a live demo, see: > http://paulfitz.github.com/daff/  Download
   the code for your preferred language here: > https://github.com/paulfitz/daff/releases  For
   certain languages you can use the command-line: ````sh npm install daff -g  # node/javascript
-  pip3 install daff    # python3 gem install daff     # ruby ````  Or use the library
-  to view csv diffs on github via a chrome extension: > https://github.com/theodi/csvhub  The
-  diff format used by `daff` is specified here: > http://dataprotocols.org/tabular-diff-format/  This
-  library is a stripped down version of the coopy toolbox (see http://share.find.coop).  To
-  compare tables from different origins,  or with automatically generated IDs, or
-  other complications, check out the coopy toolbox.  The program -----------  You
-  can run `daff`/`daff.py`/`daff.rb` as a utility program: ```` $ daff daff can produce
-  and apply tabular diffs. Call as: daff [--output OUTPUT.csv] a.csv b.csv daff [--output
-  OUTPUT.csv] parent.csv a.csv b.csv daff [--output OUTPUT.jsonbook] a.jsonbook b.jsonbook
-  daff patch [--inplace] [--output OUTPUT.csv] a.csv patch.csv daff merge [--inplace]
-  [--output OUTPUT.csv] parent.csv a.csv b.csv daff trim [--output OUTPUT.csv] source.csv
-  daff render [--output OUTPUT.html] diff.csv daff git daff version  The --inplace
-  option to patch and merge will result in modification of a.csv.  If you need more
-  control, here is the full list of flags: daff diff [--output OUTPUT.csv] [--context
-  NUM] [--all] [--act ACT] a.csv b.csv --context NUM: show NUM rows of context --all:         do
-  not prune unchanged rows --act ACT:     show only a certain kind of change (update,
-  insert, delete)  daff diff --git path old-file old-hex old-mode new-file new-hex
-  new-mode --git:         process arguments provided by git to diff drivers  daff
-  render [--output OUTPUT.html] [--css CSS.css] [--fragment] [--plain] diff.csv --css
-  CSS.css: generate a suitable css file to go with the html --fragment:    generate
-  just a html fragment rather than a page --plain:       do not use fancy utf8 characters
-  to make arrows prettier ````  Using with git --------------  Run `daff git csv`
-  to install daff as a diff and merge handler for `*.csv` files in your repository.  Run
-  `daff git` for instructions on doing this manually.  The library -----------  You
-  can use `daff` as a library from any supported language.  We take  here the example
-  of Javascript.  To use `daff` on a webpage, first include `daff.js`: ```html <script
-  src="daff.js"></script> ``` Or if using node outside the browser: ```js var daff
-  = require(''daff''); ```  For concreteness, assume we have two versions of a table,
-  `data1` and `data2`: ```js var data1 = [ [''Country'',''Capital''], [''Ireland'',''Dublin''],
-  [''France'',''Paris''], [''Spain'',''Barcelona''] ]; var data2 = [ [''Country'',''Code'',''Capital''],
-  [''Ireland'',''ie'',''Dublin''], [''France'',''fr'',''Paris''], [''Spain'',''es'',''Madrid''],
-  [''Germany'',''de'',''Berlin''] ]; ```  To make those tables accessible to the library,
-  we wrap them in `daff.TableView`: ```js var table1 = new daff.TableView(data1);
-  var table2 = new daff.TableView(data2); ```  We can now compute the alignment between
-  the rows and columns in the two tables: ```js var alignment = daff.compareTables(table1,table2).align();
-  ```  To produce a diff from the alignment, we first need a table for the output:
-  ```js var data_diff = []; var table_diff = new daff.TableView(data_diff); ```  Using
-  default options for the diff: ```js var flags = new daff.CompareFlags(); var highlighter
-  = new daff.TableDiff(alignment,flags); highlighter.hilite(table_diff); ```  The
-  diff is now in `data_diff` in highlighter format, see specification here: > http://share.find.coop/doc/spec_hilite.html  ```js
+  pip3 install daff    # python3 gem install daff     # ruby composer require paulfitz/daff-php  #
+  php ````  Or use the library to view csv diffs on github via a chrome extension:
+  > https://github.com/theodi/csvhub  The diff format used by `daff` is specified
+  here: > http://dataprotocols.org/tabular-diff-format/  This library is a stripped
+  down version of the coopy toolbox (see http://share.find.coop).  To compare tables
+  from different origins,  or with automatically generated IDs, or other complications,
+  check out the coopy toolbox.  The program -----------  You can run `daff`/`daff.py`/`daff.rb`
+  as a utility program: ```` $ daff daff can produce and apply tabular diffs. Call
+  as: daff [--output OUTPUT.csv] a.csv b.csv daff [--output OUTPUT.csv] parent.csv
+  a.csv b.csv daff [--output OUTPUT.jsonbook] a.jsonbook b.jsonbook daff patch [--inplace]
+  [--output OUTPUT.csv] a.csv patch.csv daff merge [--inplace] [--output OUTPUT.csv]
+  parent.csv a.csv b.csv daff trim [--output OUTPUT.csv] source.csv daff render [--output
+  OUTPUT.html] diff.csv daff git daff version  The --inplace option to patch and merge
+  will result in modification of a.csv.  If you need more control, here is the full
+  list of flags: daff diff [--output OUTPUT.csv] [--context NUM] [--all] [--act ACT]
+  a.csv b.csv --context NUM: show NUM rows of context --all:         do not prune
+  unchanged rows --act ACT:     show only a certain kind of change (update, insert,
+  delete)  daff diff --git path old-file old-hex old-mode new-file new-hex new-mode
+  --git:         process arguments provided by git to diff drivers  daff render [--output
+  OUTPUT.html] [--css CSS.css] [--fragment] [--plain] diff.csv --css CSS.css: generate
+  a suitable css file to go with the html --fragment:    generate just a html fragment
+  rather than a page --plain:       do not use fancy utf8 characters to make arrows
+  prettier ````  Using with git --------------  Run `daff git csv` to install daff
+  as a diff and merge handler for `*.csv` files in your repository.  Run `daff git`
+  for instructions on doing this manually.  The library -----------  You can use `daff`
+  as a library from any supported language.  We take  here the example of Javascript.  To
+  use `daff` on a webpage, first include `daff.js`: ```html <script src="daff.js"></script>
+  ``` Or if using node outside the browser: ```js var daff = require(''daff''); ```  For
+  concreteness, assume we have two versions of a table, `data1` and `data2`: ```js
+  var data1 = [ [''Country'',''Capital''], [''Ireland'',''Dublin''], [''France'',''Paris''],
+  [''Spain'',''Barcelona''] ]; var data2 = [ [''Country'',''Code'',''Capital''], [''Ireland'',''ie'',''Dublin''],
+  [''France'',''fr'',''Paris''], [''Spain'',''es'',''Madrid''], [''Germany'',''de'',''Berlin'']
+  ]; ```  To make those tables accessible to the library, we wrap them in `daff.TableView`:
+  ```js var table1 = new daff.TableView(data1); var table2 = new daff.TableView(data2);
+  ```  We can now compute the alignment between the rows and columns in the two tables:
+  ```js var alignment = daff.compareTables(table1,table2).align(); ```  To produce
+  a diff from the alignment, we first need a table for the output: ```js var data_diff
+  = []; var table_diff = new daff.TableView(data_diff); ```  Using default options
+  for the diff: ```js var flags = new daff.CompareFlags(); var highlighter = new daff.TableDiff(alignment,flags);
+  highlighter.hilite(table_diff); ```  The diff is now in `data_diff` in highlighter
+  format, see specification here: > http://share.find.coop/doc/spec_hilite.html  ```js
   [ [ ''!'', '''', ''+++'', '''' ], [ ''@@'', ''Country'', ''Code'', ''Capital'' ],
   [ ''+'', ''Ireland'', ''ie'', ''Dublin'' ], [ ''+'', ''France'', ''fr'', ''Paris''
   ], [ ''->'', ''Spain'', ''es'', ''Barcelona->Madrid'' ], [ ''+++'', ''Germany'',