taxonifi 0.1.0 → 0.2.0

data/test/file_fixtures/Lygaeoidea.csv

@@ -190,7 +190,7 @@ Identifier,Parent,Child,Rank,Synonyms,Vernaculars,VernacularsLanguage,Descriptio
 1333,1331,"Drymus crassus Van Duzee, 1910",species,,,,
 1334,1331,"Drymus unus (Say, 1832)",species,,,,
 1339,1335,"Antillocoris minutus (Bergroth, 1895)",species,,,,
-1336,1335,"Antillocoris pallidus (Uhler, 1894)",species,"Pygaeus pallidus Uhler, 1894",,,
+1336,1335,"Antillocoris pallidus (Uhler, 1894)",species,"Lygaeus pallidus Uhler, 1894",,,
 1338,1335,"Antillocoris discretus Barber, 1952",species,,,,
 1340,1335,"Antillocoris pilosulus (Stål, 1874)",species,,,,
 1342,1341,"Cligenes distinctus Distant, 1893",species,,,,

data/test/file_fixtures/names.csv

@@ -0,0 +1 @@
+Phylum,Class,Order,Family,Subfamily,Tribe,Genus,Subgenus,Species,Author,Year

data/test/helper.rb

@@ -1,6 +1,7 @@
 require 'rubygems'
 require 'bundler'
 require 'debugger'
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/taxonifi'))
 
 begin
   Bundler.setup(:default, :development)
@@ -13,6 +14,7 @@ end
 require 'test/unit'
 #require 'shoulda'
 
+
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
@@ -36,3 +38,15 @@ def generic_csv_with_names
   @csv = CSV.parse(@csv_string, {headers: true})
 end
 
+def names
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'file_fixtures/names.csv'))
+
+    csv = CSV.read(file, { 
+      headers: true,
+      col_sep: ",",
+      header_converters: :downcase
+    } ) 
+    nc = Taxonifi::Lumper.create_name_collection(:csv => csv, :initial_id => 1) 
+end
+
+

data/test/test_export_prolog.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/export/export')) 
+
+class Test_ExportProlog < Test::Unit::TestCase
+
+  def test_that_prolog_export_does_stuff
+    e = Taxonifi::Export::Prolog.new(:nc => names, :namespace => 'YYZ')
+    assert foo = e.export
+  end 
+
+
+end 
+
+

data/test/test_exporter.rb

@@ -24,9 +24,32 @@ class Test_TaxonifiExports < Test::Unit::TestCase
     } ) 
 
     nc = Taxonifi::Lumper::Lumps::ParentChildNameCollection.name_collection(csv)
+    nc.generate_ref_collection(1)
+
     e = Taxonifi::Export::SpeciesFile.new(:nc => nc, :authorized_user_id => 15)
     assert foo = e.export
   end
 
+  def test_little_file_linkages
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'file_fixtures/Fossil.csv'))
+
+    csv = CSV.read(file, { 
+      headers: true,
+      col_sep: ",",
+      header_converters: :downcase
+    } ) 
+
+    nc = Taxonifi::Lumper.create_name_collection(:csv => csv, :initial_id => 1) 
+    rc = Taxonifi::Lumper.create_ref_collection(:csv => csv) 
+    rc.uniquify_authors(1)
+    nc.ref_collection = rc
+
+    assert_equal "Crickets (Grylloptera: Grylloidea) in Dominican amber.", nc.ref_collection.object_from_row(0).title
+    assert_equal "Crickets (Grylloptera: Grylloidea) in Dominican amber.", nc.ref_collection.object_from_row(nc.collection[43].related[:link_to_ref_from_row]).title
+
+    e = Taxonifi::Export::SpeciesFile.new(:nc => nc, :authorized_user_id => 11 )
+    e.export
+  end
+
 end 
 

data/test/test_lumper_clump.rb

