daff 1.1.5 → 1.1.6

data/README.md

@@ -19,9 +19,9 @@ Download the code for your preferred language here:
 
 For certain languages you can use the command-line:
 ````sh
-npm install daff   # node/javascript
-pip3 install daff  # python3
-gem install daff   # ruby
+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:

data/lib/lib/coopy/coopy.rb

@@ -71,151 +71,184 @@ module Coopy
       end
     end
     
-    public
-    
-    def Coopy.compare_tables(local,remote)
-      ct = ::Coopy::CompareTable.new
-      comp = ::Coopy::TableComparisonState.new
-      comp.a = local
-      comp.b = remote
-      ct.attach(comp)
-      return ct
-    end
-    
-    def Coopy.compare_tables3(parent,local,remote)
-      ct = ::Coopy::CompareTable.new
-      comp = ::Coopy::TableComparisonState.new
-      comp.p = parent
-      comp.a = local
-      comp.b = remote
-      ct.attach(comp)
-      return ct
-    end
+    attr_accessor :status
+    attr_accessor :daff_cmd
     
-    # protected - in ruby this doesn't play well with static/inline methods
-    
-    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: 42, 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: 44, 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: 52, 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: 56, 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: 60, 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: 64, 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: 72, 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)
-      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)
-      ::Haxe::Log._trace.call("report is " + _hx_str(report.to_s),{ file_name: "Coopy.hx", line_number: 80, 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: 83, 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: 86, class_name: "coopy.Coopy", method_name: "randomTests"})
-      v = ::Coopy::Viterbi.new
-      td = ::Coopy::TableDiff.new(nil,nil)
-      idx = ::Coopy::Index.new
-      dr = ::Coopy::DiffRender.new
-      cf = ::Coopy::CompareFlags.new
-      hp = ::Coopy::HighlightPatch.new(nil,nil)
-      csv = ::Coopy::Csv.new
-      tm = ::Coopy::TableModifier.new(nil)
-      return 0
+    def command(io,cmd,args)
+      r = 0
+      r = io.command(cmd,args) if io.async
+      if r != 999 
+        io.write_stdout("$ " + _hx_str(cmd))
+        begin
+          _g = 0
+          while(_g < args.length) 
+            arg = args[_g]
+            _g+=1
+            io.write_stdout(" ")
+            spaced = (arg.index(" ",nil || 0) || -1) >= 0
+            io.write_stdout("\"") if spaced
+            io.write_stdout(arg)
+            io.write_stdout("\"") if spaced
+          end
+        end
+        io.write_stdout("\n")
+      end
+      r = io.command(cmd,args) if !io.async
+      return r
     end
     
-    def Coopy.cell_for(x)
-      return nil if x == nil
-      return ::Coopy::SimpleCell.new(x)
-    end
+    public
     
-    def Coopy.json_to_table(json)
-      output = nil
-      begin
-        _g = 0
-        _g1 = Reflect.fields(json)
-        while(_g < _g1.length) 
-          name = _g1[_g]
-          _g+=1
-          t = Reflect.field(json,name)
-          columns = Reflect.field(t,"columns")
-          next if columns == nil
-          rows = Reflect.field(t,"rows")
-          next if rows == nil
-          output = ::Coopy::SimpleTable.new(columns.length,rows.length)
-          has_hash = false
-          has_hash_known = false
-          begin
-            _g3 = 0
-            _g2 = rows.length
-            while(_g3 < _g2) 
-              i = _g3
-              _g3+=1
-              row = rows[i]
-              if !has_hash_known 
-                has_hash = true if Reflect.fields(row).length == columns.length
-                has_hash_known = true
-              end
-              if !has_hash 
-                lst = row
-                begin
-                  _g5 = 0
-                  _g4 = columns.length
-                  while(_g5 < _g4) 
-                    j = _g5
-                    _g5+=1
-                    val = lst[j]
-                    output.set_cell(j,i,::Coopy::Coopy.cell_for(val))
-                  end
-                end
-              else 
-                _g51 = 0
-                _g41 = columns.length
-                while(_g51 < _g41) 
-                  j1 = _g51
-                  _g51+=1
-                  val1 = Reflect.field(row,columns[j1])
-                  output.set_cell(j1,i,::Coopy::Coopy.cell_for(val1))
-                end
+    def install_git_driver(io,formats)
+      r = 0
+      if @status == nil 
+        @status = {}
+        @daff_cmd = ""
+      end
+      key = "hello"
+      if !@status.include?(key) 
+        io.write_stdout("Setting up git to use daff on")
+        begin
+          _g = 0
+          while(_g < formats.length) 
+            format = formats[_g]
+            _g+=1
+            io.write_stdout(" *." + _hx_str(format))
+          end
+        end
+        io.write_stdout(" files\n")
+        @status[key] = r
+      end
+      key = "can_run_git"
+      if !@status.include?(key) 
+        r = self.command(io,"git",["--version"])
+        return r if r == 999
+        @status[key] = r
+        if r != 0 
+          io.write_stderr("! Cannot run git, aborting\n")
+          return 1
+        end
+        io.write_stdout("- Can run git\n")
+      end
+      daffs = ["daff","daff.rb","daff.py"]
+      if @daff_cmd == "" 
+        begin
+          _g1 = 0
+          while(_g1 < daffs.length) 
+            daff = daffs[_g1]
+            _g1+=1
+            key1 = "can_run_" + _hx_str(daff)
+            if !@status.include?(key1) 
+              r = self.command(io,daff,["version"])
+              return r if r == 999
+              @status[key1] = r
+              if r == 0 
+                @daff_cmd = daff
+                io.write_stdout("- Can run " + _hx_str(daff) + " as \"" + _hx_str(daff) + "\"\n")
+                break
               end
             end
           end
         end
