hintable_levenshtein 0.0.2

data/README.rdoc

@@ -0,0 +1,35 @@
+= Hintable Levenshtein
+
+Levenshtein distances but with extra hints. Perhaps adding or deleting a space is not as big as a change as other things, or
+substituting a 'c' for a 'k' is again a cheaper operation than just any arbitrary change.
+
+Just an example
+
+  english_rules = [
+    HintableLevenshtein::RuleSet.new(0.3, HintableLevenshtein::Rule.insert(/[\.,!]/)),
+    HintableLevenshtein::RuleSet.new(0.3, HintableLevenshtein::Rule.delete(/[\.,!]/)),
+    HintableLevenshtein::RuleSet.new(0.4, HintableLevenshtein::Rule.substitute('!' => '.')),
+    HintableLevenshtein::RuleSet.new(0.4, HintableLevenshtein::Rule.substitute('!' => ',')),
+    HintableLevenshtein::RuleSet.new(0.75, HintableLevenshtein::Rule.insert(' '), HintableLevenshtein::Rule.insert(' ')),
+    HintableLevenshtein::RuleSet.new(0.5, HintableLevenshtein::Rule.insert(' ')),
+    HintableLevenshtein::RuleSet.new(0.5, HintableLevenshtein::Rule.delete(' ')),
+    HintableLevenshtein::RuleSet.new(0.7, HintableLevenshtein::Rule.substitute('z' => 's')),
+    HintableLevenshtein::RuleSet.new(0.7, HintableLevenshtein::Rule.substitute('k' => 'c')),
+    HintableLevenshtein::RuleSet.new(0.7, HintableLevenshtein::Rule.substitute('u' => 'o')),
+    HintableLevenshtein::RuleSet.new(0.7, HintableLevenshtein::Rule.substitute('e' => 'a')),
+    HintableLevenshtein::RuleSet.new(0.7, HintableLevenshtein::Rule.substitute('i' => 'y')),
+    HintableLevenshtein::RuleSet.new(1, HintableLevenshtein::Rule.delete),
+    HintableLevenshtein::RuleSet.new(1, HintableLevenshtein::Rule.insert),
+    HintableLevenshtein::RuleSet.new(1, HintableLevenshtein::Rule.substitute)
+  ]
+  
+  a = "hello kitten pizza!!"
+  b = "hello    cittin pissssa.."
+  
+  puts "normal levenshtein: #{HintableLevenshtein.new.distance(a, b)}"
+  puts "hinted levenshtein: #{HintableLevenshtein.new(english_rules).distance(a, b)}"
+  
+Would output:
+
+  normal levenshtein: 11.0
+  hinted levenshtein: 7.15

data/Rakefile

@@ -0,0 +1,48 @@
+libdir = File.expand_path("lib")
+$:.unshift(libdir) unless $:.include?(libdir)
+
+require 'hintable_levenshtein'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "hintable_levenshtein"
+    s.description = s.summary = "Levenshtein with hints"
+    s.email = "joshbuddy@gmail.com"
+    s.homepage = "http://github.com/joshbuddy/hintable_levenshtein"
+    s.authors = ["Joshua Hull"]
+    s.files = FileList["[A-Z]*", "{lib,spec}/**/*"]
+    s.rubyforge_project = 'joshbuddy-hintable_levenshtein'
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'spec'
+require 'spec/rake/spectask'
+task :spec => 'spec:all'
+namespace(:spec) do
+  Spec::Rake::SpecTask.new(:all) do |t|
+    t.spec_opts ||= []
+    t.spec_opts << "-rubygems"
+    t.spec_opts << "--options" << "spec/spec.opts"
+    t.spec_files = FileList['spec/**/*_spec.rb']
+  end
+
+end
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new('spec_with_rcov') do |t|
+  t.spec_files = FileList['spec/**/*.rb']
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec']
+end
+
+require 'rake/rdoctask'
+desc "Generate documentation"
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+  rd.rdoc_dir = 'rdoc'
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.2

data/lib/hintable_levenshtein.rb

