taxonifi 0.2.0 → 0.3.2

data/lib/model/ref_collection.rb

@@ -0,0 +1,171 @@
+module Taxonifi
+  class RefCollectionError < StandardError; end
+
+  module Model
+
+    # A collection of references.
+    class RefCollection < Taxonifi::Model::Collection
+
+      # An options index when there is one reference per row.
+      # A Hash.  {:row_number => Ref
+      attr_accessor :row_index
+     
+      # A Hash. Keys are  Ref#id, values are an Array of Person#ids.  
+      # Built on request.
+      attr_accessor :author_index 
+
+      def initialize(options = {})
+        super
+        @row_index = []
+        @author_index = {}
+        @fingerprint_index = {}
+        true
+      end 
+
+      # The instance collection class.
+      def object_class
+        Taxonifi::Model::Ref  
+      end
+        
+      # The object at a given row.
+      # TODO: inherit from Collection? 
+      def object_from_row(row_number)
+        return nil if row_number.nil?
+        @row_index[row_number]
+      end
+
+      # Incrementally (re-)assigns the id of every associated author (Person) 
+      # This is only useful if you assume every author is unique.
+      def enumerate_authors(initial_id = 0)
+        i = initial_id 
+        collection.each do ||r
+          r.authors.each do |a|
+            a.id = i
+            i += 1
+          end
+        end
+      end
+
+      # Finds unique authors, and combines them, then 
+      # rebuilds author lists using references to the new unique set.
+      def uniquify_authors(initial_id = 0)
+
+        matching_index = {
+          # ref_id => { 'ref_string_fingerprint' => [author_position in Ref.authors]} 
+        }
+
+        author_fingerprints = {}
+
+        # First pass, build matching array
+        collection.each do |r|
+          # Check for, and modify where necessary, Authors that are clearly not unique because
+          # they are replicated names in a author string, e.g. "Sweet and Sweet". 
+          matching_index[r.id] = {}
+          r.authors.each_with_index do |a,i|
+            id = a.compact_string
+            if matching_index[r.id][id]
+              matching_index[r.id][id].push(i)
+            else
+              matching_index[r.id][id] = [i]
+            end
+          end
+        end
+
+        # Next pass, modify names of necessarily unique authors so
+        # their fingerprint is unique.  Note we do not differentiate
+        # b/w sequential sets.
+        # E.g. if we have 5 names like so:
+        # Quate [1] and Quate [2]
+        # Quate [3], Smith [4] and Quate [5]
+        # Then [1,3], [2,5] become the same Person in this process.  We can not
+        # of course differentiate order, or if a 3rd "Quate" is present here given
+        # only this information.  Later on we might use Year of publication, or something
+        # similar to further "guess".
+        collection.each do |r|
+          matching_index[r.id].keys.each do |i|
+            if matching_index[r.id][i].size > 1
+              matching_index[r.id][i].each_with_index do |j,k|
+                # puts "uniquifying:" + "\_#{k}\_#{r.authors[j].last_name}"
+                r.authors[j].last_name = "\_#{k}\_#{r.authors[j].last_name}"
+              end
+            end
+          end
+        end
+
+        # Generate new authors based on identity 
+        authors = [] 
+        collection.each do |r|
+          r.authors.each do |a|
+            found = false
+            authors.each do |x|
+              if a.identical?(x)
+                found = true 
+                next           
+              end
+            end
+            if not found
+              authors.push a.clone
+            end
+          end
+        end
+
+        # Sequentially number the new authors, and index them.
+        auth_index = {}
+        authors.each_with_index do |a, i|
+          a.id = i + initial_id
+          auth_index.merge!(a.compact_string => a)
+        end
+       
+        # Replace old authors with newly built/sequntially id'ed authors 
+        collection.each do |r|
+          new_authors = []
+          r.authors.inject(new_authors){|ary, a| ary.push(auth_index[a.compact_string])}
+          r.authors = new_authors
+        end
+
+        # Remove the modifications that made authors unique 
+        # Crude to loop those unnecessary, but clean
+        authors.each do |a|
+          a.last_name.gsub!(/\_\d+\_/, '')
+        end
+
+        true 
+      end
+
+      # Build the author index. 
+      #   {Ref#id => [a1#id, ... an#id]}
+      def build_author_index
+        collection.each do |r|
+          @author_index.merge!(r.id => r.authors.collect{|a| a.id ? a.id : -1})
+        end
+      end
+
+      # Return an Array the unique author strings in this collection. 
+      def unique_author_strings
+        auths = {}
+        collection.each do |r|
+          r.authors.each do |a|
+            auths.merge!(a.display_name => nil)
+          end
+        end
+        auths.keys.sort
+      end
+
+      # Returns Array of Taxonifi::Model::Person
+      # !! Runs uniquify first. Careful, you might not want to do this
+      # !! unless you understand the consequences.
+      def unique_authors
+        uniquify_authors
+        all_authors
+      end    
+
+
+      # Returns Array of Taxonifi::Model::Person
+      def all_authors
+        @collection.collect{|r| r.authors}.flatten.compact.uniq
+      end 
+
+    end
+  end
+
+end