+        if @daff_cmd == "" 
+          io.write_stderr("! Cannot find daff, is it in your path?\n")
+          return 1
+        end
       end
-      output.trim_blank if output != nil
-      return output
+      begin
+        _g2 = 0
+        while(_g2 < formats.length) 
+          format1 = formats[_g2]
+          _g2+=1
+          key = "have_diff_driver_" + _hx_str(format1)
+          if !@status.include?(key) 
+            r = self.command(io,"git",["config","--global","--get","diff.daff-" + _hx_str(format1) + ".command"])
+            return r if r == 999
+            @status[key] = r
+          end
+          have_diff_driver = @status[key] == 0
+          key = "add_diff_driver_" + _hx_str(format1)
+          if !@status.include?(key) 
+            if !have_diff_driver 
+              r = self.command(io,"git",["config","--global","diff.daff-" + _hx_str(format1) + ".command",_hx_str(@daff_cmd) + " diff --git"])
+              return r if r == 999
+              io.write_stdout("- Added diff driver for " + _hx_str(format1) + "\n")
+            else 
+              r = 0
+              io.write_stdout("- Already have diff driver for " + _hx_str(format1) + ", not touching it\n")
+            end
+            @status[key] = r
+          end
+          key = "have_merge_driver_" + _hx_str(format1)
+          if !@status.include?(key) 
+            r = self.command(io,"git",["config","--global","--get","merge.daff-" + _hx_str(format1) + ".driver"])
+            return r if r == 999
+            @status[key] = r
+          end
+          have_merge_driver = @status[key] == 0
+          key = "name_merge_driver_" + _hx_str(format1)
+          if !@status.include?(key) 
+            if !have_merge_driver 
+              r = self.command(io,"git",["config","--global","merge.daff-" + _hx_str(format1) + ".name","daff tabular " + _hx_str(format1) + " merge"])
+              return r if r == 999
+            else 
+              r = 0
+            end
+            @status[key] = r
+          end
+          key = "add_merge_driver_" + _hx_str(format1)
+          if !@status.include?(key) 
+            if !have_merge_driver 
+              r = self.command(io,"git",["config","--global","merge.daff-" + _hx_str(format1) + ".driver",_hx_str(@daff_cmd) + " merge --output %A %O %A %B"])
+              return r if r == 999
+              io.write_stdout("- Added merge driver for " + _hx_str(format1) + "\n")
+            else 
+              r = 0
+              io.write_stdout("- Already have merge driver for " + _hx_str(format1) + ", not touching it\n")
+            end
+            @status[key] = r
+          end
+        end
+      end
+      if !io.exists(".git/config") 
+        io.write_stderr("! This next part needs to happen in a git repository.\n")
+        io.write_stderr("! Please run again from the root of a git repository.\n")
+        return 1
+      end
+      attr = ".gitattributes"
+      txt = ""
+      post = ""
+      if !io.exists(attr) 
+        io.write_stdout("- No .gitattributes file\n")
+      else 
+        io.write_stdout("- You have a .gitattributes file\n")
+        txt = io.get_content(attr)
+      end
+      need_update = false
+      begin
+        _g3 = 0
+        while(_g3 < formats.length) 
+          format2 = formats[_g3]
+          _g3+=1
+          if (txt.index("*." + _hx_str(format2),nil || 0) || -1) >= 0 
+            io.write_stderr("- Your .gitattributes file already mentions *." + _hx_str(format2) + "\n")
+          else 
+            post += "*." + _hx_str(format2) + " diff=daff-" + _hx_str(format2) + "\n"
+            post += "*." + _hx_str(format2) + " merge=daff-" + _hx_str(format2) + "\n"
+            io.write_stdout("- Placing the following lines in .gitattributes:\n")
+            io.write_stdout(post)
+            txt += "\n" if txt != "" && !need_update
+            txt += post
+            need_update = true
+          end
+        end
+      end
+      io.save_content(attr,txt) if need_update
+      io.write_stdout("- Done!\n")
+      return 0
     end
     
