taxamatch_rb 0.6.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Dmitry Mozzherin
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,61 @@
+= taxamatch_rb
+
+Taxamatch_Rb is a ruby implementation of Taxamatch algorithms developed by Tony Rees: http://www.cmar.csiro.au/datacentre/taxamatch.htm
+
+The purpose of Taxamatch gem is to facilitate fuzzy comparison of two scientific name renderings to find out if they actually point to the same scientific name.
+
+    require 'taxamatch_rb'
+    tm = Taxamatch::Base.new
+    tm.taxamatch('Homo sapien', 'Homo sapiens') #returns true
+    tm.taxamatch('Homo sapiens Linnaeus', 'Hommo sapens (Linn. 1758)') #returns true
+    tm.taxamatch('Homo sapiens Mozzherin', 'Homo sapiens Linnaeus') #returns false 
+
+Taxamatch_Rb is compatible with ruby versions 1.8.7 and 1.9.1 and higher
+
+== Installation
+
+    sudo gem install dimus-taxamatch_rb --source http://gems.github.com
+
+or
+    sudo gem sources -a http://gems.github.com #(you only have to do this once)
+    sudo gem install dimus-taxamatch_rb
+
+== Usage
+
+    require 'rubygems' #not needed for ruby > 1.9.1
+    require 'taxamatch_rb'
+
+    tm = Taxamatch::Base.new
+    
+* compare full scientific names
+
+    tm.taxamatch('Hommo sapiens L.', 'Homo sapiens Linnaeus')
+
+* preparse names for the matching (necessary for large databases of scientific names)
+
+    p = Taxamatch::Atomizer.new
+    parsed_name1 = p.parse('Monacanthus fronticinctus Günther 1867 sec. Eschmeyer 2004')
+    parsed_name2 = p.parse('Monacanthus fronticinctus (Gunther, 1867)')
+
+* compare preparsed names
+
+    tm.taxamatch_preparsed(parsed_name1, parsed_name2)
+
+* compare genera
+    
+    tm.match_genera('Monacanthus', 'MONOCANTUS')
+
+* compare species
+    
+    tm.match_species('fronticinctus', 'frontecinctus')
+
+* compare authors and years
+
+    Taxamatch::Authmatch.authmatch(['Linnaeus'], ['L','Muller'], [1786], [1787])
+
+
+You can find more examples in spec section of the code
+
+== Copyright
+
+Copyright (c) 2009 Dmitry Mozzherin. See LICENSE for details.

data/lib/taxamatch_rb.rb

@@ -0,0 +1,117 @@
+# encoding: UTF-8
+$:.unshift(File.dirname(__FILE__)) unless
+   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+# $:.unshift('taxamatch_rb')
+require 'taxamatch_rb/damerau_levenshtein_mod'
+require 'taxamatch_rb/atomizer'
+require 'taxamatch_rb/normalizer'
+require 'taxamatch_rb/phonetizer'
+require 'taxamatch_rb/authmatch'
+require 'ruby-debug'
+
+$KCODE='u' if RUBY_VERSION.split('.')[1].to_i < 9  
+
+module Taxamatch
+
+  class Base
+  
+    def initialize
+      @parser = Taxamatch::Atomizer.new
+      @dlm = Taxamatch::DamerauLevenshteinMod.new
+    end
+   
+   
+    #takes two scientific names and returns true if names match and false if they don't
+    def taxamatch(str1, str2, return_boolean = true) 
+      preparsed_1 = @parser.parse(str1)
+      preparsed_2 = @parser.parse(str2)
+      match = taxamatch_preparsed(preparsed_1, preparsed_2) rescue nil
+      return_boolean && match ? match['match'] : match
+    end
+  
+    #takes two hashes of parsed scientific names, analyses them and returns back 
+    #this function is useful when species strings are preparsed.
+    def taxamatch_preparsed(preparsed_1, preparsed_2)
+      result = nil
+      result =  match_uninomial(preparsed_1, preparsed_2) if preparsed_1[:uninomial] && preparsed_2[:uninomial] 
+      result =  match_multinomial(preparsed_1, preparsed_2) if preparsed_1[:genus] && preparsed_2[:genus]
+      if result && result['match']
+        result['match'] = match_authors(preparsed_1, preparsed_2) == 0 ? false : true 
+      end
+      return result
+    end
+  
+    def match_uninomial(preparsed_1, preparsed_2)
+      match_genera(preparsed_1[:uninomial], preparsed_2[:uninomial])
+    end
+
+    def match_multinomial(preparsed_1, preparsed_2)
+      gen_match = match_genera(preparsed_1[:genus], preparsed_2[:genus])
+      sp_match = match_species(preparsed_1[:species], preparsed_2[:species])
+      total_length = preparsed_1[:genus][:epitheton].size + preparsed_2[:genus][:epitheton].size + preparsed_1[:species][:epitheton].size + preparsed_2[:species][:epitheton].size
+      if preparsed_1[:infraspecies] && preparsed_2[:infraspecies]
+        infrasp_match = match_species(preparsed_1[:infraspecies][0], preparsed_2[:infraspecies][0])
+        total_length += preparsed_1[:infraspecies][0][:epitheton].size + preparsed_2[:infraspecies][0][:epitheton].size
+        match_hash = match_matches(gen_match, sp_match, infrasp_match)
+      elsif (preparsed_1[:infraspecies] && !preparsed_2[:infraspecies]) || (!preparsed_1[:infraspecies] && preparsed_2[:infraspecies])
+        match_hash = { 'match' => false, 'edit_distance' => 5, 'phonetic_match' => false }
+        total_length += preparsed_1[:infraspecies] ? preparsed_1[:infraspecies][0][:epitheton].size : preparsed_2[:infraspecies][0][:epitheton].size 
+      else
+        match_hash = match_matches(gen_match, sp_match)
+      end
+      match_hash.merge({'score' => (1 - match_hash['edit_distance']/(total_length/2))})
+      match_hash
+    end
+  
+    def match_genera(genus1, genus2)
+      genus1_length = genus1[:normalized].size
+      genus2_length = genus2[:normalized].size
+      match = false
+      ed = @dlm.distance(genus1[:normalized], genus2[:normalized],1,3) #TODO put block = 2
+      return {'edit_distance' => ed, 'phonetic_match' => false, 'match' => false} if ed/[genus1_length, genus2_length].min > 0.2
+      return {'edit_distance' => ed, 'phonetic_match' => true, 'match' => true} if genus1[:phonetized] == genus2[:phonetized] 
+    
+      match = true if ed <= 3 && ([genus1_length, genus2_length].min > ed * 2) && (ed < 2 || genus1[0] == genus2[0])
+      {'edit_distance' => ed, 'match' => match, 'phonetic_match' => false} 
+    end
+
+    def match_species(sp1, sp2)
+      sp1_length = sp1[:normalized].size
+      sp2_length = sp2[:normalized].size
+      sp1[:phonetized] = Taxamatch::Phonetizer.normalize_ending sp1[:phonetized]
+      sp2[:phonetized] = Taxamatch::Phonetizer.normalize_ending sp2[:phonetized]
+      match = false
+      ed = @dlm.distance(sp1[:normalized], sp2[:normalized], 1, 4) #TODO put block 4
+      return {'edit_distance' => ed, 'phonetic_match' => false, 'match' => false} if ed/[sp1_length, sp2_length].min > 0.3334
+      #puts 's: %s, %s, %s' % [sp1[:normalized], sp2[:normalized], ed]
+      return {'edit_distance' => ed, 'phonetic_match' => true, 'match' => true} if sp1[:phonetized] == sp2[:phonetized]
+    
+      match = true if ed <= 4 && ([sp1_length, sp2_length].min >= ed * 2) && (ed < 2 || sp1[:normalized][0] == sp2[:normalized][0]) && (ed < 4 || sp1[:normalized][0...3] == sp2[:normalized][0...3])
+      { 'edit_distance' => ed, 'match' => match, 'phonetic_match' => false}
+    end
+  
+    def match_authors(preparsed_1, preparsed_2)
+      au1 = preparsed_1[:all_authors]
+      au2 = preparsed_2[:all_authors]
+      yr1 = preparsed_1[:all_years]
+      yr2 = preparsed_2[:all_years]
+      Taxamatch::Authmatch.authmatch(au1, au2, yr1, yr2)
+    end
+  
+    def match_matches(genus_match, species_match, infraspecies_match = nil) 
+      match = species_match
+      if infraspecies_match
+        match['edit_distance'] += infraspecies_match['edit_distance']
+        match['match'] &&= infraspecies_match['match']
+        match['phonetic_match'] &&= infraspecies_match['phonetic_match']
+      end
+      match['edit_distance'] += genus_match['edit_distance']
+      match['match'] = false if match['edit_distance'] > (infraspecies_match ? 6 : 4)
+      match['match'] &&= genus_match['match']
+      match['phonetic_match'] &&= genus_match['phonetic_match']
+      match
+    end
+
+  end
+
+end

