taxonifi 0.2.0 → 0.3.2

data/test/test_parser.rb

@@ -2,35 +2,106 @@ require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
 require File.expand_path(File.join(File.dirname(__FILE__), '../lib/splitter/parser')) 
 
 class Test_TaxonifiSplitterParser < Test::Unit::TestCase
-
   # TODO: this could also go to builder related tests
+
   def test_that_parse_species_name_parses
-      lexer = Taxonifi::Splitter::Lexer.new("Foo (Bar) stuff things (Smith, 1912)", :species_name)
-      builder = Taxonifi::Model::SpeciesName.new
-      Taxonifi::Splitter::Parser.new(lexer, builder).parse_species_name
-      assert_equal "Foo", builder.genus.name
-      assert_equal "Bar", builder.subgenus.name
-      assert_equal builder.genus, builder.subgenus.parent 
-      assert_equal "stuff", builder.species.name
-      assert_equal builder.subgenus, builder.species.parent 
-      assert_equal "things", builder.subspecies.name
-      assert_equal builder.species, builder.subspecies.parent 
-      assert_equal "Smith", builder.names.last.author
-      assert_equal 1912, builder.names.last.year
-      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
-      Taxonifi::Splitter::Parser.new(lexer, builder).parse_species_name
-      assert_equal "Foo", builder.genus.name
-      assert_equal "stuff", builder.species.name
-      assert_equal "things", builder.subspecies.name
-      assert_equal "Smith", builder.names.last.author
-      assert_equal 1912 ,  builder.names.last.year
-      assert_equal false, builder.names.last.parens
-      assert_equal "Foo stuff things Smith, 1912", builder.display_name 
+    lexer = Taxonifi::Splitter::Lexer.new("Foo stuff Smith, 1912", :species_name)
+    builder = Taxonifi::Model::SpeciesName.new
+    Taxonifi::Splitter::Parser.new(lexer, builder).parse_species_name
+    assert_equal "Foo", builder.genus.name
+    assert_equal "stuff", builder.species.name
+    assert_equal "Smith", builder.names.last.author
+    assert_equal 1912 ,  builder.names.last.year
+    assert_equal false, builder.names.last.parens
+    assert_equal "Foo stuff Smith, 1912", builder.display_name 
+  end
+
+  def test_that_parse_species_name_parses_subspecies
+    lexer = Taxonifi::Splitter::Lexer.new("Foo stuff things Smith, 1912", :species_name)
+    builder = Taxonifi::Model::SpeciesName.new
+    Taxonifi::Splitter::Parser.new(lexer, builder).parse_species_name
+    assert_equal "Foo", builder.genus.name
+    assert_equal "stuff", builder.species.name
+    assert_equal "things", builder.subspecies.name
+    assert_equal "Smith", builder.names.last.author
+    assert_equal 1912 ,  builder.names.last.year
+    assert_equal false, builder.names.last.parens
+    assert_equal "Foo stuff things Smith, 1912", builder.display_name 
+  end
+
+  def test_that_parse_species_name_parses_subgenera
+    lexer = Taxonifi::Splitter::Lexer.new("Foo (Bar) stuff things (Smith, 1912)", :species_name)
+    builder = Taxonifi::Model::SpeciesName.new
+    Taxonifi::Splitter::Parser.new(lexer, builder).parse_species_name
+    assert_equal "Foo", builder.genus.name
+    assert_equal "Bar", builder.subgenus.name
+    assert_equal builder.genus, builder.subgenus.parent 
+    assert_equal "stuff", builder.species.name
+    assert_equal builder.subgenus, builder.species.parent 
+    assert_equal "things", builder.subspecies.name
+    assert_equal builder.species, builder.subspecies.parent 
+    assert_equal "Smith", builder.names.last.author
+    assert_equal 1912, builder.names.last.year
+    assert_equal true, builder.names.last.parens
+    assert_equal "Foo (Bar) stuff things (Smith, 1912)", builder.display_name 
+  end
+
+  def test_that_parse_species_name_parses_variety_following_subspecies
+    lexer = Taxonifi::Splitter::Lexer.new("Foo stuff things var. blorf Smith, 1912", :species_name)
+    builder = Taxonifi::Model::SpeciesName.new
+    Taxonifi::Splitter::Parser.new(lexer, builder).parse_species_name
+    assert_equal "Foo", builder.genus.name
+    assert_equal "stuff", builder.species.name
+    assert_equal "things", builder.subspecies.name
+    assert_equal "blorf", builder.variety.name
+    assert_equal "Smith", builder.names.last.author
+    assert_equal 1912 ,  builder.names.last.year
+    assert_equal false, builder.names.last.parens
+    assert_equal "Foo stuff things var. blorf Smith, 1912", builder.display_name 
+  end
+
+
+  def test_that_parse_species_name_parses_variety_following_species
+    lexer = Taxonifi::Splitter::Lexer.new("Foo stuff v. blorf Smith, 1912", :species_name)
+    builder = Taxonifi::Model::SpeciesName.new
+    Taxonifi::Splitter::Parser.new(lexer, builder).parse_species_name
+    assert_equal "Foo", builder.genus.name
+    assert_equal "stuff", builder.species.name
+    assert_equal nil, builder.subspecies
+    assert_equal "blorf", builder.variety.name
+    assert_equal "Smith", builder.names.last.author
+    assert_equal 1912 ,  builder.names.last.year
+    assert_equal false, builder.names.last.parens
+    assert_equal "Foo stuff var. blorf Smith, 1912", builder.display_name 
   end
 
