taxonifi 0.2.0 → 0.3.2

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

@@ -16,14 +16,14 @@ module Taxonifi
       # Optionly store the row this came from
       attr_accessor :row_number
 
-      # A general purpose hash populable as needed for related metadata
-      attr_accessor :related 
+      # A general purpose Hash populable as needed for related metadata
+      attr_accessor :properties
 
       # TODO: Rethink this. See @@ATTRIBUTES in subclasses.
       ATTRIBUTES = [:row_number]
 
       def initialize(options = {})
-        @related = {}
+        @properties = {}
       end
 
       # Assign on new() all attributes for the ATTRIBUTES 
@@ -35,6 +35,38 @@ module Taxonifi
         end
       end
 
+      # Add a set of properties (doesn't check for key collisions)
+      def add_properties(hash)
+        @properties.merge!(hash)
+      end
+
+      # Add a key/value pair to @properties
+      def add_property(key, value)
+        if @properties[key] 
+          return false
+        else
+          @properties.merge!(key => value)
+        end
+      end  
+
+      # Replace an existing key/value pair in @properties
+      def replace_property(key,value)
+       if !@properties[key]
+        return false
+       else
+        @properties.merge!(key => value)
+       end
+      end 
+ 
+      # Delete an existing key/value pair in @properties 
+      def delete_property(key)
+       if !@properties[key]
+         @properties.delete(key) 
+       else
+        @properties.merge!(key => value)
+       end
+      end
+
       def id=(id)
         raise Taxonifi::ModelError, "Base model objects must have Fixnum ids." if !id.nil? && id.class != Fixnum
         @id = id
@@ -70,9 +102,7 @@ module Taxonifi
         end
         ancestors 
       end
-
     end
 
-
   end
 end

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

@@ -89,8 +89,15 @@ module Taxonifi
 
       # Returns an Array which respresents
       # all the "root" objects.
+      # TODO: test
       def objects_without_parents
-        collection.select{|o| o.parent.nil?}
+        @collection.select{|o| o.parent.nil?}
+      end
+
+      # Returns an Array of immediate children
+      # TODO: test 
+      def children_of_object(o)
+        @collection.select{|i| i.parent == o}
       end
 
       protected

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

@@ -10,10 +10,10 @@ module Taxonifi
     # String 
     attr_accessor  :rank   
   
-    # String
+    # String, authors as originally read 
     attr_accessor  :author        
  
-    # String, authors as originally read 
+    # String, year as originally read 
     attr_accessor  :year         
 
     # Boolean, true if parens present (i.e. _not_ in original combination) 
@@ -22,16 +22,22 @@ module Taxonifi
     # A Taxonifi::Model::Name 
     attr_accessor  :parent      
 
-    #  A Taxonifi::Model::Name General purpose relationship, typically used to indicate synonymy.
+    # A Taxonifi::Model::Name 
+    # A general purpose relationship, typically used to indicate synonymy.
     attr_accessor  :related_name 
 
-    # Array, contains properties assignable in Taxonifi::Model::Name#new()
-    @@ATTRIBUTES = [:name, :rank, :year, :parens, :parent, :author, :related_name]
+    # A Taxonifi::Model::Reference 
+    # The original description. 
+    attr_accessor :original_description_reference
 
-    # optionally parsed/index
+    # An Array, contains assignable properties in Taxonifi::Model::Name#new()
+    @@ATTRIBUTES = [:name, :rank, :year, :parens, :author, :related_name ]
+
+    # An Array of Taxonifi::Model::Person 
+    # Optionally parsed/index
     attr_accessor :authors                    
 
-    # optionally parsed/index
+    # Optionally parsed/index
     attr_accessor :author_year_index    
 
     def initialize(options = {})
@@ -41,11 +47,16 @@ module Taxonifi
       }.merge!(options)
 
       @parent = nil
+      @authors ||= []
+
       build(@@ATTRIBUTES, opts)
-      add_author_year(opts[:author_year]) if !opts[:author_year].nil? && opts[:author_year].size > 0
+      assign_author_year(opts)
+
+
+      @id = opts[:id] 
       @parent = opts[:parent] if (!opts[:parent].nil? && opts[:parent].class == Taxonifi::Model::Name)
-      @id = opts[:id] # if !opts[:id].nil? && opts[:id].size != 0
-      @authors ||= []
+      @original_description_reference = opts[:original_description_reference] if (!opts[:original_description_reference].nil? && opts[:original_description_reference].class == Taxonifi::Model::Ref)
+
       true
     end 
 
