taxonifi 0.1.0

data/test/test_taxonifi_name.rb

@@ -0,0 +1,186 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/models/name')) 
+
+class TestTaxonifiName < Test::Unit::TestCase
+
+  def test_truth
+    assert(true)
+  end
+
+  def test_new_name
+    assert n = Taxonifi::Model::Name.new() 
+  end
+
+  def test_that_name_has_a_name
+    n = Taxonifi::Model::Name.new() 
+    assert n.respond_to?(:name)
+  end
+
+  def test_that_name_has_an_id
+    n = Taxonifi::Model::Name.new() 
+    assert n.respond_to?(:id)
+  end
+
+  def test_that_name_has_a_parent
+    n = Taxonifi::Model::Name.new() 
+    assert n.respond_to?(:parent) 
+  end
+
+  def test_that_name_has_a_rank
+    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) 
+  end
+
+  def test_that_name_returns_false_with_bad_rank
+    n = Taxonifi::Model::Name.new() 
+    assert_raise Taxonifi::NameError do
+      n.rank = "FOO"
+    end 
+  end
+
+  def test_that_name_allows_legal_rank
+    n = Taxonifi::Model::Name.new() 
+    assert n.rank = "genus"
+  end
+
+  def test_that_name_rank_is_case_insensitive
+    n = Taxonifi::Model::Name.new() 
+    assert n.rank = "Genus"
+    assert n.rank = "GENUS"
+  end
+
+  def test_that_rank_is_required_before_parent
+    n = Taxonifi::Model::Name.new() 
+    assert_raise Taxonifi::NameError do
+      n.parent = Taxonifi::Model::Name.new() 
+    end
+  end
+
+  def test_that_parent_is_a_taxonifi_name
+    n = Taxonifi::Model::Name.new() 
+    n.rank = "genus" # avoid that raise
+    assert_raise Taxonifi::NameError do
+      n.parent = "foo"
+    end
+  end
+
+ 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"
+    p = Taxonifi::Model::Name.new() 
+    p.rank = "species"
+    assert_raise Taxonifi::NameError do
+      n.parent = p
+    end
+  end
+
+  def test_that_parent_can_be_set
+    n = Taxonifi::Model::Name.new() 
+    n.rank = "genus"
+    p = Taxonifi::Model::Name.new() 
+    p.rank = "species"
+    assert p.parent = n
+    assert_equal "genus", p.parent.rank
+  end
+
+  def test_that_attributes_can_be_assigned_on_new
+    n0 = Taxonifi::Model::Name.new(:name => "Baridae", :rank => "Family")
+    n = Taxonifi::Model::Name.new(:name => "Foo", :rank => "Genus", :author => "Frank", :year => 2020, :parent => n0)
+    assert_equal "Foo", n.name
+    assert_equal "genus", n.rank
+    assert_equal 2020, n.year
+    assert_equal "Frank", n.author
+    assert_equal n0, n.parent
+  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 )
+  end
+
+  def test_ancestors
+    create_a_few_names 
+    assert_equal [@n0, @n1], @n2.ancestors
+  end
+
+  def test_ancestor_ids
+    create_a_few_names 
+    assert_equal [2,15], @n2.ancestor_ids
+  end
+
+  def test_parent_ids_sf_style
+    create_a_few_names 
+    assert_equal '2-15-14g-19s-11', @n4.parent_ids_sf_style
+    assert_equal '2-15-14g-19s', @n3.parent_ids_sf_style
+    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
+
+  # 
+  # ICZN Subclass
+  #
+  
+  def test_that_iczn_family_ends_in_idae
+    n = Taxonifi::Model::IcznName.new
+    assert_raise Taxonifi::NameError do
+      n.rank = "family"
+      n.name = "Foo"
+    end
+  end
+
+  def test_that_iczn_subfamily_ends_in_inae
+    n = Taxonifi::Model::IcznName.new
+    assert_raise Taxonifi::NameError do
+      n.rank = "subfamily"
+      n.name = "Foo"
+    end
+  end
+
+  def test_that_iczn_tribe_ends_in_ini
+    n = Taxonifi::Model::IcznName.new
+    assert_raise Taxonifi::NameError do
+      n.rank = "tribe"
+      n.name = "Foo"
+    end
+  end
+
+  def test_that_iczn_subtribe_ends_in_ina
+    n = Taxonifi::Model::IcznName.new
+    assert_raise Taxonifi::NameError do
+      n.rank = "subtribe"
+      n.name = "Foo"
+    end
+
+    assert n.name = "Fooina"
+  end
+
+
+
+
+
+end