-    public
-    
-    def Coopy.coopyhx(io)
+    def coopyhx(io)
       args = io.args
       return ::Coopy::Coopy.random_tests if args[0] == "--test"
       more = true
@@ -293,6 +326,34 @@ module Coopy
       end
       cmd = args[0]
       if args.length < 2 
+        if cmd == "version" 
+          io.write_stdout(_hx_str(::Coopy::Coopy.version) + "\n")
+          return 0
+        end
+        if cmd == "git" 
+          io.write_stdout("You can use daff to improve git's handling of csv files, by using it as a\ndiff driver (for showing what has changed) and as a merge driver (for merging\nchanges between multiple versions).\n")
+          io.write_stdout("\n")
+          io.write_stdout("Automatic setup\n")
+          io.write_stdout("---------------\n\n")
+          io.write_stdout("Run:\n")
+          io.write_stdout("  daff git csv\n")
+          io.write_stdout("\n")
+          io.write_stdout("Manual setup\n")
+          io.write_stdout("------------\n\n")
+          io.write_stdout("Create and add a file called .gitattributes in the root directory of your\nrepository, containing:\n\n")
+          io.write_stdout("  *.csv diff=daff-csv\n")
+          io.write_stdout("  *.csv merge=daff-csv\n")
+          io.write_stdout("\nCreate a file called .gitconfig in your home directory (or alternatively\nopen .git/config for a particular repository) and add:\n\n")
+          io.write_stdout("  [diff \"daff-csv\"]\n")
+          io.write_stdout("  command = daff diff --git\n")
+          io.write_stderr("\n")
+          io.write_stdout("  [merge \"daff-csv\"]\n")
+          io.write_stdout("  name = daff tabular merge\n")
+          io.write_stdout("  driver = daff merge --output %A %O %A %B\n\n")
+          io.write_stderr("Make sure you can run daff from the command-line as just \"daff\" - if not,\nreplace \"daff\" in the driver and command lines above with the correct way\nto call it.")
+          io.write_stderr("\n")
+          return 0
+        end
         io.write_stderr("daff can produce and apply tabular diffs.\n")
         io.write_stderr("Call as:\n")
         io.write_stderr("  daff [--output OUTPUT.csv] a.csv b.csv\n")
@@ -302,7 +363,8 @@ module Coopy
         io.write_stderr("  daff merge [--inplace] [--output OUTPUT.csv] parent.csv a.csv b.csv\n")
         io.write_stderr("  daff trim [--output OUTPUT.csv] source.csv\n")
         io.write_stderr("  daff render [--output OUTPUT.html] diff.csv\n")
-        io.write_stderr("  daff git csv\n")
+        io.write_stderr("  daff git\n")
+        io.write_stderr("  daff version\n")
         io.write_stderr("\n")
         io.write_stderr("The --inplace option to patch and merge will result in modification of a.csv.\n")
         io.write_stderr("\n")
@@ -323,7 +385,7 @@ module Coopy
       end
       cmd1 = args[0]
       offset = 1