@@ -0,0 +1,75 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/lumper/clump')) 
+
+# Builder construction
+
+class Test_TaxonifiLumperClump < Test::Unit::TestCase
+
+  def setup
+    @headers = ["family", "genus", "species", "author", "year"]
+    @csv_string = CSV.generate() do |csv|
+      csv <<  @headers
+      csv << ["Fooidae", "Foo", "bar", "Smith", "1854"]
+    end
+
+    @csv = CSV.parse(@csv_string, {headers: true})
+  end
+
+  def test_new_clump_without_params_can_be_created
+    assert c = Taxonifi::Lumper::Clump.new
+  end
+
+  def test_new_clump_with_default_csv_can_be_created
+    assert c = Taxonifi::Lumper::Clump.new(@csv)
+  end
+
+  def test_that_csv_can_be_added_to_clump_that_has_no_csv
+    c = Taxonifi::Lumper::Clump.new
+    assert c.add_csv(@csv)
+  end
+
+  def test_that_clump_with_csv_will_not_add_csv
+    c = Taxonifi::Lumper::Clump.new
+    c.add_csv(@csv)
+    assert !c.add_csv(@csv)
+  end
+
+  def test_that_clump_with_csv_can_detach_csv
+    c = Taxonifi::Lumper::Clump.new
+    c.add_csv(@csv)
+    assert c.remove_csv
+  end
+
+  def test_that_clump_without_csv_can_not_detach_csv
+    c = Taxonifi::Lumper::Clump.new
+    assert !c.remove_csv
+  end
+
+  def test_that_name_collection_can_be_derived_from_clump
+    c = Taxonifi::Lumper::Clump.new
+    c.add_csv(@csv)
+    assert c.get_from_csv(:collection => :name)
+    assert_equal ['collection0'], c.collections.keys
+    assert_equal Taxonifi::Model::NameCollection, c.collections['collection0'].class
+  end
+
+  def test_that_ref_collection_can_be_derived_from_clump
+    c = Taxonifi::Lumper::Clump.new
+    c.add_csv(@csv)
+    assert c.get_from_csv(:collection => :ref, :name => 'my_collection')
+    assert_equal ['my_collection'], c.collections.keys
+    assert_equal Taxonifi::Model::RefCollection, c.collections['my_collection'].class
+  end
+
+  def test_that_existing_named_collections_are_not_overwritten
+    c = Taxonifi::Lumper::Clump.new
+    c.add_csv(@csv)
+    assert c.get_from_csv(:collection => :name, :name => 'my_collection')
+    assert !c.get_from_csv(:collection => :name, :name => 'my_collection')
+  end
+
+
+  # name.ref -> 
+
+end 
+

data/test/test_lumper_names.rb

@@ -28,34 +28,33 @@ class Test_TaxonifiLumperNames < Test::Unit::TestCase
   def test_available_lumps
     assert Taxonifi::Lumper.available_lumps( Taxonifi::Lumper::QUAD ).include?(:quadrinomial)
     assert Taxonifi::Lumper.available_lumps( Taxonifi::Lumper::AUTHOR_YEAR + Taxonifi::Lumper::QUAD ).include?(:quad_author_year)
-    assert (not Taxonifi::Lumper.available_lumps( Taxonifi::Lumper::AUTHOR_YEAR + Taxonifi::Lumper::QUAD ).include?(:names) )
+    assert !Taxonifi::Lumper.available_lumps( Taxonifi::Lumper::AUTHOR_YEAR + Taxonifi::Lumper::QUAD ).include?(:names) 
   end
 
   def test_create_name_collection_creates_a_name_collection
-    assert_equal Taxonifi::Model::NameCollection, Taxonifi::Lumper.create_name_collection(@csv).class
+    assert_equal Taxonifi::Model::NameCollection, Taxonifi::Lumper.create_name_collection(:csv => @csv).class
   end
 
   def test_that_create_name_collection_raises_when_fed_non_csv
     assert_raises Taxonifi::Lumper::LumperError do
