everypolitician-daff 1.3.26

data/lib/lib/lambda.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+  class Lambda 
+    
+    def Lambda.array(it)
+      a = Array.new
+      _it = Rb::RubyIterator.new(it)
+      while(_it.has_next) do
+        i = _it._next
+        a.push(i)
+      end
+      a
+    end
+    
+    def Lambda.map(it,f)
+      l = List.new
+      _it = Rb::RubyIterator.new(it)
+      while(_it.has_next) do
+        x = _it._next
+        l.add((f).call(x))
+      end
+      l
+    end
+    
+    def Lambda.has(it,elt)
+      _it = Rb::RubyIterator.new(it)
+      while(_it.has_next) do
+        x = _it._next
+        return true if x == elt
+      end
+      false
+    end
+    
+  haxe_me ["Lambda"]
+  end
+

data/lib/lib/list.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+  class List 
+    
+    def initialize
+      @length = 0
+    end
+    
+    # protected - in ruby this doesn't play well with static/inline methods
+    
+    attr_accessor :h
+    attr_accessor :q
+    
+    public
+    
+    attr_accessor :length
+    
+    def add(item)
+      x = [item]
+      if @h == nil 
+        @h = x
+      else 
+        @q[1] = x
+      end
+      @q = x
+      @length+=1
+    end
+    
+    def iterator 
+      ::X_List::ListIterator.new(@h)
+    end
+    
+  haxe_me ["List"]
+  end
+

data/lib/lib/math.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+# This space left blank
+

data/lib/lib/rb/boot.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Rb
+  class Boot 
+    
+    # protected - in ruby this doesn't play well with static/inline methods
+    
+    def Boot.__trace(v,i)
+      if i != nil 
+        puts "#{v} #{i.inspect}"
+      else 
+        puts v
+      end
+    end
+    
+    public
+    
+    def Boot.__instanceof(o,cl)
+      return false if cl == nil
+      if cl == Fixnum 
+        return o.is_a? Fixnum
+      elsif cl == Float 
+        return o.is_a?(Float) || o.is_a?(Fixnum)
+      elsif cl == TrueClass 
+        return ((o.is_a? TrueClass)||(o.is_a? FalseClass))
+      elsif cl == String 
+        return o.is_a? String
+      else 
+        return true if cl == Object
+        return false if o == nil
+        return o.is_a?(cl)
+      end
+    end
+    
+  haxe_me ["rb", "Boot"]
+  end
+
+end

data/lib/lib/rb/ruby_iterator.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Rb
+  class RubyIterator 
+    
+    def initialize(x)
+      if x.is_a?(Hash) 
+        @ref = x.values.each
+        @at = 0
+        @len = x.size
+      elsif x.respond_to?("each") 
+        @ref = x.each
+        @at = 0
+        @len = x.size
+      elsif x.respond_to?("iterator") 
+        @ref = x.iterator
+        @at = -1
+        @at = -2 if !@ref.respond_to?("has_next")
+      else 
+        @ref = x
+        @at = -2
+      end
+    end
+    
+    protected
+    
+    attr_accessor :ref
+    attr_accessor :at
+    attr_accessor :len
+    
+    public
+    
+    def has_next 
+      return @ref[:has_next].call if @at == -1
+      return @ref[:has_next][:call].call if @at == -2
+      @at < @len
+    end
+    
+    def _next 
+      return @ref[:_next].call if @at == -1
+      return @ref[:_next][:call].call if @at == -2
+      @at+=1
+      @ref.next
+    end
+    
+  haxe_me ["rb", "RubyIterator"]
+  end
+
+end

data/lib/lib/reflect.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+  class Reflect 
+    
+    def Reflect.field(o,field)
+      begin
+        result = o[field]
+        result = o[field.to_sym] if result == nil
+        return result
+      rescue => e
+        e = hx_rescued(e)
+        return field
+      end
+    end
+    
+    def Reflect.fields(o)
+      if o.respond_to?("attributes") 
+        return o.attributes
+      else 
+        return o.keys
+      end
+    end
+    
+    def Reflect.is_function(f)
+      f.respond_to?("call")
+    end
+    
+    def Reflect.compare(a,b)
+      if a == b 
+        return 0
+      elsif a > b 
+        return 1
+      else 
+        return -1
+      end
+    end
+    
+  haxe_me ["Reflect"]
+  end
+

