taxonifi 0.1.0

data/test/helper.rb

@@ -0,0 +1,38 @@
+require 'rubygems'
+require 'bundler'
+require 'debugger'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'test/unit'
+#require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+class Test::Unit::TestCase
+end
+
+# TODO: rename to reflect format
+def generic_csv_with_names
+  @headers = %W{identifier parent child rank synonyms}
+  @csv_string = CSV.generate() do |csv|
+    csv <<  @headers
+    csv << [0, nil, "Root", "class", nil ]
+    csv << [1, "0", "Aidae", "Family", nil ]
+    csv << [2, "0", "Bidae", "Family", nil ]
+    csv << [3, "1", "Foo", "Genus", nil ]
+    csv << [4, "3", "Foo bar", "species", nil ]                                          # case testing
+    csv << [5, "4", "Foo bar bar", "species", nil ]                                      
+    csv << [6, "3", "Foo bar stuff (Guy, 1921)", "species", "Foo bar blorf (Guy, 1921)"] # initial subspecies rank data had rank blank, assuming they will be called species
+  end
+
+  @csv = CSV.parse(@csv_string, {headers: true})
+end
+

data/test/test_exporter.rb

@@ -0,0 +1,32 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/export/export')) 
+
+class Test_TaxonifiExports < Test::Unit::TestCase
+
+  def test_that_new_generic_export_can_be_instantiated
+    assert Taxonifi::Export::Base.new
+  end
+
+  def dont_test_that_species_file_export_does_stuff
+    csv = generic_csv_with_names
+    nc = Taxonifi::Lumper::Lumps::EolNameCollection.name_collection(csv)
+    e = Taxonifi::Export::SpeciesFile.new(:nc => nc, :authorized_user_id => 15)
+    assert foo = e.export
+  end 
+
+  def test_big_file
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'file_fixtures/Lygaeoidea.csv'))
+
+    csv = CSV.read(file, { 
+      headers: true,
+      col_sep: ",",
+      header_converters: :downcase
+    } ) 
+
+    nc = Taxonifi::Lumper::Lumps::ParentChildNameCollection.name_collection(csv)
+    e = Taxonifi::Export::SpeciesFile.new(:nc => nc, :authorized_user_id => 15)
+    assert foo = e.export
+  end
+
+end 
+

data/test/test_lumper_geogs.rb

@@ -0,0 +1,59 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+# Builder construction
+
+class Test_TaxonifiLumperGeogs < Test::Unit::TestCase
+
+  def setup
+    @headers = ["country", "state", "county"]
+    @csv_string = CSV.generate() do |csv|
+      csv <<  @headers
+      csv << ["Canada", "", nil]
+      csv << ["Canada", "Saskatchewan", nil]
+      csv << ["USA", "Texas", nil]
+      csv << ["USA", "Texas", "Brazos"]
+      csv << ["Utopia", nil, "Wonderland"]
+    end
+
+    # The row_index looks like this:
+    # 0
+    # 0 1
+    # 2 3 
+    # 2 3 4 
+    # 5 6  
+    #
+    # The name_index looks like
+    # {:country => {"Canada" => 0, "USA" => 2, "Utopia" => 5} ... etc.
+
+    @csv = CSV.parse(@csv_string, {headers: true})
+  end
+
+  def _create_a_collection
+    @gc = Taxonifi::Lumper.create_geog_collection(@csv)
+  end
+
+  def test_available_lumps
+     assert_equal [:basic_geog], Taxonifi::Lumper.available_lumps(@csv.headers)
+  end
+
+    def test_that_create_geog_collection_creates_a_geog_collection
+    gc = Taxonifi::Lumper.create_geog_collection(@csv)
+    assert_equal Taxonifi::Model::GeogCollection, gc.class
+  end
+
+  def test_that_create_geog_collection_instantiates_geogs
+    _create_a_collection 
+    assert_equal 7, @gc.collection.size
+    assert_equal "Canada", @gc.collection.first.name
+    assert_equal "Wonderland", @gc.collection.last.name
+  end
+
+  def test_that_create_geog_collection_assigns_parenthood
+    _create_a_collection 
+    assert_equal 0, @gc.collection[1].parent.id
+    assert_equal 5, @gc.collection[6].parent.id
+    assert_equal 3, @gc.collection[4].parent.id
+  end
+
+end 
+