-      Taxonifi::Lumper.create_name_collection("FOO")
+      Taxonifi::Lumper.create_name_collection(:csv => "FOO")
     end
   end
 
   def test_that_create_name_collection_populates_a_name_collection
-    nc = Taxonifi::Lumper.create_name_collection(@csv)
+    nc = Taxonifi::Lumper.create_name_collection(:csv => @csv)
     assert_equal 3, nc.collection.size
     assert_equal ["Fooidae", "Foo", "bar"], nc.collection.collect{|n| n.name}
   end
 
   def test_that_create_name_collection_assigns_row_number
-    nc = Taxonifi::Lumper.create_name_collection(@csv)
+    nc = Taxonifi::Lumper.create_name_collection(:csv => @csv)
     assert_equal 0, nc.collection.first.row_number
     assert_equal 0, nc.collection.last.row_number
   end
   
-
   def test_that_create_name_collection_parentifies
-    nc = Taxonifi::Lumper.create_name_collection(@csv)
+    nc = Taxonifi::Lumper.create_name_collection(:csv => @csv)
     assert_equal nc.collection[0], nc.collection[1].parent
     assert_equal nc.collection[1], nc.collection[2].parent
   end
@@ -74,7 +73,7 @@ class Test_TaxonifiLumperNames < Test::Unit::TestCase
     # 0 4 7
 
     csv = CSV.parse(string, {headers: true})
-    nc = Taxonifi::Lumper.create_name_collection(csv)
+    nc = Taxonifi::Lumper.create_name_collection(:csv => csv)
 
     assert_equal nc.collection[2], nc.collection[5].parent
     assert_equal nc.collection[0], nc.collection[2].parent
@@ -98,7 +97,7 @@ class Test_TaxonifiLumperNames < Test::Unit::TestCase
     # 3  foo 
 
     csv = CSV.parse(string, {headers: true})
-    nc = Taxonifi::Lumper.create_name_collection(csv)
+    nc = Taxonifi::Lumper.create_name_collection(:csv => csv)
     assert_equal 1, nc.collection[3].author.size
     assert_equal 'Smith', nc.collection[3].author.first.last_name
     assert_equal 1854, nc.collection[3].year
@@ -113,6 +112,65 @@ class Test_TaxonifiLumperNames < Test::Unit::TestCase
     assert_equal false, nc.collection[3].parens
   end
 
+  def test_that_create_a_name_collection_handles_related_columns
+    string = CSV.generate() do |csv|
+      csv << %w{family genus species author_year foo bar Stuff}
+      csv << ["Fooidae", "Foo", "bar", "Smith, 1854"  , nil,  1 , "one"]
+    end
+   
+    # 0  Fooidae
+    # 1  Foo
+    # 2  bar
+
+    csv = CSV.parse(string, {headers: true})
+    nc = Taxonifi::Lumper.create_name_collection(:csv => csv)
+    assert_equal nil, nc.collection[2].related['foo']
+    assert_equal "1", nc.collection[2].related['bar']          # !!! everything converted to String
+    assert_equal 'one', nc.collection[2].related['Stuff']
+  end
+
+  def test_that_create_a_name_collection_handles_varieties
+    string = CSV.generate() do |csv|
+      csv << %w{family genus species variety author_year}
+      csv << ["Fooidae", "Foo", "bar", "varblorf", "Smith, 1854"]
+      csv << ["Fooidae", "Foo", "foo", "varblorf", "(Smith, 1854)"]
+      csv << ["Fooidae", "Foo", "bar", "varbliff", "(Smith, 1854)"]
+    end
+
+    # Names added by rank
+    # 0  Fooidae
+    # 1  Foo
+    # 2  bar
+    # 3  foo
+    # 4  varblorf 
+    # 5  varblorf 
+    # 6  varbliff 
+
+    csv = CSV.parse(string, {headers: true})
+    nc = Taxonifi::Lumper.create_name_collection(:csv => csv)
+
+    assert_equal nc.collection[1], nc.collection[2].parent
+    assert_equal nc.collection[1], nc.collection[3].parent
+    assert_equal nc.collection[2], nc.collection[4].parent
+    assert_equal 'variety', nc.collection[4].rank
+    assert_equal 'varblorf', nc.collection[5].name
+    assert_equal 'Smith', nc.collection[6].author.first.last_name
+
+  # assert_equal 1, nc.collection[3].author.size
+
+  # assert_equal 1854, nc.collection[3].year
+
+  # # Name only applies to the "last" name in the order.
+  # assert_equal nil, nc.collection[0].author
+  # assert_equal nil, nc.collection[1].author
+  # assert_equal 1, nc.collection[2].author.size
+
+  # assert_equal nil, nc.collection[0].parens
+  # assert_equal true, nc.collection[2].parens
+  # assert_equal false, nc.collection[3].parens
+
+  end
+
 #--- reference collections
 
 end 