@@ -63,8 +74,8 @@ module Taxonifi
     end
 
     # Set the rank.
-    def rank=(rank)
-      r = rank.to_s.downcase.strip
+    def rank=(value)
+      r = value.to_s.downcase.strip
       if !RANKS.include?(r) 
         raise NameError, "#{r} is not a valid rank."
       end
@@ -76,7 +87,7 @@ module Taxonifi
     # TODO: Family group extension; ICZN specific 
     def index_rank
       case rank
-      when 'species', 'subspecies'
+      when 'species', 'subspecies', 'variety'
         'species_group'
       when 'genus', 'subgenus'
         'genus_group'
@@ -88,6 +99,8 @@ module Taxonifi
     end
 
     # Set the parent (a Taxonifi::Model::Name) 
+    # Passing "true" allows you to bypass the parent level restriction, do so
+    # with great caution.
     def parent=(parent)
       if @rank.nil?
         raise Taxonifi::NameError, "Parent of name can not be set if rank of child is not set." 
@@ -98,7 +111,8 @@ module Taxonifi
         raise NameError, "Parent is not a Taxonifi::Model::Name."
       end
 
-      if RANKS.index(parent.rank) >= RANKS.index(self.rank)
+      if (RANKS.index(parent.rank) >= RANKS.index(self.rank))
+        #  warn "WARNING:: Assigning parent to Name at same or lower rank than self (#{rank})."
         raise NameError, "Parent is same or lower rank than self (#{rank})."
       end
 
@@ -113,13 +127,70 @@ module Taxonifi
       (self.parens == true) ? "(#{au})" : au
     end
 
+
     # Return the author year string. 
     def author_year_string
-      au = [self.author, self.year].compact.join(", ")
+      # Build based on People 
+
+      auth = nil
+      if authors.size > 0
+        case authors.size
+        when 1
+          auth = self.author
+        when 2 
+          auth = authors.map(&:last_name).join(" & ")
+        when 2...100
+          auth =  authors[0..-1].map(&:last_name).join(", ") + " & " + authors.last.last_name
+        end
+        # Build based on string
+      else
+        auth = self.author
+      end
+      au = [auth, self.year].compact.join(", ")
       return nil if au.size == 0
       au
     end
 
+    # Return a String, the human readable version of this name (genus, subgenus, species, subspecies, variety author, year)
+    def display_name
+      [nomenclator_name, author_year].compact.join(" ")
+    end
+
+    # Return a String, the human readable version of this name (genus, subgenus, species, subspecies)
+    def nomenclator_name 
+      case @rank
+      # TODO: update for infrasubspecifics if we start tracking those
+      when 'species', 'subspecies', 'genus', 'subgenus', 'variety'
+        nomenclator_array.compact.join(" ")
+      else
+        @name
+      end
+    end
+
+    # Return a Boolean, True if @rank is one of 'genus', 'subgenus', 'species', 'subspecies' 
+    # TODO: update for infrasubspecifics if we start tracking those
+    def nomenclator_name?
+      %w{genus subgenus species subspecies variety}.include?(@rank)
+    end
+
+    # Return an Array of lenght 4 of Names representing a Species or Genus group name
+    # [genus, subgenus, species, subspecies, infrasubspecific]
+    def nomenclator_array
+      case @rank
+      when 'variety'
+        return [parent_name_at_rank('genus'), (parent_name_at_rank('subgenus') ? "(#{parent_name_at_rank('subgenus')})" : nil), parent_name_at_rank('species'),  parent_name_at_rank('subspecies'), "var. #{@name}"]
+      when 'species', 'subspecies'
+        return [parent_name_at_rank('genus'), (parent_name_at_rank('subgenus') ? "(#{parent_name_at_rank('subgenus')})" : nil), parent_name_at_rank('species'),  parent_name_at_rank('subspecies'), nil]
+      when 'subgenus'
+        return [parent_name_at_rank('genus'), "(#{@name})", nil, nil, nil]
+      when 'genus'
+        return [@name, nil, nil, nil, nil]
+      else
+        return false
+      end
+       
+    end
+
     # Return a Taxonifi::Model::Name representing the finest genus_group_parent.
     # TODO: ICZN specific(?)
     def genus_group_parent
@@ -164,24 +235,7 @@ module Taxonifi
       nil 
     end
 