data/test/test_taxonifi_name_collection.rb

@@ -0,0 +1,158 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/models/name_collection')) 
+
+class TestTaxonifiNameCollection < Test::Unit::TestCase
+
+  def test_that_add_objects_adds_to_collection
+    c = Taxonifi::Model::NameCollection.new
+    n = Taxonifi::Model::Name.new
+    assert c.add_object(n)
+    assert_equal(1, c.collection.size)
+  end
+
+  def test_that_name_collections_have_collections
+    c = Taxonifi::Model::NameCollection.new
+    assert c.respond_to?(:collection)
+    assert_equal([], c.collection)
+  end
+
+  def test_that_name_collection_returns_encompassing_rank
+    c = Taxonifi::Model::NameCollection.new
+    n = Taxonifi::Model::Name.new
+    n.rank = 'species'  
+    c.add_object(n)
+    assert_equal 'subgenus', c.encompassing_rank 
+  end
+
+  def test_names_at_rank_returns_names
+    c = Taxonifi::Model::NameCollection.new
+    n = Taxonifi::Model::Name.new
+    n.rank = 'species'  
+    c.add_object(n)
+
+    n1 = Taxonifi::Model::Name.new
+    n1.rank = 'species'  
+    c.add_object(n1)
+
+    assert_equal 2, c.names_at_rank('species').size 
+  end
+
+  def test_that_add_objects_tests_for_existing_name_id_and_raises
+    c = Taxonifi::Model::NameCollection.new
+    n = Taxonifi::Model::Name.new
+    n.rank = 'species'  
+    n.id = 1 
+    assert_raise Taxonifi::CollectionError do
+      c.add_object(n)
+    end
+  end
+
+  def test_that_current_free_id_is_incremented
+    c = Taxonifi::Model::NameCollection.new
+    n = Taxonifi::Model::Name.new
+    assert_equal 0, c.current_free_id
+    c.add_object(n)
+    assert_equal 1, c.current_free_id
+  end
+
+  def test_that_by_id_index_is_built
+    c = Taxonifi::Model::NameCollection.new
+    n = Taxonifi::Model::Name.new
+    assert_equal 0, c.current_free_id
+    c.add_object(n)
+    assert_equal ({0 => n}), c.by_id_index
+  end
+
+  def test_that_object_by_id_returns
+    c = Taxonifi::Model::NameCollection.new
+    n = Taxonifi::Model::Name.new
+    n.rank = 'species'  
+    id = c.add_object(n).id
+    assert_equal id, c.object_by_id(id).id
+  end
+
+  def test_that_parent_id_vector_returns_a_id_vector
+    c = Taxonifi::Model::NameCollection.new
+
+    n1 = Taxonifi::Model::Name.new(:name => "Fooidae", :rank => "family")
+    n2 = Taxonifi::Model::Name.new(:name => "Bar",     :rank => "genus")
+    n3 = Taxonifi::Model::Name.new(:name => "blorf",   :rank => "species")
+
+    assert_equal "family",  n1.rank
+    assert_equal "genus",   n2.rank
+    assert_equal "species", n3.rank
+
+    c.add_object(n1)
+    c.add_object(n2)
+    c.add_object(n3)
+
+    assert_equal 0, n1.id
+    assert_equal 1, n2.id
+    assert_equal 2, n3.id
+
+
+    n3.parent = n2
+    n2.parent = n1
+
+    #  c.object_by_id(2).parent = c.object_by_id(1)
+    #  c.object_by_id(1).parent = c.object_by_id(0)
+
+    assert_equal [0,1], c.parent_id_vector(2)
+    assert_equal [0], c.parent_id_vector(1)
+  end 
+
+  def test_that_name_collection_indexes_by_name_as_well_as_id
+    c = Taxonifi::Model::NameCollection.new
+    n1 = Taxonifi::Model::Name.new(:name => "Fooidae", :rank => "family")
+    c.add_object(n1) 
+    assert_equal "Fooidae", c.by_name_index['family'].keys.first
+  end
+
+  def test_name_exists?
+    c = Taxonifi::Model::NameCollection.new
+    n1 = Taxonifi::Model::Name.new(:name => "Fooidae", :rank => "family")
+    n2 = Taxonifi::Model::Name.new(:name => "Bar",     :rank => "genus", :parent => n1)
+    n3 = Taxonifi::Model::Name.new(:name => "Bar",     :rank => "genus", :parent => n1)
+    n4 = Taxonifi::Model::Name.new(:name => "Bar",     :rank => "subgenus", :parent => n2)
+    n5 = Taxonifi::Model::Name.new(:name => "foo",     :rank => "species", :parent => n2)
+    n6 = Taxonifi::Model::Name.new(:name => "foo",     :rank => "species", :parent => n2)
+    c.add_object(n1) 
+    c.add_object(n2) 
+    c.add_object(n5) 
+    assert c.name_exists?(n3), "Name exists, but not caught."
+    assert c.name_exists?(n6), "Name exists, but not caught."
+    assert !c.name_exists?(n4), "Name doesn't exist, but asserted to."
+    assert_equal n2.id, c.name_exists?(n3) 
+  end
+
+  def test_that_name_collection_generate_ref_collection
+    c = Taxonifi::Model::NameCollection.new
+    c.generate_ref_collection
+    assert rc = c.ref_collection
+    assert_equal Taxonifi::Model::RefCollection,  rc.class
+  end 
+
+  def test_that_name_collection_populates_ref_collection
+    c = Taxonifi::Model::NameCollection.new
+    n1 = Taxonifi::Model::Name.new(:name => "Fooidae", :rank => "family", :author => "Smith and Jones", :year => 2002)
+    n2 = Taxonifi::Model::Name.new(:name => "Bar",     :rank => "genus", :parent => n1)
+    n3 = Taxonifi::Model::Name.new(:name => "foo",     :rank => "species", :parent => n2, :author => "Smith, Jones and Simon", :year => 2012)
+    n4 = Taxonifi::Model::Name.new(:name => "bar",     :rank => "species", :parent => n2, :author => "Jones", :year => 2011)
+    n5 = Taxonifi::Model::Name.new(:name => "blorf",   :rank => "species", :parent => n2, :author => "Jones", :year => 2011)
+
+    [n1,n2,n3,n4].each do |n| 
+      c.add_object(n) 
+    end
+
+    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
+    foo = 1
+  end
+
+end
+