data/lib/taxamatch_rb/atomizer.rb

@@ -0,0 +1,82 @@
+# encoding: UTF-8
+require 'biodiversity'
+
+module Taxamatch
+
+  class Atomizer
+    def initialize
+      @parser = ScientificNameParser.new
+      @parsed_raw = nil
+      @res = {}
+    end
+  
+    def parse(name)
+      @res = {:all_authors => [], :all_years => []}
+      @parsed_raw = @parser.parse(name)[:scientificName]
+      organize_results
+    end
+  
+    def parsed_raw
+      return @parsed_raw
+    end
+
+  protected
+
+    def organize_results
+      pr = @parsed_raw
+      return nil unless pr[:parsed]
+      d = pr[:details][0]
+      process_node(:uninomial, d[:uninomial])
+      process_node(:genus, d[:genus])
+      process_node(:species, d[:species], true)
+      process_infraspecies(d[:infraspecies])
+      @res[:all_authors] = @res[:all_authors].uniq.map {|a| Taxamatch::Normalizer.normalize(a)}
+      @res[:all_years].uniq!
+      @res.keys.size > 2 ? @res : nil
+    end
+  
+    def process_node(name, node, is_species = false)
+      return unless node
+      @res[name] = {}
+      @res[name][:epitheton] = node[:epitheton]
+      @res[name][:normalized] = Taxamatch::Normalizer.normalize(node[:epitheton])
+      @res[name][:phonetized] = Taxamatch::Phonetizer.near_match(node[:epitheton], is_species)
+      get_authors_years(node, @res[name])
+    end
+  
+    def process_infraspecies(node)
+      return unless node
+      @res[:infraspecies] = []
+      node.each do |infr|
+        hsh = {}
+        hsh[:epitheton] = infr[:epitheton]
+        hsh[:normalized] = Taxamatch::Normalizer.normalize(infr[:epitheton])
+        hsh[:phonetized] = Taxamatch::Phonetizer.near_match(infr[:epitheton], true)
+        get_authors_years(infr,hsh)
+        @res[:infraspecies] << hsh
+      end
+    end
+  
+    def get_authors_years(node, res)
+      res[:authors] = []
+      res[:years] = []
+      [:basionymAuthorTeam, :combinationAuthorTeam].each do |au|
+        if node[au]
+          res[:authors] += node[au][:author] 
+          res[:years] << node[au][:year] if node[au][:year]
+          if node[au][:exAuthorTeam]
+            res[:authors] += node[au][:exAuthorTeam][:author]
+            res[:years] << node[au][:exAuthorTeam][:year] if node[au][:exAuthorTeam][:year]
+          end
+        end
+      end
+      res[:authors].uniq!
+      res[:normalized_authors] = res[:authors].map {|a| Taxamatch::Normalizer.normalize_author(a)}
+      res[:years].uniq!
+      @res[:all_authors] += res[:normalized_authors] if res[:normalized_authors].size > 0
+      @res[:all_years] += res[:years] if res[:years].size > 0
+    end
+
+  end
+end
+

data/lib/taxamatch_rb/authmatch.rb