-    # Return the human readable version of this name with author year (String)
-    def display_name
-      [nomenclator_name, author_year].compact.join(" ")
-    end
-
-    # Return the human readable version of this name, without author year (String)
-    def nomenclator_name 
-      case @rank
-      when 'species', 'subspecies'
-        [parent_name_at_rank('genus'), (parent_name_at_rank('subgenus') ? "(#{parent_name_at_rank('subgenus')})" : nil), parent_name_at_rank('species'),  parent_name_at_rank('subspecies')].compact.join(" ")
-      when 'subgenus'
-        [parent_name_at_rank('genus'), "(#{@name})"].compact.join(" ")
-      else
-        [@name].compact.join(" ")
-      end
-    end
-
-    # Return a dashed "vector" of ids representing the ancestor parent closure, like:
+        # Return a dashed "vector" of ids representing the ancestor parent closure, like:
     #  0-1-14-29g-45s-99-100.
     #  Postfixed g means "genus", postifed s means "subgenus.  As per SpecieFile usage.
     #  TODO: !! malformed because the valid name is not injected.  Note that this can be generated internally post import.
@@ -197,26 +251,64 @@ module Taxonifi
           ids.push a.id.to_s
         end
       end
-
       ids.join("-")
     end
 
-    # Return names indexed by author_year.
+    # Return a Taxonifi::Model::AuthorYear representing author/year
+    # !! Identical to method in Taxonifi::Model::Ref
+    # !! *Not* necessarily unique.
     def author_year_index
       @author_year_index ||= generate_author_year_index
     end
 
-    # Generate/return the author year index.
+    # Generate and return (String) the author year index.
     def generate_author_year_index
       @author_year_index = Taxonifi::Model::AuthorYear.new(people: @authors, year: @year).compact_index
     end
 
+    # TODO: test
+    # Returne True of False based on @rank
+    def species_group?
+      true if @rank == 'species' || @rank == 'subspecies'
+    end
+
+    # TODO: test
+    # Returne True of False based on @rank
+    def genus_group?
+      true if @rank == 'genus' || @rank == 'subgenus'
+    end
+
     # Return a String of Prolog rules representing this Name
     def prologify
       "false"
+    end
 
+  protected
+
+  # Generate @authors = [People], @year = 1999 from incoming initialization options.
+  def assign_author_year(opts)
+    # If for some reason already set get out
+    raise NameError, "Name initialization error, @authors set prior to conversionf from @author_year." if @year && !@authors.nil? && @authors.size > 0
+    author_year = nil
+    if !opts[:author_year].nil? && (opts[:author_year].size > 0)
+      author_year = opts[:author_year]
+    elsif !opts[:author].nil? && !@year.nil? && (opts[:author].size > 0) && (@year.size > 0)
+      author_year = opts[:author] + ", " + @year.to_s
     end
 
+    if !author_year.nil?
+      if ay = Taxonifi::Splitter::Builder.build_author_year(author_year) 
+        @year = ay.year
+        @authors = ay.people
+        true
+      else
+        false
+      end
+    end
+  end
+
+
+
   end 
 
   # ICZN specific sublassing of a taxonomic name.

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

@@ -5,28 +5,61 @@ module Taxonifi
     # A collection of taxonomic names. 
     class NameCollection < Taxonifi::Model::Collection
 
-      # A by-name (string index) 
+      # A Hash. Keys are the name (String), values are ids of Names in the collection. 
+      # { rank => { name => [ids] }}
+      # There are two special ranks "genus_group" and "species_group".
+      # E.g.: {'species_group' => {'bar' => [1,2,93]}})
       attr_accessor :by_name_index
-     
+
       # A Taxonifi::Model::RefCollection, optionally generated from Author/Year strings 
       attr_accessor :ref_collection
 
       # An optional collection of existing combinations of species names, as represented by 
       # individual arrays of Taxonifi::Model::Names.  Note you can not use a Taxonifi::Model::SpeciesName 
       # for this purpose because getting/setting names therin will affect other combinations
+      # TODO: DEPRECATE? !?!
       attr_accessor :combinations
 
+      # A Hash. Contains metadata when non-unique names are found in input parsing
+      # {unique row identifier => { redundant row identifier => {properties hash}}}
+      # TODO: reconsider, move to superclass or down to record base
+      # TODO: Test
+      attr_accessor :duplicate_entry_buffer
+
+      # A Hash.  Index (keys) created by the collection, values are an Array of Strings
+      # representing the genus, subgenus, species, and subspecies name.
+      # Automatically populated when .add_object is used. 
+      # Alternately populated with .add_nomenclator(Name)
+      # Nomenclator values are not repeated.  
+      # Index is used in @citations.
+      # {  @nomenclator_index => [genus_string, subgenus_string, species_string, subspecies_string, infrasubspecific_string (e.g. variety)], ...  }
+      # !! The names represented in the Array of strings does *NOT* have to be represented in the NameCollection.
+      attr_accessor :nomenclators
+
+      # An Integer used for indexing nomenclator records in @nomenclators.  Contains the next available index value.
+      attr_accessor :nomenclator_index
+
+      # TaxonNameID => [[ nomenclator_index, Ref ], ... []]
+      attr_accessor :citations
+
       def initialize(options = {})
         super 