+  
+  def test_that_parse_species_name_parses_variety_following_species_without_author_year
+    lexer = Taxonifi::Splitter::Lexer.new("Foo stuff v. blorf", :species_name)
+    builder = Taxonifi::Model::SpeciesName.new
+    Taxonifi::Splitter::Parser.new(lexer, builder).parse_species_name
+    assert_equal "Foo", builder.genus.name
+    assert_equal "stuff", builder.species.name
+    assert_equal nil, builder.subspecies
+    assert_equal "blorf", builder.variety.name
+    assert_equal nil, builder.names.last.parens # not set
+    assert_equal "Foo stuff var. blorf", builder.display_name 
+  end
+
+
+  def test_that_parse_species_name_parses_variety_following_species_without_author_year_II
+    lexer = Taxonifi::Splitter::Lexer.new("Calyptonotus rolandri var. opacus", :species_name)
+    builder = Taxonifi::Model::SpeciesName.new
+    Taxonifi::Splitter::Parser.new(lexer, builder).parse_species_name
+    assert_equal "Calyptonotus", builder.genus.name
+    assert_equal "rolandri", builder.species.name
+    assert_equal nil, builder.subspecies
+    assert_equal "opacus", builder.variety.name
+    assert_equal nil, builder.names.last.parens # not set
+    assert_equal "Calyptonotus rolandri var. opacus", builder.display_name 
+  end
+
+
+
 end 
 

data/test/test_splitter_tokens.rb

@@ -14,6 +14,21 @@ end
 
 class Test_TaxonifiSplitterTokens < Test::Unit::TestCase
 
+  def test_variety
+    lexer = Taxonifi::Splitter::Lexer.new("var. blorf")
+    assert lexer.pop(Taxonifi::Splitter::Tokens::Variety)
+
+    lexer = Taxonifi::Splitter::Lexer.new(" var. blorf")
+    assert lexer.pop(Taxonifi::Splitter::Tokens::Variety)
+
+    lexer = Taxonifi::Splitter::Lexer.new("v. blorf")
+    assert lexer.pop(Taxonifi::Splitter::Tokens::Variety)
+  
+    lexer = Taxonifi::Splitter::Lexer.new("  v. blorf ")
+    assert lexer.pop(Taxonifi::Splitter::Tokens::Variety)
+  end
+
+
   def test_year
     lexer = Taxonifi::Splitter::Lexer.new("1235")
     assert lexer.pop(Taxonifi::Splitter::Tokens::Year)
@@ -53,7 +68,7 @@ class Test_TaxonifiSplitterTokens < Test::Unit::TestCase
     assert lexer.pop(Taxonifi::Splitter::Tokens::RightParen)
   end
 
-  def test_right_paren
+  def test_comma
     lexer = Taxonifi::Splitter::Lexer.new(",")
     assert lexer.pop(Taxonifi::Splitter::Tokens::Comma)
   end
@@ -167,9 +182,15 @@ class Test_TaxonifiSplitterTokens < Test::Unit::TestCase
         "Costa Lima, A. M. da, C. A. Campos Seabra, and C. R. Hathaway",                                              # 36
         "Falcon, L. A., R. van den Bosch, C. A. Ferris, L. K. Stromberg, L. K. Etzel, R. E. Stinner, and T. F. Leigh",  # 37
         "Kinzer, R. E., J. W. Davis, Jr., J. R. Coppedge, and S. L. Jones",                                           # 38
-        "Doesburg, P. H. van, Jr. "                                                                                   # 39
+        "Doesburg, P. H. van, Jr. ",                                                                                  # 39
+        "Arias J. R., Young D. G."                                                                                    # 40 
     ]
 
