daff 1.2.6 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 99676b5f3069a96639961074611e5c8c0125361a
-  data.tar.gz: 61f811c90251dfee2afc8f187731813aad4bece7
+  metadata.gz: 469baec08599142e1445a291410b340d9b621c52
+  data.tar.gz: f9781651f9ca2650d61a1ba5632b2e8e40543b1a
 SHA512:
-  metadata.gz: 1ebb393d477f490c2a733cd5ea055c64cc41cd32ef52fea5df7f92f8eee5983eea96bf7c4e79a377d3765a86d497a0e6cba38b520ea46ade3f6b644f11ff6f08
-  data.tar.gz: d70b61f7f4cb52e6e6d9a22cb9f50b8ce1c3fed78031baff2ae5c4ab1f9450131ed7a74f28abd49193dce685f107694420c7ec9d8f971953cb4257c02813ae4c
+  metadata.gz: cfc0aa8b457f18094e9d8ed4c9835fee504ecc9875949a4c5e74057821eae741941bf98a75c9c295b520a2f22b1add61dd5099d63f900894bbe63c31cde47888
+  data.tar.gz: 5a510890fe93b6b2d7c771524fe25f811f48a3addb377f97f565aa1f6507caa4069b09900c32c6c26c4242bf83b80dea94d47685472f53f733e44eecdf9333a4

data/README.md

@@ -84,7 +84,7 @@ for `*.csv` files in your repository.  Run `daff git` for instructions
 on doing this manually. Your CSV diffs and merges will get smarter,
 since git will suddenly understand about rows and columns, not just lines:
 
