fuzzy_search 0.3

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Kristian Meier, (c) 2011 David Simon
+
+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.md

@@ -0,0 +1,54 @@
+# fuzzy_search
+
+Search through your models while tolerating slight mis-spellings. If you have a Person in your database named O'Reilly, you want your users to be able to find it even if they type "OReilly" or "O'Rielly".
+
+This gem is not as powerful as dedicated search tools like Solr, but it's much quicker and easier to set up. It uses your regular database for indexing, rather than an external service that has to be maintained separately.
+
+Currently only Rails 2 is supported. I welcome any contributions that resolve this!
+
+## Installation
+
+Add `fuzzy_search` to your Rails project's Gemfile, and do the usual `bundle install` dance.
+
+Then, run the generator and migrate to create the search table:
+
+    $ ./script/generate fuzzy_search_setup
+    $ rake db:migrate
+
+## Example
+
+To allow a model to be searched, specify which columns are to be indexed:
+
+```ruby
+class Person < ActiveRecord::Base
+    # ...
+    fuzzy_searchable_on :first_name, :last_name
+    # ...
+end
+```
+Now, the gem will update the index whenever a Person is saved. To index all the existing records in a model, do this:
+
+```ruby
+Person.rebuild_fuzzy_search_index!
+```
+
+The fuzzy_search method returns arrays:
+
+```ruby
+people = Person.fuzzy_search "OReilly"
+```
+
+Fuzzy find works on scopes too, including named_scopes and on-the-fly scopes:
+
+```ruby
+people = Person.scoped({:conditions => ["state='active'"]}).fuzzy_search("OReilly")
+```
+
+## Licence and credits
+
+This gem is based on the rails-fuzzy-search plugin by iulianu
+(https://github.com/iulianu/rails-fuzzy-search), which was in
+turn based on the act_as_fuzzy_search plugin for DataMapper
+by mkristian (http://github.com/mkristian/kristians_rails_plugins).
+
+This gem is available under the MIT Licence.

data/Rakefile

@@ -0,0 +1,79 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rdoc/task'
+require 'rubygems/package_task'
+
+def common_test_settings(t)
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test fuzzy_search.'
+Rake::TestTask.new(:test) do |t|
+  common_test_settings(t)
+end
+
+desc 'Run tests automatically as files change'
+task :watchr do |t|
+  exec 'watchr test/test.watchr'
+end
+
+desc 'Generate documentation for fuzzy_search.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'FuzzySearch'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'rcov/rcovtask'
+  
+  Rcov::RcovTask.new(:rcov) do |t|
+    common_test_settings(t)
+    t.rcov_opts << '-o coverage -x "/ruby/,/gems/,/test/,/migrate/"'
+  end
+rescue LoadError
+  # Rcov wasn't available
+end
+
+begin
+  require 'ruby-prof/task'
+  
+  RubyProf::ProfileTask.new(:profile) do |t|
+    common_test_settings(t)
+    t.output_dir = "#{File.dirname(__FILE__)}/profile"
+    t.printer = :call_tree
+    t.min_percent = 10
+  end
+rescue LoadError
+  # Ruby-prof wasn't available
+end
+
+require 'lib/fuzzy_search_ver'
+gemspec = Gem::Specification.new do |s|
+  s.name         = "fuzzy_search"
+  s.version      = FuzzySearch::VERSION
+  s.authors      = ["Kristian Meier", "David Mike Simon"]
+  s.email        = "david.mike.simon@gmail.com"
+  s.homepage     = "http://github.com/DavidMikeSimon/fuzzy_search"
+  s.summary      = "Search ActiveRecord models for strings similar to a query string"
+  s.description  = "Implements fuzzy searching for ActiveRecord, using your database's own indexing instead of depending on external tools."
+
+  s.files        = `git ls-files .`.split("\n") - [".gitignore"]
+  s.platform     = Gem::Platform::RUBY
+  s.require_path = 'lib'
+  s.rubyforge_project = '[none]'
+
+  s.add_dependency('ar-extensions', '0.9.5')
+end
+
+Gem::PackageTask.new(gemspec) do |pkg|
+end

data/lib/fuzzy_model_extensions.rb

@@ -0,0 +1,112 @@
+module FuzzySearch
+  module ModelExtensions
+    def self.included(base)
+      base.extend ClassMethods
+
+      base.write_inheritable_attribute :fuzzy_search_properties, []
+      base.class_inheritable_reader :fuzzy_search_properties
+
+      base.write_inheritable_attribute :fuzzy_search_threshold, 5
+      base.class_inheritable_reader :fuzzy_search_threshold
+    end
+
+    module ClassMethods
+      def fuzzy_searchable_on(*properties)
+        # TODO: Complain if fuzzy_searchable_on is called more than once
+        write_inheritable_attribute :fuzzy_search_properties, properties
+        has_many :fuzzy_search_trigrams, :as => :rec, :dependent => :destroy
+        after_save :update_fuzzy_search_trigrams!
+        named_scope :fuzzy_search_scope, lambda { |words| generate_fuzzy_search_scope_params(words) }
+        extend WordNormalizerClassMethod unless respond_to? :normalize
+        include InstanceMethods
+      end
+
+      def fuzzy_search(words)
+        # TODO: If fuzzy_search_scope doesn't exist, provide a useful error
+        fuzzy_search_scope(words).all
+      end
+
+      def rebuild_fuzzy_search_index!
+        FuzzySearchTrigram.delete_all(:rec_type => self.class.name)
+        all.each do |rec|
+          rec.update_fuzzy_search_trigrams!
+        end
+      end
+
+      private
+
+      def generate_fuzzy_search_scope_params(words)
+        no_results = {:conditions => "0 = 1"}
+        return no_results unless words != nil
+        words = words.strip.to_s.split(/[\s\-]+/) unless words.instance_of? Array
+        return no_results unless words.size > 0
+
+        trigrams = []
+        words.each do |w|
+          word = ' ' + normalize(w) + ' '
+          word_as_chars = word.mb_chars
+          trigrams << (0..word_as_chars.length-3).collect {|idx| word_as_chars[idx,3].to_s}
+        end
+        trigrams = trigrams.flatten.uniq
+
+        # Transform the list of columns in the searchable entity into 
+        # a SQL fragment like:
+        # "table_name.id, table_name.field1, table_name.field2, ..."
+        entity_fields = columns.map {|col| table_name + "." + col.name}.join(", ")
+
+        # The SQL expression for calculating fuzzy_score
+        # Has to be used multiple times because some databases (i.e. Postgres) do not support HAVING on named SELECT fields
+        # TODO: See if we can't get the count(*) out of here, that's a non-trivial operation in some databases
+        fuzzy_score_expr = "(((count(*)*100.0)/#{trigrams.size}) + " +
+          "((count(*)*100.0)/(SELECT count(*) FROM fuzzy_search_trigrams WHERE rec_id = #{table_name}.#{primary_key} AND rec_type = '#{name}')))/2.0"
+
+        # TODO: Optimize this query. In a large trigram table, this is going to go through a lot of dead ends.
+        # Maybe I need to just bite the bullet and learn how to do procedures? That would break cross-database compatibility, though...
+        return {
+          :select => "#{fuzzy_score_expr} AS fuzzy_score, #{entity_fields}",
+          :joins => ["LEFT OUTER JOIN fuzzy_search_trigrams ON fuzzy_search_trigrams.rec_id = #{table_name}.#{primary_key}"],
+          :conditions => ["fuzzy_search_trigrams.token IN (?) AND rec_type = '#{name}'", trigrams],
+          :group => "#{table_name}.#{primary_key}",
+          :order => "fuzzy_score DESC",
+          :having => "#{fuzzy_score_expr} >= #{fuzzy_search_threshold}"
+        }
+      end
+    end
+
+    module WordNormalizerClassMethod
+      def normalize(word)
+        word.mb_chars.normalize(:kd).gsub(/[^\x00-\x7F]/n,'').downcase.to_s
+      end
+    end
+
+    module InstanceMethods
+      def update_fuzzy_search_trigrams!
+        FuzzySearchTrigram.delete_all(:rec_id => self.id, :rec_type => self.class.name)
+
+        # to avoid double entries
+        tokens = []
+        self.class.fuzzy_search_properties.each do |prop|
+          prop_value = send(prop)
+          next if prop_value.nil?
+          # split the property into words (which are separated by whitespaces)
+          # and generate the trigrams for each word
+          prop_value.to_s.split(/[\s\-]+/).each do |p|
+            # put a space in front and at the end to emphasize the endings
+            word = ' ' + self.class.normalize(p) + ' '
+            word_as_chars = word.mb_chars
+            (0..word_as_chars.length - 3).each do |idx|
+              token = word_as_chars[idx, 3].to_s
+              tokens << token unless tokens.member?(token)
+            end
+          end
+        end
+
+        FuzzySearchTrigram.import(
+          [:token, :rec_id, :rec_type],
+          tokens.map{|t| [t, self.id, self.class.name]},
+          :validate => false
+        )
+      end
+    end
+  end
+end

data/lib/fuzzy_search.rb

@@ -0,0 +1,17 @@
+require 'ar-extensions' # External dependency
+# Monkey patch a bug in ar-extensions which breaks postgres compatibility
+module ActiveRecord # :nodoc:
+  module ConnectionAdapters # :nodoc:
+    class AbstractAdapter # :nodoc:
+      def next_value_for_sequence(sequence_name)
+        %{nextval('#{sequence_name}')}
+      end
+    end
+  end
+end
+
+require 'fuzzy_model_extensions'
+require 'fuzzy_search_trigram'
+require 'fuzzy_search_ver'
+
+ActiveRecord::Base.send(:include, FuzzySearch::ModelExtensions)

data/lib/fuzzy_search_trigram.rb

@@ -0,0 +1,2 @@
+class FuzzySearchTrigram < ActiveRecord::Base
+end

data/lib/fuzzy_search_ver.rb

@@ -0,0 +1,3 @@
+module FuzzySearch
+  VERSION = "0.3"
+end

data/rails_generators/fuzzy_search_setup/fuzzy_search_setup_generator.rb

@@ -0,0 +1,8 @@
+class FuzzySearchSetupGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      m.migration_template "create_fuzzy_search_trigrams.rb", "db/migrate",
+        :migration_file_name => "create_fuzzy_search_trigrams"
+    end
+  end
+end

data/rails_generators/fuzzy_search_setup/templates/create_fuzzy_search_trigrams.rb

@@ -0,0 +1,15 @@
+class CreateFuzzySearchTrigrams < ActiveRecord::Migration
+  def self.up
+    create_table :fuzzy_search_trigrams, :id => false do |t|
+      t.column :token, :string, :limit => 3
+      t.column :rec_type, :string
+      t.column :rec_id, :integer
+    end
+
+    add_index :fuzzy_search_trigrams, [:rec_type, :token]
+  end
+
+  def self.down
+    drop_table :fuzzy_search_trigrams
+  end
+end

data/test/app_root/app/models/email.rb

@@ -0,0 +1,3 @@
+class Email < ActiveRecord::Base
+  fuzzy_searchable_on :address
+end

data/test/app_root/app/models/person.rb

@@ -0,0 +1,3 @@
+class Person < ActiveRecord::Base
+  fuzzy_searchable_on :first_name, :last_name
+end

data/test/app_root/config/boot.rb

@@ -0,0 +1,115 @@
+# Allow customization of the rails framework path
+RAILS_FRAMEWORK_ROOT = (ENV['RAILS_FRAMEWORK_ROOT'] || "#{File.dirname(__FILE__)}/../../../../../../vendor/rails") unless defined?(RAILS_FRAMEWORK_ROOT) 
+
+# Don't change this file!
+# Configure your app in config/environment.rb and config/environments/*.rb
+
+RAILS_ROOT = "#{File.dirname(__FILE__)}/.." unless defined?(RAILS_ROOT)
+
+module Rails
+  class << self
+    def boot!
+      unless booted?
+        preinitialize
+        pick_boot.run
+      end
+    end
+
+    def booted?
+      defined? Rails::Initializer
+    end
+
+    def pick_boot
+      (vendor_rails? ? VendorBoot : GemBoot).new
+    end
+
+    def vendor_rails?
+      File.exist?(RAILS_FRAMEWORK_ROOT)
+    end
+
+    def preinitialize
+      load(preinitializer_path) if File.exist?(preinitializer_path)
+    end
+
+    def preinitializer_path
+      "#{RAILS_ROOT}/config/preinitializer.rb"
+    end
+  end
+
+  class Boot
+    def run
+      load_initializer
+      Rails::Initializer.run(:set_load_path)
+    end
+  end
+
+  class VendorBoot < Boot
+    def load_initializer
+      require "#{RAILS_FRAMEWORK_ROOT}/railties/lib/initializer"
+      Rails::Initializer.run(:install_gem_spec_stubs)
+      Rails::GemDependency.add_frozen_gem_path
+    end
+  end
+
+  class GemBoot < Boot
+    def load_initializer
+      self.class.load_rubygems
+      load_rails_gem
+      require 'initializer'
+    end
+
+    def load_rails_gem
+      if version = self.class.gem_version
+        gem 'rails', version
+      else
+        gem 'rails'
+      end
+    rescue Gem::LoadError => load_error
+      $stderr.puts %(Missing the Rails #{version} gem. Please `gem install -v=#{version} rails`, update your RAILS_GEM_VERSION setting in config/environment.rb for the Rails version you do have installed, or comment out RAILS_GEM_VERSION to use the latest version installed.)
+      exit 1
+    end
+
+    class << self
+      def rubygems_version
+        Gem::RubyGemsVersion rescue nil
+      end
+
+      def gem_version
+        if defined? RAILS_GEM_VERSION
+          RAILS_GEM_VERSION
+        elsif ENV.include?('RAILS_GEM_VERSION')
+          ENV['RAILS_GEM_VERSION']
+        else
+          parse_gem_version(read_environment_rb)
+        end
+      end
+
+      def load_rubygems
+        require 'rubygems'
+        min_version = '1.3.1'
+        unless rubygems_version >= min_version
+          $stderr.puts %Q(Rails requires RubyGems >= #{min_version} (you have #{rubygems_version}). Please `gem update --system` and try again.)
+          exit 1
+        end
+ 
+      rescue LoadError
+        $stderr.puts %Q(Rails requires RubyGems >= #{min_version}. Please install RubyGems and try again: http://rubygems.rubyforge.org)
+        exit 1
+      end
+
+      def parse_gem_version(text)
+        $1 if text =~ /^[^#]*RAILS_GEM_VERSION\s*=\s*["']([!~<>=]*\s*[\d.]+)["']/
+      end
+
+      private
+        def read_environment_rb
+          environment_rb = "#{RAILS_ROOT}/config/environment.rb"
+          environment_rb = "#{HELPER_RAILS_ROOT}/config/environment.rb" unless File.exists?(environment_rb)
+          File.read(environment_rb)
+        end
+    end
+  end
+end
+
+# All that for this:
+Rails.boot!

data/test/app_root/config/database.yml

@@ -0,0 +1,6 @@
+test:
+  adapter: sqlite3
+  database: ":memory:"
+  verbosity: quiet
+  pool: 5
+  timeout: 5000

data/test/app_root/config/environment.rb

@@ -0,0 +1,9 @@
+require File.join(File.dirname(__FILE__), 'boot')
+
+RAILS_GEM_VERSION = '2.3.12'
+
+Rails::Initializer.run do |config|
+  config.cache_classes = false
+  config.whiny_nils = true
+  config.action_controller.session = {:key => 'rails_session', :secret => 'd229e4d22437432705ab3985d4d246'}
+end

data/test/app_root/config/environments/test.rb

@@ -0,0 +1,20 @@
+config.cache_classes = true
+
+# Log error messages when you accidentally call methods on nil.
+config.whiny_nils = true
+
+# Show full error reports and disable caching
+config.action_controller.consider_all_requests_local = true
+config.action_controller.perform_caching             = false
+config.action_view.cache_template_loading            = true
+
+# Disable request forgery protection in test environment
+config.action_controller.allow_forgery_protection    = false
+
+# Tell Action Mailer not to deliver emails to the real world.
+# The :test delivery method accumulates sent emails in the
+# ActionMailer::Base.deliveries array.
+config.action_mailer.delivery_method = :test
+
+# Avoid excessively huge log files
+config.log_level = :error

data/test/app_root/config/routes.rb

@@ -0,0 +1,4 @@
+ActionController::Routing::Routes.draw do |map|
+  map.connect ':controller/:action/:id'
+  map.connect ':controller/:action/:id.:format'
+end

data/test/app_root/db/migrate/20100529235049_create_tables.rb

@@ -0,0 +1,18 @@
+class CreateTables < ActiveRecord::Migration
+  def self.up
+    create_table :emails do |t|
+      t.string :address
+    end
+
+    create_table :people do |t|
+      t.string :first_name
+      t.string :last_name
+      t.string :hobby
+    end
+  end
+  
+  def self.down
+    drop_table :emails
+    drop_table :people
+  end
+end

data/test/app_root/db/migrate/20111013132330_create_fuzzy_search_trigrams.rb

@@ -0,0 +1,15 @@
+class CreateFuzzySearchTrigrams < ActiveRecord::Migration
+  def self.up
+    create_table :fuzzy_search_trigrams, :id => false do |t|
+      t.column :token, :string, :limit => 3
+      t.column :rec_type, :string
+      t.column :rec_id, :integer
+    end
+
+    add_index :fuzzy_search_trigrams, [:rec_type, :token]
+  end
+
+  def self.down
+    drop_table :fuzzy_search_trigrams
+  end
+end

data/test/app_root/vendor/plugins/fuzzy_search/init.rb

@@ -0,0 +1,2 @@
+# Pretend the gem is a plugin for the test environment
+require "#{File.dirname(__FILE__)}/../../../../../lib/fuzzy_search.rb"

data/test/factories.rb

@@ -0,0 +1,13 @@
+require 'factory_girl'
+
+FactoryGirl.define do
+  factory :person do
+    first_name 'John'
+    last_name 'Doe'
+    hobby 'Flying kites'
+  end
+
+  factory :email do
+    address 'foo@bar.com'
+  end
+end

data/test/test.watchr

@@ -0,0 +1,6 @@
+require 'autowatchr'
+
+Autowatchr.new(self) do |config|
+  config.test_re = '^%s.+/.+\_test.rb$' % config.test_dir
+  config.test_file = "unit/%s_test.rb"
+end

data/test/test_helper.rb

@@ -0,0 +1,69 @@
+ENV['RAILS_ENV'] = 'test'
+
+prev_dir = Dir.getwd
+begin
+  Dir.chdir("#{File.dirname(__FILE__)}/..")
+  
+  begin
+    # Used when running test files directly
+    $LOAD_PATH << "#{File.dirname(__FILE__)}/../lib"
+    require "#{File.dirname(__FILE__)}/app_root/config/environment"
+  rescue LoadError
+    # This is needed for root-level rake task 'test'
+    require "app_root/config/environment"
+  end
+ensure
+  Dir.chdir(prev_dir)
+end
+
+require 'rubygems'
+require 'minitest/autorun'
+require 'redgreen'
+require 'pp'
+
+# Set default string encoding to unicode
+$KCODE = 'u'
+
+module MiniTest
+  def self.filter_backtrace(backtrace)
+    backtrace = backtrace.select do |e|
+      if ENV['FULL_BACKTRACE']
+        true
+      else
+        !(e.include?("/ruby/") || e.include?("/gems/"))
+      end
+    end
+
+    common_prefix = nil
+    backtrace.each do |elem|
+      next if elem.start_with? "./"
+      if common_prefix
+        until elem.start_with? common_prefix
+          common_prefix.chop!
+        end
+      else
+        common_prefix = String.new(elem)
+      end
+    end
+
+    return backtrace.map do |element|
+      if element.start_with? common_prefix && common_prefix.size < element.size
+        element[common_prefix.size, element.size]
+      elsif element.start_with? "./"
+        element[2, element.size]
+      elsif element.start_with?(Dir.getwd)
+        element[Dir.getwd.size+1, element.size]
+      else
+        element
+      end
+    end
+  end
+end
+
+require 'factories'
+MiniTest::Unit::TestCase.send(:include, Factory::Syntax::Methods)
+
+MiniTest::Unit::TestCase.add_setup_hook do
+  ActiveRecord::Migration.verbose = false
+  ActiveRecord::Migrator.migrate("#{Rails.root}/db/migrate") # Migrations in the test app
+end

data/test/unit/fuzzy_search_test.rb

@@ -0,0 +1,108 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+describe "fuzzy_search" do
+  before do 
+    create(:person, :last_name => "meier", :first_name => "kristian")
+    create(:person, :last_name => "meyer", :first_name => "christian", :hobby => "Bicycling")
+    create(:person, :last_name => "mayr", :first_name => "Chris")
+    create(:person, :last_name => "maier", :first_name => "christoph", :hobby => "Bicycling")
+    create(:person, :last_name => "mueller", :first_name => "andreas")
+    create(:person, :last_name => "öther", :first_name => "name")
+    create(:person, :last_name => "yet another", :first_name => "name")
+
+    create(:email, :address => "öscar@web.oa")
+    create(:email, :address => "david.mike.simon@gmail.com")
+    create(:email, :address => "billg@microsoft.com")
+  end
+
+  after do
+    Person.delete_all
+    Email.delete_all
+    FuzzySearchTrigram.delete_all
+  end
+
+  it "can search for records with similar strings to a query" do
+    assert_equal 3, Person.fuzzy_search("meyr").size
+    assert_equal 1, Person.fuzzy_search("myr").size
+  end
+  
+  it "can search on multiple columns" do
+    result = Person.fuzzy_search("kristin meiar")
+    assert_equal "kristian", result[0].first_name
+    assert_equal "meier", result[0].last_name
+  end
+
+  it "sorts results by their fuzzy match score" do
+    result = Person.fuzzy_search("kristian meier")
+    assert_equal 100, result[0].fuzzy_score
+    prior = 100
+    (1..3).each do |idx|
+      assert result[idx].fuzzy_score <= prior
+      prior = result[idx].fuzzy_score
+    end
+  end
+
+  it "returns an empty result set when given an empty query string" do
+    assert_empty Person.fuzzy_search("")
+    assert_empty Person.fuzzy_search(nil)
+  end
+
+  it "updates the search index automatically when a new record is saved" do
+    assert_empty Person.fuzzy_search("Dave")
+    create(:person, :first_name => "David", :last_name => "Simon")
+    refute_empty Person.fuzzy_search("Dave")
+  end
+
+  it "updates the search index automatically when a record is updated" do
+    assert_empty Person.fuzzy_search("Obama")
+    refute_empty Person.fuzzy_search("yet")
+
+    p = Person.find_by_last_name("yet another")
+    p.last_name = "Obama"
+    p.save!
+
+    refute_empty Person.fuzzy_search("Obama")
+    assert_empty Person.fuzzy_search("yet")
+  end
+
+  it "destroys search index entries when a record is destroyed" do
+    size = Person.fuzzy_search("other").size
+    assert size > 0
+    Person.destroy_all(:last_name => "öther")
+    assert_equal size, Person.fuzzy_search("other").size + 1
+  end
+
+  it "only finds records of the ActiveRecord model you're searching on" do
+    refute_empty Person.fuzzy_search("meier")
+    assert_empty Email.fuzzy_search("meier")
+
+    assert_empty Person.fuzzy_search("oscar")
+    refute_empty Email.fuzzy_search("oscar")
+  end
+
+  it "can normalize strings" do
+    assert_equal("aaaaaa", Person.normalize("ÀÁÂÃÄÅ"))
+  end
+
+  it "normalizes strings before searching on them" do
+    assert_equal 1, Person.fuzzy_search("Müll").size
+    assert_equal 1, Email.fuzzy_search("öscar").size
+  end
+
+  it "normalizes record strings before indexing them" do
+    assert_equal 1, Email.fuzzy_search("oscar").size
+  end
+
+  it "can search through a scope" do
+    scope = Person.scoped({:conditions => {:hobby => "Bicycling"}})
+    assert_equal 4, Person.fuzzy_search("chris").size
+    assert_equal 2, scope.fuzzy_search("chris").size
+  end
+
+  it "can rebuild the search index from scratch" do
+    FuzzySearchTrigram.delete_all
+    assert_empty Person.fuzzy_search("chris")
+    Person.rebuild_fuzzy_search_index!
+    refute_empty Person.fuzzy_search("chris")
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: fuzzy_search
+version: !ruby/object:Gem::Version 
+  hash: 13
+  prerelease: 
+  segments: 
+  - 0
+  - 3
+  version: "0.3"
+platform: ruby
+authors: 
+- Kristian Meier
+- David Mike Simon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-13 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ar-extensions
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 0
+        - 9
+        - 5
+        version: 0.9.5
+  type: :runtime
+  version_requirements: *id001
+description: Implements fuzzy searching for ActiveRecord, using your database's own indexing instead of depending on external tools.
+email: david.mike.simon@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/fuzzy_model_extensions.rb
+- lib/fuzzy_search.rb
+- lib/fuzzy_search_trigram.rb
+- lib/fuzzy_search_ver.rb
+- rails_generators/fuzzy_search_setup/fuzzy_search_setup_generator.rb
+- rails_generators/fuzzy_search_setup/templates/create_fuzzy_search_trigrams.rb
+- test/app_root/app/models/email.rb
+- test/app_root/app/models/person.rb
+- test/app_root/config/boot.rb
+- test/app_root/config/database.yml
+- test/app_root/config/environment.rb
+- test/app_root/config/environments/test.rb
+- test/app_root/config/routes.rb
+- test/app_root/db/migrate/20100529235049_create_tables.rb
+- test/app_root/db/migrate/20111013132330_create_fuzzy_search_trigrams.rb
+- test/app_root/vendor/plugins/fuzzy_search/init.rb
+- test/factories.rb
+- test/test.watchr
+- test/test_helper.rb
+- test/unit/fuzzy_search_test.rb
+homepage: http://github.com/DavidMikeSimon/fuzzy_search
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: "[none]"
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Search ActiveRecord models for strings similar to a query string
+test_files: []
+