data/test/test_lumper_parent_child_name_collection.rb

@@ -17,17 +17,17 @@ class Test_TaxonifiLumperParentChildNameCollection < Test::Unit::TestCase
     @csv = CSV.parse(@csv_string, {headers: true})
   end
 
-  def _create_a_collection
+  def create_a_collection
     @nc = Taxonifi::Lumper::Lumps::ParentChildNameCollection.name_collection(@csv)
   end
 
   def test_that_name_collection_returns_a_name_collection
-    _create_a_collection
+    create_a_collection
     assert_equal Taxonifi::Model::NameCollection, @nc.class
   end
 
   def test_that_higher_taxon_names_are_created
-    _create_a_collection
+    create_a_collection
     assert_equal "Aidae", @nc.names_at_rank('family').first.name
     assert_equal "family",  @nc.names_at_rank('family').first.rank
     assert_equal "Foo",     @nc.names_at_rank('genus').first.name
@@ -37,5 +37,49 @@ class Test_TaxonifiLumperParentChildNameCollection < Test::Unit::TestCase
     assert @nc.names_at_rank("subspecies").collect{|n| n.name}.include?("blorf") 
   end
 
+  def test_that_synonyms_are_properly_recognized_and_set
+    csv_string = CSV.generate() do |csv|
+      csv <<  @headers
+      csv <<    [0,  nil, 'Root','class',nil]
+      csv <<    [1,  0,   'Lygaeidae','family',nil]
+      csv <<    [2,  1,   'Lygaeus','genus', nil]
+      csv <<    [3,  1,   'Neortholomus','genus',nil]
+      csv <<    [4,  3,   'Neortholomus scolopax (Say, 1832)','species','Lygaeus scolopax Say, 1832']
+      csv <<    [5,  3,   'Neortholomus foo (Say, 1832)','species']
+      csv <<    [6,  3,   'Neortholomus bar (Say, 1832)','species']
+      csv <<    [7,  6,   'Neortholomus bar bar (Say, 1832)', nil]
+      csv <<    [8,  3,   'Neortholomus aus (Say, 1832)','species']
+      csv <<    [9,  8,   'Neortholomus aus bus (Say, 1832)', nil]
+    # not yet observed
+    # csv <<    [7,  3,   'Neortholomus (Neortholomus) blorf (Say, 1832)','species'] 
+    # csv <<    [8,  3,   'Neortholomus (Neortholomus) blorf (Say, 1832)','species']
+    end
+    csv = CSV.parse(csv_string, {headers: true})
+
+    nc = Taxonifi::Lumper::Lumps::ParentChildNameCollection.name_collection(csv)
+   
+    # These are the names to instantiate when we assume nominotypical names are identical, a combination is added when names 
+    # are used in other combinations
+    assert_equal ["Root", "Lygaeidae", "Lygaeus", "Neortholomus", "Neortholomus scolopax (Say, 1832)", "Neortholomus foo (Say, 1832)", "Neortholomus bar (Say, 1832)", "Neortholomus aus (Say, 1832)", "Neortholomus aus bus (Say, 1832)"  ], nc.name_string_array
+    assert_equal 9, nc.collection.size 
+    
+    assert_equal 'bus Say, 1832', nc.collection.last.name_author_year_string
+    
+    assert_equal 2, nc.combinations.size
+
+    # These tests a little too dependent on array order (word of warning), which is meaningless
+    assert_equal 'Lygaeus', nc.combinations.last.first.name
+    assert_equal [3, nil, 5, nil], nc.combinations.last.collect{|n| n.nil? ? nil : n.id } # ids start at 1 by default
+
+    assert_equal 'Neortholomus', nc.combinations[0].first.name
+    assert_equal [4, nil, 7,7], nc.combinations[0].collect{|n| n.nil? ? nil : n.id } # ids start at 1 by default
+
+    # when author/year the same ignore?!
+    # examine tblTaxonHIstory?  ... the name *is* present but the taxon history won't be.
+
+    foo = 1
+
+  end
+
 end 
 

