ximate 0.0.1

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+ext/*.bundle
+ext/*.o
+ext/Makefile
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in ximate.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,38 @@
+= Ximate
+
+ApproXIMATE fuzzy search for Ruby on Rails activerecord models.
+
+== Requirements
+
+* Rails >= 3.0.0
+
+
+== Installation
+
+    gem install ximate
+
+== Usage
+
+In your model puts some like this:
+
+    class Post < ActiveRecord::Base
+      define_index(:en) do
+        add_text title
+        add_text keywords.join(' ')
+        add_text body(:en)
+      end
+    end
+
+Then you can perform a search
+
+    Post.asearch('Economy').where(:public => true).limit(5)
+
+== Questions or problems?
+
+If you have any issues with rplot please add an {issue on
+GitHub}[https://github.com/pioz/ximate/issues] or fork the project and
+send a pull request.
+
+== Copyright
+
+Copyright (c) 2010 Enrico Pilotto. MIT license.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/ext/bitap_fuzzy_search.c

@@ -0,0 +1,88 @@
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <ruby.h>
+
+#include <stdio.h>
+
+char *
+downcase2 (const char *s)
+{
+  int i, size = strlen (s);
+  if (size > 31) size = 31;
+  char *down_s = malloc (size + 1);
+  for (i = 0; i < size; i++)
+    down_s[i] = tolower (s[i]);
+  down_s[size] = '\0';
+  return down_s;
+}
+
+
+static VALUE
+bitap_fuzzy_search (VALUE self, VALUE text, VALUE pattern, VALUE errors_percent)
+{
+  char *p = downcase2 (StringValuePtr (pattern));
+  if (p[0] == '\0') return Qnil;
+  char *t = downcase2 (StringValuePtr (text));
+  int n = strlen (t);
+  int m = strlen (p);
+  if (abs (n - m) > 2) return Qnil;
+  const char *result = NULL;
+  unsigned long *R;
+  unsigned long bitmasks[CHAR_MAX + 1];
+  int i, d;
+
+  int errors = (FIX2INT (errors_percent) * m) / 100;
+  if (errors == 0) errors = 1;
+
+  /* Initialize the bit array R */
+  R = malloc ((errors + 1) * sizeof (*R));
+  for (i = 0; i <= errors; ++i)
+    R[i] = ~1;
+
+  /* Initialize the pattern bitmasks */
+  for (i = 0; i <= CHAR_MAX; ++i)
+    bitmasks[i] = ~0;
+  for (i = 0; i < m; ++i)
+    bitmasks[p[i]] &= ~(1UL << i);
+
+  for (i = 0; t[i] != '\0'; ++i)
+    {
+      /* Update the bit arrays */
+      unsigned long old_Rd1 = R[0];
+
+      R[0] |= bitmasks[t[i]];
+      R[0] <<= 1;
+
+      for (d = 1; d <= errors; ++d)
+        {
+          unsigned long tmp = R[d];
+          /* Substitution is all we care about */
+          R[d] = (old_Rd1 & (R[d] | bitmasks[t[i]])) << 1;
+          old_Rd1 = tmp;
+        }
+
+    if (0 == (R[errors] & (1UL << m)) && (i - m + 1) == 0)
+      {
+        result = (t + i - m) + 1;
+        break;
+      }
+    }
+
+  free (R);
+  free (p);
+  free (t);
+
+  if (result)
+    return rb_str_new2 (result);
+  return Qnil;
+}
+
+
+void
+Init_bitap_fuzzy_search ()
+{
+  /* Define Bitap fuzzy search class */
+  VALUE fuzzy = rb_define_class ("Fuzzy", rb_cObject);
+  rb_define_singleton_method (fuzzy, "search", bitap_fuzzy_search, 3);
+}

data/ext/extconf.rb

