dimus-taxamatch_rb 0.1.1

data/lib/taxamatch_rb/parser.rb

@@ -0,0 +1,83 @@
+# encoding: UTF-8
+require 'biodiversity'
+
+class Parser
+  def initialize
+    @parser = ScientificNameParser.new
+    @parsed_raw = nil
+    @res = {}
+  end
+  
+  def parse(name)
+    @res = {:all_authors => [], :all_years => []}
+    @parsed_raw = JSON.load(@parser.parse(name).to_json)['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].uniq!
+    @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] = Normalizer.normalize(node['epitheton'])
+    @res[name][:phonetized] = 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] = Normalizer.normalize(infr['epitheton'])
+      hsh[:phonetized] = 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[:years].uniq!
+    @res[:all_authors] += res[:authors] if res[:authors].size > 0
+    @res[:all_years] += res[:years] if res[:years].size > 0
+  end
+
+end
+
+if __FILE__ == $0
+  require 'pp'
+  p = Parser.new
+  puts p.parse('Salmonella werahensis (Castellani) Hauduroy and Ehringer in Hauduroy 1937')  
+end

data/lib/taxamatch_rb/phonetizer.rb

@@ -0,0 +1,74 @@
+# encoding: UTF-8
+
+class Phonetizer
+  
+  def self.near_match(a_word, normalize_ending = false)
+    a_word = a_word.strip rescue ''
+    return '' if a_word == ''
+    a_word = 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
+    
+  protected
+    
+  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

data/lib/taxamatch_rb.rb