data/test/test_taxonifi_ref.rb

@@ -0,0 +1,90 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/models/ref')) 
+
+class TestTaxonifiRef < Test::Unit::TestCase
+
+  def test_new_ref
+    assert n = Taxonifi::Model::Ref.new() 
+  end
+
+  def test_that_a_ref_has_authors
+    n = Taxonifi::Model::Ref.new() 
+    assert n.respond_to?(:authors)
+  end
+
+  def test_that_a_ref_has_title
+    n = Taxonifi::Model::Ref.new() 
+    assert n.respond_to?(:title)
+  end
+
+  def test_that_a_ref_has_year
+    n = Taxonifi::Model::Ref.new() 
+    assert n.respond_to?(:year)
+  end
+
+  def test_that_a_ref_has_publication
+    n = Taxonifi::Model::Ref.new() 
+    assert n.respond_to?(:publication)
+  end
+
+  def test_that_a_ref_has_volume_year
+    n = Taxonifi::Model::Ref.new() 
+    assert n.respond_to?(:volume)
+    assert n.respond_to?(:year)
+  end
+
+  def test_that_a_ref_has_page_fields
+    n = Taxonifi::Model::Ref.new() 
+    assert n.respond_to?(:pg_start)
+    assert n.respond_to?(:pg_end)
+    assert n.respond_to?(:pages)
+    assert n.respond_to?(:cited_page)
+  end
+
+  def create_a_ref
+    @ref = Taxonifi::Model::Ref.new(
+                                 :authors => [Taxonifi::Model::Person.new(:last_name => "Foo", :initials => "AC")],  
+                                 :year => 2012,
+                                 :title => "Place to be",
+                                 :publication => "Journal Du Jour",
+                                 :pg_start => 1,
+                                 :pg_end => 2,
+                                 :volume => 3,
+                                 :number => 4
+                                )
+  end
+
+  def test_identical?
+    create_a_ref
+    foo = @ref.clone
+    bar = @ref.clone
+    assert foo.identical?(bar)
+    bar.title = "Foo"
+    assert !foo.identical?(bar)
+  end
+
+  def test_that_ref_assigns_passed_options
+    create_a_ref
+    assert_equal "Place to be", @ref.title
+    assert_equal 4, @ref.number
+  end
+
+  def test_that_compact_string_is_compact
+    create_a_ref
+    assert_equal '|ac|foo||2012|placetobe|journaldujour|3|4||1|2|', @ref.compact_string
+  end
+
+  def test_that_author_year_strings_translate_to_author_years
+    r = Taxonifi::Model::Ref.new(:author_year => 'Smith and Jones, 1920')
+    assert_equal 2, r.authors.size 
+    assert_equal 1920, r.year
+  end
+
+  def test_author_year_index
+    r = Taxonifi::Model::Ref.new(:author_year => 'Smith and Jones, 1920')
+    assert_equal '1920-||smith|-||jones|', r.author_year_index
+  end
+
+
+
+end