-      if !Lambda.has(["diff","patch","merge","trim","render","git"],cmd1) 
+      if !Lambda.has(["diff","patch","merge","trim","render","git","version"],cmd1) 
         if (cmd1.index(".",nil || 0) || -1) != -1 || (cmd1.index("--",nil || 0) || -1) == 0 
           cmd1 = "diff"
           offset = 0
@@ -331,28 +393,7 @@ module Coopy
       end
       if cmd1 == "git" 
         types = args.slice!(offset,args.length - offset)
-        io.write_stdout("You can use daff to improve git's handling of csv files, by using it as a\ndiff driver (for showing what has changed) and as a merge driver (for merging\nchanges between multiple versions).  Here is how.\n")
-        io.write_stdout("\n")
-        io.write_stdout("Create and add a file called .gitattributes in the root directory of your\nrepository, containing:\n\n")
-        begin
-          _g2 = 0
-          while(_g2 < types.length) 
-            t = types[_g2]
-            _g2+=1
-            io.write_stdout("  *." + _hx_str(t) + " diff=daff-diff\n")
-            io.write_stdout("  *." + _hx_str(t) + " merge=daff-merge\n")
-          end
-        end
-        io.write_stdout("\nCreate a file called .gitconfig in your home directory (or alternatively\nopen .git/config for a particular repository) and add:\n\n")
-        io.write_stdout("  [merge \"daff-merge\"]\n")
-        io.write_stdout("  name = daff tabular merge\n")
-        io.write_stdout("  driver = daff merge --output %A %O %A %B\n\n")
-        io.write_stdout("  [diff \"daff-diff\"]\n")
-        io.write_stdout("  command = daff diff --git\n")
-        io.write_stderr("\n")
-        io.write_stderr("Make sure you can run daff from the command-line as just \"daff\" - if not,\nreplace \"daff\" in the driver and command lines above with the correct way\nto call it.")
-        io.write_stderr("\n")
-        return 0
+        return self.install_git_driver(io,types)
       end
       if git 
         ct = args.length - offset
@@ -423,9 +464,158 @@ module Coopy
       end
     end
     