-        @by_name_index = {'genus_group' => {}, 'species_group' => {} }                 # "foo => [1,2,3]"
-         Taxonifi::RANKS[0..-5].inject(@by_name_index){|hsh, v| hsh.merge!(v => {})}  # Lumping species and genus group names 
-
-        @by_name_index['unknown'] = {} # unranked names get dumped in here
-        @ref_collection = nil
-        @combinations = [] 
+        @by_name_index = {'genus_group' => {}, 'species_group' => {}, 'unknown' => {}}     # Lumping species and genus group names, unranked named are in 'unknown'
+        Taxonifi::RANKS[0..-5].inject(@by_name_index){|hsh, v| hsh.merge!(v => {})}        # TODO: Still needed?! 
+        @ref_collection = options[:ref_collection]
+        @citations = {} 
+        @combinations = []
+        @nomenclators = {} 
+        @nomenclator_index = options[:initial_nomenclator_index] 
+        @nomenclator_index ||= 1
+        @duplicate_entry_buffer = {} # Move to Collection?!
         true
       end 
 
+      def ref_collection=(ref_collection)
+        @ref_collection ||= ref_collection
+      end
+
       def object_class
         Taxonifi::Model::Name
       end
@@ -70,7 +103,7 @@ module Taxonifi
           by_name_index[rank][name.name_author_year_string].each do |id|
             full_parent_vector = parent_id_vector(name.parent.id) 
             return id if full_parent_vector == parent_id_vector(id)  # this hits species/genus group names
-            
+
             vector = parent_id_vector(id)
             next if vector.last != name.parent.id                    # can stop looking at this possiblity
             vector.pop                                               # compare just parents
@@ -83,20 +116,60 @@ module Taxonifi
         false 
       end
 
-      # Add an individaul name object, indexing it.
+      # Add an individual Name instance, indexing it.
       def add_object(obj)
         super
         index_by_name(obj)
+        derive_nomenclator(obj) if obj.nomenclator_name?
         obj
       end
 
-      # Add an individaul name object, without indexing it. 
+      # Add an individaul Name instance, without indexing it. 
       def add_object_pre_indexed(obj)
         super
         index_by_name(obj)
         obj
       end
 
+      # TODO: Test
+      def derive_nomenclator(obj)
+        if obj.nomenclator_name? && !obj.authors.nil? && !obj.year.nil?
+          add_nomenclator(obj.nomenclator_array)
+        end
+      end
+
+      # Add a Nomenclator (Array) to the index.
+      # Returns the index of the Nomenclator added.
+      # TODO: Test
+      def add_nomenclator(nomenclator_array)
+        raise if (!nomenclator_array.class == Array) || (nomenclator_array.length != 5)
+        if @nomenclators.has_value?(nomenclator_array)
+          return @nomenclators.key(nomenclator_array) 
+        else
+          @nomenclators.merge!(@nomenclator_index => nomenclator_array) 
+          @nomenclator_index += 1
+          return @nomenclator_index - 1
+        end
+      end
+
+      # Return the Integer (index) for a name
+      def nomenclator_id_for_name(name)
+        @nomenclators.key(name.nomenclator_array) 
+      end
+
+      # Add a Citation 
+      # Returns the index of the Nomenclator added.
+      # TODO: Test/Validate
+      def add_citation(name, ref, nomenclator_index, properties)
+        if @citations[name.id]
+          return false if @citations[name.id].collect{|i| [i[0],i[1]] }.include?([ref.id, nomenclator_index])
+          @citations[name.id].push([ref.id, nomenclator_index, properties])
+        else
+          @citations[name.id] = [[ref.id, nomenclator_index, properties]]
+        end
+        true
+      end
+
       # Add a Taxonifi::Model::SpeciesName object
       # as individual objects.
       def add_species_name(sn)
@@ -126,24 +199,17 @@ module Taxonifi
         end
       end
 