data/test/test_lumper_hierarchical_collection.rb

@@ -0,0 +1,88 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/lumper/lumper')) 
+
+# Builder construction
+
+class Test_TaxonifiLumperHierarchicalCollection < Test::Unit::TestCase
+
+  def setup
+    @headers = ["a", "b", "c"]
+    @csv_string = CSV.generate() do |csv|
+      csv <<  @headers
+      csv << %w{a b c}
+    end
+
+    @csv = CSV.parse(@csv_string, {headers: true})
+  end
+
+  def test_that_create_hierarchical_collection_creates_collection
+    c = Taxonifi::Lumper.create_hierarchical_collection(@csv, %w{a b c},  )
+    assert_equal Taxonifi::Model::Collection, c.class
+  end
+
+  def test_that_a_hierarchical_collection_instantiates_generic_objects
+    c = Taxonifi::Lumper.create_hierarchical_collection(@csv, %w{a b c})
+    assert_equal Taxonifi::Model::GenericObject, c.collection.first.class
+  end
+
+  def test_that_collection_store_names
+    c = Taxonifi::Lumper.create_hierarchical_collection(@csv, %w{a b c})
+    assert_equal "a", c.collection.first.name
+    assert_equal "b", c.collection[1].name
+    assert_equal "c", c.collection[2].name
+  end
+
+  def test_that_header_order_is_applied
+    c = Taxonifi::Lumper.create_hierarchical_collection(@csv, %w{c a b})
+    assert_equal "c", c.collection.first.name
+    assert_equal "a", c.collection[1].name
+    assert_equal "b", c.collection[2].name
+  end
+
+  def test_that_parent_objects_are_assigned
+    c = Taxonifi::Lumper.create_hierarchical_collection(@csv, %w{a b c})
+    assert_equal nil, c.collection.first.parent
+    assert_equal "a", c.collection[1].parent.name
+    assert_equal "b", c.collection[2].parent.name
+  end
+
+  def test_that_parents_are_assigned_across_blank_columns
+    csv_string = CSV.generate() do |csv|
+      csv <<  @headers
+      csv << ["a", nil, "c"]
+    end
+    csv = CSV.parse(csv_string, {headers: true})
+    c = Taxonifi::Lumper.create_hierarchical_collection(csv, %w{a b c})
+    assert_equal nil, c.collection.first.parent
+    assert_equal "a", c.collection[1].parent.name
+  end
+
+  def test_that_names_at_rank_are_synonymous_when_parents_are_identical
+    csv_string = CSV.generate() do |csv|
+      csv <<  @headers
+      csv << ["a", "b", "c"]
+      csv << ["a", "b", "d"]
+      csv << ["e", "b", "f"]
+    end
+    csv = CSV.parse(csv_string, {headers: true})
+    c = Taxonifi::Lumper.create_hierarchical_collection(csv, %w{a b c})
+    assert_equal %w{a b c d e b f}, c.collection.collect{|o| o.name}
+    assert_equal 7, c.collection.size
+  end
+
+# def test_that_create_geog_collection_instantiates_geogs
+#   _create_a_collection 
+#   assert_equal 7, @gc.collection.size
+#   assert_equal "Canada", @gc.collection.first.name
+#   assert_equal "Wonderland", @gc.collection.last.name
+# end
+
+# def test_that_create_geog_collection_assigns_parenthood
+#   _create_a_collection 
+#   assert_equal 0, @gc.collection[1].parent.id
+#   assert_equal 5, @gc.collection[6].parent.id
+#   assert_equal 3, @gc.collection[4].parent.id
+# end
+
+end 
+

data/test/test_lumper_names.rb