+    
+    class << self
+    attr_accessor :version
+    end
+    @version = "1.1.6"
+    
+    def Coopy.compare_tables(local,remote)
+      ct = ::Coopy::CompareTable.new
+      comp = ::Coopy::TableComparisonState.new
+      comp.a = local
+      comp.b = remote
+      ct.attach(comp)
+      return ct
+    end
+    
+    def Coopy.compare_tables3(parent,local,remote)
+      ct = ::Coopy::CompareTable.new
+      comp = ::Coopy::TableComparisonState.new
+      comp.p = parent
+      comp.a = local
+      comp.b = remote
+      ct.attach(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
+      ::Haxe::Log._trace.call("table size is " + _hx_str(tab.get_width) + "x" + _hx_str(tab.get_height),{ file_name: "Coopy.hx", line_number: 44, 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: 46, 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: 54, 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: 58, 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: 62, 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: 66, 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: 74, 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)
+      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)
+      ::Haxe::Log._trace.call("report is " + _hx_str(report.to_s),{ file_name: "Coopy.hx", line_number: 82, 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: 85, 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: 88, class_name: "coopy.Coopy", method_name: "randomTests"})
+      v = ::Coopy::Viterbi.new
+      td = ::Coopy::TableDiff.new(nil,nil)
+      idx = ::Coopy::Index.new
+      dr = ::Coopy::DiffRender.new
+      cf = ::Coopy::CompareFlags.new
+      hp = ::Coopy::HighlightPatch.new(nil,nil)
+      csv = ::Coopy::Csv.new
+      tm = ::Coopy::TableModifier.new(nil)
+      return 0
+    end
+    
+    def Coopy.cell_for(x)
+      return nil if x == nil
+      return ::Coopy::SimpleCell.new(x)
+    end
+    
+    def Coopy.json_to_table(json)
+      output = nil
+      begin
+        _g = 0
+        _g1 = Reflect.fields(json)
+        while(_g < _g1.length) 
+          name = _g1[_g]
+          _g+=1
+          t = Reflect.field(json,name)
+          columns = Reflect.field(t,"columns")
+          next if columns == nil
+          rows = Reflect.field(t,"rows")
+          next if rows == nil
+          output = ::Coopy::SimpleTable.new(columns.length,rows.length)
+          has_hash = false
+          has_hash_known = false
+          begin
+            _g3 = 0
+            _g2 = rows.length
+            while(_g3 < _g2) 
+              i = _g3
+              _g3+=1
+              row = rows[i]
+              if !has_hash_known 
+                has_hash = true if Reflect.fields(row).length == columns.length
+                has_hash_known = true
+              end
+              if !has_hash 
+                lst = row
+                begin
+                  _g5 = 0
+                  _g4 = columns.length
+                  while(_g5 < _g4) 
+                    j = _g5
+                    _g5+=1
+                    val = lst[j]
+                    output.set_cell(j,i,::Coopy::Coopy.cell_for(val))
+                  end
+                end
+              else 
+                _g51 = 0
+                _g41 = columns.length
+                while(_g51 < _g41) 
+                  j1 = _g51
+                  _g51+=1
+                  val1 = Reflect.field(row,columns[j1])
+                  output.set_cell(j1,i,::Coopy::Coopy.cell_for(val1))
+                end
+              end
+            end
+          end
+        end
+      end
+      output.trim_blank if output != nil
+      return output
+    end
+    
+    public
+    
     def Coopy.main 
       io = ::Coopy::TableIO.new
-      return ::Coopy::Coopy.coopyhx(io)
+      coopy1 = ::Coopy::Coopy.new
+      return coopy1.coopyhx(io)
     end
     
     def Coopy.show(t)
@@ -452,7 +642,7 @@ module Coopy
           txt += "\n"
         end
       end
-      ::Haxe::Log._trace.call(txt,{ file_name: "Coopy.hx", line_number: 432, class_name: "coopy.Coopy", method_name: "show"})
+      ::Haxe::Log._trace.call(txt,{ file_name: "Coopy.hx", line_number: 615, class_name: "coopy.Coopy", method_name: "show"})
     end
     
     def Coopy.jsonify(t)

data/lib/lib/coopy/table_io.rb

@@ -28,6 +28,24 @@ module Coopy
       HxSys.stderr.write_string(txt)
     end
     
+    def command(cmd,args)
+      begin
+        return HxSys.command(cmd,args)
+      rescue => e
+        return 1
+      end
+      return 1
+    end
+    
+    def async 
+      return false
+    end
+    
+    def exists(path)
+      return File.exist?(path)
+      return false
+    end
+    
   end
 
 end

data/lib/lib/sys.rb

@@ -7,6 +7,52 @@
       return ARGV
     end
     
+    # protected - in ruby this doesn't play well with static/inline methods
+    
+    def HxSys.escape_argument(arg)
+      ok = true
+      begin
+        _g1 = 0
+        _g = arg.length
+        while(_g1 < _g) 
+          i = _g1
+          _g1+=1
+          _g2 = (arg[i].ord rescue nil)
+          case(_g2)
+          when 32,34
+            ok = false
+          when 0,13,10
+            arg = arg[0,i]
+          end if _g2 != nil
+        end
+      end
+      return arg if ok
+      return "\"" + _hx_str(arg.split("\"").join("\\\"")) + "\""
+    end
+    
+    public
+    
+    def HxSys.command(cmd,args = nil)
+      if args != nil 
+        cmd = HxSys.escape_argument(cmd)
+        begin
+          _g = 0
+          while(_g < args.length) 
+            a = args[_g]
+            _g+=1
+            cmd += " " + _hx_str(HxSys.escape_argument(a))
+          end
+        end
+      end
+      result = nil
+      if system(cmd) 
+        result = 0
+      else 
+        result = 1
+      end
+      return result
+    end
+    
     def HxSys.stdout 
       return ::Sys::Io::FileOutput.new(STDOUT)
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: daff
 version: !ruby/object:Gem::Version
-  version: 1.1.5
+  version: 1.1.6
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-10 00:00:00.000000000 Z
+date: 2014-07-11 00:00:00.000000000 Z
 dependencies: []
 description: Diff and patch tables
 email:
@@ -117,8 +117,8 @@ summary: ! '[![Build Status](https://travis-ci.org/paulfitz/daff.svg?branch=mast
   for comparing tables that share a common origin, in other 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: ````sh npm install daff   # node/javascript
-  pip3 install daff  # python3 gem install daff   # ruby ````  Or use the library
+  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