data/lib/lib/std.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+  class Std 
+    
+    def Std._is(v,t)
+      ::Rb::Boot.__instanceof(v,t)
+    end
+    
+  haxe_me ["Std"]
+  end
+

data/lib/lib/string_buf.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+  class StringBuf 
+    
+    def initialize
+      @b = ""
+    end
+    
+    # protected - in ruby this doesn't play well with static/inline methods
+    
+    attr_accessor :b
+    
+    public
+    
+    attr_accessor :length
+  haxe_me ["StringBuf"]
+  end
+

data/lib/lib/sys/io/file_handle.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Sys
+module Io
+  class FileHandle
+    ISENUM__ = true
+    attr_accessor :tag
+    attr_accessor :index
+    attr_accessor :params
+    def initialize(t,index,p = nil ) @tag = t; @index = index; @params = p; end
+    
+    CONSTRUCTS__ = []
+    def ==(a) (!a.nil?) && (a.respond_to? 'ISENUM__') && a.tag === @tag && a.index === @index && a.params == @params end
+  end
+
+end
+end

data/lib/lib/sys/io/file_output.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Sys
+module Io
+  class FileOutput < ::Haxe::Io::Output 
+    
+    def initialize(f)
+      @__f = f
+    end
+    
+    protected
+    
+    attr_accessor :__f
+    
+    public
+    
+     
+    
+    def write_byte(c)
+      @__f.putc(c)
+    end
+     
+    
+    def write_bytes(b,p,l)
+      s = b.get_string(p,l)
+      r = @__f.write(s)
+      raise hx_raise(::Haxe::Io::Error.custom("An error occurred")) if r < l
+      r
+    end
+    
+  haxe_me ["sys", "io", "FileOutput"]
+  end
+
+end
+end

data/lib/lib/sys/io/hx_file.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Sys
+module Io
+  class HxFile 
+    
+    def HxFile.get_content(path)
+      IO.read(path)
+    end
+    
+    def HxFile.save_content(path,content)
+      IO.write(path,content)
+    end
+    
+  haxe_me ["sys", "io", "File"]
+  end
+
+end
+end

data/lib/lib/type.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+  class Type 
+    
+    def Type._typeof(v)
+      return ValueType.tnull if v == nil
+      begin
+        _g = v.class.to_s
+        case(_g)
+        when "TrueClass"
+          return ValueType.tbool
+        when "FalseClass"
+          return ValueType.tbool
+        when "String"
+          return ValueType.tclass(String)
+        when "Fixnum"
+          return ValueType.tint
+        when "Float"
+          return ValueType.tfloat
+        when "Proc"
+          return ValueType.tfunction
+        when "Array"
+          return ValueType.tclass(Array)
+        when "Hash"
+          return ValueType.tobject
+        else
+          return ValueType.tenum(v.class) if v.respond_to?("ISENUM__")
+          return ValueType.tclass(v.class) if v.respond_to?("class")
+          return ValueType.tunknown
+        end
+      end
+    end
+    
+  haxe_me ["Type"]
+  end
+

data/lib/lib/value_type.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+  class ValueType
+    ISENUM__ = true
+    attr_accessor :tag
+    attr_accessor :index
+    attr_accessor :params
+    def initialize(t,index,p = nil ) @tag = t; @index = index; @params = p; end
+    
+    def ValueType.tbool() ValueType.new("TBool",3) end
+    def ValueType.tclass(c)  ValueType.new("TClass",6,[c]) end
+    def ValueType.tenum(e)  ValueType.new("TEnum",7,[e]) end
+    def ValueType.tfloat() ValueType.new("TFloat",2) end
+    def ValueType.tfunction() ValueType.new("TFunction",5) end
+    def ValueType.tint() ValueType.new("TInt",1) end
+    def ValueType.tnull() ValueType.new("TNull",0) end
+    def ValueType.tobject() ValueType.new("TObject",4) end
+    def ValueType.tunknown() ValueType.new("TUnknown",8) end
+    CONSTRUCTS__ = ["TNull","TInt","TFloat","TBool","TObject","TFunction","TClass","TEnum","TUnknown"]
+    def ==(a) (!a.nil?) && (a.respond_to? 'ISENUM__') && a.tag === @tag && a.index === @index && a.params == @params end
+  end
+