data/test/test_lumper_refs.rb

@@ -1,4 +1,4 @@
-require 'helper'
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper')) 
 require File.expand_path(File.join(File.dirname(__FILE__), '../lib/lumper/lumper')) 
 
 # Builder construction
@@ -33,15 +33,15 @@ class Test_TaxonifiLumperRefs < Test::Unit::TestCase
   end
 
   def test_create_ref_collection
-    assert_equal Taxonifi::Model::RefCollection, Taxonifi::Lumper.create_ref_collection(@csv).class
+    assert_equal Taxonifi::Model::RefCollection, Taxonifi::Lumper.create_ref_collection(:csv => @csv).class
   end
 
   def test_creates_refs
-    assert_equal 1, Taxonifi::Lumper.create_ref_collection(@csv).collection.size
+    assert_equal 1, Taxonifi::Lumper.create_ref_collection(:csv => @csv).collection.size
   end
 
   def test_assigns_attributes_to_instantiated_refs
-    rc = Taxonifi::Lumper.create_ref_collection(@csv)
+    rc = Taxonifi::Lumper.create_ref_collection(:csv => @csv)
     assert_equal ["J"], rc.collection.first.authors.first.initials
     assert_equal "Smith", rc.collection.first.authors.first.last_name
     assert_equal "2012", rc.collection.first.year
@@ -60,7 +60,7 @@ class Test_TaxonifiLumperRefs < Test::Unit::TestCase
       csv << ["Smith J. and Barnes S.", "2012", "Bar and foo", "Journal of Foo", "2", "3", "2-3, 190", nil, "2", "4", "2(4)" ]
     end
     csv = CSV.parse(csv_string, {headers: true})
-    rc = Taxonifi::Lumper.create_ref_collection(csv)
+    rc = Taxonifi::Lumper.create_ref_collection(:csv => csv)
     assert_equal 1, rc.collection.size
   end
 
@@ -72,7 +72,7 @@ class Test_TaxonifiLumperRefs < Test::Unit::TestCase
       csv << ["Smith J. and Bartes S.", "2012", "Bar and foo", "Journal of Foo", "2", "3", "2-3, 190", nil, "2", "4", "2(4)" ]
     end
     csv = CSV.parse(csv_string, {headers: true})
-    rc = Taxonifi::Lumper.create_ref_collection(csv)
+    rc = Taxonifi::Lumper.create_ref_collection(:csv => csv)
     assert_equal 2, rc.collection.size
   end
 
@@ -83,9 +83,24 @@ class Test_TaxonifiLumperRefs < Test::Unit::TestCase
       csv << ["Smith J.", "2012", "Foo and bar", "Journal of Foo", "2", "3", "2-3, 190", nil, "2", "4", "2(4)" ]
     end
     csv = CSV.parse(csv_string, {headers: true})