data/lib/{models → model}/species_name.rb

@@ -8,7 +8,7 @@ module Taxonifi
     # Taxonifi::Model::Names have no ids!  
 
     class SpeciesName < Taxonifi::Model::Base
-      ATTRIBUTES = [:genus, :subgenus, :species, :subspecies, :parent]
+      ATTRIBUTES = [:genus, :subgenus, :species, :subspecies, :variety, :parent]
       ATTRIBUTES.each do |a|
         attr_accessor a
       end
@@ -20,6 +20,20 @@ module Taxonifi
         true
       end 
 
+      # Create a new SpeciesName from a string format
+      # TODO: Is this replicated somewhere else?
+      # Examples: 
+      #   Taxonifi::Model::SpeciesName.new_from_string('Aus bus Smith, 1920')
+      #   Taxonifi::Model::SpeciesName.new_from_string('Aus (Cus) bus dus (Smith, 1920)')
+      def self.new_from_string(name)
+        raise Taxonifi::SpeciesNameError, "No name passed to SpeciesName.new_from_string" if name.nil? || name.length == 0 
+        #  Appears to be a validly formatted species epithet at this point.
+        lexer = Taxonifi::Splitter::Lexer.new(name, :species_name)
+        builder = Taxonifi::Model::SpeciesName.new
+        Taxonifi::Splitter::Parser.new(lexer, builder).parse_species_name
+        builder
+      end
+
       # Set the genus name.
       def genus=(genus)
         @genus = genus
@@ -46,6 +60,13 @@ module Taxonifi
         @subspecies.parent = @species
       end
 
+      # Set the variety name.
+      def variety=(variety)
+        raise Taxonifi::SpeciesNameError, "Varieties name must have a species name before variety can be assigned" if @species.nil? 
+        @variety = variety 
+        @variety.parent = (@subspecies ? @subspecies : @species)
+      end
+
       # Set the parent name.
       def parent=(parent)
         if parent.class != Taxonifi::Model::Name
@@ -72,12 +93,12 @@ module Taxonifi
       end
 
       # Returns true if this combination contains a nominotypic subspecies name 
-      def nominotypical_species
+      def nominotypical_species?
         names.species && names.subspecies && (names.species.name == names.subspecies.name)
       end
 
       # Returns true if this combinations contains a nominotypic subgenus 
-      def nominotypical_genus
+      def nominotypical_genus?
         names.genus && names.subgenus && (names.genus.name == names.subgenus.name)
       end
 

data/lib/splitter/builder.rb

@@ -3,7 +3,7 @@ module Taxonifi::Splitter::Builder
 
     # Load all builders (= models)
     #  TODO: perhaps use a different scope that doesn't require loading all at once
-    Dir.glob( File.expand_path(File.join(File.dirname(__FILE__), "../models/*.rb") )) do |file|
+    Dir.glob( File.expand_path(File.join(File.dirname(__FILE__), "../model/*.rb") )) do |file|
       require file
     end
 

