similis 0.1

data/lib/similis.rb

@@ -0,0 +1,131 @@
+require 'similis/soundex_processor'
+require 'similis/levenshtein_processor'
+
+module Similis
+  @@lists = Hash.new
+  @@last_method_used = nil
+  VERSION = "0.1"
+
+  def self.last_method_used 
+    @@last_method_used
+  end
+  
+  #Holds the list of words to be processed by algorithms like soundex
+  class ToBeProcessedList
+    @words = []
+    @processed_words = []
+    @method_used
+
+    PROCESSORS = {:soundex => SoundexProcessor}
+
+    def initialize list
+      @words = list
+      @processed_words = []
+    end
+
+    def get_processed_list
+      @processed_words
+    end
+
+    def get_method
+      @method_used
+    end
+
+    def with method
+      @method_used = method
+      @words.each do |w|
+        value = PROCESSORS[method].calculate w
+        @processed_words << {:word => w, :value => value}
+      end
+    end
+  end
+
+  def self.metaphone
+    #TODO: Implement
+  end
+
+  def self.soundex string
+    @@last_method_used = :soundex
+    SoundexProcessor.calculate string
+  end
+
+  def self.needleman_wunsch
+    #TODO: Implement
+  end
+
+  #Usage: Similis.preprocess({:key => list_of_words}).with(:algorithm)
+  def self.preprocess my_hash
+    k = my_hash.keys.first
+    @@lists[k] = ToBeProcessedList.new(my_hash[k])
+    @@lists[k]
+  end
+
+
+  #Calculates the Levenstein distance between two words
+  def self.levenshtein(word, other, ins=2, del=1, sub=1)
+    @@last_method_used = :levenshtein
+    LevenshteinProcessor.calculate(word, other, ins, del, sub)
+  end
+
+  #The default method for finding a similar word, is by using Levenshtein distance
+  def self.default_method word, list
+
+    chosen_words = Hash.new
+
+    best_distance = 999999
+
+    list.each do |w|
+      begin 
+        w.gsub!(/\n/,"")
+        w.gsub!(/\r/, "")
+      rescue 
+      end
+      distance = levenshtein(word, w)
+      if(distance <= best_distance)
+        chosen_words[distance] = Array.new if chosen_words[distance].nil?
+        chosen_words[distance] << w
+        best_distance = distance
+      end
+    end
+    #lets return the word if there is only one, or the list of words if there are more
+    if !chosen_words[best_distance].nil? and chosen_words[best_distance].count == 1
+      chosen_words[best_distance][0]
+    else
+      chosen_words[best_distance]
+    end
+  end
+
+  #Finds the most similar words using a preprocessed list 
+  def self.find_using_soundex word, list
+    chosen_words = Hash.new
+    soundex_key = soundex word
+    list.each do |item|
+      if item[:value] == soundex_key
+        chosen_words[soundex_key] = Array.new if chosen_words[soundex_key].nil?
+        chosen_words[soundex_key] << item[:word]
+      end
+    end
+    if !chosen_words[soundex_key].nil? and chosen_words[soundex_key].count == 1
+      chosen_words[soundex_key][0]
+    else 
+      chosen_words[soundex_key]
+    end
+  end
+
+  #Finds the most similar word to "word" from the list
+  def self.find_similar(word, list) 
+    method = nil
+
+    if list.is_a? Symbol #If we're referencing the list, using a key for a preprocessed list...
+      method = @@lists[list].get_method
+      list = @@lists[list].get_processed_list
+    end
+
+    if !method.nil? and self.respond_to? method
+      self.send("find_using_#{method}".to_sym, word, list)
+    else
+      default_method word, list
+    end
+  end
+
+end

data/lib/similis/levenshtein_processor.rb

@@ -0,0 +1,28 @@
+class LevenshteinProcessor
+
+  #Code taken from the net.. need to double check if it can be improved
+  def self.calculate word, other, ins, del, sub
+    return nil if word.nil? || other.nil?
+
+    dm = []
+    dm[0] = (0..word.length).collect { |i| i * ins}
+    fill = [0] * (word.length - 1)
+
+    for i in 1..other.length
+      dm[i] = [i * del, fill.flatten] 
+    end
+
+    for i in 1..other.length
+      for j in 1..word.length
+        dm[i][j] = [
+          dm[i-1][j-1] + (word[i-1] == other[i-1] ? 0 : sub),
+          dm[i][j-1] + ins,
+          dm[i-1][j] + del
+          ].min
+      end
+    end
+
+    dm[other.length][word.length]
+  end
+end
+

data/lib/similis/soundex_processor.rb

@@ -0,0 +1,14 @@
+class SoundexProcessor
+  #Mike Stok's version of this algorithm
+  def self.calculate string
+    begin
+      copy = string.upcase.tr '^A-Z', ''
+      return nil if copy.empty?
+      first_letter = copy[0, 1]
+      copy.tr_s! 'AEHIOUWYBFPVCGJKQSXZDTLMNR', '00000000111122222222334556'
+      copy.sub!(/^(.)\1*/, '').gsub!(/0/, '')
+      "#{first_letter}#{copy.ljust(3,"0")}"
+    rescue 
+    end
+  end
+end

data/lib/similis/version.rb

@@ -0,0 +1,4 @@
+
+module Similis
+  VERSION = "0.1"
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: similis
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Fernando Doglio
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-01 00:00:00.000000000Z
+dependencies: []
+description: This gem allows you to search for the closest word inside a list of specified
+  known/valid words
+email: deleteman@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/similis.rb
+- lib/similis/levenshtein_processor.rb
+- lib/similis/soundex_processor.rb
+- lib/similis/version.rb
+homepage: https://github.com/deleteman/similis
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Finds the similarities between words, using different algorithms
+test_files: []