@@ -0,0 +1,89 @@
+# Algorithms for Taxamatch::Authmatch are developed by Patrick Leary of uBio and EOL fame
+
+module Taxamatch
+  class Authmatch
+
+    def self.authmatch(authors1, authors2, years1, years2)
+      unique_authors1, unique_authors2 = remove_duplicate_authors(authors1, authors2)
+      year_difference = compare_years(years1, years2)
+      get_score(authors1, unique_authors1, authors2, unique_authors2, year_difference)
+    end
+  
+    def self.get_score(authors1, unique_authors1, authors2, unique_authors2, year_diff)
+      count_before = authors1.size + authors2.size
+      count_after = unique_authors1.size + unique_authors2.size
+      score = 0
+      if count_after == 0
+        if year_diff != nil
+          if year_diff == 0
+            score = 100
+          elsif year_diff == 1
+            score = 54  
+          end
+        else
+          score = 94
+        end
+      elsif unique_authors1.size == 0 || unique_authors2.size == 0
+        if year_diff != nil
+          if year_diff == 0
+            score = 91
+          elsif year_diff == 1
+            score = 51
+          end
+        else
+          score = 90
+        end
+      else
+        score = ((1 - count_after.to_f/count_before.to_f) * 100).round
+        score = 0 unless year_diff == nil || (year_diff && year_diff == 0)  
+      end
+      score > 50 ? score : 0
+    end
+  
+    def self.remove_duplicate_authors(authors1, authors2)
+      unique_authors1 = authors1.dup
+      unique_authors2 = authors2.dup
+      authors1.each do |au1|
+        authors2.each do |au2|
+          au1_match = au2_match = false
+          if au1 == au2
+            au1_match = au2_match = true
+          elsif au1 == au2[0...au1.size]          
+            au1_match = true
+          elsif au1[0...au2.size] == au2
+            au2_match = true
+          end
+          if (au1.size >= 3 && au1_match) || (au2.size >= 3 && au2_match) || (au1_match && au2_match)
+            unique_authors1.delete au1
+            unique_authors2.delete au2
+          elsif au1_match
+            unique_authors1.delete au1
+          elsif au2_match
+            unique_authors2.delete au2
+          else
+            #TODO: masking a bug in damerau levenshtsin mod which appears comparing 1letter to a longer string
+            if au1.size > 1 && au2.size > 1 && self.fuzzy_match_authors(au1, au2)
+              unique_authors1.delete au1
+              unique_authors2.delete au2
+            end
+          end
+        end
+      end
+      [unique_authors1, unique_authors2]
+    end
+  
+    def self.fuzzy_match_authors(author1, author2)
+      au1_length = author1.size
+      au2_length = author2.size
+      dlm = Taxamatch::DamerauLevenshteinMod.new
+      ed = dlm.distance(author1, author2,2,3) #get around a bug in C code, but it really has to be fixed
+      (ed <= 3 && ([au1_length, au2_length].min > ed * 2) && (ed < 2 || author1[0] == author2[0]))
+    end
+
+    def self.compare_years(years1, years2)
+      return 0 if years1 == [] && years2 == []
+      return (years1[0].to_i - years2[0].to_i).abs if years1.size == 1 && years2.size == 1
+      nil
+    end
+  end
+end

data/lib/taxamatch_rb/damerau_levenshtein_mod.rb

@@ -0,0 +1,139 @@
+# encoding: UTF-8
+require 'rubygems'
+require 'inline'
+require 'time'
+module Taxamatch
+
+  class DamerauLevenshteinMod
+    def distance(str1, str2, block_size=2, max_distance=10)
+      # puts str1.unpack("U*");
+      distance_utf(str1.unpack("U*"), str2.unpack("U*"), block_size, max_distance)
+    end
+
+    inline do |builder|
+      builder.c "
+      static VALUE distance_utf(VALUE _s, VALUE _t, int block_size, int max_distance){
+        int i, i1, j, j1, k, sl, half_sl, tl, half_tl, cost, *d, distance, del, ins, subs, transp, block;
+        int stop_execution = 0;
+        int min = 0;
+        int current_distance = 0;
+
+        VALUE *sv = RARRAY_PTR(_s);
+        VALUE *tv = RARRAY_PTR(_t);
+      
+        sl = RARRAY_LEN(_s);
+        tl = RARRAY_LEN(_t);
+      
+        if (sl == 0) return INT2NUM(tl);
+        if (tl == 0) return INT2NUM(sl);
+        //case of lengths 1 must present or it will break further in the code
+        if (sl == 1 && tl == 1 && sv[0] != tv[0]) return INT2NUM(1);
+      
+        int s[sl];
+        int t[tl];
+      
+        for (i=0; i < sl; i++) s[i] = NUM2INT(sv[i]);
+        for (i=0; i < tl; i++) t[i] = NUM2INT(tv[i]);
+      
+        sl++;
+        tl++;
+      
+        //one-dimentional representation of 2 dimentional array len(s)+1 * len(t)+1
+        d = malloc((sizeof(int))*(sl)*(tl));
+        //populate 'vertical' row starting from the 2nd position (first one is filled already)
+        for(i = 0; i < tl; i++){
+          d[i*sl] = i;
+        }
+      
+        //fill up array with scores
+        for(i = 1; i<sl; i++){
+          d[i] = i;
+          if (stop_execution == 1) break;
+          current_distance = 10000;
+          for(j = 1; j<tl; j++){
+          
+            cost = 1;
+            if(s[i-1] == t[j-1]) cost = 0;
+          
+            half_sl = (sl - 1)/2;
+            half_tl = (tl - 1)/2;
+          
+            block = block_size < half_sl ? block_size : half_sl;
+            block = block < half_tl ? block : half_tl;
+          
+            while (block >= 1){   
+              int swap1 = 1;
+              int swap2 = 1;
+              i1 = i - (block * 2);
+              j1 = j - (block * 2);
+              for (k = i1; k < i1 + block; k++) {
+                if (s[k] != t[k + block]){
+                  swap1 = 0;
+                  break;
+                }
+              }
+              for (k = j1; k < j1 + block; k++) {
+                if (t[k] != s[k + block]){
+                  swap2 = 0;
+                  break;
+                }
+              }
+            
+              del = d[j*sl + i - 1] + 1; 
+              ins = d[(j-1)*sl + i] + 1;
+              min = del;
+              if (ins < min) min = ins;
+              //if (i == 2 && j==2) return INT2NUM(swap2+5); 
+              if (i >= block && j >= block && swap1 == 1 && swap2 == 1){
+                transp = d[(j - block * 2) * sl + i - block * 2] + cost + block -1; 
+                if (transp < min) min = transp;
+                block = 0;
+              } else if (block == 1) {
+                subs = d[(j-1)*sl + i - 1] + cost;
+                if (subs < min) min = subs;
+              }
+              block--;
+            } 
+            d[j*sl+i]=min;          
+            if (current_distance > d[j*sl+i]) current_distance = d[j*sl+i];
+          }
+          if (current_distance > max_distance) {
+            stop_execution = 1;
+          }
+        }
+        distance=d[sl * tl - 1];
+        if (stop_execution == 1) distance = current_distance;
+      
+        free(d);
+        return INT2NUM(distance);
+      }
+     "
+    end
+  end
+end
+
+if __FILE__ == $0
+  a=Taxamatch::DamerauLevenshteinMod.new
+  s = 'Cedarinia scabra Sjöstedt 1921'.unpack('U*')
+  t = 'Cedarinia scabra Söjstedt 1921'.unpack('U*')
+  
+  #puts s.join(",")
+  #puts t.join(",")
+
+  start = Time.now
+  (1..100000).each do
+   a.distance('Cedarinia scabra Sjöstedt 1921', 'Cedarinia scabra Söjstedt 1921',1,10)
+  end
+  puts "with unpack time: " + (Time.now - start).to_s + ' sec'
+
+  start = Time.now
+  (1..100000).each do
+   a.distance_utf(s, t, 1, 10)
+  end
+  puts 'utf time: ' + (Time.now - start).to_s + ' sec'
+
+  #puts a.distance('Cedarinia scabra Sjöstedt 1921','Cedarinia scabra Söjstedt 1921')
+  #puts a.distance_utf(s, t, 2, 10) 
+  #puts a.distance('tar','atp',1,10);
+  puts a.distance('sub', 'usb', 1, 10);
+end