data/lib/splitter/parser.rb

@@ -39,6 +39,11 @@ class Taxonifi::Splitter::Parser
       @builder.send("#{r}=", Taxonifi::Model::Name.new(:name => t.send(r), rank: r) ) if t.send(r)
     end
 
+    if @lexer.peek(Taxonifi::Splitter::Tokens::Variety)
+      t = @lexer.pop(Taxonifi::Splitter::Tokens::Variety)
+      @builder.variety = Taxonifi::Model::Name.new(:name => t.variety, rank: 'variety')  
+    end
+
     if @lexer.peek(Taxonifi::Splitter::Tokens::AuthorYear)
       t = @lexer.pop(Taxonifi::Splitter::Tokens::AuthorYear)
       @builder.names.last.author = t.authors

data/lib/splitter/tokens.rb

@@ -63,8 +63,8 @@ module Taxonifi::Splitter::Tokens
     end
   end
 
-  # Complex breakdown of author strings. Handles
-  # a wide variety of formats.   
+  # Complex breakdown of author strings.
+  # Handles a wide variety of formats.   
   # See test_splitter_tokens.rb for scope. As with
   # AuthorYear this will match just about anything when used alone.
   # Add exceptions at will, just test using TestSplittTokens#test_authors.
@@ -103,6 +103,33 @@ module Taxonifi::Splitter::Tokens
         str = nil
       end
 
