daff 1.1.2 → 1.1.5

data/README.md

@@ -0,0 +1,242 @@
+[![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: 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 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 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 [--output OUTPUT.csv] source.csv patch.csv
+  daff trim [--output OUTPUT.csv] source.csv
+  daff render [--output OUTPUT.html] diff.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 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 see how to use daff to improve `git`'s handling
+of csv files.
+
+````
+$ daff git csv
+You can use daff to improve git's handling of csv files, by using it as a
+diff driver (for showing what has changed) and as a merge driver (for merging
+changes between multiple versions).  Here is how.
+
+Create and add a file called .gitattributes in the root directory of your
+repository, containing:
+
+  *.csv diff=daff-diff
+  *.csv merge=daff-merge
+
+Create a file called .gitconfig in your home directory (or alternatively
+open .git/config for a particular repository) and add:
+
+  [merge "daff-merge"]
+  name = daff tabular merge
+  driver = daff merge --output %A %O %A %B
+
+  [diff "daff-diff"]
+  command = daff diff --git
+
+Make sure you can run daff from the command-line as just "daff" - if not,
+replace "daff" in the driver and command lines above with the correct way
+to call it.
+````
+
+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', 'de', 'Berlin' ] ]
+```
+
+For visualization, you may want to convert this to a HTML table
+with appropriate classes on cells so you can color-code inserts,
+deletes, updates, etc.  You can do this with:
+```js
+var diff2html = new daff.DiffRender();
+diff2html.render(table_diff);
+var table_diff_html = diff2html.html();
+```
+
+For 3-way differences (that is, comparing two tables given knowledge
+of a common ancestor) use `daff.compareTables3` (give ancestor
+table as the first argument).
+
+Here is how to apply that difference as a patch:
+```js
+var patcher = new daff.HighlightPatch(table1,table_diff);
+patcher.apply();
+// table1 should now equal table2
+```
+
+For other languages, you should find sample code in 
+the packages on the [Releases](https://github.com/paulfitz/daff/releases) page.
+
+
+Supported languages
+-------------------
+
+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
+
+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:
+
+```
+make js
+make php
+make py
+make java
+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.
+
+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.
+ * 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.
+ * http://blog.ouseful.info/2013/08/27/diff-or-chop-github-csv-data-files-and-openrefine/ : counterpoint - a post discussing tracked-changes rather than diffs.
+
+## License
+
+daff is distributed under the MIT License.

data/lib/daff.rb

@@ -36,6 +36,7 @@ require_relative 'lib/coopy/highlight_patch_unit'
 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/mover'
 require_relative 'lib/coopy/ordering'
 require_relative 'lib/coopy/report'

data/lib/lib/coopy/coopy.rb

@@ -223,6 +223,8 @@ module Coopy
       css_output = nil
       fragment = false
       pretty = true
+      inplace = false
+      git = false
       flags = ::Coopy::CompareFlags.new
       flags.always_show_header = true
       while(more) 
@@ -275,6 +277,16 @@ module Coopy
               flags.unchanged_context = context if context >= 0
               args.slice!(i,2)
               break
+            elsif tag == "--inplace" 
+              more = true
+              inplace = true
+              args.slice!(i,1)
+              break
+            elsif tag == "--git" 
+              more = true
+              git = true
+              args.slice!(i,1)
+              break
             end
           end
         end
@@ -286,9 +298,13 @@ module Coopy
         io.write_stderr("  daff [--output OUTPUT.csv] a.csv b.csv\n")
         io.write_stderr("  daff [--output OUTPUT.csv] parent.csv a.csv b.csv\n")
         io.write_stderr("  daff [--output OUTPUT.jsonbook] a.jsonbook b.jsonbook\n")
-        io.write_stderr("  daff patch [--output OUTPUT.csv] source.csv patch.csv\n")
+        io.write_stderr("  daff patch [--inplace] [--output OUTPUT.csv] a.csv patch.csv\n")
+        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("\n")
+        io.write_stderr("The --inplace option to patch and merge will result in modification of a.csv.\n")
         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")
@@ -296,21 +312,65 @@ module Coopy
         io.write_stderr("     --all:         do not prune unchanged rows\n")
         io.write_stderr("     --act ACT:     show only a certain kind of change (update, insert, delete)\n")
         io.write_stderr("\n")
+        io.write_stderr("  daff diff --git path old-file old-hex old-mode new-file new-hex new-mode\n")
+        io.write_stderr("     --git:         process arguments provided by git to diff drivers\n")
+        io.write_stderr("\n")
         io.write_stderr("  daff render [--output OUTPUT.html] [--css CSS.css] [--fragment] [--plain] diff.csv\n")
         io.write_stderr("     --css CSS.css: generate a suitable css file to go with the html\n")
         io.write_stderr("     --fragment:    generate just a html fragment rather than a page\n")
         io.write_stderr("     --plain:       do not use fancy utf8 characters to make arrows prettier\n")
         return 1
       end
-      output = "-" if output == nil
       cmd1 = args[0]
       offset = 1
-      if !Lambda.has(["diff","patch","trim","render"],cmd1) 
+      if !Lambda.has(["diff","patch","merge","trim","render","git"],cmd1) 
         if (cmd1.index(".",nil || 0) || -1) != -1 || (cmd1.index("--",nil || 0) || -1) == 0 
           cmd1 = "diff"
           offset = 0
         end
       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
+      end
+      if git 
+        ct = args.length - offset
+        if ct != 7 
+          io.write_stderr("Expected 7 parameters from git, but got " + _hx_str(ct) + "\n")
+          return 1
+        end
+        git_args = args.slice!(offset,ct)
+        args.slice!(0,args.length)
+        offset = 0
+        path = git_args[0]
+        old_file = git_args[1]
+        new_file = git_args[4]
+        io.write_stdout("--- a/" + _hx_str(path) + "\n")
+        io.write_stdout("+++ b/" + _hx_str(path) + "\n")
+        args.push(old_file)
+        args.push(new_file)
+      end
       tool = ::Coopy::Coopy.new
       tool.io = io
       parent = nil
@@ -318,12 +378,20 @@ module Coopy
         parent = tool.load_table(args[offset])
         offset+=1
       end
-      a = tool.load_table(args[offset])
+      aname = args[offset]
+      a = tool.load_table(aname)
       b = nil
       b = tool.load_table(args[1 + offset]) if args.length - offset >= 2
+      if inplace 
+        io.write_stderr("Please do not use --inplace when specifying an output.\n") if output != nil
+        output = aname
+        return 1
+      end
+      output = "-" if output == nil
+      ok = true
       if cmd1 == "diff" 
-        ct = ::Coopy::Coopy.compare_tables3(parent,a,b)
-        align = ct.align
+        ct1 = ::Coopy::Coopy.compare_tables3(parent,a,b)
+        align = ct1.align
         td = ::Coopy::TableDiff.new(align,flags)
         o = ::Coopy::SimpleTable.new(0,0)
         td.hilite(o)
@@ -332,6 +400,12 @@ module Coopy
         patcher = ::Coopy::HighlightPatch.new(a,b)
         patcher.apply
         tool.save_table(output,a)
+      elsif cmd1 == "merge" 
+        merger = ::Coopy::Merger.new(parent,a,b,flags)
+        conflicts = merger.apply
+        ok = conflicts == 0
+        io.write_stderr(_hx_str(conflicts) + " conflict" + _hx_str((((conflicts > 1) ? "s" : ""))) + "\n") if conflicts > 0
+        tool.save_table(output,a)
       elsif cmd1 == "trim" 
         tool.save_table(output,a)
       elsif cmd1 == "render" 
@@ -342,7 +416,11 @@ module Coopy
         tool.save_text(output,renderer.html)
         tool.save_text(css_output,renderer.sample_css) if css_output != nil
       end
-      return 0
+      if ok 
+        return 0
+      else 
+        return 1
+      end
     end
     
     def Coopy.main 
@@ -374,7 +452,7 @@ module Coopy
           txt += "\n"
         end
       end
-      ::Haxe::Log._trace.call(txt,{ file_name: "Coopy.hx", line_number: 353, class_name: "coopy.Coopy", method_name: "show"})
+      ::Haxe::Log._trace.call(txt,{ file_name: "Coopy.hx", line_number: 432, class_name: "coopy.Coopy", method_name: "show"})
     end
     
     def Coopy.jsonify(t)

data/lib/lib/coopy/merger.rb

@@ -0,0 +1,183 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class Merger 
+    
+    def initialize(parent,local,remote,flags)
+      @parent = parent
+      @local = local
+      @remote = remote
+      @flags = flags
+    end
+    
+    # protected - in ruby this doesn't play well with static/inline methods
+    
+    attr_accessor :parent
+    attr_accessor :local
+    attr_accessor :remote
+    attr_accessor :flags
+    attr_accessor :order
+    attr_accessor :units
+    attr_accessor :column_order
+    attr_accessor :column_units
+    attr_accessor :row_mix_local
+    attr_accessor :row_mix_remote
+    attr_accessor :column_mix_local
+    attr_accessor :column_mix_remote
+    attr_accessor :conflicts
+    
+    public
+    
+    def shuffle_dimension(dim_units,len,fate,cl,cr)
+      at = 0
+      begin
+        _g = 0
+        while(_g < dim_units.length) 
+          cunit = dim_units[_g]
+          _g+=1
+          if cunit.p < 0 
+            if cunit.l < 0 
+              if cunit.r >= 0 
+                begin
+                  cr[cunit.r] = at
+                  at
+                end
+                at+=1
+              end
+            else 
+              begin
+                cl[cunit.l] = at
+                at
+              end
+              at+=1
+            end
+          elsif cunit.l >= 0 
+            if cunit.r < 0 
+            else 
+              begin
+                cl[cunit.l] = at
+                at
+              end
+              at+=1
+            end
+          end
+        end
+      end
+      begin
+        _g1 = 0
+        while(_g1 < len) 
+          x = _g1
+          _g1+=1
+          idx = cl[x]
+          if idx == nil 
+            fate.push(-1)
+          else 
+            fate.push(idx)
+          end
+        end
+      end
+      return at
+    end
+    
+    def shuffle_columns 
+      @column_mix_local = {}
+      @column_mix_remote = {}
+      fate = Array.new
+      wfate = self.shuffle_dimension(@column_units,@local.get_width,fate,@column_mix_local,@column_mix_remote)
+      @local.insert_or_delete_columns(fate,wfate)
+    end
+    
+    def shuffle_rows 
+      @row_mix_local = {}
+      @row_mix_remote = {}
+      fate = Array.new
+      hfate = self.shuffle_dimension(@units,@local.get_height,fate,@row_mix_local,@row_mix_remote)
+      @local.insert_or_delete_rows(fate,hfate)
+    end
+    
+    def apply 
+      @conflicts = 0
+      ct = ::Coopy::Coopy.compare_tables3(@parent,@local,@remote)
+      align = ct.align
+      @order = align.to_order_pruned(true)
+      @units = @order.get_list
+      @column_order = align.meta.to_order_pruned(false)
+      @column_units = @column_order.get_list
+      allow_insert = @flags.allow_insert
+      allow_delete = @flags.allow_delete
+      allow_update = @flags.allow_update
+      view = @parent.get_cell_view
+      begin
+        _g = 0
+        _g1 = @units
+        while(_g < _g1.length) 
+          row = _g1[_g]
+          _g+=1
+          if row.l >= 0 && row.r >= 0 && row.p >= 0 
+            _g2 = 0
+            _g3 = @column_units
+            while(_g2 < _g3.length) 
+              col = _g3[_g2]
+              _g2+=1
+              if col.l >= 0 && col.r >= 0 && col.p >= 0 
+                pcell = @parent.get_cell(col.p,row.p)
+                rcell = @remote.get_cell(col.r,row.r)
+                if !view.equals(pcell,rcell) 
+                  lcell = @local.get_cell(col.l,row.l)
+                  if view.equals(pcell,lcell) 
+                    @local.set_cell(col.l,row.l,rcell)
+                  else 
+                    @local.set_cell(col.l,row.l,::Coopy::Merger.make_conflicted_cell(view,pcell,lcell,rcell))
+                    @conflicts+=1
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+      self.shuffle_columns
+      self.shuffle_rows
+      _it = ::Rb::RubyIterator.new(@column_mix_remote.keys)
+      while(_it.has_next) do
+        x = _it._next
+        x2 = @column_mix_remote[x]
+        begin
+          _g4 = 0
+          _g11 = @units
+          while(_g4 < _g11.length) 
+            unit = _g11[_g4]
+            _g4+=1
+            if unit.l >= 0 && unit.r >= 0 
+              @local.set_cell(x2,@row_mix_local[unit.l],@remote.get_cell(x,unit.r))
+            elsif unit.p < 0 && unit.r >= 0 
+              @local.set_cell(x2,@row_mix_remote[unit.r],@remote.get_cell(x,unit.r))
+            end
+          end
+        end
+      end
+      _it2 = ::Rb::RubyIterator.new(@row_mix_remote.keys)
+      while(_it2.has_next) do
+        y = _it2._next
+        y2 = @row_mix_remote[y]
+        begin
+          _g5 = 0
+          _g12 = @column_units
+          while(_g5 < _g12.length) 
+            unit1 = _g12[_g5]
+            _g5+=1
+            @local.set_cell(@column_mix_local[unit1.l],y2,@remote.get_cell(unit1.r,y)) if unit1.l >= 0 && unit1.r >= 0
+          end
+        end
+      end
+      return @conflicts
+    end
+    
+    def Merger.make_conflicted_cell(view,pcell,lcell,rcell)
+      return view.to_datum("((( " + _hx_str(view.to_s(pcell)) + " ))) " + _hx_str(view.to_s(lcell)) + " /// " + _hx_str(view.to_s(rcell)))
+    end
+    
+  end
+
+end

data/lib/lib/coopy/table.rb

@@ -12,6 +12,8 @@ module Coopy
     def insertOrDeleteRows(fate,hfate) puts "Abstract Table.insertOrDeleteRows called" end
     def insertOrDeleteColumns(fate,wfate) puts "Abstract Table.insertOrDeleteColumns called" end
     def trimBlank() puts "Abstract Table.trimBlank called" end
+    def get_width() puts "Abstract Table.get_width called" end
+    def get_height() puts "Abstract Table.get_height called" end
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: daff
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.1.5
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-10 00:00:00.000000000 Z
+date: 2014-07-10 00:00:00.000000000 Z
 dependencies: []
 description: Diff and patch tables
 email:
@@ -61,6 +61,7 @@ files:
 - lib/lib/coopy/table_comparison_state.rb
 - lib/lib/coopy/csv.rb
 - lib/lib/coopy/ordering.rb
+- lib/lib/coopy/merger.rb
 - lib/lib/coopy/change.rb
 - lib/lib/coopy/sparse_sheet.rb
 - lib/lib/coopy/report.rb
@@ -82,6 +83,7 @@ files:
 - lib/lib/haxe/format/json_printer.rb
 - lib/lib/sys.rb
 - bin/daff.rb
+- README.md
 homepage: https://github.com/paulfitz/daff
 licenses:
 - MIT
@@ -106,44 +108,59 @@ rubyforge_project:
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: ! '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 of the "same" table.  For a live demo, see: > http://paulfitz.github.com/daff/  Get
-  the core library for your preferred language here: > https://github.com/paulfitz/daff/releases  Or
-  with node: ````sh npm install daff ````  Or with pip: ````sh pip3 install daff  #
-  currently needs python3 ````  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
+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:
+  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
+  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
+  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 -----------  There
-  is a commandline utility wrapping the core functions of the library: ```` $ 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 [--output OUTPUT.csv] source.csv patch.csv daff
-  trim [--output OUTPUT.csv] source.csv daff render [--output OUTPUT.html] diff.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 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 ````  The
-  library -----------  To use this library from Javascript, first include `daff.js`
-  on a webpage: ```html <script src="daff.js"></script> ``` Or with nodejs: ```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);
+  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 [--output OUTPUT.csv] source.csv patch.csv daff trim [--output OUTPUT.csv]
+  source.csv daff render [--output OUTPUT.html] diff.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 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 see how to use daff to improve `git`''s handling of csv files.  ````
+  $ daff git csv You can use daff to improve git''s handling of csv files, by using
+  it as a diff driver (for showing what has changed) and as a merge driver (for merging
+  changes between multiple versions).  Here is how.  Create and add a file called
+  .gitattributes in the root directory of your repository, containing:  *.csv diff=daff-diff
+  *.csv merge=daff-merge  Create a file called .gitconfig in your home directory (or
+  alternatively open .git/config for a particular repository) and add:  [merge "daff-merge"]
+  name = daff tabular merge driver = daff merge --output %A %O %A %B  [diff "daff-diff"]
+  command = daff diff --git  Make sure you can run daff from the command-line as just
+  "daff" - if not, replace "daff" in the driver and command lines above with the correct
+  way to call it. ````  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'' ],
@@ -156,22 +173,22 @@ summary: ! 'daff: data diff ===============  This is a library for comparing tab
   differences (that is, comparing two tables given knowledge of a common ancestor)
   use `daff.compareTables3` (give ancestor table as the first argument).  Here is
   how to apply that difference as a patch: ```js var patcher = new daff.HighlightPatch(table1,table_diff);
-  patcher.apply(); // table1 should now equal table2 ```  Other languages ---------------  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++  The Javascript translation is available via npm.  PHP and C++ translations
-  are posted 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)
+  patcher.apply(); // table1 should now equal table2 ```  For other languages, you
+  should find sample code in  the packages on the [Releases](https://github.com/paulfitz/daff/releases)
+  page.   Supported languages -------------------  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  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:  ``` make js make php make py make
   java 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 [Ruby port](https://github.com/paulfitz/coopy-ruby)
-  that is a full translation but may include utter gibberish.  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.  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
+  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.  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. * 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/