@@ -0,0 +1,32 @@
+ENV['RC_ARCHS'] = '' if RUBY_PLATFORM =~ /darwin/
+
+require 'mkmf'
+
+LIBDIR      = Config::CONFIG['libdir']
+INCLUDEDIR  = Config::CONFIG['includedir']
+
+HEADER_DIRS = [
+  # First search /opt/local for macports
+  '/opt/local/include',
+  # Then search /usr/local for people that installed from source
+  '/usr/local/include',
+  # Check the ruby install locations
+  INCLUDEDIR,
+  # Finally fall back to /usr
+  '/usr/include',
+]
+
+LIB_DIRS = [
+  # First search /opt/local for macports
+  '/opt/local/lib',
+  # Then search /usr/local for people that installed from source
+  '/usr/local/lib',
+  # Check the ruby install locations
+  LIBDIR,
+  # Finally fall back to /usr
+  '/usr/lib',
+]
+
+dir_config('fuzzy_search', HEADER_DIRS, LIB_DIRS)
+
+create_makefile('fuzzy_search/fuzzy_search')

data/ext/fuzzy_search.c

@@ -0,0 +1,96 @@
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <ruby.h>
+
+#include <stdio.h>
+
+char *
+downcase (const char *s)
+{
+  int i, size = strlen (s);
+  if (size > 31) size = 31;
+  char *down_s = malloc (size + 1);
+  for (i = 0; i < size; i++)
+    down_s[i] = tolower (s[i]);
+  down_s[size] = '\0';
+  return down_s;
+}
+
+int
+minimum (int x, int y, int z)
+{
+  int min = x;
+  if (y < min) min = y;
+  if (z < min) min = z;
+  return min;
+}
+
+int
+maximun (int x, int y)
+{
+  return (x < y) ? y : x;
+}
+
+int
+levenshtein_distance (const char *s, const char *t)
+{
+  /* Declarations */
+  int n = strlen (s);
+  int m = strlen (t);
+  int i, j, k, distance;
+
+  /* Init matrix */
+  int *prev = malloc ((n + 1) * sizeof (int));
+  int *curr = malloc ((n + 1) * sizeof (int));
+  int *tmp = NULL;
+  for (i = 0; i <= n; ++i) prev[i] = i;
+
+  /* Start */
+  for (i = 1; i <= m; i++)
+    {
+      curr[0] = i;
+      for (j = 1; j <= n; j++)
+        {
+          if (s[i-1] != t[j-1])
+            {
+              k = minimum (curr[j-1], prev[j-1], prev[j]);
+              curr[j] = k + 1;
+            }
+          else
+            curr[j] = prev[j-1];
+        }
+      tmp = prev;
+      prev = curr;
+      curr = tmp;
+      memset ((void*)curr, 0, sizeof (int) * (n + 1));
+    }
+  distance = prev[n];
+
+  free (prev);
+  free (curr);
+
+  return distance;
+}
+
+static VALUE
+fuzzy_equal (VALUE self, VALUE text, VALUE pattern, VALUE errors_percent)
+{
+  const char *t = StringValuePtr (text);
+  const char *p = StringValuePtr (pattern);
+  int errors = (errors_percent * maximun (strlen (t), strlen (p))) / 100;
+  int distance = levenshtein_distance (t, p);
+  // printf ("Allowed errors: %d - Levenshtein's distance: %d\n", errors, distance);
+  if (distance <= errors)
+    return Qtrue;
+  return Qfalse;
+}
+
+
+void
+Init_fuzzy_search ()
+{
+  /* Define Bitap fuzzy search class */
+  VALUE fuzzy = rb_define_class ("Fuzzy", rb_cObject);
+  rb_define_singleton_method (fuzzy, "equal", fuzzy_equal, 3);
+}

data/init.rb

@@ -0,0 +1 @@
+require 'ximate'

data/lib/ximate.rb

@@ -0,0 +1,5 @@
+require File.join(File.dirname(__FILE__), 'ximate/search')
+require File.join(File.dirname(__FILE__), 'ximate/activerecord/relation')
+require File.join(File.dirname(__FILE__), '../ext/fuzzy_search')
+
+ActiveRecord::Base.send(:include, Ximate)

data/lib/ximate/activerecord/relation.rb