+    lexer = Taxonifi::Splitter::Lexer.new(auths[40])
+    assert t = lexer.pop(Taxonifi::Splitter::Tokens::Authors)
+    assert_equal ['Arias', 'Young'], t.names.collect{|n| n[:last_name] }
+    assert_equal [%w{J R}, %w{D G}] , t.names[0..1].collect{|n| n[:initials] }
+
     lexer = Taxonifi::Splitter::Lexer.new(auths[39])
     assert t = lexer.pop(Taxonifi::Splitter::Tokens::Authors)
     assert_equal ['Doesburg'], t.names.collect{|n| n[:last_name] }
@@ -298,13 +319,13 @@ class Test_TaxonifiSplitterTokens < Test::Unit::TestCase
     assert_equal 1, t.names.size
     assert_equal "Smith", t.names[0][:last_name]
 
-    lexer = Taxonifi::Splitter::Lexer.new(auths[12])
+    lexer = Taxonifi::Splitter::Lexer.new(auths[13])
     assert t = lexer.pop(Taxonifi::Splitter::Tokens::Authors)
     assert_equal 2, t.names.size
     assert_equal "Smith", t.names[0][:last_name]
     assert_equal "Barnes", t.names[1][:last_name]
 
-    lexer = Taxonifi::Splitter::Lexer.new(auths[13])
+    lexer = Taxonifi::Splitter::Lexer.new(auths[12])
     assert t = lexer.pop(Taxonifi::Splitter::Tokens::Authors)
     assert_equal 2, t.names.size
     assert_equal "Smith", t.names[0][:last_name]

data/test/test_taxonifi_base.rb

@@ -1,5 +1,5 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
-require File.expand_path(File.join(File.dirname(__FILE__), '../lib/models/base')) 
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/model/base')) 
 
 class TestTaxonifiBase < Test::Unit::TestCase
 

data/test/test_taxonifi_geog.rb

@@ -1,5 +1,5 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
-require File.expand_path(File.join(File.dirname(__FILE__), '../lib/models/name')) 
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/model/name')) 
 
 class TestTaxonifiGeog < Test::Unit::TestCase
 

data/test/test_taxonifi_name.rb

@@ -1,5 +1,5 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
-require File.expand_path(File.join(File.dirname(__FILE__), '../lib/models/name')) 
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/model/name')) 
 
 class TestTaxonifiName < Test::Unit::TestCase
 
@@ -30,12 +30,12 @@ class TestTaxonifiName < Test::Unit::TestCase
     n = Taxonifi::Model::Name.new() 
     assert n.respond_to?(:rank) 
   end
- 
+
   def test_that_name_has_an_author
     n = Taxonifi::Model::Name.new() 
     assert n.respond_to?(:author) 
   end
-  
+
   def test_that_name_has_a_year
     n = Taxonifi::Model::Name.new() 
     assert n.respond_to?(:year) 
@@ -74,13 +74,12 @@ class TestTaxonifiName < Test::Unit::TestCase
     end
   end
 
- def test_that_rank_can_be_set
+  def test_that_rank_can_be_set
     n = Taxonifi::Model::Name.new() 
     n.rank = "family"
     assert_equal "family", n.rank
   end
 
-
   def test_that_parent_is_higher_rank_than_child
     n = Taxonifi::Model::Name.new() 
     n.rank = "genus"
@@ -111,11 +110,11 @@ class TestTaxonifiName < Test::Unit::TestCase
   end
 
   def create_a_few_names
-   @n0 = Taxonifi::Model::Name.new(:name => "Baridae", :rank => "Family", :id => 2)
-   @n1 = Taxonifi::Model::Name.new(:name => "Barinae", :rank => "Subfamily", :id => 15, :parent => @n0)
-   @n2 = Taxonifi::Model::Name.new(:name => "Foo", :rank => "Genus", :author => "Frank", :year => 2020, :id => 14,  :parent => @n1 )
-   @n3 = Taxonifi::Model::Name.new(:name => "Bar", :rank => "Subgenus", :author => "Frank", :year => 2020, :id => 19,  :parent => @n2 )
-   @n4 = Taxonifi::Model::Name.new(:name => "boo", :rank => "Species", :author => "Frank", :year => 2020, :id => 11,  :parent => @n3 )
+    @n0 = Taxonifi::Model::Name.new(:name => "Baridae", :rank => "Family", :id => 2)
+    @n1 = Taxonifi::Model::Name.new(:name => "Barinae", :rank => "Subfamily", :id => 15, :parent => @n0)
+    @n2 = Taxonifi::Model::Name.new(:name => "Foo", :rank => "Genus", :author => "Frank", :year => 2020, :id => 14,  :parent => @n1 )
+    @n3 = Taxonifi::Model::Name.new(:name => "Bar", :rank => "Subgenus", :author => "Frank", :year => 2020, :id => 19,  :parent => @n2 )
+    @n4 = Taxonifi::Model::Name.new(:name => "boo", :rank => "Species", :author => "Frank", :year => 2020, :id => 11,  :parent => @n3 )
   end
 
   def dont_test_prologify