-    rc = Taxonifi::Lumper.create_ref_collection(csv)
+    rc = Taxonifi::Lumper.create_ref_collection(:csv => csv)
     assert_equal "Foo and bar", rc.object_from_row(1).title
   end
 
+  def test_that_create_a_ref_collection_handles_related_columns
+    csv_string = CSV.generate() do |csv|
+      csv <<  @headers + ['foo', 'bar']
+      csv << ["Smith J. and Barnes S.", "2012", "Bar and foo", "Journal of Foo", "2", "3", "2-3, 190", nil, "2", "4", "2(4)", "foo value", 1 ]
+      csv << ["Smith J.", "2012", "Foo and bar", "Journal of Foo", "2", "3", "2-3, 190", nil, "2", "4", "2(4)", nil, "bar value" ]
+    end
+    csv = CSV.parse(csv_string, {headers: true})
+    rc = Taxonifi::Lumper.create_ref_collection(:csv => csv)
+  
+    assert_equal "foo value", rc.collection.first.related['foo'] 
+    assert_equal nil, rc.collection.last.related['foo'] 
+    assert_equal '1', rc.collection.first.related['bar'] 
+    assert_equal 'bar value', rc.collection.last.related['bar'] 
+  end
+
 end 
 

data/test/test_obo_nomenclature.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/export/export')) 
+
+class Test_TaxonifiExportOboNomenclature < Test::Unit::TestCase
+
+  def test_that_obo_nomenlature_export_does_stuff
+    e = Taxonifi::Export::OboNomenclature.new(:nc => names, :namespace => 'YYZ')
+    assert foo = e.export
+  end 
+
+
+end 
+
+

data/test/test_parser.rb

@@ -17,7 +17,8 @@ class Test_TaxonifiSplitterParser < Test::Unit::TestCase
       assert_equal builder.species, builder.subspecies.parent 
       assert_equal "Smith", builder.names.last.author
       assert_equal 1912, builder.names.last.year
-      assert_equal false, builder.names.last.parens
+      assert_equal true, builder.names.last.parens
+      assert_equal "Foo (Bar) stuff things (Smith, 1912)", builder.display_name 
 
       lexer = Taxonifi::Splitter::Lexer.new("Foo stuff things Smith, 1912", :species_name)
       builder = Taxonifi::Model::SpeciesName.new
@@ -27,7 +28,8 @@ class Test_TaxonifiSplitterParser < Test::Unit::TestCase
       assert_equal "things", builder.subspecies.name
       assert_equal "Smith", builder.names.last.author
       assert_equal 1912 ,  builder.names.last.year
-      assert_equal true, builder.names.last.parens
+      assert_equal false, builder.names.last.parens
+      assert_equal "Foo stuff things Smith, 1912", builder.display_name 
   end
 
 end 

data/test/test_splitter_tokens.rb

@@ -397,6 +397,15 @@ class Test_TaxonifiSplitterTokens < Test::Unit::TestCase
       assert_equal "1", t.pg_start
       assert_equal "10", t.pg_end
     end
+
+    str = '12-33. ix 14, 19'
+    lexer = Taxonifi::Splitter::Lexer.new(str, :pages)
+    assert t = lexer.pop(Taxonifi::Splitter::Tokens::Pages)
+    assert_equal "12", t.pg_start
+    assert_equal "33", t.pg_end
+    assert_equal "ix 14, 19", t.remainder
+
+
   end
 
 end 

data/test/test_taxonifi_accessor.rb