+      # Look for an exception case.  Last name, commas, no and.  The idea is to decompose and
+      # have nothing left, if possible then the match is good.
+      if str && !naked_and && (str.split(",").size > 1) && (str =~ /[A-Z]\./)
+        test_str = str.clone 
+        ok = true 
+        pseudo_individuals = test_str.split(",").collect{|i| i.strip}
+        pseudo_individuals.each do |pi|
+          # All names must be identically formatted in this special case.
+          if pi =~ /(([A-Z][a-z]+)\s*(([A-Z]\.\s*)+))/
+            if not($1 == pi)
+              ok = false
+            end
+          else
+            ok = false
+          end
+          test_str.gsub!(/#{Regexp.quote(pi)}/, "")
+        end
+        
+        if ok 
+          test_str.gsub!(/\s*/, "") 
+          if test_str.split(//).uniq == [","]
+            individuals = pseudo_individuals
+            str = nil 
+          end
+        end
+      end
+
       prefix = ['van den ', 'Van ', "O'", "Mc", 'Campos ', 'Costa ']
       pre_reg = prefix.collect{|p| "(#{Regexp.escape(p)})?"}.join
 
@@ -135,7 +162,7 @@ module Taxonifi::Splitter::Tokens
         while parsing
           individual = ''
           check_for_more_individuals = false
-          [m2, m1].each do |regex|
+          [ m2, m1].each do |regex|
             if str =~ regex
               individual = $1
               str.slice!(individual)
@@ -165,7 +192,7 @@ module Taxonifi::Splitter::Tokens
 
       individuals.push(last_individual) if !last_individual.nil?
       individuals.flatten!
-
+      
       # At this point we have isolated individuals.  Strategy is to slice out initials and remainder is last name.
       # Initials regex matches any A-B. A. or " A ", "A-B" pattern (including repeats) 
       # TODO: Make a Token
@@ -257,11 +284,13 @@ module Taxonifi::Splitter::Tokens
   #   Foo stuff von Helsing, 1920
   class Quadrinomial < Token
     attr_reader :genus, :subgenus, :species, :subspecies
-    @regexp = Regexp.new(/\A\s*(([A-Z][^\s]+)\s*(\([A-Z][a-z]+\))?\s?([a-z][^\s]+)?\s?([a-z][^\s]+)?)\s*/)
+  
+    # Makes use of negative look ahead for a a period ( (?!\.) ) at the end of a word bounder (\b). 
+    @regexp = Regexp.new(/\A\s*(([A-Z][^\s]+\w)\s*(\([A-Z][a-z]+\))?\s?([a-z][^\s]+(?!\.))?\s?([a-z][^\s]*(?!\.)\b)?)\s*/)
 
     def initialize(str)
       str.strip 
-      str =~ /\A\s*([A-Z][^\s]+)\s*(\([A-Z][a-z]+\))?\s?([a-z][^\s]+)?\s?([a-z][^\s]+)?\s*/i
+      str =~ /\A\s*([A-Z][^\s]+\w)\s*(\([A-Z][a-z]+\))?\s?([a-z][^\s]+(?!\.))?\s?([a-z][^\s]*(?!\.)\b)?\s*/i
       @genus = $1 
       @subgenus = $2
       @species = $3
@@ -272,6 +301,19 @@ module Taxonifi::Splitter::Tokens
       end
     end
   end
+  
+  # A token to match variety 
+  # Matches: 
+  # var. blorf
+  # v. blorf
+  class Variety < Token
+    attr_reader :variety
+    @regexp = Regexp.new(/\A\s*((var\.\s*|v\.\s*)(\w+))/i)
+    def initialize (str)
+      str =~ Regexp.new(/\A\s*(var\.\s*|v\.\s*)(\w+)/i)
+      @variety = $2
+    end
+  end
 
   # !! You must register token lists as symbols in
   # !! Taxonifi::Splitter
@@ -282,15 +324,16 @@ module Taxonifi::Splitter::Tokens
   # Create an untested list at your own risk, any proposed
   # ordering will be accepted as long as tests pass.
   
-  # All tokens.
+  # All tokens.  Order matters!
   def self.global_token_list
     [ 
+      Taxonifi::Splitter::Tokens::AuthorYear,
       Taxonifi::Splitter::Tokens::Quadrinomial,
+      Taxonifi::Splitter::Tokens::Variety,
       Taxonifi::Splitter::Tokens::LeftParen,
       Taxonifi::Splitter::Tokens::Year,
       Taxonifi::Splitter::Tokens::Comma,
       Taxonifi::Splitter::Tokens::RightParen,
-      Taxonifi::Splitter::Tokens::AuthorYear,
       Taxonifi::Splitter::Tokens::Authors,
       Taxonifi::Splitter::Tokens::VolumeNumber,
       Taxonifi::Splitter::Tokens::Pages,
@@ -312,10 +355,12 @@ module Taxonifi::Splitter::Tokens
   end
 
   # Tokens used in breaking down species names.
+  # Order matters.
   def self.species_name
     [
-      Taxonifi::Splitter::Tokens::Quadrinomial,
       Taxonifi::Splitter::Tokens::AuthorYear,
+      Taxonifi::Splitter::Tokens::Quadrinomial,
+      Taxonifi::Splitter::Tokens::Variety
     ]
   end
 

data/lib/taxonifi/version.rb

@@ -0,0 +1,3 @@
+module Taxonifi 
+  VERSION = "0.3.2"
+end

data/lib/taxonifi.rb

@@ -29,20 +29,16 @@ module Taxonifi
       variety
   }
 
-
-  require File.expand_path(File.join(File.dirname(__FILE__), 'lumper/lumper'))
   require File.expand_path(File.join(File.dirname(__FILE__), 'splitter/splitter'))
   require File.expand_path(File.join(File.dirname(__FILE__), 'assessor/assessor'))
   require File.expand_path(File.join(File.dirname(__FILE__), 'export/export'))
 
-  Dir.glob( File.expand_path(File.join(File.dirname(__FILE__), "models/*.rb") )) do |file|
-    require file
-  end
-
-  Dir.glob( File.expand_path(File.join(File.dirname(__FILE__), "utils/*.rb") )) do |file|
-    require file
+  # TODO use **/*.rb syntax
+  %w{model utils lumper}.each do |dir|
+    Dir.glob( File.expand_path(File.join(File.dirname(__FILE__), "#{dir}/*.rb") )) do |file|
+      require file
+    end
   end
 
 
-
 end

data/taxonifi.gemspec

@@ -1,116 +1,46 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'taxonifi/version'
 
 Gem::Specification.new do |s|
   s.name = "taxonifi"
-  s.version = "0.2.0"
+  s.version = Taxonifi::VERSION
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["mjy"]
   s.date = "2013-03-27"
-  s.description = "Taxonifi contains simple models and utilties of use in for parsing lists of taxonomic name (life) related metadata"
-  s.email = "diapriid@gmail.com"
+  
+  s.summary = "A general purpose framework for scripted handling of taxonomic names or other heirarchical metadata."
+  s.description = 'Taxonifi contains simple models and utilties of use in for parsing lists of taxonomic name (life) related metadata or other heirarchically defined data.'
+  s.email = 'diapriid@gmail.com'
   s.extra_rdoc_files = [
     "LICENSE.txt",
-    "README.rdoc"
-  ]
-  s.files = [
-    ".document",
-    "Gemfile",
-    "Gemfile.lock",
-    "LICENSE.txt",
-    "README.rdoc",
-    "Rakefile",
-    "VERSION",
-    "lib/assessor/assessor.rb",
-    "lib/assessor/base.rb",
-    "lib/assessor/row_assessor.rb",
-    "lib/export/export.rb",
-    "lib/export/format/base.rb",
-    "lib/export/format/obo_nomenclature.rb",
-    "lib/export/format/prolog.rb",
-    "lib/export/format/species_file.rb",
-    "lib/lumper/clump.rb",
-    "lib/lumper/lumper.rb",
-    "lib/lumper/lumps/parent_child_name_collection.rb",
-    "lib/models/author_year.rb",
-    "lib/models/base.rb",
-    "lib/models/collection.rb",
-    "lib/models/generic_object.rb",
-    "lib/models/geog.rb",
-    "lib/models/geog_collection.rb",
-    "lib/models/name.rb",
-    "lib/models/name_collection.rb",
-    "lib/models/person.rb",
-    "lib/models/ref.rb",
-    "lib/models/ref_collection.rb",
-    "lib/models/shared_class_methods.rb",
-    "lib/models/species_name.rb",
-    "lib/splitter/builder.rb",
-    "lib/splitter/lexer.rb",
-    "lib/splitter/parser.rb",
-    "lib/splitter/splitter.rb",
-    "lib/splitter/tokens.rb",
-    "lib/taxonifi.rb",
-    "lib/utils/array.rb",
-    "lib/utils/hash.rb",
-    "taxonifi.gemspec",
-    "test/file_fixtures/Fossil.csv",
-    "test/file_fixtures/Lygaeoidea.csv",
-    "test/file_fixtures/names.csv",
-    "test/helper.rb",
-    "test/test_export_prolog.rb",
-    "test/test_exporter.rb",
-    "test/test_lumper_clump.rb",
-    "test/test_lumper_geogs.rb",
-    "test/test_lumper_hierarchical_collection.rb",
-    "test/test_lumper_names.rb",
-    "test/test_lumper_parent_child_name_collection.rb",
-    "test/test_lumper_refs.rb",
-    "test/test_obo_nomenclature.rb",
-    "test/test_parser.rb",
-    "test/test_splitter.rb",
-    "test/test_splitter_tokens.rb",
-    "test/test_taxonifi.rb",
-    "test/test_taxonifi_accessor.rb",
-    "test/test_taxonifi_base.rb",
-    "test/test_taxonifi_geog.rb",
-    "test/test_taxonifi_name.rb",
-    "test/test_taxonifi_name_collection.rb",
-    "test/test_taxonifi_ref.rb",
-    "test/test_taxonifi_ref_collection.rb",
-    "test/test_taxonifi_species_name.rb"
+    "README.md"
   ]
+ 
+  s.files         = `git ls-files -z`.split("\x0")
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
   s.homepage = "http://github.com/SpeciesFile/taxonifi"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.25"
-  s.summary = "A general purpose framework for scripted handling of taxonomic names"
+  s.rubygems_version = "2.4.5"
+
+  s.add_dependency "rake", '~> 10.4'
+
+  s.add_development_dependency "bundler", "~> 1.9"
+  s.add_development_dependency 'awesome_print', '~> 1.6'
+  s.add_development_dependency 'did_you_mean', '~> 0.9'
+  s.add_development_dependency "byebug", "~> 4.0"
+  # s.add_development_dependency "rdoc", "~> 4.2"
+
+  s.add_development_dependency "builder", "~> 3.2"
+
+
+  # Travis
+
 
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
-      s.add_development_dependency(%q<bundler>, ["> 1.0.0"])
-      s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
-      s.add_development_dependency(%q<activerecord>, ["= 3.2.8"])
-      s.add_development_dependency(%q<debugger>, [">= 0"])
-    else
-      s.add_dependency(%q<rdoc>, ["~> 3.12"])
-      s.add_dependency(%q<bundler>, ["> 1.0.0"])
-      s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
-      s.add_dependency(%q<activerecord>, ["= 3.2.8"])
-      s.add_dependency(%q<debugger>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<rdoc>, ["~> 3.12"])
-    s.add_dependency(%q<bundler>, ["> 1.0.0"])
-    s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
-    s.add_dependency(%q<activerecord>, ["= 3.2.8"])
-    s.add_dependency(%q<debugger>, [">= 0"])
-  end
 end
 

data/test/helper.rb

@@ -1,6 +1,6 @@
 require 'rubygems'
 require 'bundler'
-require 'debugger'
+require 'byebug'
 require File.expand_path(File.join(File.dirname(__FILE__), '../lib/taxonifi'))
 
 begin

data/test/test_exporter.rb

@@ -45,7 +45,7 @@ class Test_TaxonifiExports < Test::Unit::TestCase
     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
+    assert_equal "Crickets (Grylloptera: Grylloidea) in Dominican amber.", nc.ref_collection.object_from_row(nc.collection[43].properties[:link_to_ref_from_row]).title
 
     e = Taxonifi::Export::SpeciesFile.new(:nc => nc, :authorized_user_id => 11 )
     e.export

data/test/test_lumper_names.rb

@@ -98,18 +98,18 @@ class Test_TaxonifiLumperNames < Test::Unit::TestCase
 
     csv = CSV.parse(string, {headers: true})
     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 1, nc.collection[3].authors.size
+    assert_equal 'Smith', nc.collection[3].authors.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 1, nc.collection[2].authors.size
 
     assert_equal nil, nc.collection[0].parens
-    assert_equal true, nc.collection[2].parens
-    assert_equal false, nc.collection[3].parens
+    assert_equal false, nc.collection[2].parens
+    assert_equal true, nc.collection[3].parens
   end
 
   def test_that_create_a_name_collection_handles_related_columns
@@ -124,9 +124,9 @@ class Test_TaxonifiLumperNames < Test::Unit::TestCase
 
     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']
+    assert_equal nil, nc.collection[2].properties['foo']
+    assert_equal "1", nc.collection[2].properties['bar']          # !!! everything converted to String
+    assert_equal 'one', nc.collection[2].properties['Stuff']
   end
 
   def test_that_create_a_name_collection_handles_varieties
@@ -154,7 +154,7 @@ class Test_TaxonifiLumperNames < Test::Unit::TestCase
     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 'Smith', nc.collection[6].authors.first.last_name
 
   # assert_equal 1, nc.collection[3].author.size
 

data/test/test_lumper_refs.rb

@@ -96,10 +96,10 @@ class Test_TaxonifiLumperRefs < Test::Unit::TestCase
     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'] 
+    assert_equal "foo value", rc.collection.first.properties['foo'] 
+    assert_equal nil, rc.collection.last.properties['foo'] 
+    assert_equal '1', rc.collection.first.properties['bar'] 
+    assert_equal 'bar value', rc.collection.last.properties['bar'] 
   end
 
 end