@@ -140,7 +139,7 @@ class TestTaxonifiName < Test::Unit::TestCase
   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
@@ -165,14 +164,14 @@ class TestTaxonifiName < Test::Unit::TestCase
     assert_equal '2-15-14g', @n2.parent_ids_sf_style
     assert_equal '2-15', @n1.parent_ids_sf_style
   end 
- 
+
   def test_author_year_index
     n = Taxonifi::Model::Name.new(author_year: 'Smith and Jones, 1920')
     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)                      # 
+    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 
@@ -185,7 +184,7 @@ class TestTaxonifiName < Test::Unit::TestCase
   # 
   # ICZN Subclass
   #
-  
+
   def test_that_iczn_family_ends_in_idae
     n = Taxonifi::Model::IcznName.new
     assert_raise Taxonifi::NameError do

data/test/test_taxonifi_name_collection.rb

@@ -161,6 +161,12 @@ class TestTaxonifiNameCollection < Test::Unit::TestCase
     assert_equal n11.id, c.name_exists?(n12)
   end
 
+  def test_that_name_collection_can_assign_ref_collections
+    r = Taxonifi::Model::RefCollection.new
+    c = Taxonifi::Model::NameCollection.new(:ref_collection => r)
+    assert c.ref_collection == r
+  end
+
   def test_that_name_collection_generate_ref_collection
     c = Taxonifi::Model::NameCollection.new
     c.generate_ref_collection
@@ -182,14 +188,14 @@ class TestTaxonifiNameCollection < Test::Unit::TestCase
 
     c.generate_ref_collection
     assert_equal 3, c.ref_collection.collection.size 
-    # References are sorted 
-    assert_equal ['Jones'], c.ref_collection.collection.first.authors.collect{|r| r.last_name} 
-    assert_equal ['Smith', 'Jones'], c.ref_collection.collection[1].authors.collect{|r| r.last_name} 
-    assert_equal ['Smith', 'Jones', 'Simon'], c.ref_collection.collection.last.authors.collect{|r| r.last_name}
-    assert_equal 2011, c.ref_collection.collection.first.year
+    assert_equal ['Smith', 'Jones'], c.ref_collection.collection.first.authors.collect{|r| r.last_name} 
+    assert_equal ['Smith', 'Jones', 'Simon'], c.ref_collection.collection[1].authors.collect{|r| r.last_name}
+    assert_equal ['Jones'], c.ref_collection.collection.last.authors.collect{|r| r.last_name} 
+    assert_equal 2011, c.ref_collection.collection.last.year
     foo = 1
   end
 
 
+
 end
 

data/test/test_taxonifi_ref.rb

@@ -1,5 +1,5 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
-require File.expand_path(File.join(File.dirname(__FILE__), '../lib/models/ref')) 
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/model/ref')) 
 
 class TestTaxonifiRef < Test::Unit::TestCase
 

data/test/test_taxonifi_ref_collection.rb

@@ -1,7 +1,7 @@
 require 'helper'
-require File.expand_path(File.join(File.dirname(__FILE__), '../lib/models/ref_collection')) 
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/model/ref_collection')) 
 
-class TestTaxonifiCollection < Test::Unit::TestCase
+class TestTaxonifiRefCollection < Test::Unit::TestCase
 
   def test_that_add_objects_adds_refs
     c = Taxonifi::Model::RefCollection.new
@@ -51,18 +51,55 @@ class TestTaxonifiCollection < Test::Unit::TestCase
   def test_uniquify_authors
     c = Taxonifi::Model::RefCollection.new
     ['Smith, A.R. 1920', 'Jones, A.R. and Smith, A.R. 1940', 'Jones, B. 1999', 'Jones, A. R. 1922', 'Jones, A. R., Smith, A.R. and Frank, A. 1943'].each do |a|
+      # smith ar
+      # jones ar
+      # jones b
+      # frank a
       n = Taxonifi::Model::Ref.new(:author_year => a)
       c.add_object(n)
     end