@@ -4,37 +4,44 @@ require File.expand_path(File.join(File.dirname(__FILE__), '../lib/assessor/asse
 class Test_TaxonifiAccessor < Test::Unit::TestCase
 
   def setup
-    @headers = ["family", "genus", "species", "author", "year"]
+    @headers = ["family", "genus", "subgenus", "species", "subspecies", "variety", "author", "year"]
     @csv_string = CSV.generate() do |csv|
       csv <<  @headers
-      csv << ["Fooidae", "Foo", "bar", "Smith", "1854"]
+      csv << ["Fooidae"]                                                                     # 0
+      csv << ["Fooidae", "Blorf"]                                                            # 1  
+      csv << ["Fooidae", "Blorf", "Bliff"]                                                   # 2  
+      csv << ["Fooidae", "Foo",    nil,     "bar",   nil,      nil,      "Smith",  "1854"]   # 3
+      csv << ["Fooidae", "Bar",    nil,     "bar",   "subbar", nil,      "Smith",  "1854"]   # 4
+      csv << ["Fooidae", "Bar",    nil,     "bar",   nil,      "varbar", "Smith",  "1854"]   # 5
     end
 
-    @csv = CSV.parse(@csv_string, {headers: true})
+    @csv = CSV.parse(@csv_string, {headers: true, header_converters: :downcase})
   end
 
   def test_first_available
-    assert_equal [:family, 'Fooidae'], Taxonifi::Assessor::RowAssessor.first_available(@csv.first, [:family, :genus])
+    assert_equal [:family, 'Fooidae'], Taxonifi::Assessor::RowAssessor.first_available(@csv[3], [:family, :genus])
   end
 
   def test_last_available
-    assert_equal [:genus, 'Foo'], Taxonifi::Assessor::RowAssessor.last_available(@csv.first, [:family, :genus])
+    assert_equal [:genus, 'Bar'], Taxonifi::Assessor::RowAssessor.last_available(@csv[5], [:family, :genus])
   end
 
   def test_lump_name_rank
-    assert_equal :species, Taxonifi::Assessor::RowAssessor.lump_name_rank(@csv.first)
-    @csv << ["Fooidae"]
-    assert_equal :family, Taxonifi::Assessor::RowAssessor.lump_name_rank(@csv[1])
-    @csv << ["Fooidae", "Blorf"] 
-    assert_equal :genus, Taxonifi::Assessor::RowAssessor.lump_name_rank(@csv[2])
+    assert_equal :family, Taxonifi::Assessor::RowAssessor.lump_name_rank(@csv[0])
+    assert_equal :genus, Taxonifi::Assessor::RowAssessor.lump_name_rank(@csv[1])
+    assert_equal :subgenus, Taxonifi::Assessor::RowAssessor.lump_name_rank(@csv[2])
+    assert_equal :species, Taxonifi::Assessor::RowAssessor.lump_name_rank(@csv[3])
+    assert_equal :subspecies, Taxonifi::Assessor::RowAssessor.lump_name_rank(@csv[4])
+    assert_equal :variety, Taxonifi::Assessor::RowAssessor.lump_name_rank(@csv[5])
   end
 
-  def test_lump_rank_parent
-    assert_equal ["genus", "Foo"], Taxonifi::Assessor::RowAssessor.parent_taxon_column(@csv.first)
-  end
+  # DEPRECATED
+  # def test_lump_rank_parent
+  #   assert_equal [nil, nil ], Taxonifi::Assessor::RowAssessor.parent_taxon_column(@csv.first)
+  #   assert_equal ["family", "Fooidae"], Taxonifi::Assessor::RowAssessor.parent_taxon_column(@csv.first)
+  # end
 
   def test_intersecting_lumps_with_data
-
       headers = ["authors"]
       csv_string = CSV.generate() do |csv|
         csv <<  headers
@@ -45,7 +52,6 @@ class Test_TaxonifiAccessor < Test::Unit::TestCase
   end 
 
   def test_lumps_with_data
- 
       headers = Taxonifi::Lumper::LUMPS[:citation_small]
       csv_string = CSV.generate() do |csv|
         csv <<  headers

data/test/test_taxonifi_base.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/models/base')) 
+
+class TestTaxonifiBase < Test::Unit::TestCase
+
+  def test_new_base
+    assert b = Taxonifi::Model::Base.new() 
+  end
+
+  def test_that_base_has_an_id
+    n = Taxonifi::Model::Base.new() 
+    assert n.respond_to?(:id)
+  end
+ 
+  def test_that_base_has_a_row_number
+    n = Taxonifi::Model::Base.new() 
+    assert n.respond_to?(:row_number)
+  end
+
+  def test_identical_by_attributes
+    n = Taxonifi::Model::Base.new() 
+    assert n.identical?(n)
+  end
+
+end

data/test/test_taxonifi_name.rb

@@ -118,6 +118,35 @@ class TestTaxonifiName < Test::Unit::TestCase
    @n4 = Taxonifi::Model::Name.new(:name => "boo", :rank => "Species", :author => "Frank", :year => 2020, :id => 11,  :parent => @n3 )
   end
 
+  def dont_test_prologify
+    create_a_few_names
+    n0 = [
+      "rank(#{@n0.id}, #{@n0.rank})",
+      "edge(#{@n0.id}, #{@n0.parent ? @no.parent.id : "_"})",
+      "name({@n0.id}, #{@n0.name})"
+    ]
+    assert_equal n0.join("\n") , @n0.prologify
+  end
+
+  def test_name_author_year_string
+    create_a_few_names
+    assert_equal 'Baridae', @n0.name_author_year_string
+    assert_equal 'Barinae', @n1.name_author_year_string
+    assert_equal 'Foo Frank, 2020', @n2.name_author_year_string
+    assert_equal 'Bar Frank, 2020', @n3.name_author_year_string
+    assert_equal 'boo Frank, 2020', @n4.name_author_year_string
+  end
+
+  def test_nomenclator_name
+    create_a_few_names
+    n5 = Taxonifi::Model::Name.new(:name => "beep", :rank => "Subspecies", :author => "Frank", :year => 2020, :id => 11,  :parent => @n4 )
+    
+    assert_equal 'Foo', @n2.nomenclator_name 
+    assert_equal 'Foo (Bar)', @n3.nomenclator_name
+    assert_equal 'Foo (Bar) boo', @n4.nomenclator_name
+    assert_equal 'Foo (Bar) boo beep', n5.nomenclator_name
+  end
+
   def test_ancestors
     create_a_few_names 
     assert_equal [@n0, @n1], @n2.ancestors
@@ -128,6 +157,7 @@ class TestTaxonifiName < Test::Unit::TestCase
     assert_equal [2,15], @n2.ancestor_ids
   end
 
+  # TODO: fix to inject valid id to confirm to SF
   def test_parent_ids_sf_style
     create_a_few_names 
     assert_equal '2-15-14g-19s-11', @n4.parent_ids_sf_style
@@ -141,6 +171,17 @@ class TestTaxonifiName < Test::Unit::TestCase
     assert_equal '1920-||smith|-||jones|', n.author_year_index
   end
 
+  def test_genus_group_parent
+    n1 = Taxonifi::Model::Name.new(name: "Fooidae", rank: "family",     author: nil ,    year: nil)                      # 
+    n2 = Taxonifi::Model::Name.new(name: "Foo",     rank: "genus",      author: nil ,    year: nil,   :parent => n1)     # Foo
+    n3 = Taxonifi::Model::Name.new(name: "Bar",     rank: "subgenus",   author: nil ,    year: nil,   :parent => n2)     # Foo (Bar)
+    n4 = Taxonifi::Model::Name.new(name: "aus",     rank: "species",    author: nil ,    year: nil,   :parent => n3)     # Foo (Bar) aus 
+    n5 = Taxonifi::Model::Name.new(name: "bus",     rank: "subspecies", author: 'Smith', year: 1920,  :parent => n4)     # Foo (Bar) aus bus
+
+    assert_equal n3, n4.genus_group_parent
+    assert_equal n3, n5.genus_group_parent
+  end
+
   # 
   # ICZN Subclass
   #
@@ -179,8 +220,4 @@ class TestTaxonifiName < Test::Unit::TestCase
     assert n.name = "Fooina"
   end
 
-
-
-
-
 end