-      # Return an array of the names in the collection
-      def name_string_array
-        collection.collect{|n| n.display_name}
-      end 
-   
-
-      # Take the author/years of these names and generate a reference collection.
+      # Take the author/years of these names and generate a RefCollection.
       # Start the ids assigned to the references with initial_id.
       def generate_ref_collection(initial_id = 0)
         rc = Taxonifi::Model::RefCollection.new(:initial_id => initial_id)
-        if collection.size > 0
-          uniques = collection.inject({}){|hsh, n| hsh.merge!(n.author_year_string => nil)}.keys.compact
-          if  uniques.size > 0
-            uniques.sort.each_with_index do |r, i|
-              next if r.size == 0
-              ref = Taxonifi::Model::Ref.new(:author_year => r)        
-              rc.add_object(ref)
-            end
+        temp_index = {} 
+        @collection.each do |n|
+          index = n.author_year_index
+          if !temp_index[index] && index.size > 0
+            temp_index.merge!(index => nil)
+            ref = Taxonifi::Model::Ref.new(authors: n.authors, year: n.year) 
+            rc.add_object(ref)
           end
         end
         @ref_collection = rc 
@@ -152,10 +218,10 @@ module Taxonifi
       # Assign a reference collection to this name collection. 
       # !! Overwrites existing reference collection, including ones built
       # using generate_ref_collection. 
-      def ref_collection=(ref_collection)
+      def ref_collection=(ref_collection = Taxonifi::Model::RefCollection)
         @ref_collection = ref_collection if ref_collection.class == Taxonifi::Model::RefCollection
       end
-     
+
       # Return an Array of "homonyms" within the rank
       # provided.  Useful for finding missmatched upper heirarchies,
       # if nc is a name_collection:
@@ -169,7 +235,7 @@ module Taxonifi
       #  end 
       #
       def homonyms_at_rank(rank) 
-       raise if !RANKS.include?(rank)
+        raise if !RANKS.include?(rank)
         uniques = {}
         names_at_rank(rank).each do |n|
           uniques.merge!(n.name => []) if !uniques[n.name]
@@ -179,12 +245,47 @@ module Taxonifi
         uniques
       end
 
+      # Add a record to @duplicate_entry_buffer
+      def add_duplicate_entry_metadata(name_id, row_identifier, data_hash)
+        @duplicate_entry_buffer[name_id] = Hash.new if !@duplicate_entry_buffer[name_id]
+        @duplicate_entry_buffer[name_id].merge!(row_identifier => data_hash)
+      end
+
+      # For all species group names, assigns to property 'original_genus_id' the id of the parent genus group name if parens are not set.
+      # Returns an Array of ids for those names for which the property has *NOT* been set.
+      def add_original_genus_id_property
+        not_added = [] 
+        by_name_index['species_group'].values.flatten.uniq.each do |id|
+          name = object_by_id(id) 
+          if name.parens != true
+            name.add_property('original_genus_id', name.genus_group_parent.id)
+          else
+            not_added.push(name.id)
+          end
+        end
+        not_added
+      end
+
+      # Return an Array of Strings
+      def genus_group_name_strings
+        by_name_index['genus_group'].keys
+      end
+
+      # Return an Array of Strings
+      def species_group_name_strings
+        by_name_index['species_group'].keys
+      end
+
+      # Return an array of the names in the collection
+      # DEPRECATE for name_strings
+      def name_string_array
+        collection.collect{|n| n.display_name}
+      end 
+
       protected
 
-      # Index the object by name into the
-      # @by_name_index variable (this looks like:
-      #  {"Foo bar" => [1,2,93]})
-      #  Pass a Taxonifi::Name
+      # Index the object by name into the @by_name_index variable 
+      # Pass a Taxonifi::Name
       def index_by_name(name)
         rank = name.rank
         rank = 'species_group' if %w{species subspecies variety}.include?(rank)

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

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "../models/base.rb"))
+require File.expand_path(File.join(File.dirname(__FILE__), "../model/base.rb"))
 
 module Taxonifi
   module Model

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

@@ -71,12 +71,14 @@ module Taxonifi
         s
       end
 
-      # Return a by author_year index.
+      # Return a Taxonifi::Model::AuthorYear representing author/year
+      # !! Identical to method in Taxonifi::Model::Name
+      # !! *Not* necessarily unique.
       def author_year_index
         @author_year_index ||= generate_author_year_index
       end
 
-      # (re-) generate the author year index.
+      # (Re-) generate the author year index.
       def generate_author_year_index
         @author_year_index = Taxonifi::Model::AuthorYear.new(people: @authors, year: @year).compact_index
       end