data/test/test_taxonifi_ref_collection.rb

@@ -0,0 +1,69 @@
+require 'helper'
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/models/ref_collection')) 
+
+class TestTaxonifiCollection < Test::Unit::TestCase
+
+  def test_that_add_objects_adds_refs
+    c = Taxonifi::Model::RefCollection.new
+    n = Taxonifi::Model::Ref.new
+    assert c.add_object(n)
+    assert_equal(1, c.collection.size)
+  end
+
+  def test_that_ref_collections_have_refs
+    c = Taxonifi::Model::RefCollection.new
+    assert c.respond_to?(:collection)
+    assert_equal([], c.collection)
+  end
+
+  def test_that_add_objects_tests_for_existing_ref_id_and_raises
+    c = Taxonifi::Model::RefCollection.new
+    n = Taxonifi::Model::Ref.new
+    n.id = 1 
+    assert_raise Taxonifi::CollectionError do
+      c.add_object(n)
+    end
+  end
+  
+  def test_that_current_free_id_is_incremented
+    c = Taxonifi::Model::RefCollection.new
+    n = Taxonifi::Model::Ref.new
+    assert_equal 0, c.current_free_id
+    c.add_object(n)
+    assert_equal 1, c.current_free_id
+  end
+
+  def test_that_by_id_index_is_built
+    c = Taxonifi::Model::RefCollection.new
+    n = Taxonifi::Model::Ref.new
+    assert_equal 0, c.current_free_id
+    c.add_object(n)
+    assert_equal ({0 => n}), c.by_id_index
+  end
+
+  def test_that_object_by_id_returns
+    c = Taxonifi::Model::RefCollection.new
+    n = Taxonifi::Model::Ref.new
+    id = c.add_object(n).id
+    assert_equal id, c.object_by_id(id).id
+  end
+
+  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|
+      n = Taxonifi::Model::Ref.new(:author_year => a)
+      c.add_object(n)
+    end
+    assert_equal 4, c.unique_authors.size
+    assert_not_equal c.collection.first.authors.first, c.collection[1].authors.last
+    c.uniquify_authors(5)
+    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
+
+
+
+end
+