-    assert_equal 4, c.unique_authors.size
+   
+    assert_equal 8, c.all_authors.size
     assert_not_equal c.collection.first.authors.first, c.collection[1].authors.last
+    
     c.uniquify_authors(5)
+    assert_equal 4, c.all_authors.size
     assert_equal c.collection.first.authors.first, c.collection[1].authors.last
     assert_equal c.collection.first.authors.first, c.collection[4].authors[1]
     assert_equal c.collection[1].authors.first, c.collection[3].authors.first
     assert_equal 5, c.collection.first.authors.first.id 
   end
 
+  def test_uniquify_tricky_authors
+    c = Taxonifi::Model::RefCollection.new
+    ['Quate and Quate, 1920',].each do |a|
+      n = Taxonifi::Model::Ref.new(:author_year => a)
+      c.add_object(n)
+    end
+
+    assert_equal 2, c.unique_authors.size
+    c.uniquify_authors(0)
+    assert_equal 2, c.unique_authors.size
+    assert_not_equal c.collection.first.authors.first, c.collection.first.authors.last
+  end
+
+  def test_uniquify_trickier_authors
+    c = Taxonifi::Model::RefCollection.new
+    ['Quate and Quate, 1920', 'Quate, Smith and Quate, 1921', 'Smith, 1930', 'Quate, Quate, and Smith, 2000'].each do |a|
+      # Quate1
+      # Quate2
+      # Smith1
+      n = Taxonifi::Model::Ref.new(:author_year => a)
+      c.add_object(n)
+    end
+
+    assert_equal 9, c.all_authors.size
+    c.uniquify_authors(0)
+    assert_equal 3, c.unique_authors.size
+    # assert_not_equal c.collection.first.authors.first, c.collection.first.authors.last
+  end
+
+
 
 
 end

data/test/test_taxonifi_species_name.rb

@@ -1,5 +1,5 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
-require File.expand_path(File.join(File.dirname(__FILE__), '../lib/models/species_name')) 
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/model/species_name')) 
 
 class TestTaxonifiSpeciesName < Test::Unit::TestCase
 
@@ -92,4 +92,54 @@ class TestTaxonifiSpeciesName < Test::Unit::TestCase
     assert_equal "Foo (Bar) stuff things (Jones, 2012)", sn3.display_name
   end
 
+  def test_new_from_string_for_simple_species_name
+    string = "Foo bar Smith, 1920"
+    sn = Taxonifi::Model::SpeciesName.new_from_string(string)
+    assert_equal "Foo", sn.genus.name
+    assert_equal "bar", sn.species.name
+    assert_equal 1920, sn.species.year
+    assert_equal "Smith", sn.species.authors.first.last_name
+  end
+
+  def test_new_from_string_for_more_complex_species_name
+    string = 'Aus (Cus) bus dus (Smith, 1920)'
+    sn = Taxonifi::Model::SpeciesName.new_from_string(string)
+    assert_equal "Aus", sn.genus.name
+    assert_equal "Cus", sn.subgenus.name
+    assert_equal "bus", sn.species.name
+    assert_equal "dus", sn.subspecies.name
+    assert_equal 1920, sn.subspecies.year
+    assert_equal "Smith", sn.subspecies.authors.first.last_name
+    assert_equal true, sn.subspecies.parens
+  end
+
+  def test_new_from_simple_ampersand_authors
+    string = 'Pericoma deceptrix Quate & Brown, 2004'
+    sn = Taxonifi::Model::SpeciesName.new_from_string(string)
+    assert_equal "Pericoma", sn.genus.name
+    assert_equal nil, sn.subgenus
+    assert_equal "deceptrix", sn.species.name
+    assert_equal nil, sn.subspecies
+    assert_equal 2004, sn.species.year 
+    assert_equal "Quate", sn.species.authors.first.last_name
+    assert_equal "Brown", sn.species.authors.last.last_name
+    assert_equal false, sn.species.parens
+  end
+
+  def test_new_from_simple_ampersand_parened_authors
+    string = 'Pericoma deceptrix (Quate & Brown, 2004)'
+    sn = Taxonifi::Model::SpeciesName.new_from_string(string)
+    assert_equal "Pericoma", sn.genus.name
+    assert_equal nil, sn.subgenus
+    assert_equal "deceptrix", sn.species.name
+    assert_equal nil, sn.subspecies
+    assert_equal 2004, sn.species.year 
+    assert_equal "Quate", sn.species.authors.first.last_name
+    assert_equal "Brown", sn.species.authors.last.last_name
+    assert_equal true, sn.species.parens
+  end
+
+
+
+
 end

data/travis/before_install.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+gem install bundler -v=1.9.4