data/lib/taxamatch_rb/normalizer.rb

@@ -0,0 +1,55 @@
+# encoding: UTF-8
+
+module Taxamatch
+  
+  module Normalizer
+    def self.normalize(string)
+      utf8_to_ascii(string).upcase
+    end
+  
+    def self.normalize_word(word)
+      self.normalize(word).gsub(/[^A-Z0-9\-]/, '').strip
+    end
+    
+    def self.normalize_author(string)
+      self.normalize(string).gsub(/[^A-Z]/, ' ').gsub(/[\s]{2,}/, ' ').strip
+    end
+
+  protected
+    def self.utf8_to_ascii(string)
+      string = string.gsub(/[ÀÂÅÃÄÁẤẠ]/, "A")
+      string = string.gsub(/[ÉÈÊË]/, "E")
+      string = string.gsub(/[ÍÌÎÏ]/, "I")
+      string = string.gsub(/[ÓÒÔØÕÖỚỔ]/, "O")
+      string = string.gsub(/[ÚÙÛÜ]/, "U")
+      string = string.gsub(/[Ý]/, "Y")
+      string = string.gsub(/Æ/, "AE")
+      string = string.gsub(/[ČÇ]/, "C")
+      string = string.gsub(/[ŠŞ]/, "S")
+      string = string.gsub(/[Đ]/, "D")
+      string = string.gsub(/Ž/, "Z")
+      string = string.gsub(/Ñ/, "N")
+      string = string.gsub(/Œ/, "OE")
+      string = string.gsub(/ß/, "B")
+      string = string.gsub(/Ķ/, "K")
+      string = string.gsub(/[áàâåãäăãắảạậầằ]/, "a")
+      string = string.gsub(/[éèêëĕěếệểễềẻ]/, "e")
+      string = string.gsub(/[íìîïǐĭīĩỉï]/, "i")
+      string = string.gsub(/[óòôøõöŏỏỗộơọỡốơồờớổ]/, "o")
+      string = string.gsub(/[úùûüůưừựủứụ]/, "u")
+      string = string.gsub(/[žź]/, "z")
+      string = string.gsub(/[ýÿỹ]/, "y")
+      string = string.gsub(/[đ]/, "d")
+      string = string.gsub(/æ/, "ae")
+      string = string.gsub(/[čćç]/, "c")
+      string = string.gsub(/[ñńň]/, "n")
+      string = string.gsub(/œ/, "oe")
+      string = string.gsub(/[śšş]/, "s")
+      string = string.gsub(/ř/, "r")
+      string = string.gsub(/ğ/, "g")
+      string = string.gsub(/Ř/, "R")
+    end
+
+  end
+
+end

data/lib/taxamatch_rb/phonetizer.rb

@@ -0,0 +1,79 @@
+# encoding: UTF-8
+module Taxamatch
+
+  module Phonetizer
+    
+    def self.phonetize(a_word, normalize_ending = false)
+      self.near_match(a_word, normalize_ending)
+    end
+    
+    def self.near_match(a_word, normalize_ending = false)
+      a_word = a_word.strip rescue ''
+      return '' if a_word == ''
+      a_word = Taxamatch::Normalizer.normalize a_word
+      case a_word
+        when /^AE/
+          a_word = 'E' + a_word[2..-1]
+        when /^CN/
+          a_word = 'N' + a_word[2..-1]
+        when /^CT/
+          a_word = 'T' + a_word[2..-1]
+        when /^CZ/
+          a_word = 'C' + a_word[2..-1]
+        when /^DJ/
+          a_word = 'J' + a_word[2..-1]
+        when /^EA/
+          a_word = 'E' + a_word[2..-1]
+        when /^EU/
+          a_word = 'U' + a_word[2..-1]
+        when /^GN/
+          a_word = 'N' + a_word[2..-1]
+        when /^KN/
+          a_word = 'N' + a_word[2..-1]
+        when /^MC/
+          a_word = 'MAC' + a_word[2..-1]
+        when /^MN/
+          a_word = 'N' + a_word[2..-1]
+        when /^OE/
+          a_word = 'E' + a_word[2..-1]
+        when /^QU/
+          a_word = 'Q' + a_word[2..-1]
+        when /^PS/
+          a_word = 'S' + a_word[2..-1]
+        when /^PT/
+          a_word = 'T' + a_word[2..-1]
+        when /^TS/
+          a_word = 'S' + a_word[2..-1]
+        when /^WR/
+          a_word = 'R' + a_word[2..-1]
+        when /^X/
+          a_word = 'Z' + a_word[1..-1]
+      end
+      first_char = a_word.split('')[0]
+      rest_chars = a_word.split('')[1..-1].join('')   
+      rest_chars.gsub!('AE', 'I')
+      rest_chars.gsub!('IA', 'A')
+      rest_chars.gsub!('OE', 'I')
+      rest_chars.gsub!('OI', 'A')
+      rest_chars.gsub!('SC', 'S')
+      rest_chars.gsub!('H', '')
+      rest_chars.tr!('EOUYKZ', 'IAIICS')
+      a_word = (first_char + rest_chars).squeeze
+    
+      if normalize_ending && a_word.size > 4
+        a_word = self.normalize_ending(a_word)
+      end
+      a_word
+    end
+    
+    def self.normalize_ending(a_word)
+        # -- deal with variant endings -is (includes -us, -ys, -es), -im (was -um), -as (-os)
+        # -- at the end of a string translate all to -a
+        a_word.gsub!(/IS$/, 'A')
+        a_word.gsub!(/IM$/, 'A')
+        a_word.gsub(/AS$/, 'A')
+    end
+  
+  end
+
+end