@@ -0,0 +1,22 @@
+module ActiveRecord
+
+  class Relation
+    attr_accessor :ranks
+
+    alias_method :orig_to_a, :to_a
+    alias_method :orig_initialize, :initialize
+
+    def initialize(klass, table)
+      @ranks = {}
+      orig_initialize(klass, table)
+    end
+
+    def to_a
+      return orig_to_a if @ranks.empty?
+      orig_to_a.sort do |x, y|
+        @ranks[y.id] <=> @ranks[x.id]
+      end
+    end
+  end
+
+end

data/lib/ximate/search.rb

@@ -0,0 +1,79 @@
+module Ximate
+
+  DATA = {}
+  OPTIONS = {:order_by_rank => true, :error_percent => 20}
+
+  def self.included(base)
+    base.extend(Search)
+  end
+
+
+  module Search
+    def define_index(locale = I18n.default_locale, &block)
+      table = self.to_s.underscore.pluralize.to_sym
+      DATA[locale.to_sym] ||= {}
+      DATA[locale.to_sym][table] ||= {}
+
+      extend  ClassMethods
+      include InstanceMethods
+
+      after_save :update_index
+
+      self.to_s.classify.constantize.all.each do |p|
+        p.update_index(locale, &block)
+      end
+
+    end
+  end
+
+
+  module ClassMethods
+
+    def asearch(pattern)
+      table = self.to_s.underscore.pluralize.to_sym
+      matches = {}
+      DATA[I18n.locale] ||= {}
+      DATA[I18n.locale][table] ||= {}
+      DATA[I18n.locale][table].each do |word, ids|
+        if Fuzzy.equal(word, pattern.downcase, OPTIONS[:error_percent])
+          ids.each {|id, rank| matches[id] = matches[id].to_i + rank}
+        end
+      end
+      return where('1 = 0') if matches.empty?
+      rel = scoped
+      rel.ranks = matches if OPTIONS[:order_by_rank]
+      rel.where("#{table}.id IN (#{matches.keys.join(',')})")
+    end
+  end
+
+
+  module InstanceMethods
+
+    def add_text(text)
+      @words ||= []
+      @words += text.to_s.gsub(/<[^>]*>/i, ' ').gsub(/[\.,'":;!\?\(\)]/, ' ').split(' ').map{|word| word.downcase}
+    end
+
+    def update_index(locale = I18n.default_locale, &block)
+      table = self.class.to_s.underscore.pluralize.to_sym
+      remove_index(locale)
+      instance_eval(&block)
+      @words.each do |word|
+        ids = (DATA[locale.to_sym][table][word] ||= {})
+        ids[self.id] ||= 0
+        ids[self.id] += 1
+      end
+    end
+
+    def remove_index(locale)
+      table = self.class.to_s.underscore.pluralize.to_sym
+      @words = []
+      DATA[locale.to_sym][table].each do |word, ids|
+        ids.delete(self.id)
+        DATA[locale.to_sym][table].delete(word) if ids.empty?
+      end
+    end
+
+  end
+
+end

data/lib/ximate/version.rb

@@ -0,0 +1,3 @@
+module Ximate
+  VERSION = "0.0.1"
+end

data/ximate.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'ximate/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'ximate'
+  s.version     = Ximate::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Enrico Pilotto']
+  s.email       = ['enrico@megiston.it']
+  s.homepage    = 'https://github.com/pioz/ximate'
+  s.summary     = %q{Approximate fuzzy search for Ruby on Rails}
+  s.description = %q{Approximate fuzzy search for Ruby on Rails activerecord models.}
+  s.license     = 'MIT'
+
+  s.rubyforge_project = 'ximate'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.extensions    = ['ext/extconf.rb']
+  s.require_paths = ['lib', 'ext']
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: ximate
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Enrico Pilotto
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-05 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: Approximate fuzzy search for Ruby on Rails activerecord models.
+email: 
+- enrico@megiston.it
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- ext/bitap_fuzzy_search.c
+- ext/extconf.rb
+- ext/fuzzy_search.c
+- init.rb
+- lib/ximate.rb
+- lib/ximate/activerecord/relation.rb
+- lib/ximate/search.rb
+- lib/ximate/version.rb
+- ximate.gemspec
+has_rdoc: true
+homepage: https://github.com/pioz/ximate
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+- ext
+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: ximate
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: Approximate fuzzy search for Ruby on Rails
+test_files: []
+