-![Example CSV diff](scripts/diff.png)
+![Example CSV diff](http://paulfitz.github.io/daff-doc/images/daff_vs_diff.png)
 
 The library
 -----------
@@ -181,7 +181,6 @@ patcher.apply();
 For other languages, you should find sample code in 
 the packages on the [Releases](https://github.com/paulfitz/daff/releases) page.
 
-
 Supported languages
 -------------------
 
@@ -198,10 +197,10 @@ can be translated reasonably well into at least the following languages:
 
 Some translations are done for you on the
 [Releases](https://github.com/paulfitz/daff/releases) page.
-To make another translation, 
-follow the 
-[Haxe getting started tutorial](http://haxe.org/doc/start) for the
-language you care about, then do one of:
+To make another translation, or to compile from source
+first follow the [Haxe getting started tutorial](http://haxe.org/doc/start) for the
+language you care about.  At the time of writing, if you are on OSX, you should
+install haxe using `brew install haxe --HEAD`.  Then do one of:
 
 ```
 make js
@@ -236,6 +235,7 @@ Reading material
 
  * http://dataprotocols.org/tabular-diff-format/ : a specification of the diff format we use.
  * http://theodi.org/blog/csvhub-github-diffs-for-csv-files : using this library with github.
+ * https://github.com/ropensci/unconf/issues/19 : a thread about diffing data in which daff shows up in at least four guises (see if you can spot them all).
  * http://theodi.org/blog/adapting-git-simple-data : using this library with gitlab.
  * http://okfnlabs.org/blog/2013/08/08/diffing-and-patching-data.html : a summary of where the library came from.
  * http://blog.okfn.org/2013/07/02/git-and-github-for-data/ : a post about storing small data in git/github.

data/lib/daff.rb

@@ -52,6 +52,7 @@ require_relative 'lib/type'
 require_relative 'lib/coopy/alignment'
 require_relative 'lib/coopy/cell_builder'
 require_relative 'lib/coopy/cell_info'
+require_relative 'lib/coopy/column_change'
 require_relative 'lib/coopy/compare_flags'
 require_relative 'lib/coopy/compare_table'
 require_relative 'lib/coopy/coopy'
@@ -66,10 +67,14 @@ require_relative 'lib/coopy/index'
 require_relative 'lib/coopy/index_item'
 require_relative 'lib/coopy/index_pair'
 require_relative 'lib/coopy/merger'
+require_relative 'lib/coopy/meta'
 require_relative 'lib/coopy/mover'
 require_relative 'lib/coopy/ndjson'
 require_relative 'lib/coopy/nested_cell_builder'
 require_relative 'lib/coopy/ordering'
+require_relative 'lib/coopy/property_change'
+require_relative 'lib/coopy/row_change'
+require_relative 'lib/coopy/row_stream'
 require_relative 'lib/coopy/table'
 require_relative 'lib/coopy/simple_table'
 require_relative 'lib/coopy/view'
@@ -86,6 +91,7 @@ require_relative 'lib/coopy/table_comparison_state'
 require_relative 'lib/coopy/table_diff'
 require_relative 'lib/coopy/table_io'
 require_relative 'lib/coopy/table_modifier'
+require_relative 'lib/coopy/table_stream'
 require_relative 'lib/coopy/terminal_diff_render'
 require_relative 'lib/coopy/unit'
 require_relative 'lib/coopy/viterbi'

data/lib/lib/coopy/alignment.rb

@@ -55,8 +55,8 @@ module Coopy
     end
     
     def link(a,b)
-      @map_a2b[a] = b
-      @map_b2a[b] = a
+      @map_a2b[a] = b if a != -1
+      @map_b2a[b] = a if b != -1
       @map_count+=1
     end
     
@@ -66,23 +66,25 @@ module Coopy
     end
     
     def get_index_columns 
-      return @index_columns
+      @index_columns
     end
     
     def a2b(a)
-      return @map_a2b[a]
+      @map_a2b[a]
     end
     
     def b2a(b)
-      return @map_b2a[b]
+      @map_b2a[b]
     end
     
     def count 
-      return @map_count
+      @map_count
     end
     
     def to_s 
-      return "" + "not implemented yet"
+      result = "" + "not implemented yet" + " // " + "not implemented yet"
+      result += " (" + _hx_str(@reference.to_s) + ")" if @reference != nil
+      result
     end
     
     def to_order 
@@ -93,7 +95,7 @@ module Coopy
       end
       @order_cache = self.to_order3 if @order_cache == nil
       @order_cache_has_reference = true if @reference != nil
-      return @order_cache
+      @order_cache
     end
     
     def add_to_order(l,r,p = -2)
@@ -103,201 +105,176 @@ module Coopy
     end
     
     def get_source 
-      return @ta
+      @ta
     end
     
     def get_target 
-      return @tb
+      @tb
     end
     
     def get_source_header 
-      return @ia
+      @ia
     end
     
     def get_target_header 
-      return @ib
+      @ib
     end
     
     protected
     
     def to_order3 
-      ref = @reference
-      if ref == nil 
-        ref = ::Coopy::Alignment.new
-        ref.range(@ha,@ha)
-        ref.tables(@ta,@ta)
-        begin
-          _g1 = 0
-          _g = @ha
-          while(_g1 < _g) 
-            i = _g1
-            _g1+=1
-            ref.link(i,i)
+      order = Array.new
+      if @reference == nil 
+        _it = ::Rb::RubyIterator.new(@map_a2b.keys)
+        while(_it.has_next) do
+          k = _it._next
+          unit = ::Coopy::Unit.new
+          unit.l = k
+          unit.r = self.a2b(k)
+          order.push(unit)
+        end
+        _it2 = ::Rb::RubyIterator.new(@map_b2a.keys)
+        while(_it2.has_next) do
+          k1 = _it2._next
+          if self.b2a(k1) == -1 
+            unit1 = ::Coopy::Unit.new
+            unit1.l = -1
+            unit1.r = k1
+            order.push(unit1)
           end
         end
-      end
-      order = ::Coopy::Ordering.new
-      order.ignore_parent if @reference == nil
-      xp = 0
-      xl = 0
-      xr = 0
-      hp = @ha
-      hl = ref.hb
-      hr = @hb
-      vp = {}
-      vl = {}
-      vr = {}
-      begin
-        _g2 = 0
-        while(_g2 < hp) 
-          i1 = _g2
-          _g2+=1
-          vp[i1] = i1
+      else 
+        _it3 = ::Rb::RubyIterator.new(@map_a2b.keys)
+        while(_it3.has_next) do
+          k2 = _it3._next
+          unit2 = ::Coopy::Unit.new
+          unit2.p = k2
+          unit2.l = @reference.a2b(k2)
+          unit2.r = self.a2b(k2)
+          order.push(unit2)
         end
-      end
-      begin
-        _g3 = 0
-        while(_g3 < hl) 
-          i2 = _g3
-          _g3+=1
-          vl[i2] = i2
+        _it4 = ::Rb::RubyIterator.new(@reference.map_b2a.keys)
+        while(_it4.has_next) do
+          k3 = _it4._next
+          if @reference.b2a(k3) == -1 
+            unit3 = ::Coopy::Unit.new
+            unit3.p = -1
+            unit3.l = k3
+            unit3.r = -1
+            order.push(unit3)
+          end
         end
-      end
-      begin
-        _g4 = 0
-        while(_g4 < hr) 
-          i3 = _g4
-          _g4+=1
-          vr[i3] = i3
+        _it5 = ::Rb::RubyIterator.new(@map_b2a.keys)
+        while(_it5.has_next) do
+          k4 = _it5._next
+          if self.b2a(k4) == -1 
+            unit4 = ::Coopy::Unit.new
+            unit4.p = -1
+            unit4.l = -1
+            unit4.r = k4
+            order.push(unit4)
+          end
         end
       end
-      ct_vp = hp
-      ct_vl = hl
-      ct_vr = hr
-      prev = -1
-      ct = 0
-      max_ct = (hp + hl + hr) * 10
-      while(ct_vp > 0 || ct_vl > 0 || ct_vr > 0) 
-        ct+=1
-        if ct > max_ct 
-          puts "Ordering took too long, something went wrong"
-          break
-        end
-        xp = 0 if xp >= hp
-        xl = 0 if xl >= hl
-        xr = 0 if xr >= hr
-        if xp < hp && ct_vp > 0 
-          if self.a2b(xp) == nil && ref.a2b(xp) == nil 
-            if vp.include?(xp) 
-              order.add(-1,-1,xp)
-              prev = xp
-              vp.delete(xp)
-              ct_vp-=1
-            end
-            xp+=1
-            next
+      top = order.length
+      remotes = Array.new
+      locals = Array.new
+      begin
+        _g = 0
+        while(_g < top) 
+          o = _g
+          _g+=1
+          if order[o].r >= 0 
+            remotes.push(o)
+          else 
+            locals.push(o)
           end
         end
-        zl = nil
-        zr = nil
-        if xl < hl && ct_vl > 0 
-          zl = ref.b2a(xl)
-          if zl == nil 
-            if vl.include?(xl) 
-              order.add(xl,-1,-1)
-              vl.delete(xl)
-              ct_vl-=1
-            end
-            xl+=1
-            next
+      end
+      remote_sort = lambda {|a,b|
+        order[a].r - order[b].r
+      }
+      local_sort = lambda {|a1,b1|
+        return 0 if a1 == b1
+        return order[a1].l - order[b1].l if order[a1].l >= 0 && order[b1].l >= 0
+        return 1 if order[a1].l >= 0
+        return -1 if order[b1].l >= 0
+        a1 - b1
+      }
+      if @reference != nil 
+        remote_sort = lambda {|a2,b2|
+          return 0 if a2 == b2
+          o1 = order[a2].r - order[b2].r
+          if order[a2].p >= 0 && order[b2].p >= 0 
+            o2 = order[a2].p - order[b2].p
+            return o1 if o1 * o2 < 0
+            o3 = order[a2].l - order[b2].l
+            return o3
           end
-        end
-        if xr < hr && ct_vr > 0 
-          zr = self.b2a(xr)
-          if zr == nil 
-            if vr.include?(xr) 
-              order.add(-1,xr,-1)
-              vr.delete(xr)
-              ct_vr-=1
+          o1
+        }
+        local_sort = lambda {|a3,b3|
+          return 0 if a3 == b3
+          if order[a3].l >= 0 && order[b3].l >= 0 
+            o11 = order[a3].l - order[b3].l
+            if order[a3].p >= 0 && order[b3].p >= 0 
+              o21 = order[a3].p - order[b3].p
+              return o11 if o11 * o21 < 0
+              return o21
             end
-            xr+=1
-            next
           end
-        end
-        if zl != nil 
-          if self.a2b(zl) == nil 
-            if vl.include?(xl) 
-              order.add(xl,-1,zl)
-              prev = zl
-              vp.delete(zl)
-              ct_vp-=1
-              vl.delete(xl)
-              ct_vl-=1
-              xp = zl + 1
+          return 1 if order[a3].l >= 0
+          return -1 if order[b3].l >= 0
+          a3 - b3
+        }
+      end
+      remotes.sort!{|a,b| remote_sort.call(a,b)}
+      locals.sort!{|a,b| local_sort.call(a,b)}
+      revised_order = Array.new
+      at_r = 0
+      at_l = 0
+      begin
+        _g1 = 0
+        while(_g1 < top) 
+          o4 = _g1
+          _g1+=1
+          if at_r < remotes.length && at_l < locals.length 
+            ur = order[remotes[at_r]]
+            ul = order[locals[at_l]]
+            if ul.l == -1 && ul.p >= 0 && ur.p >= 0 
+              if ur.p > ul.p 
+                revised_order.push(ul)
+                at_l+=1
+                next
+              end
+            elsif ur.l > ul.l 
+              revised_order.push(ul)
+              at_l+=1
+              next
             end
-            xl+=1
+            revised_order.push(ur)
+            at_r+=1
             next
           end
-        end
-        if zr != nil 
-          if ref.a2b(zr) == nil 
-            if vr.include?(xr) 
-              order.add(-1,xr,zr)
-              prev = zr
-              vp.delete(zr)
-              ct_vp-=1
-              vr.delete(xr)
-              ct_vr-=1
-              xp = zr + 1
-            end
-            xr+=1
+          if at_r < remotes.length 
+            ur1 = order[remotes[at_r]]
+            revised_order.push(ur1)
+            at_r+=1
             next
           end
-        end
-        if zl != nil && zr != nil && self.a2b(zl) != nil && ref.a2b(zr) != nil 
-          if zl == prev + 1 || zr != prev + 1 
-            if vr.include?(xr) 
-              order.add(ref.a2b(zr),xr,zr)
-              prev = zr
-              vp.delete(zr)
-              ct_vp-=1
-              begin
-                key = ref.a2b(zr)
-                vl.delete(key)
-              end
-              ct_vl-=1
-              vr.delete(xr)
-              ct_vr-=1
-              xp = zr + 1
-              xl = ref.a2b(zr) + 1
-            end
-            xr+=1
-            next
-          else 
-            if vl.include?(xl) 
-              order.add(xl,self.a2b(zl),zl)
-              prev = zl
-              vp.delete(zl)
-              ct_vp-=1
-              vl.delete(xl)
-              ct_vl-=1
-              begin
-                key1 = self.a2b(zl)
-                vr.delete(key1)
-              end
-              ct_vr-=1
-              xp = zl + 1
-              xr = self.a2b(zl) + 1
-            end
-            xl+=1
+          if at_l < locals.length 
+            ul1 = order[locals[at_l]]
+            revised_order.push(ul1)
+            at_l+=1
             next
           end
         end
-        xp+=1
-        xl+=1
-        xr+=1
       end
-      return order
+      order = revised_order
+      result = ::Coopy::Ordering.new
+      result.set_list(order)
+      result.ignore_parent if @reference == nil
+      result
     end
     
   haxe_me ["coopy", "Alignment"]