data/spec/damerau_levenshtein_mod_test.txt

@@ -0,0 +1,63 @@
+######################
+# Tests for modified Damerau Levenshtein Distance algorithm (UTF-8 compatible)
+#
+# * B. Boehmer, T. Rees, Modified Damerau-Levenshtein Distance, Boehmer & Rees 2008
+# * F.J. Damerau. A technique for computer detection and correction of spelling errors, Communications of the ACM, 1964
+#
+# Fields:
+# String1|String2|maximum distance|transposition block size|expected distance
+#  - String1, String2
+#     compared strings
+#  - maximum distance
+#     stops execution of the algorithm when calculated distance exceeds the maximum distance number
+#  - transosition block size
+#     determines how many characters can be transposed. Block size 1 returns score according to Damerau-Levenshtein algorithm
+#  - expected distance
+#     resulting distance that has to be achieved by the algorithm
+#  Note: algorithm does not try to normalize or interpret strings in any way.
+######################
+
+#it whould recognize the exact match
+Pomatomus|Pomatomus|10|1|0
+
+#it should not try to normalize incoming strings
+ Pomatomus|Pomatomus|10|1|1
+Pomatomus|pomatomus|10|1|1
+
+#it should calculate special cases
+Pomatomus||10|1|9
+|Pomatomus|10|1|9
+P|p|10|1|1
+#TODO: one letter vs longer string generates a big negative number
+#L|Linneaus|10|1|7
+
+
+#it should calculate Damerau Levenshtein distance with 1 character transpositions, insertions, deletions, substitutions (block size 1)
+Pomatomus|Pomatomux|10|1|1
+Pmatomus|Pomatomus|10|1|1
+Pomatomus|Pmatomus|10|1|1
+Rpmatomus|Pomatomus|10|1|2
+Pommtomus|Pomatomus|10|1|1
+Potamomus|Pomatomus|10|1|2
+Cedarinia scabra Sjöstedt 1921|Cedarinia scabra Sjostedt 1921|10|1|1
+Pomatomus|oPmatomus|10|1|1
+Pomatomus|Pomatomsu|10|1|1
+Pomtaomus|Pomatomus|10|1|1
+Pomatoums|Pomatomus|10|1|1
+Potamomus|Pomatomus|10|1|2
+Cedarinia scabra Sjöstedt 1921|Cedarinia scabra Söjstedt 1921|10|2|1
+
+#it should calculate Modified Damerau Levenshtein distance with 2 or more characters transposition (block size > 2)
+serrulatus|serratulus|10|2|2
+Pomatomus|Poomumats|10|3|3
+vesiculosus|vecusilosus|10|1|4
+vesiculosus|vecusilosus|10|2|2
+trimerophyton|mertriophyton|10|1|6
+trimerophyton|mertriophyton|10|3|3
+
+#it should stop trying if distance exceeds maximum allowed distance
+Pxxxxomus|Pomatomus|10|1|4
+Pxxxxomus|Pomatomus|2|1|3
+
+#
+PUNCTATA|PUNCTATA|10|1|0

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  gem 'rspec'
+  require 'spec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'taxamatch_rb'
+
+def read_test_file(file, fields_num)
+  f = open(file)
+  f.each do |line|
+    fields = line.split("|")
+    if line.match(/^\s*#/) == nil && fields.size == fields_num
+      fields[-1] = fields[-1].split('#')[0].strip
+      yield(fields)
+    else
+      yield(nil)
+    end
+  end
+end
+
+def make_taxamatch_hash(string)
+  normalized = Taxamatch::Normalizer.normalize(string)
+  {:epitheton => string, :normalized => normalized, :phonetized => Taxamatch::Phonetizer.near_match(normalized)}
+end

data/spec/taxamatch_rb_spec.rb

@@ -0,0 +1,254 @@
+# encoding: UTF-8
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe 'DamerauLevenshteinMod' do
+  it 'should get tests' do
+    read_test_file(File.expand_path(File.dirname(__FILE__)) + '/damerau_levenshtein_mod_test.txt', 5) do |y|
+      dl = Taxamatch::DamerauLevenshteinMod.new
+      if y
+        res = dl.distance(y[0], y[1], y[3].to_i, y[2].to_i)
+        puts y if res != y[4].to_i
+        res.should == y[4].to_i
+      end
+    end
+  end
+end
+
+describe 'Atomizer' do
+  before(:all) do
+    @parser = Taxamatch::Atomizer.new
+  end
+  
+  it 'should parse uninomials' do
+    @parser.parse('Betula').should == {:all_authors=>[], :all_years=>[], :uninomial=>{:epitheton=>"Betula", :normalized=>"BETULA", :phonetized=>"BITILA", :authors=>[], :years=>[], :normalized_authors=>[]}}
+    @parser.parse('Ærenea Lacordaire, 1872').should == {:all_authors=>["LACORDAIRE"], :all_years=>["1872"], :uninomial=>{:epitheton=>"Aerenea", :normalized=>"AERENEA", :phonetized=>"ERINIA", :authors=>["Lacordaire"], :years=>["1872"], :normalized_authors=>["LACORDAIRE"]}}
+  end
+  
+  it 'should parse binomials' do
+    @parser.parse('Leœptura laetifica Dow, 1913').should == {:all_authors=>["DOW"], :all_years=>["1913"], :genus=>{:epitheton=>"Leoeptura", :normalized=>"LEOEPTURA", :phonetized=>"LIPTIRA", :authors=>[], :years=>[], :normalized_authors=>[]}, :species=>{:epitheton=>"laetifica", :normalized=>"LAETIFICA", :phonetized=>"LITIFICA", :authors=>["Dow"], :years=>["1913"], :normalized_authors=>["DOW"]}}
+  end
+  
+  it 'should parse trinomials' do 
+    @parser.parse('Hydnellum scrobiculatum zonatum (Banker) D. Hall et D.E. Stuntz 1972').should == {:all_authors=>["BANKER", "D HALL", "D E STUNTZ"], :all_years=>["1972"], :genus=>{:epitheton=>"Hydnellum", :normalized=>"HYDNELLUM", :phonetized=>"HIDNILIM", :authors=>[], :years=>[], :normalized_authors=>[]}, :species=>{:epitheton=>"scrobiculatum", :normalized=>"SCROBICULATUM", :phonetized=>"SCRABICILATA", :authors=>[], :years=>[], :normalized_authors=>[]}, :infraspecies=>[{:epitheton=>"zonatum", :normalized=>"ZONATUM", :phonetized=>"ZANATA", :authors=>["Banker", "D. Hall", "D.E. Stuntz"], :years=>["1972"], :normalized_authors=>["BANKER", "D HALL", "D E STUNTZ"]}]}
+  end
+end
+
+
+describe 'Taxamatch::Normalizer' do
+  it 'should normalize  strings' do
+    Taxamatch::Normalizer.normalize('abcd').should == 'ABCD'
+    Taxamatch::Normalizer.normalize('Leœptura').should == 'LEOEPTURA'
+    Taxamatch::Normalizer.normalize('Ærenea').should == 'AERENEA'
+    Taxamatch::Normalizer.normalize('Fallén').should == 'FALLEN'
+    Taxamatch::Normalizer.normalize('Choriozopella trägårdhi').should == 'CHORIOZOPELLA TRAGARDHI'
+  end
+  
+  it 'should normalize words' do
+    Taxamatch::Normalizer.normalize_word('L-3eœ|pt[ura$').should == 'L-3EOEPTURA'
+  end
+end
+
+describe 'Taxamatch::Base' do
+  before(:all) do
+    @tm = Taxamatch::Base.new
+  end
+  
+  it 'should get txt tests' do
+    dl = Taxamatch::DamerauLevenshteinMod.new
+    read_test_file(File.expand_path(File.dirname(__FILE__)) + '/taxamatch_test.txt', 4) do |y|
+      if y
+        y[2] = y[2] == 'true' ? true : false
+        res = @tm.taxamatch(y[0], y[1], false)
+        puts "%s, %s, %s, %s" % [y[0], y[1], y[2], y[3]] 
+        res['match'].should == y[2]
+        res['edit_distance'].should == y[3].to_i
+      end
+    end
+  end
+  
+  it 'should work with names that cannot be parsed' do
+    res = @tm.taxamatch('Quadraspidiotus ostreaeformis MacGillivray, 1921','Quadraspidiotus ostreaeformis Curtis)')
+    res = false
+  end
+  
+  it 'should compare genera' do
+    #edit distance 1 always match
+    g1 = make_taxamatch_hash 'Plantago'
+    g2 = make_taxamatch_hash 'Plantagon'
+    @tm.match_genera(g1, g2).should == {'phonetic_match' => false, 'edit_distance' => 1, 'match' => true}
+    #edit_distance above threshold does not math
+    g1 = make_taxamatch_hash 'Plantago'
+    g2 = make_taxamatch_hash 'This shouldnt match'
+    @tm.match_genera(g1, g2).should == {'phonetic_match' => false, 'match' => false, 'edit_distance' => 4}
+    #phonetic_match matches
+    g1 = make_taxamatch_hash 'Plantagi'
+    g2 = make_taxamatch_hash 'Plantagy'
+    @tm.match_genera(g1, g2).should == {'phonetic_match' => true, 'edit_distance' => 1, 'match' => true}
+    #distance 1 in first letter also matches
+    g1 = make_taxamatch_hash 'Xantheri'
+    g2 = make_taxamatch_hash 'Pantheri'
+    @tm.match_genera(g1, g2).should == {'phonetic_match' => false, 'edit_distance' => 1, 'match' => true}
+    #phonetic match tramps everything
+    g1 = make_taxamatch_hash 'Xantheriiiiiiiiiiiiiii'
+    g2 = make_taxamatch_hash 'Zanthery'
+    @tm.match_genera(g1, g2).should == {'phonetic_match' => true, 'edit_distance' => 4, 'match' => true}
+    #same first letter and distance 2 should match
+    g1 = make_taxamatch_hash 'Xantherii'
+    g2 = make_taxamatch_hash 'Xantherrr'
+    @tm.match_genera(g1, g2).should == {'phonetic_match' => false, 'match' => true, 'edit_distance' => 2}
+    #First letter is the same and distance is 3 should match, no phonetic match
+    g1 = make_taxamatch_hash 'Xantheriii'
+    g2 = make_taxamatch_hash 'Xantherrrr'
+    @tm.match_genera(g1, g2).should == {'phonetic_match' => false, 'match' => true, 'edit_distance' => 3}
+    #Should not match if one of words is shorter than 2x edit distance and distance is 2 or 3
+    g1 = make_taxamatch_hash 'Xant'
+    g2 = make_taxamatch_hash 'Xanthe'
+    @tm.match_genera(g1, g2).should ==  {'phonetic_match' => false, 'match' => false, 'edit_distance' => 2}
+    #Should not match if edit distance > 3 and no phonetic match
+    g1 = make_taxamatch_hash 'Xantheriiii'
+    g2 = make_taxamatch_hash 'Xantherrrrr'
+    @tm.match_genera(g1, g2).should ==  {'phonetic_match' => false, 'match' => false, 'edit_distance' => 4}
+  end
+
+  it 'should compare species' do
+    #Exact match
+    s1 = make_taxamatch_hash 'major'
+    s2 = make_taxamatch_hash 'major'
+    @tm.match_species(s1, s2).should ==  {'phonetic_match' => true, 'match' => true, 'edit_distance' => 0}
+    #Phonetic match always works
+    s1 = make_taxamatch_hash 'xanteriiiiiiii'
+    s2 = make_taxamatch_hash 'zantereeeeeeee'
+    @tm.match_species(s1, s2).should ==  {'phonetic_match' => true, 'match' => true, 'edit_distance' => 5}
+    #Phonetic match works with different endings
+    s1 = make_taxamatch_hash 'majorum'
+    s2 = make_taxamatch_hash 'majoris'
+    @tm.match_species(s1, s2).should ==  {'phonetic_match' => true, 'match' => true, 'edit_distance' => 2}
+    #Distance 4 matches if first 3 chars are the same
+    s1 = make_taxamatch_hash 'majorrrrr'
+    s2 = make_taxamatch_hash 'majoraaaa'
+    @tm.match_species(s1, s2).should == {'phonetic_match' => false, 'match' => true, 'edit_distance' => 4}
+    #Should not match if Distance 4 matches and first 3 chars are not the same
+    s1 = make_taxamatch_hash 'majorrrrr'
+    s2 = make_taxamatch_hash 'marorraaa'
+    @tm.match_species(s1, s2).should == {'phonetic_match' => false, 'match' => false, 'edit_distance' => 4}
+    #Distance 2 or 3 matches if first 1 char is the same
+    s1 = make_taxamatch_hash 'morrrr'
+    s2 = make_taxamatch_hash 'moraaa'
+    @tm.match_species(s1, s2).should == {'phonetic_match' => false, 'match' => true, 'edit_distance' => 3}
+    #Should not match if Distance 2 or 3 and first 1 char is not the same
+    s1 = make_taxamatch_hash 'morrrr'
+    s2 = make_taxamatch_hash 'torraa'
+    @tm.match_species(s1, s2).should == {'phonetic_match' => false, 'match' => false, 'edit_distance' => 3} 
+    #Distance 1 will match anywhere
+    s1 = make_taxamatch_hash 'major'
+    s2 = make_taxamatch_hash 'rajor'
+    @tm.match_species(s1, s2).should == {'phonetic_match' => false, 'match' => true, 'edit_distance' => 1} 
+    #Will not match if distance 3 and length is less then twice of the edit distance
+    s1 = make_taxamatch_hash 'marrr'
+    s2 = make_taxamatch_hash 'maaaa'
+    @tm.match_species(s1, s2).should == {'phonetic_match' => false, 'match' => false, 'edit_distance' => 3}
+  end
+  
+  it 'should match mathes' do
+    #No trobule case
+    gmatch = {'match' => true, 'phonetic_match' => true, 'edit_distance' => 1}
+    smatch = {'match' => true, 'phonetic_match' => true, 'edit_distance' => 1}
+    @tm.match_matches(gmatch, smatch).should == {'phonetic_match' => true, 'edit_distance' => 2, 'match' => true}
+    #Will not match if either genus or sp. epithet dont match
+    gmatch = {'match' => false, 'phonetic_match' => false, 'edit_distance' => 1}
+    smatch = {'match' => true, 'phonetic_match' => true, 'edit_distance' => 1}
+    @tm.match_matches(gmatch, smatch).should == {'phonetic_match'=>false, 'edit_distance'=>2, 'match'=>false}
+    gmatch = {'match' => true, 'phonetic_match' => true, 'edit_distance' => 1}
+    smatch = {'match' => false, 'phonetic_match' => false, 'edit_distance' => 1}    
+    @tm.match_matches(gmatch, smatch).should == {'phonetic_match'=>false, 'edit_distance'=>2, 'match'=>false}
+    #Should not match if binomial edit distance > 4 NOTE: EVEN with full phonetic match
+    gmatch = {'match' => true, 'phonetic_match' => true, 'edit_distance' => 3}
+    smatch = {'match' => true, 'phonetic_match' => true, 'edit_distance' => 2}
+    @tm.match_matches(gmatch, smatch).should == {'phonetic_match'=>true, 'edit_distance'=>5, 'match'=>false}
+    #Should not have phonetic match if one of the components does not match phonetically
+    gmatch = {'match' => true, 'phonetic_match' => false, 'edit_distance' => 1}
+    smatch = {'match' => true, 'phonetic_match' => true, 'edit_distance' => 1}
+    @tm.match_matches(gmatch, smatch).should == {'phonetic_match'=>false, 'edit_distance'=>2, 'match'=>true}
+    gmatch = {'match' => true, 'phonetic_match' => true, 'edit_distance' => 1}
+    smatch = {'match' => true, 'phonetic_match' => false, 'edit_distance' => 1}
+    @tm.match_matches(gmatch, smatch).should == {'phonetic_match'=>false, 'edit_distance'=>2, 'match'=>true}
+    #edit distance should be equal the sum of of edit distances
+    gmatch = {'match' => true, 'phonetic_match' => true, 'edit_distance' => 2}
+    smatch = {'match' => true, 'phonetic_match' => true, 'edit_distance' => 2}
+    @tm.match_matches(gmatch, smatch).should == {'phonetic_match'=>true, 'edit_distance'=>4, 'match'=>true}
+  end
+
+  describe 'Taxamatch::Authmatch' do
+    before(:all) do
+      @am = Taxamatch::Authmatch
+    end
+    
+    it 'should calculate score' do
+      res = @am.authmatch(['Linnaeus', 'Muller'], ['L'], [], [1788])
+      res.should == 90
+      res = @am.authmatch(['Linnaeus'],['Kurtz'], [], [])
+      res.should == 0
+      #found all authors, same year
+      res = @am.authmatch(['Linnaeus', 'Muller'], ['Muller', 'Linnaeus'], [1766], [1766])
+      res.should == 100
+      #all authors, 1 year diff
+      res = @am.authmatch(['Linnaeus', 'Muller'], ['Muller', 'Linnaeus'], [1767], [1766])
+      res.should == 54
+      #year is not counted in
+      res = @am.authmatch(['Linnaeus', 'Muller'], ['Muller', 'Linnaeus'], [1767], [])
+      res.should == 94
+      #found all authors on one side, same year
+      res = @am.authmatch(['Linnaeus', 'Muller', 'Kurtz'], ['Muller', 'Linnaeus'], [1767], [1767])
+      res.should == 91
+      #found all authors on one side, 1 year diff
+      res = @am.authmatch(['Linnaeus', 'Muller', 'Kurtz'], ['Muller', 'Linnaeus'], [1766], [1767])
+      res.should == 51
+      #found all authors on one side, year does not count
+      res = @am.authmatch(['Linnaeus', 'Muller'], ['Muller', 'Linnaeus', 'Kurtz'], [1766], [])
+      res.should == 90
+      #found some authors
+      res = @am.authmatch(['Stepanov', 'Linnaeus', 'Muller'], ['Muller', 'Kurtz', 'Stepanov'], [1766], [])
+      res.should == 67
+      #if year does not match or not present no match for previous case
+      res = @am.authmatch(['Stepanov', 'Linnaeus', 'Muller'], ['Muller', 'Kurtz', 'Stepanov'], [1766], [1765])
+      res.should == 0
+    end
+    
+    it 'should compare years' do
+      @am.compare_years([1882],[1880]).should == 2
+      @am.compare_years([1882],[]).should == nil
+      @am.compare_years([],[]).should == 0
+      @am.compare_years([1788,1798], [1788,1798]).should be_nil
+    end
+    
+    it 'should remove duplicate authors' do 
+      #Li submatches Linnaeus and it its size 3 is big enought to remove Linnaeus
+      #Muller is identical
+      res = @am.remove_duplicate_authors(['Lin', 'Muller'], ['Linnaeus', 'Muller'])
+      res.should == [[], []]
+      #same in different order
+      res = @am.remove_duplicate_authors(['Linnaeus', 'Muller'], ['Linn', 'Muller'])
+      res.should == [[], []]      
+      #auth Li submatches Linnaeus, but Li size less then 3 required to remove Linnaeus
+      res = @am.remove_duplicate_authors(['Dem', 'Li'], ['Linnaeus', 'Stepanov'])
+      res.should == [["Dem"], ["Linnaeus", "Stepanov"]]
+      #fuzzy match
+      res = @am.remove_duplicate_authors(['Dem', 'Lennaeus'], ['Linnaeus', 'Stepanov'])
+      res.should == [["Dem"], ["Stepanov"]]
+      res = @am.remove_duplicate_authors(['Linnaeus', 'Muller'], ['L', 'Kenn'])
+      res.should == [['Linnaeus', 'Muller'], ['Kenn']]
+      res = @am.remove_duplicate_authors(['Linnaeus', 'Muller'], ['Muller', 'Linnaeus', 'Kurtz'])
+      res.should == [[],['Kurtz']]
+    end
+
+    it 'should fuzzy match authors' do
+      #TODO: fix the bug revealed by this test
+      # res = @am.fuzzy_match_authors('L', 'Muller')
+      # res.should be_false
+    end
+    
+  end
+
+end
+
+

data/spec/taxamatch_test.txt

@@ -0,0 +1,45 @@
+###
+#
+# Tests for string comparison by taxamatch algorithm
+# name1|name2|match|edit_distance
+#
+##
+# Comparing uninomials
+Pomatomus|Pomatomas|true|1
+Pomatomus L.|Pomatomas Linn.|true|1
+Pomatomus Ber|Pomatomas Linn|false|1
+Pomatomus L. 1753|Pomatomus Linn. 1800|false|0
+
+## additional authorship should match
+Puma concolor|Puma concolor L.|true|0
+#
+## one-letter misspeling in species epithet should match
+Puma concolor|Puma cancolor|true|1
+#
+Pomatomus saltatrix|Pomatomus saltratix|true|2
+Pomatomus saltator|Pomatomus saltatrix|true|3
+#
+Loligo pealeii|Loligo plei|false|3
+#
+## different authors should not match
+Puma concolor Linnaeus|Puma concolor Kurtz|false|0
+#
+##real life examples
+Biatora borealis|Bactra borealis Diakonoff 1964|false|3
+#
+Homo sapien|Homo sapiens|true|1
+Homo sapiens Linnaeus|Homo sapens (Linn. 1758) |true|1
+Homo sapiens Mozzherin|Homo sapiens Linneaus|false|0
+#
+Quinqueloculina punctata|Quinqueloculina punctata d'Orbigny 1905|true|0
+Pomatomus saltator (Linnaeus, 1766)|Pomatomus saltatrix (Linnaeus, 1766)|true|0|3
+#
+#Trinomial names
+Homo sapiens stupidus|Homo spiens stupidus|true|1
+Pomatomus saltator saltator L. 1753|Pomatomus saltator var. saltatror L. 1753|true|1
+Pomatomus saltator L. 1753|Pomatomus saltator var. saltatror L. 1753|false|5
+Pomatomus saltator saltator saltatorische|Pomatomus saltator soltator|true|1
+
+
+
+

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification 
+name: taxamatch_rb
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 6
+  - 0
+  version: 0.6.0
+platform: ruby
+authors: 
+- Dmitry Mozzherin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-19 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: RubyInline
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: biodiversity
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 5
+        - 13
+        version: 0.5.13
+  type: :runtime
+  version_requirements: *id002
+description: This gem implements algorithsm for fuzzy matching scientific names developed by Tony Rees
+email: dmozzherin@eol.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- README.rdoc
+- lib/taxamatch_rb.rb
+- lib/taxamatch_rb/atomizer.rb
+- lib/taxamatch_rb/authmatch.rb
+- lib/taxamatch_rb/damerau_levenshtein_mod.rb
+- lib/taxamatch_rb/normalizer.rb
+- lib/taxamatch_rb/phonetizer.rb
+- spec/damerau_levenshtein_mod_test.txt
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/taxamatch_rb_spec.rb
+- spec/taxamatch_test.txt
+- LICENSE
+has_rdoc: true
+homepage: http://github.com/dimus/taxamatch_rb
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Implementation of Tony Rees Taxamatch algorithms
+test_files: 
+- spec/spec_helper.rb
+- spec/taxamatch_rb_spec.rb