data/lib/lib/x_list/list_iterator.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module X_List
+  class ListIterator 
+    
+    def initialize(head)
+      @head = head
+      @val = nil
+    end
+    
+    # protected - in ruby this doesn't play well with static/inline methods
+    
+    attr_accessor :head
+    attr_accessor :val
+    
+    public
+    
+    def has_next 
+      @head != nil
+    end
+    
+    def _next 
+      @val = @head[0]
+      @head = @head[1]
+      @val
+    end
+    
+  haxe_me ["_List", "ListIterator"]
+  end
+
+end

metadata

@@ -0,0 +1,235 @@
+--- !ruby/object:Gem::Specification
+name: everypolitician-daff
+version: !ruby/object:Gem::Version
+  version: 1.3.26
+platform: ruby
+authors:
+- James Smith
+- Paul Fitzpatrick
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-08-17 00:00:00.000000000 Z
+dependencies: []
+description: Diff and patch tables
+email:
+- james@floppy.org.uk
+- paul@robotrebuilt.com
+executables:
+- daff.rb
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/daff.rb
+- lib/daff.rb
+- lib/lib/coopy/alignment.rb
+- lib/lib/coopy/cell_builder.rb
+- lib/lib/coopy/cell_info.rb
+- lib/lib/coopy/column_change.rb
+- lib/lib/coopy/combined_table.rb
+- lib/lib/coopy/combined_table_body.rb
+- lib/lib/coopy/combined_table_head.rb
+- lib/lib/coopy/compare_flags.rb
+- lib/lib/coopy/compare_table.rb
+- lib/lib/coopy/conflict_info.rb
+- lib/lib/coopy/coopy.rb
+- lib/lib/coopy/cross_match.rb
+- lib/lib/coopy/csv.rb
+- lib/lib/coopy/diff_render.rb
+- lib/lib/coopy/diff_summary.rb
+- lib/lib/coopy/flat_cell_builder.rb
+- lib/lib/coopy/highlight_patch.rb
+- lib/lib/coopy/highlight_patch_unit.rb
+- lib/lib/coopy/index.rb
+- lib/lib/coopy/index_item.rb
+- lib/lib/coopy/index_pair.rb
+- lib/lib/coopy/json_table.rb
+- lib/lib/coopy/json_tables.rb
+- lib/lib/coopy/merger.rb
+- lib/lib/coopy/meta.rb
+- lib/lib/coopy/mover.rb
+- lib/lib/coopy/ndjson.rb
+- lib/lib/coopy/nested_cell_builder.rb
+- lib/lib/coopy/ordering.rb
+- lib/lib/coopy/property_change.rb
+- lib/lib/coopy/row.rb
+- lib/lib/coopy/row_change.rb
+- lib/lib/coopy/row_stream.rb
+- lib/lib/coopy/simple_meta.rb
+- lib/lib/coopy/simple_table.rb
+- lib/lib/coopy/simple_view.rb
+- lib/lib/coopy/sparse_sheet.rb
+- lib/lib/coopy/sql_column.rb
+- lib/lib/coopy/sql_compare.rb
+- lib/lib/coopy/sql_database.rb
+- lib/lib/coopy/sql_helper.rb
+- lib/lib/coopy/sql_table.rb
+- lib/lib/coopy/sql_table_name.rb
+- lib/lib/coopy/sql_tables.rb
+- lib/lib/coopy/sqlite_helper.rb
+- lib/lib/coopy/table.rb
+- lib/lib/coopy/table_comparison_state.rb
+- lib/lib/coopy/table_diff.rb
+- lib/lib/coopy/table_io.rb
+- lib/lib/coopy/table_modifier.rb
+- lib/lib/coopy/table_stream.rb
+- lib/lib/coopy/table_view.rb
+- lib/lib/coopy/tables.rb
+- lib/lib/coopy/terminal_diff_render.rb
+- lib/lib/coopy/unit.rb
+- lib/lib/coopy/view.rb
+- lib/lib/coopy/viterbi.rb
+- lib/lib/haxe/ds/int_map.rb
+- lib/lib/haxe/ds/string_map.rb
+- lib/lib/haxe/format/json_parser.rb
+- lib/lib/haxe/format/json_printer.rb
+- lib/lib/haxe/imap.rb
+- lib/lib/haxe/io/bytes.rb
+- lib/lib/haxe/io/eof.rb
+- lib/lib/haxe/io/error.rb
+- lib/lib/haxe/io/output.rb
+- lib/lib/hx_overrides.rb
+- lib/lib/hx_sys.rb
+- lib/lib/lambda.rb
+- lib/lib/list.rb
+- lib/lib/math.rb
+- lib/lib/rb/boot.rb
+- lib/lib/rb/ruby_iterator.rb
+- lib/lib/reflect.rb
+- lib/lib/std.rb
+- lib/lib/string_buf.rb
+- lib/lib/sys/io/file_handle.rb
+- lib/lib/sys/io/file_output.rb
+- lib/lib/sys/io/hx_file.rb
+- lib/lib/type.rb
+- lib/lib/value_type.rb
+- lib/lib/x_list/list_iterator.rb
+homepage: https://github.com/everypolitician/daff
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+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)
+  [![PHP version](https://badge.fury.io/ph/paulfitz%2Fdaff-php.svg)](http://badge.fury.io/ph/paulfitz%2Fdaff-php)
+  [![Bower version](https://badge.fury.io/bo/daff.svg)](http://badge.fury.io/bo/daff)
+  ![Badge count](http://img.shields.io/:badges-7/7-33aa33.svg)  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/  Install the library for your
+  favorite language: ````sh npm install daff -g  # node/javascript pip install daff     #
+  python gem install daff     # ruby composer require paulfitz/daff-php  # php install.packages(''daff'')
+  # R wrapper by Edwin de Jonge bower install daff   # web/javascript ````  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  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.ndjson] a.ndjson b.ndjson
+  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 ````  Formats supported are CSV, TSV, and [ndjson](http://dataprotocols.org/ndjson/).  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. Your CSV diffs and merges will get smarter, since git will
+  suddenly understand about rows and columns, not just lines:  ![Example CSV diff](http://paulfitz.github.io/daff-doc/images/daff_vs_diff.png)  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 * Python * Java * C# * C++ * 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. 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 make php make py make java make cs make
+  cpp ```  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.  Other possibilities:  * There''s a daff wrapper for R
+  written by [Edwin de Jonge](https://github.com/edwindj), see https://github.com/edwindj/daff
+  and http://cran.r-project.org/web/packages/daff * There''s a hand-written ruby port
+  by [James Smith](https://github.com/Floppy), see https://github.com/theodi/coopy-ruby  API
+  documentation -----------------  * You can browse the `daff` classes at http://paulfitz.github.io/daff-doc/  Sponsors
+  --------  <img src="http://datacommons.coop/images/the_zen_of_venn.png" alt="the
+  zen of venn" height="100"> The [Data Commons Co-op](http://datacommons.coop),  "perhaps
+  the geekiest of all cooperative organizations on the planet," has given great moral
+  support during the development of `daff`. Donate a multiple of `42.42` in your currency
+  to let them know you care: [http://datacommons.coop/donate/](http://datacommons.coop/donate/)  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. * 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. * http://blog.byronjsmith.com/makefile-shortcuts.html
+  : a tutorial on using `make` for data, with daff in the mix. "Since git considers
+  changes on a per-line basis, looking at diffs of comma-delimited and tab-delimited
+  files can get obnoxious. The program daff fixes this problem."  ## License  daff
+  is distributed under the MIT License.'
+test_files: []