@@ -0,0 +1,444 @@
+$:.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/parser'
+require 'taxamatch_rb/normalizer'
+require 'taxamatch_rb/phonetizer'
+
+class Taxamatch
+  
+  def initialize
+    @parser = Parser.new
+  end
+  # 
+  # 
+  # #takes two scientific names and returns true if names matched and false if they did not
+  # def taxamatch(str1, str2) {
+  #   taxa1 = @parser.parse_prepare(str1)
+  #   taxa2 = @parser.parse_prepare(str2)
+  #   
+  #   full_taxamatch(taxa1, taxa2)[:mached]
+  # }
+  # 
+  # #takes two hashes of parsed scientific names, analyses them and returns back 
+  # #this function is useful when species strings are preparsed.
+  # def full_taxamatch
+  # end
+
+end
+
+
+# 
+#     public function name_strings_match($name_string1, $name_string2) {
+#       $info_1 = new Splitter(null,$name_string1);
+#       $info_2 = new Splitter(null,$name_string2);
+#       return $this->name_objects_match($info_1, $info_2);
+#     }
+#     
+#     public function name_objects_match($name_object_1, $name_object_2) {
+#       $genus_match = $this->match_genera($name_object_1->genus, $name_object_2->genus);
+#       $epithets_match = $this->match_species_epithets($name_object_1->species, $name_object_2->species);
+#       $total_length = strlen($name_object_1->genus) + strlen($name_object_1->species) + strlen($name_object_2->genus) + strlen($name_object_2->species);
+#       $match = $this->match_binomials($genus_match, $epithets_match);
+#       return $this->match_response_to_float($match, $total_length);
+#     }
+#     
+#     public function match_response_to_float($match_response, $total_length_of_strings) {
+#       if(!$match_response['match']) return 0.0;
+#       
+#       return (1 - ($match_response['edit_distance'] / ($total_length_of_strings/2)));
+#     }
+#     
+#     public function match_genera($genus1, $genus2) {
+#       $match = $phonetic_match = false;
+#       $nm = new NearMatch();
+#       $genus1_phonetic = $nm->near_match($genus1);
+#       $genus2_phonetic = $nm->near_match($genus2);
+#       $genus1_length = strlen($genus1);
+# 
+#       $temp_genus_ED = $this->mdld($genus2, $genus1, 2);
+#       // add the genus post-filter
+#       // min. 51% "good" chars
+#       // first char must match for ED 2+
+#       if( ($temp_genus_ED <= 3 && ( min( strlen( $genus2 ), $genus1_length ) > ( $temp_genus_ED * 2 ))
+#             && ( $temp_genus_ED < 2 || ( substr($genus2,0,1) == substr($genus1,0,1) ) ) )    
+#           || ($genus1_phonetic == $genus2_phonetic) ) {
+#         $match = true;
+#         // accept as exact or near match; append to genus results table
+#         $this->debug['process'][] = "6a (near_match_genus:$genus2_phonetic) (this_near_match_genus:$genus1_phonetic)";
+# 
+#         if($genus1_phonetic == $genus2_phonetic) $phonetic_match = true;
+#       }
+#       return array(
+#         'match' => $match, 
+#         'phonetic_match' => $phonetic_match, 
+#         'edit_distance' => $temp_genus_ED);
+#     }
+#     
+#     public function match_species_epithets($species_epithet1, $species_epithet2) {
+#       $match = false;
+#       $phonetic_match = false;
+#       $epithet1_length = strlen($species_epithet1);
+#       $epithet2_length = strlen($species_epithet2);
+#       
+#       $nm = new NearMatch();
+#       $epithet1_phonetic = $nm->near_match($species_epithet1);
+#       $epithet2_phonetic = $nm->near_match($species_epithet2);
+#       $temp_species_ED = $this->mdld($species_epithet2, $species_epithet1, 4);
+#       // add the species post-filter
+#       // min. 50% "good" chars
+#       // first char must match for ED2+
+#       // first 3 chars must match for ED4
+#       if ($epithet2_phonetic == $epithet1_phonetic) $match = true;
+#       elseif( ($temp_species_ED <= 4 && min($epithet2_length, $epithet1_length) >= ($temp_species_ED*2)
+#         && ($temp_species_ED < 2 || strpos($species_epithet2 , substr($species_epithet1,0,1)) !== false)
+#         && ($temp_species_ED < 4 || strpos($species_epithet2 , substr($species_epithet1,0,3)) !== false))) $match = true;
+#       
+#       // if phonetic match, set relevant flag
+#       if ($epithet2_phonetic == $epithet1_phonetic) $phonetic_match = true;
+#       
+#       return array('match' => $match, 'phonetic_match' => $phonetic_match, 'edit_distance' => $temp_species_ED);
+#     }
+#     
+#     
+#     public function match_binomials($genus_match, $species_epithets_match) {
+#       $binomial_match = $species_epithets_match;
+#       $binomial_match['edit_distance'] = $genus_match["edit_distance"] + $species_epithets_match["edit_distance"];
+#       
+#       if(!$genus_match['match']) $binomial_match['match'] = false;
+#       if($binomial_match["edit_distance"] > 4)  $binomial_match['match'] = false;
+#       if(!$genus_match['phonetic_match']) $binomial_match['phonetic_match'] = false;
+#       
+#       
+#       return $binomial_match;
+#     }
+#     
+#     // public function match_species($genus1, $species_epithet1, $genus2, $species_epithet2, $genus_edit_distance) {
+#     //  $match = false;
+#     //  $phonetic_match = false;
+#     //  $epithet1_length = strlen($species_epithet1);
+#     //  $epithet2_length = strlen($species_epithet2);
+#     //  
+#     //  $nm = new NearMatch();
+#     //  $genus1_phonetic = $nm->near_match(genus1);
+#     //  $genus2_phonetic = $nm->near_match(genus2);     
+#     //  $epithet1_phonetic = $nm->near_match($species_epithet1);
+#     //  $epithet2_phonetic = $nm->near_match($species_epithet2);
+#     //  $temp_species_ED = $this->mdld($species2, $species1, 4);
+#     //  // add the species post-filter
+#     //  // min. 50% "good" chars
+#     //  // first char must match for ED2+
+#     //  // first 3 chars must match for ED4
+#     //  if ( ($epithet2_phonetic == $epithet1_phonetic) 
+#     //    || ( ($genus_edit_distance + $temp_species_ED <= 4)
+#     //    && ($temp_species_ED <= 4 && min(strlen($epithet2_length),$epithet1_length) >= ($temp_species_ED*2)
+#     //    && ($temp_species_ED < 2 || strpos($species_epithet2 , substr($species_epithet1,1,1)) !== false)
+#     //    && ($temp_species_ED < 4 || strpos($species_epithet2 , substr($species_epithet1,1,3)) !== false) 
+#     //    && ($genus_edit_distance + $temp_species_ED <= 4) ))) {
+#     //    $match = true;
+#     //    // accept as exact or near match, append to species results table
+#     //    // if phonetic match, set relevant flag
+#     //    if ( ($genus2_phonetic == $genus1_phonetic) && ($epithet2_phonetic == $epithet1_phonetic) ) $phonetic_match = true;
+#     //  }
+#     //  return array('match' => $match, 'phonetic_match' => $phonetic_match, 'edit_distance' => $temp_species_ED);
+#     // }
+# 
+#     /**
+#      * Function : process
+#      * Purpose: Perform exact and fuzzy matching on a species name, or single genus name
+#      * Input: - genus, genus+species, or genus+species+authority (in this version), as "searchtxt"
+#      *        - "search_mode" to control search mode: currently normal (default) / rapid / no_shaping
+#      *        - "debug" - print internal parameters used if not null
+#      * Outputs: list of genera and species that match (or near match) input terms, with associated
+#      *   ancillary info as desired
+#      * Remarks:
+#      *   (1) This demo version is configured to access base data in three tables:
+#      *          - genlist_test1 (genus info); primary key (PK) is genus_id
+#      *          - splist_test1 (species info); PK is species_id, has genus_id as foreign key (FK)
+#      *              (= link to relevant row in genus table)
+#      *          - auth_abbrev_test1 (authority abbreviations - required by subsidiary function
+#      *            "normalize_auth". Refer README file for relevant minimum table definitions.
+#      *       If authority comparisons are not required, calls to "normalize_auth" can be disabled and
+#      *         relevant function commented out, removing need for third table.
+#      *       (In a production system, table and column names can be varied as desired so long as
+#      *         code is altered at relevant points, also could be re-configured to hold all genus+species info together in a single table with minor re-write).
+#      *   (2) Writes to and reads back from pre-defined global temporary tables
+#      *      "genus_id_matches" and "species_id_matches", new instances of these are automatically
+#      *      created for each session (i.e., do not need clearing at procedure end). Refer
+#      *      README file for relevant table definitions.
+#      *   (3) When result shaping is on in this version, a relevant message displayed as required
+#      *      for developer feedback, if more distant results are being masked (in producton version,
+#      *       possibly would not do this)
+#      *   (4) Requires the following subsidiary functions (supplied elsewhere in this package):
+#      *         - normalize
+#      *         - normalize_auth
+#      *         - reduce_spaces
+#      *         - ngram
+#      *         - compare_auth
+#      *         - near_match
+#      *         - mdld
+#      *   (5) Accepts "+" as input separator in place of space (e.g. "Homo+sapiens"), e.g. for calling
+#      *         via a HTTP GET request as needed.
+#      * @param string $searchtxt : genus, genus+species, or genus+species+authority
+#      * @param string $search_mode : normal (default) / rapid / no_shaping
+#      * @param boolean $cache
+#      * @return boolean
+#      */
+#     public function process($searchtxt, $search_mode='normal', $cache = false) {
+# 
+#       $this->input = $searchtxt;
+# 
+#       $this->debug['process'][] = "1 (searchtxt:$searchtxt) (search_mode:$search_mode)";
+#       $this->searchtxt = $searchtxt;
+#       $this->search_mode=$search_mode;
+# 
+#       // accept "+" as separator if supplied, tranform to space
+#       if ( strpos($this->searchtxt,'+') !== false ) {
+#         $text_str = str_replace('+',' ',$this->searchtxt);
+#       } else {
+#         $text_str = $this->searchtxt;
+#       }
+# 
+#       $this->debug['process'][] = "1a (text_str:$text_str)";
+#       
+#       if ( is_null($text_str) || $text_str == '' ) {
+#         $this->debug['process'][] = "2 Return(false)";
+#         return false;
+#       }
+# 
+#       // Clearing the temporary tables
+#       $this->db->clearTempTables();
+# 
+#       // includes stripping of presumed non-relevant content including subgenera, comments, cf's, aff's, etc... to 
+# 
+#       // Normalizing the search text
+#       $n = new Normalize($this->db);
+# 
+#       $this->debug['process'][] = "3 (text_str:$text_str)";
+# 
+#       if(!$this->chop_overload) {
+#         // leave presumed genus + species + authority (in this instance), with  genus and species in uppercase
+#         $splitter = new Splitter($n,$text_str);
+#         
+#         $this->this_search_genus = $this_search_genus = $splitter->get('genus');
+#         $this->this_search_species = $this_search_species = $splitter->get('species');
+#         $this->this_authority = $this_authority = $splitter->get('author');     
+#       }
+# 
+#       // cache_flag switch detemines if caching is allowed for the source
+#       if($this->cache_flag == true) {
+# 
+#         if ( $this_search_genus != '' && $this_search_species != '' && $this_authority != '' ) {
+#           $cache_key = $this_search_genus . '-' . $this_search_species . '-' . $this_authority . '_' . $search_mode;
+#           $cache_path = $this->cache_path . $this->db->source . "/authority/";
+#         } else if ( $this_search_genus != '' && $this_search_species != '' ) {
+#           $cache_key = $this_search_genus . '-' . $this_search_species . '_' . $search_mode;
+#           $cache_path = $this->cache_path . $this->db->source . "/species/";
+#         } else if ( $this_search_genus != '' ) {
+#           $cache_key = $this_search_genus . '_' . $search_mode;
+#           $cache_path = $this->cache_path . $this->db->source . "/genus/";
+#         }
+#         
+#         $this->mkdir_recursive($cache_path);
+#         $this->_cache = new Cache( $cache_path );
+#         $this->_cache->setKey($cache_key);
+# 
+#       }
+# 
+#       $cache_loop_flag = false;
+#       if($cache == true && $this->cache_flag == true) {
+#         if($this->_cache->cache_exists()) $cache_loop_flag = true;
+#       }
+# 
+#       if(!$cache_loop_flag) {
+# 
+#         $this->debug['process'][] = "3a (this_search_genus:$this_search_genus) (this_search_species:$this_search_species) (this_authority:$this_authority)";
+#   
+#         $nm = new NearMatch();
+#         $this_near_match_genus = $nm->near_match($this_search_genus);
+#   
+#         $this->debug['process'][] = "3b (this_near_match_genus:$this_near_match_genus)";
+# //TODO refactor inside of a method
+#         $this_genus_start = substr($this_search_genus,0,3);
+#         $this_genus_end = substr($this_search_genus,-3);
+#         $this_genus_length = strlen($this_search_genus);
+# //TODO_END
+#         $this->debug['process'][] = "3c (this_search_genus,$this_search_genus) (this_genus_start:$this_genus_start) (this_genus_end:$this_genus_end) (this_genus_length:$this_genus_length)";
+#   
+#         if ($this_search_species != '') {
+#           $this_near_match_species = $nm->near_match($this_search_species, 'epithet_only');
+#           $this_species_length = strlen($this_search_species);
+#           $this->debug['process'][] = "4 (this_search_species:$this_search_species) (this_near_match_species:$this_near_match_species) (this_species_length:$this_species_length)";
+#         }
+#   
+#   
+#         // now look for exact or near matches on genus first select candidate genera for edit distance (MDLD) test
+#   
+#         // for drec in genus_cur loop -- includes the genus pre-filter (main portion)
+#         $genus_res = $this->db->genus_cur($this->search_mode, $this_near_match_genus, $this_near_match_species, $this_genus_length,$this_genus_start,$this_genus_end);
+#   
+#         $this->debug['process'][] = "5 (genus_res:$genus_res)";
+#   
+#         if(count($genus_res)) {
+#           foreach($genus_res as $drec) {
+#           // test candidate genera for edit distance, keep if satisfies post-test criteria
+#           $this->genera_tested++;
+#           // do the genus edit distance test
+#           
+#           $genus_match = $this->match_genera($this_search_genus, $drec->search_genus_name);
+#           if ($genus_match['match']) {
+#             $phonetic_flag = $genus_match['phonetic_match'] ? 'Y' : null;
+#             $this->db->saveGenusMatches($drec->genus_id, $drec->genus, $genus_match['edit_distance'], $phonetic_flag);
+#   
+#             if ( ($this_search_species != null) && ($this_search_species != '') ) {
+#               $species_res = $this->db->species_cur($drec->genus_id, $this_species_length );
+#   
+#               if(count($species_res)) {
+#                 foreach($species_res as $drec1) {
+#                   $this->species_tested++;
+#                   
+#                   // do the species edit distance test
+#                   $species_epithets_match = $this->match_species_epithets($this_search_species, $drec1->search_species_name);
+#                   $binomials_match = $this->match_binomials($genus_match, $species_epithets_match);
+#                   if ($binomials_match['match']) {
+#                     
+#                     $bionial_phonetic_flag = $binomials_match['phonetic_match'] ? 'Y' : null;
+#                     $this->db->saveSpeciesMatches($drec1->species_id, $drec1->genus_species, $genus_match['edit_distance'], $temp_species_ED, $binomials_match['edit_distance'], $bionial_phonetic_flag);
+#                   } // 
+#                 } // End foreach species_res
+#               } // End If elements exist for species_res
+#             } // End Search Species Exist
+#           }
+#         }
+#       }
+#     } // End Cache Loop Flag
+#     return true;
+#   }
+# 
+#     /**
+#      * generateResponse
+#      * Result generation section (including ranking, result shaping,
+#      * and authority comparison) - for demo purposes only
+#      * NB, in a production system this would be replaced by something
+#      * more appropriate, e.g. write to a file or database table,
+#      * generate a HTML page for web display,
+#      * generate XML response, etc. etc.
+#      * @param boolean $cache
+#      * @return boolean
+#      */
+#     public function generateResponse($cache) {
+# 
+#       $cache_loop_flag = false;
+#       if($cache == true && $this->cache_flag == true) {
+#         if($this->_cache->cache_exists()) $cache_loop_flag = true;
+#       }
+#   
+#   //    if($cache == true && $this->_cache->cache_exists() && $this->cache_flag == true) {
+#       if($cache_loop_flag) {
+#       
+#         $this->data = $this->_cache->fetch();
+#         $data_array = json_decode($this->data,true);
+#         $data_array['cache'] = $cache;
+#         $this->data = json_encode($data_array);
+#         
+#       } else {
+#       
+#         // genus exact, phonetic, and other near matches
+#         $this->output['input'] = $this->searchtxt;
+#         $this->debug['generateResponse'][] = "1 (input:" . $this->searchtxt . ")";
+#     
+#         // Genus Exact
+#         $this->debug['generateResponse'][] = "1a (getGenusAuthority:exact)";
+#         $this->getGenusAuthority(0,'exact');
+#         // Genus Phonetic
+#         $this->debug['generateResponse'][] = "1b (getGenusAuthority:phonetic)";
+#         $this->getGenusAuthority('P','phonetic');
+#         // Genus near matches
+#         $this->debug['generateResponse'][] = "1c (getGenusAuthority:near_1)";
+#         $this->getGenusAuthority(1,'near_1');
+#         $this->debug['generateResponse'][] = "1d (getGenusAuthority:near_2)";
+#         $this->getGenusAuthority(2,'near_2');
+#   
+#         if(!is_array($this->output['genus']) && $this->this_search_genus != '') {$this->output['genus'] = array();}
+#     
+#         if ( !is_null($this->this_search_species) ) {
+#           // species exact, phonetic, and other near matches
+#     
+#           $this->debug['generateResponse'][] = "2a (getSpeciesAuthority:exact) ($this->this_authority)";
+#           $this->getSpeciesAuthority( 0, 'exact', $this->this_authority );
+#           $this->debug['generateResponse'][] = "2b (getSpeciesAuthority:phonetic) ($this->this_authority)";
+#           $this->getSpeciesAuthority( 'P', 'phonetic', $this->this_authority );
+#           $this->debug['generateResponse'][] = "2c (getSpeciesAuthority:near_1) ($this->this_authority)";
+#           $this->getSpeciesAuthority( 1, 'near_1', $this->this_authority );
+#           $this->debug['generateResponse'][] = "2d (getSpeciesAuthority:near_2) ($this->this_authority)";
+#           $this->getSpeciesAuthority( 2, 'near_2', $this->this_authority );
+#                   
+#           // -- Here is the result shaping section (only show ED 3 if no ED 1,2 or phonetic matches, only
+#           // --   show ED 4 if no ED 1,2,3 or phonetic matches). By default shaping is on, unless disabled
+#           // --   via the input parameter "search_mode" set to 'no_shaping'.
+#           // --   In this demo we supplement any actual shaping with a message to show that it has been invoked,
+#           // --   to show the system operates correctly.
+#           if ($this->species_found == 'Y') {
+#             $temp_species_count = $this->db->countSpeciesMatches(3);
+#             $this->debug['generateResponse'][] = "3 (temp_species_count:$temp_species_count)";
+#           }
+#     
+#           if( $temp_species_count > 0 && $this->search_mode == 'no_shaping' ) {
+#             $this->debug['generateResponse'][] = "4 (getSpeciesAuthority:near_3) ($this->this_authority)";
+#             $this->getSpeciesAuthority( 3, 'near_3', $this->this_authority );
+#     
+#             if( $this->species_found == 'Y' ) {
+#               $temp_species_count = $this->db->countSpeciesMatches(4);
+#             }
+#     
+#             if( $temp_species_count > 0 && $this->search_mode == 'no_shaping') {
+#               $this->debug['generateResponse'][] = "4 (getSpeciesAuthority:near_4) ($this->this_authority)";
+#               $this->getSpeciesAuthority( 4, 'near_4', $this->this_authority );
+#             }
+#           } // END temp_species_count > 0 and "no_shaping"
+#           
+#         } // END If this_search_species
+#         
+#         if(!is_array($this->output['species']) && $this->this_search_species != '') {$this->output['species'] = array();}
+#         if($this->output_type == 'rest') {
+#           if($this->debug_flag) {
+#             $this->data = json_encode( array( 'success' => true, 'cache' => $cache, 'data' => $this->output, 'debug' => $this->debug ) );
+#           } else {
+#             $this->data = json_encode( array( 'success' => true, 'cache' => $cache, 'data' => $this->output));
+#           }
+#         } else {
+#           $this->data = $this->output;
+#         }
+#   
+#         if($this->cache_flag == true) {
+#           if( ! $this->_cache->cache_exists()) {
+#             if($this->debug_flag) {
+#               $op_array = array (
+#                 'success' => true
+#                 , 'cache_date' => date('Y-m-d')
+#                 , 'data' => $this->output
+#                 , 'debug' => $this->debug
+#               );
+#             } else {
+#               $op_array = array (
+#                 'success' => true
+#                 , 'cache_date' => date('Y-m-d')
+#                 , 'data' => $this->output
+#               );
+#       
+#             }
+#             $op = json_encode($op_array);
+#             $this->_cache->update($op);
+#             $tmp_cache_key = $this->_cache->getKey();
+#             $this->_cache->setKey($tmp_cache_key . '_debug');
+#             $dbg = @json_encode($this->debug);
+#             $this->_cache->update($dbg);
+#             $this->_cache->setKey($tmp_cache_key);
+#           }
+#         }
+#       }
+#   
+#       return true;
+#   
+#     }

data/spec/damerau_levenshtein_mod_test.txt

@@ -0,0 +1,58 @@
+######################
+# 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
+
+
+#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|null

data/spec/spec.opts

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