@@ -0,0 +1,119 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/lumper/lumper')) 
+
+# Builder construction
+
+class Test_TaxonifiLumperNames < 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_that_setup_setups
+    assert_equal @headers, @csv.headers
+  end
+
+  def test_available_lumps_raise_without_arrays
+    assert_raises Taxonifi::Lumper::LumperError do
+      Taxonifi::Lumper.available_lumps( "foo" )
+    end
+  end
+
+  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) )
+  end
+
+  def test_create_name_collection_creates_a_name_collection
+    assert_equal Taxonifi::Model::NameCollection, Taxonifi::Lumper.create_name_collection(@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")
+    end
+  end
+
+  def test_that_create_name_collection_populates_a_name_collection
+    nc = Taxonifi::Lumper.create_name_collection(@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)
+    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)
+    assert_equal nc.collection[0], nc.collection[1].parent
+    assert_equal nc.collection[1], nc.collection[2].parent
+  end
+
+  def test_that_create_a_name_collection_handles_homonomy
+    string = CSV.generate() do |csv|
+      csv <<  @headers
+      csv << ["Fooidae", "Foo", "bar", "Smith", "1854"]
+      csv << ["Blorf",   "Foo", "bar", "Smith", "1854"]
+      csv << ["Fooidae", "Bar", "bar", "Smith", "1854"]
+    end
+
+    # The index should break down like this
+    # 0 2 5
+    # 1 3 6
+    # 0 4 7
+
+    csv = CSV.parse(string, {headers: true})
+    nc = Taxonifi::Lumper.create_name_collection(csv)
+
+    assert_equal nc.collection[2], nc.collection[5].parent
+    assert_equal nc.collection[0], nc.collection[2].parent
+    assert_equal nc.collection[1], nc.collection[3].parent
+    assert_equal nc.collection[3], nc.collection[6].parent
+    assert_equal nc.collection[0], nc.collection[4].parent
+    assert_equal nc.collection[4], nc.collection[7].parent
+  end
+
+
+  def test_that_create_a_name_collection_handles_author_year
+    string = CSV.generate() do |csv|
+      csv << %w{family genus species author_year}
+      csv << ["Fooidae", "Foo", "bar", "Smith, 1854"]
+      csv << ["Fooidae", "Foo", "foo", "(Smith, 1854)"]
+    end
+   
+    # 0  Fooidae
+    # 1  Foo
+    # 2  bar
+    # 3  foo 
+
+    csv = CSV.parse(string, {headers: true})
+    nc = Taxonifi::Lumper.create_name_collection(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
+
+    # 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

@@ -0,0 +1,41 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class Test_TaxonifiLumperParentChildNameCollection < Test::Unit::TestCase
+
+  def setup
+    @headers = %W{identifier parent child rank synonyms}
+    @csv_string = CSV.generate() do |csv|
+      csv <<  @headers
+      csv << [0, nil, "Root", "class", nil ]
+      csv << [1, "0", "Aidae", "Family", nil ]
+      csv << [2, "1", "Foo", "Genus", nil ]
+      csv << [3, "2", "Foo bar", "species", nil ]                                          # case testing
+      csv << [4, "2", "Foo bar stuff (Guy, 1921)", "species", "Foo bar blorf (Guy, 1921)"] # initial subspecies rank data had rank blank, assuming they will be called species
+      csv << [5, "0", "Bidae", "Family", nil ]
+    end
+
+    @csv = CSV.parse(@csv_string, {headers: true})
+  end
+
+  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
+    assert_equal Taxonifi::Model::NameCollection, @nc.class
+  end
+
+  def test_that_higher_taxon_names_are_created
+    _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
+    assert @nc.names_at_rank("species").collect{|n| n.name}.include?("bar") 
+    assert_equal 1, @nc.names_at_rank("genus").size 
+    assert @nc.names_at_rank("subspecies").collect{|n| n.name}.include?("stuff") 
+    assert @nc.names_at_rank("subspecies").collect{|n| n.name}.include?("blorf") 
+  end
+
+end 
+

data/test/test_lumper_refs.rb

@@ -0,0 +1,91 @@
+require 'helper'
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/lumper/lumper')) 
+
+# Builder construction
+
+class Test_TaxonifiLumperRefs < Test::Unit::TestCase
+
+  def setup
+    @headers = ["authors", "year", "title", "publication", "pg_start", "pg_end",  "pages", "cited_page"  ,"volume", "number", "volume_number"]
+    @csv_string = CSV.generate() do |csv|
+      csv <<  @headers
+      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})
+  end
+
+  def test_available_lumps
+     assert_equal [:citation_basic, :citation_small], Taxonifi::Lumper.available_lumps(@csv.headers)
+  end
+
+  def test_intersecting_lumps
+    headers = ["authors"]
+      csv_string = CSV.generate() do |csv|
+        csv <<  headers
+        csv << ["Smith J. and Barnes S."]
+      end
+
+     csv = CSV.parse(csv_string, {headers: true})
+
+     assert_equal [:citation_basic, :citation_small], Taxonifi::Lumper.intersecting_lumps(csv.headers)
+     assert_equal [], Taxonifi::Lumper.available_lumps(csv.headers)
+  end
+
+  def test_create_ref_collection
+    assert_equal Taxonifi::Model::RefCollection, Taxonifi::Lumper.create_ref_collection(@csv).class
+  end
+
+  def test_creates_refs
+    assert_equal 1, Taxonifi::Lumper.create_ref_collection(@csv).collection.size
+  end
+
+  def test_assigns_attributes_to_instantiated_refs
+    rc = Taxonifi::Lumper.create_ref_collection(@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
+    assert_equal "Bar and foo", rc.collection.first.title
+    assert_equal "Journal of Foo", rc.collection.first.publication
+    assert_equal "2", rc.collection.first.volume
+    assert_equal "4", rc.collection.first.number
+    assert_equal "2", rc.collection.first.pg_start
+    assert_equal "3", rc.collection.first.pg_end
+  end
+
+  def test_indexes_unique_refs
+    csv_string = CSV.generate() do |csv|
+      csv <<  @headers
+      csv << ["Smith J. and Barnes S.", "2012", "Bar and foo", "Journal of Foo", "2", "3", "2-3, 190", nil, "2", "4", "2(4)" ]
+      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)
+    assert_equal 1, rc.collection.size
+  end
+
+  def test_indexes_unique_refs2
+    csv_string = CSV.generate() do |csv|
+      csv <<  @headers
+      csv << ["Smith J. and Barnes S.", "2012", "Bar and foo", "Journal of Foo", "2", "3", "2-3, 190", nil, "2", "4", "2(4)" ]
+      csv << ["Smith J. and Barnes S.", "2012", "Bar and foo", "Journal of Foo", "2", "3", "2-3, 190", nil, "2", "4", "2(4)" ]
+      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)
+    assert_equal 2, rc.collection.size
+  end
+
+  def test_that_refs_can_be_returned_by_row
+   csv_string = CSV.generate() do |csv|
+      csv <<  @headers
+      csv << ["Smith J. and Barnes S.", "2012", "Bar and foo", "Journal of Foo", "2", "3", "2-3, 190", nil, "2", "4", "2(4)" ]
+      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)
+    assert_equal "Foo and bar", rc.object_from_row(1).title
+  end
+
+end 
+

data/test/test_parser.rb

@@ -0,0 +1,34 @@
+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 false, builder.names.last.parens
+
+      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 true, builder.names.last.parens
+  end
+
+end 
+

data/test/test_splitter.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/splitter/splitter')) 
+
+class SplitterTest < Test::Unit::TestCase
+  def test_truth
+    assert true
+  end
+end
+
+class Test_TaxonifiSplitterLexer < Test::Unit::TestCase
+
+  def test_that_vanilla_new_succeed
+    assert lexer = Taxonifi::Splitter::Lexer.new("foo")
+  end
+
+  def test_that_lexer_can_only_be_passed_valid_token_lists
+    assert_raises Taxonifi::Splitter::SplitterError do
+      lexer = Taxonifi::Splitter::Lexer.new("foo", :bar)
+    end
+  end
+
+  def test_that_lexer_can_be_created_with_token_list_subsets
+    assert lexer = Taxonifi::Splitter::Lexer.new("foo")
+  end
+
+end 
+