data/test/test_taxonifi_species_name.rb

@@ -0,0 +1,95 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/models/species_name')) 
+
+class TestTaxonifiSpeciesName < Test::Unit::TestCase
+
+  def test_truth
+    assert(true)
+  end
+
+  def test_new_name
+    assert n = Taxonifi::Model::SpeciesName.new() 
+  end
+
+  def test_that_name_has_a_genus
+    assert n = Taxonifi::Model::SpeciesName.new() 
+    assert n.respond_to?(:genus)
+  end
+
+  def test_that_name_has_a_subgenus
+    assert n = Taxonifi::Model::SpeciesName.new() 
+    assert n.respond_to?(:subgenus)
+  end
+
+  def test_that_name_has_a_species
+    assert n = Taxonifi::Model::SpeciesName.new() 
+    assert n.respond_to?(:species)
+  end
+
+  def test_that_name_has_a_sub_species
+    assert n = Taxonifi::Model::SpeciesName.new() 
+    assert n.respond_to?(:subspecies)
+  end
+
+  def test_that_parent_is_a_taxonifi_name
+    n = Taxonifi::Model::SpeciesName.new() 
+    assert_raise Taxonifi::SpeciesNameError do
+      n.parent = "foo"
+    end
+  end
+
+  def test_that_parent_rank_must_be_higher_than_genus
+    n = Taxonifi::Model::SpeciesName.new() 
+    p = Taxonifi::Model::Name.new() 
+    p.rank = "species"
+    assert_raise Taxonifi::SpeciesNameError do
+      n.parent = p
+    end
+  end
+
+  def test_that_names_are_taxonifi_names
+    p = Taxonifi::Model::Name.new() 
+  end
+
+  def test_that_genus_must_be_assigned_before_species
+    n = Taxonifi::Model::Name.new(:rank => 'species', :name => "foo")
+
+    assert_raise Taxonifi::SpeciesNameError do
+      sn = Taxonifi::Model::SpeciesName.new(:species => n) 
+    end
+
+    n.rank = 'genus'
+    n.name = 'Foo'
+
+    assert sn = Taxonifi::Model::SpeciesName.new(:genus => n) 
+  end
+
+  def test_that_species_must_be_assigned_before_subspecies
+    n = Taxonifi::Model::Name.new(:rank => 'subspecies', :name => "foo")
+    g = Taxonifi::Model::Name.new(:rank => 'genus', :name => "species")
+
+    assert_raise Taxonifi::SpeciesNameError do
+      sn = Taxonifi::Model::SpeciesName.new(:subspecies => n, :genus => g) 
+    end
+  end
+
+  def test_display_name_formatting
+    g  = Taxonifi::Model::Name.new(:rank => 'genus', :name => "Foo")
+    sg = Taxonifi::Model::Name.new(:rank => 'subgenus', :name => "Bar")
+    s  = Taxonifi::Model::Name.new(:rank => 'species', :name => "stuff")
+    ss = Taxonifi::Model::Name.new(:rank => 'subspecies', :name => "things", :author => "Jones", :year => 2012 )
+   
+    sn1 = Taxonifi::Model::SpeciesName.new(:genus => g, :species => s) 
+    assert_equal "Foo stuff", sn1.display_name
+
+    sn2 = Taxonifi::Model::SpeciesName.new(:genus => g, :subgenus => sg, :species => s) 
+    assert_equal "Foo (Bar) stuff", sn2.display_name
+
+    sn3 = Taxonifi::Model::SpeciesName.new(:genus => g, :subgenus => sg, :species => s, :subspecies => ss) 
+    assert_equal "Foo (Bar) stuff things Jones, 2012", sn3.display_name
+  
+    ss.parens = false
+    assert_equal "Foo (Bar) stuff things (Jones, 2012)", sn3.display_name
+  end
+
+end