@@ -0,0 +1,129 @@
+class HintableLevenshtein
+  
+  autoload :Event,   File.join(File.dirname(__FILE__), 'hintable_levenshtein', 'event')
+  autoload :RuleSet, File.join(File.dirname(__FILE__), 'hintable_levenshtein', 'rule_set')
+  
+  def initialize(new_rule_set = nil, &block)
+    @rule_set = []
+
+    instance_eval(&block) if block
+    
+    if new_rule_set
+      rule_set.concat(new_rule_set)
+    end
+    
+    if rule_set.empty?
+      rule_set << RuleSet.new(1, Rule.delete)
+      rule_set << RuleSet.new(1, Rule.insert)
+      rule_set << RuleSet.new(1, Rule.substitute)
+    end
+  end
+  
+  def rule_set_sizes
+    @rule_set_sizes ||= rule_set.collect{|r| r.rules.size}.uniq.sort.reverse
+  end
+
+  def largest_rule_size
+    rule_set_sizes.first
+  end
+  
+  def delete(score, match)
+    rule_set << RuleSet.new(score, Rule.delete(match))
+  end
+  
+  def insert(score, match)
+    rule_set << RuleSet.new(score, Rule.insert(match))
+  end
+  
+  def substitute(score, match)
+    rule_set << RuleSet.new(score, Rule.substitute(match))
+  end
+  
+  Position = Struct.new(:x, :y)
+  
+  def distance(s, t)
+    matrix = levenshtein_matrix(s, t)
+    steps = calculate_steps(s, t, matrix)
+    calculate_score(steps)
+  end
+  
+  private
+  
+  attr_reader :rule_set
+  
+  def levenshtein_matrix(s, t)
+    d = Array.new(s.size + 1) {|i| Array.new(t.size + 1)}
+    
+    (0..s.size).each do |m|
+      (0..t.size).each do |n|
+        if m * n == 0
+          d[m][n] = m + n
+        else
+          d[m][n] = [
+            d[m-1][n] + 1,
+            d[m][n-1] + 1,
+            d[m-1][n-1] + (s[m-1] == t[n-1] ? 0 : 1)
+          ].min
+        end
+      end
+    end
+    
+    d
+  end
+  
+  def calculate_steps(s, t, matrix)
+    position = Position.new(s.size, t.size)
+    value = matrix[position.x][position.y]
+    steps = []
+    while matrix[position.x][position.y] != 0
+      previous_position = position.dup
+      if position.x == 0
+        previous.y -= 1
+      elsif position.y == 0
+        previous.x -= 1
+      else
+        possible_values = [matrix[position.x - 1][position.y], matrix[position.x][position.y - 1], matrix[position.x - 1][position.y - 1]]
+        case possible_values.min
+        when possible_values[2]
+          position.x -= 1
+          position.y -= 1
+        when possible_values[1]
+          position.y -= 1
+        when possible_values[0]
+          position.x -= 1
+        end
+      end
+
+      next unless value != matrix[position.x][position.y]
+      
+      value = matrix[position.x][position.y]
+      steps << if previous_position.x == position.x + 1 && previous_position.y == position.y + 1
+        Event.new(:substitute, s[position.x] => t[position.y])
+      elsif previous_position.x == (position.x + 1)
+        Event.new(:delete, s[position.x].chr)
+      else
+        Event.new(:insert, t[position.y].chr)
+      end
+    end
+    steps
+  end
+  
+  def calculate_score(steps)
+    score = 0.0
+    rule_set_sizes.each do |set_size|
+      rule_set.select{|r| r.rules.size == set_size}.each do |rule|
+        (0..(steps.size - set_size)).each do |offset|
+          analyzed_set = steps[offset..(offset + set_size - 1)]
+          unless analyzed_set.any?{|s| s.nil?}
+            if rule.match?(analyzed_set)
+              steps.fill(nil, offset, set_size)
+              score += rule.score
+            end
+          end
+        end
+      end
+    end
+    score
+  end
+  
+end

data/lib/hintable_levenshtein/event.rb

@@ -0,0 +1,31 @@
+class HintableLevenshtein
+  class Event
+    
+    attr_reader :type, :chr, :from, :to
+    
+    def initialize(type, chr = nil)
+      @type = type
+      case type
+      when :substitute
+        unless chr.nil?
+          @from = chr.keys.first
+          @from = @from.chr unless @from.is_a?(String)
+          @to = chr.values.first
+          @to = @to.chr unless @to.is_a?(String)
+        else
+          @from = @to = nil
+        end
+      else
+        @chr = chr.is_a?(String) ? chr : chr.chr
+      end
+    end
+
+    def to_s
+      if from
+        "#{type} -> #{from}..#{to}"
+      else
+        "#{type} -> #{chr}"
+      end
+    end
+  end
+end

data/lib/hintable_levenshtein/rule_set.rb

