daff 1.1.19 → 1.2.1

data/README.md

@@ -15,10 +15,7 @@ words multiple versions 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:
+Install the library for your favorite language:
 ````sh
 npm install daff -g  # node/javascript
 pip3 install daff    # python3
@@ -26,6 +23,9 @@ gem install daff     # ruby
 composer require paulfitz/daff-php  # php
 ````
 
+Other translations are available here:
+> https://github.com/paulfitz/daff/releases
+
 Or use the library to view csv diffs on github via a chrome extension:
 > https://github.com/theodi/csvhub
 
@@ -77,7 +77,10 @@ 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.
+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)
 
 The library
 -----------
@@ -182,12 +185,12 @@ The `daff` library is written in [Haxe](http://haxe.org/), which
 can be translated reasonably well into at least the following languages:
 
  * Javascript
- * PHP
  * Python
  * Java
  * C#
  * C++
- * (via a hack, just for `daff`) Ruby
+ * Ruby (using an [unofficial haxe target](https://github.com/paulfitz/haxe) developed for `daff`) 
+ * PHP
 
 Some translations are done for you on the
 [Releases](https://github.com/paulfitz/daff/releases) page.
@@ -205,12 +208,15 @@ make cs
 make cpp
 ```
 
-[@Floppy](https://github.com/Floppy) has made a lovingly-hand-written [native Ruby port](https://github.com/theodi/coopy-ruby) that covers core functionality.  I've made a brutally-machine-converted port that is a full translation but less idiomatic.
-
 For each language, the `daff` library expects to be handed an interface to tables you create, rather than creating them
 itself.  This is to avoid inefficient copies from one format to another.  You'll find a `SimpleTable` class you can use if
 you find this awkward.
 
+API documentation
+-----------------
+
+ * You can browse the `daff` classes at http://paulfitz.github.io/daff-doc/
+
 Reading material
 ----------------
 

data/lib/daff.rb

@@ -38,12 +38,8 @@ require_relative 'lib/hx_sys'
 require_relative 'lib/value_type'
 require_relative 'lib/type'
 require_relative 'lib/coopy/alignment'
-require_relative 'lib/coopy/bag'
 require_relative 'lib/coopy/cell_builder'
 require_relative 'lib/coopy/cell_info'
-require_relative 'lib/coopy/change'
-require_relative 'lib/coopy/change_type'
-require_relative 'lib/coopy/compare'
 require_relative 'lib/coopy/compare_flags'
 require_relative 'lib/coopy/compare_table'
 require_relative 'lib/coopy/coopy'
@@ -60,8 +56,6 @@ require_relative 'lib/coopy/index_pair'
 require_relative 'lib/coopy/merger'
 require_relative 'lib/coopy/mover'
 require_relative 'lib/coopy/ordering'
-require_relative 'lib/coopy/report'
-require_relative 'lib/coopy/simple_cell'
 require_relative 'lib/coopy/table'
 require_relative 'lib/coopy/simple_table'
 require_relative 'lib/coopy/view'
@@ -74,9 +68,7 @@ require_relative 'lib/coopy/table_modifier'
 require_relative 'lib/coopy/table_text'
 require_relative 'lib/coopy/terminal_diff_render'
 require_relative 'lib/coopy/unit'
-require_relative 'lib/coopy/viewed_datum'
 require_relative 'lib/coopy/viterbi'
-require_relative 'lib/coopy/workspace'
 require_relative 'lib/haxe/imap'
 require_relative 'lib/haxe/ds/int_map'
 require_relative 'lib/haxe/ds/string_map'

data/lib/lib/coopy/alignment.rb

@@ -12,8 +12,8 @@ module Coopy
       @reference = nil
       @meta = nil
       @order_cache_has_reference = false
-      @ia = 0
-      @ib = 0
+      @ia = -1
+      @ib = -1
     end
     
     protected

data/lib/lib/coopy/compare_flags.rb

@@ -30,6 +30,18 @@ module Coopy
     attr_accessor :ids
     attr_accessor :columns_to_ignore
     
+    def filter(act,allow)
+      if @acts == nil 
+        @acts = {}
+        @acts["update"] = !allow
+        @acts["insert"] = !allow
+        @acts["delete"] = !allow
+      end
+      return false if !@acts.include?(act)
+      @acts[act] = allow
+      return true
+    end
+    
     def allow_update 
       return true if @acts == nil
       return @acts.include?("update")

data/lib/lib/coopy/compare_table.rb

@@ -4,7 +4,8 @@
 module Coopy
   class CompareTable 
     
-    def initialize
+    def initialize(comp)
+      @comp = comp
     end
     
     protected
@@ -14,16 +15,18 @@ module Coopy
     
     public
     
-    def attach(comp)
-      @comp = comp
+    def run 
       more = self.compare_core
-      while(more && comp.run_to_completion) 
+      while(more && @comp.run_to_completion) 
         more = self.compare_core
       end
       return !more
     end
     
     def align 
+      while(!@comp.completed) 
+        self.run
+      end
       alignment = ::Coopy::Alignment.new
       self.align_core(alignment)
       return alignment
@@ -316,7 +319,7 @@ module Coopy
           end
         end
       end
-      align.link(0,0)
+      align.link(0,0) if ha > 0 && hb > 0
     end
     
     def align_columns(align,a,b)
@@ -412,7 +415,14 @@ module Coopy
           end
         end
       end
-      return if ma_best == nil
+      if ma_best == nil 
+        if a.get_height > 0 && b.get_height == 0 
+          align.headers(0,-1)
+        elsif a.get_height == 0 && b.get_height > 0 
+          align.headers(-1,0)
+        end
+        return
+      end
       _it2 = ::Rb::RubyIterator.new(ma_best.keys)
       while(_it2.has_next) do
         key3 = _it2._next

data/lib/lib/coopy/coopy.rb

@@ -88,27 +88,8 @@ module Coopy
       end if ext == "json" || ext == ""
       @format_preference = "csv"
       csv = ::Coopy::Csv.new(@delim_preference)
-      data = csv.parse_table(txt)
-      h = data.length
-      w = 0
-      w = data[0].length if h > 0
-      output = ::Coopy::SimpleTable.new(w,h)
-      begin
-        _g = 0
-        while(_g < h) 
-          i = _g
-          _g+=1
-          begin
-            _g1 = 0
-            while(_g1 < w) 
-              j = _g1
-              _g1+=1
-              val = data[i][j]
-              output.set_cell(j,i,::Coopy::Coopy.cell_for(val))
-            end
-          end
-        end
-      end
+      output = ::Coopy::SimpleTable.new(0,0)
+      csv.parse_table(txt,output)
       output.trim_blank if output != nil
       return output
     end
@@ -139,8 +120,6 @@ module Coopy
       return r
     end
     
-    public
-    
     def install_git_driver(io,formats)
       r = 0
       if @status == nil 
@@ -290,9 +269,11 @@ module Coopy
       return 0
     end
     
+    public
+    
     def coopyhx(io)
       args = io.args
-      return ::Coopy::Coopy.random_tests if args[0] == "--test"
+      return ::Coopy::Coopy.keep_around if args[0] == "--keep"
       more = true
       output = nil
       css_output = nil
@@ -564,77 +545,31 @@ module Coopy
     class << self
     attr_accessor :version
     end
-    @version = "1.1.19"
+    @version = "1.2.1"
     
     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)
+      ct = ::Coopy::CompareTable.new(comp)
       return ct
     end
     
     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)
+      ct = ::Coopy::CompareTable.new(comp)
       return ct
     end
     
     # protected - in ruby this doesn't play well with static/inline methods
     
-    def Coopy.random_tests 
-      st = ::Coopy::SimpleTable.new(15,6)
-      tab = st
-      puts "table size is " + _hx_str(tab.get_width) + "x" + _hx_str(tab.get_height)
-      tab.set_cell(3,4,::Coopy::SimpleCell.new(33))
-      puts "element is " + _hx_str(lambda{ s = tab.get_cell(3,4)
-      _r = s.to_s}.call())
-      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)
-      puts "report is " + _hx_str(report.to_s)
-      d2 = ::Coopy::ViewedDatum.get_simple_view(::Coopy::SimpleCell.new(50))
-      report.clear
-      compare.compare(d1,d2,d3,report)
-      puts "report is " + _hx_str(report.to_s)
-      d2 = ::Coopy::ViewedDatum.get_simple_view(::Coopy::SimpleCell.new(20))
-      report.clear
-      compare.compare(d1,d2,d3,report)
-      puts "report is " + _hx_str(report.to_s)
-      d1 = ::Coopy::ViewedDatum.get_simple_view(::Coopy::SimpleCell.new(20))
-      report.clear
-      compare.compare(d1,d2,d3,report)
-      puts "report is " + _hx_str(report.to_s)
-      comp = ::Coopy::TableComparisonState.new
-      ct = ::Coopy::CompareTable.new
-      comp.a = st
-      comp.b = st
-      ct.attach(comp)
-      puts "comparing tables"
-      t1 = ::Coopy::SimpleTable.new(3,2)
-      t2 = ::Coopy::SimpleTable.new(3,2)
-      t3 = ::Coopy::SimpleTable.new(3,2)
-      dt1 = ::Coopy::ViewedDatum.new(t1,::Coopy::SimpleView.new)
-      dt2 = ::Coopy::ViewedDatum.new(t2,::Coopy::SimpleView.new)
-      dt3 = ::Coopy::ViewedDatum.new(t3,::Coopy::SimpleView.new)
-      compare.compare(dt1,dt2,dt3,report)
-      puts "report is " + _hx_str(report.to_s)
-      t3.set_cell(1,1,::Coopy::SimpleCell.new("hello"))
-      compare.compare(dt1,dt2,dt3,report)
-      puts "report is " + _hx_str(report.to_s)
-      t1.set_cell(1,1,::Coopy::SimpleCell.new("hello"))
-      compare.compare(dt1,dt2,dt3,report)
-      puts "report is " + _hx_str(report.to_s)
+    def Coopy.keep_around 
+      st = ::Coopy::SimpleTable.new(1,1)
       v = ::Coopy::Viterbi.new
       td = ::Coopy::TableDiff.new(nil,nil)
       idx = ::Coopy::Index.new
@@ -715,6 +650,8 @@ module Coopy
       return coopy1.coopyhx(io)
     end
     
+    # protected - in ruby this doesn't play well with static/inline methods
+    
     def Coopy.show(t)
       w = t.get_width
       h = t.get_height

data/lib/lib/coopy/csv.rb

@@ -92,25 +92,46 @@ module Coopy
       return result
     end
     
-    def parse_table(txt)
+    def parse_table(txt,tab)
+      return false if !tab.is_resizable
       @cursor = 0
       @row_ended = false
       @has_structure = true
-      result = Array.new
-      row = Array.new
+      tab.resize(0,0)
+      w = 0
+      h = 0
+      at = 0
+      yat = 0
       while(@cursor < txt.length) 
-        cell = self.parse_cell(txt)
-        row.push(cell)
+        cell = self.parse_cell_part(txt)
+        if yat >= h 
+          h = yat + 1
+          tab.resize(w,h)
+        end
+        if at >= w 
+          w = at + 1
+          tab.resize(w,h)
+        end
+        tab.set_cell(at,h - 1,cell)
+        at+=1
         if @row_ended 
-          result.push(row)
-          row = Array.new
+          at = 0
+          yat+=1
         end
         @cursor+=1
       end
-      return result
+      return true
     end
     
-    def parse_cell(txt)
+    def make_table(txt)
+      tab = ::Coopy::SimpleTable.new(0,0)
+      self.parse_table(txt,tab)
+      return tab
+    end
+    
+    protected
+    
+    def parse_cell_part(txt)
       return nil if txt == nil
       @row_ended = false
       first_non_underscore = txt.length
@@ -173,11 +194,13 @@ module Coopy
       return result
     end
     
-    def parse_single_cell(txt)
+    public
+    
+    def parse_cell(txt)
       @cursor = 0
       @row_ended = false
       @has_structure = false
-      return self.parse_cell(txt)
+      return self.parse_cell_part(txt)
     end
     
   haxe_me

data/lib/lib/coopy/diff_render.rb

@@ -75,12 +75,12 @@ module Coopy
       return self.html
     end
     
-    def render(rows)
-      return if rows.get_width == 0 || rows.get_height == 0
+    def render(tab)
+      return self if tab.get_width == 0 || tab.get_height == 0
       render = self
       render.begin_table
       change_row = -1
-      tt = ::Coopy::TableText.new(rows)
+      tt = ::Coopy::TableText.new(tab)
       cell = ::Coopy::CellInfo.new
       corner = tt.get_cell_text(0,0)
       off = nil
@@ -90,11 +90,11 @@ module Coopy
         off = 0
       end
       if off > 0 
-        return if rows.get_width <= 1 || rows.get_height <= 1
+        return self if tab.get_width <= 1 || tab.get_height <= 1
       end
       begin
         _g1 = 0
-        _g = rows.get_height
+        _g = tab.get_height
         while(_g1 < _g) 
           row = _g1
           _g1+=1
@@ -107,7 +107,7 @@ module Coopy
           render.begin_row(row_mode)
           begin
             _g3 = 0
-            _g2 = rows.get_width
+            _g2 = tab.get_width
             while(_g3 < _g2) 
               c = _g3
               _g3+=1
@@ -119,6 +119,7 @@ module Coopy
         end
       end
       render.end_table
+      return self
     end
     
     def sample_css 
@@ -212,6 +213,8 @@ module Coopy
       end
     end
     
+    # protected - in ruby this doesn't play well with static/inline methods
+    
     def DiffRender.mark_spaces(sl,sr)
       return sl if sl == sr
       return sl if sl == nil || sr == nil
@@ -239,6 +242,8 @@ module Coopy
       return slo
     end
     
+    public
+    
     def DiffRender.render_cell(tt,x,y)
       cell = ::Coopy::CellInfo.new
       corner = tt.get_cell_text(0,0)