@@ -0,0 +1,70 @@
+class HintableLevenshtein
+  class RuleSet
+    
+    include Comparable
+    
+    attr_reader :rules, :score
+    def initialize(score, *rules)
+      @rules = rules
+      @score = score
+    end
+  
+    def to_s
+      "#{score} -> #{rules.collect{|r| r.to_s} * ', '}"
+    end
+  
+    def match?(events)
+      return if events.size != rules.size
+      events.each_with_index do |e, idx|
+        return unless rules[idx].match?(e)
+      end
+      true
+    end
+  end
+
+  class Rule
+    def self.delete(matcher = nil)
+      new(:delete, matcher)
+    end
+    
+    def self.insert(matcher = nil)
+      new(:insert, matcher)
+    end
+  
+    def self.substitute(matcher = {})
+      new(:substitute, matcher)
+    end
+  
+    attr_reader :type, :matcher
+  
+    def match?(event)
+      if event.type == type
+        case type
+        when :delete, :insert
+          ret = case matcher
+          when nil
+            true
+          when String
+            !matcher.index(event.chr).nil?
+          when Array
+            matcher.include?(event.chr)
+          else
+            matcher === event.chr
+          end
+        when :substitute
+          matcher.empty? || matcher[event.from] == event.to || matcher[event.to] == event.from
+        end
+      end
+    end
+  
+    def to_s
+      "#{type} #{matcher.inspect}"
+    end
+
+    private
+    def initialize(type, matcher)
+      @type = type
+      @matcher = matcher
+    end
+  end  
+end

data/spec/hl_spec.rb

@@ -0,0 +1,30 @@
+require 'lib/hintable_levenshtein'
+
+describe HintableLevenshtein do
+  it "should do this thing" do
+    english_rules = [
+      HintableLevenshtein::RuleSet.new(0.3, HintableLevenshtein::Rule.insert(/[\.,!]/)),
+      HintableLevenshtein::RuleSet.new(0.3, HintableLevenshtein::Rule.delete(/[\.,!]/)),
+      HintableLevenshtein::RuleSet.new(0.4, HintableLevenshtein::Rule.substitute('!' => '.')),
+      HintableLevenshtein::RuleSet.new(0.4, HintableLevenshtein::Rule.substitute('!' => ',')),
+      HintableLevenshtein::RuleSet.new(0.75, HintableLevenshtein::Rule.insert(' '), HintableLevenshtein::Rule.insert(' ')),
+      HintableLevenshtein::RuleSet.new(0.5, HintableLevenshtein::Rule.insert(' ')),
+      HintableLevenshtein::RuleSet.new(0.5, HintableLevenshtein::Rule.delete(' ')),
+      HintableLevenshtein::RuleSet.new(0.7, HintableLevenshtein::Rule.substitute('z' => 's')),
+      HintableLevenshtein::RuleSet.new(0.7, HintableLevenshtein::Rule.substitute('k' => 'c')),
+      HintableLevenshtein::RuleSet.new(0.7, HintableLevenshtein::Rule.substitute('u' => 'o')),
+      HintableLevenshtein::RuleSet.new(0.7, HintableLevenshtein::Rule.substitute('e' => 'a')),
+      HintableLevenshtein::RuleSet.new(0.7, HintableLevenshtein::Rule.substitute('i' => 'y')),
+      HintableLevenshtein::RuleSet.new(1, HintableLevenshtein::Rule.delete),
+      HintableLevenshtein::RuleSet.new(1, HintableLevenshtein::Rule.insert),
+      HintableLevenshtein::RuleSet.new(1, HintableLevenshtein::Rule.substitute)
+    ]
+
+    a = "hello kitten pizza!!"
+    b = "hello    cittin pissssa.."
+
+    HintableLevenshtein.new.distance(a, b).should == 11
+    HintableLevenshtein.new(english_rules).distance(a, b).should == 7.15
+    
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,7 @@
+--colour
+--format
+specdoc
+--loadby
+mtime
+--reverse
+--backtrace

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: hintable_levenshtein
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Joshua Hull
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-18 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: Levenshtein with hints
+email: joshbuddy@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/hintable_levenshtein.rb
+- lib/hintable_levenshtein/event.rb
+- lib/hintable_levenshtein/rule_set.rb
+- spec/hl_spec.rb
+- spec/spec.opts
+has_rdoc: true
+homepage: http://github.com/joshbuddy/hintable_levenshtein
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: joshbuddy-hintable_levenshtein
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Levenshtein with hints
+test_files: 
+- spec/hl_spec.rb