acts_as_fulltextable 0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+*.DS_Store
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in acts_as_fulltextable.gemspec
+rails_version = '~> 3.1'
+
+#gem 'actionpack',   rails_version
+gem 'activerecord', rails_version
+
+gem 'rake', '~> 0.8.7'
+#gem 'mocha', '0.9.7'
+#gem 'sqlite3-ruby', '1.3.1'
+gem 'mysql', :group => :mysql

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Anthony Figueroa
+
+MIT License
+
+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,71 @@
+# ActsAsFulltextable
+
+This gem is based on the old Rails 2 plugin made by boone (https://github.com/boone/acts_as_fulltextable). 
+
+It allows you to create an auxiliary table to be used for full-text searches.
+It behaves like a polymorphic association, so it can be used with any
+ActiveRecord model.
+
+
+It has been tested on Rails 3.1+. Ruby 1.9.1+.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'acts_as_fulltextable'
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem 'acts_as_fulltextable', :git => 'git://github.com/toptierlabs/acts_as_fulltextable.git'
+
+
+## Usage
+
+Create a migration for the models that you want to make searches. 
+
+    $ rails generate fulltext_rows model1 model2 model3 ....
+    $ rake db:migrate
+
+
+Add acts_as_fulltextable in any model, followed by the list of searchable fields.
+
+i.e. 
+```ruby 
+
+class Person < ActiveRecord::Base
+  attr_accessible :age, :description, :name
+
+  acts_as_fulltextable :description, :name
+end
+
+```
+
+You can either run a search on a single model:
+  Model.find_fulltext('query to run', :limit => 10, :offset => 0)
+
+Or you can run it on more models at once:
+  FulltextRow.search('query to run', :only => [:only, :this, :models], :limit => 10, :offset => 0)
+
+## Warning
+
+Should you add acts_as_fulltextable to a new model after the initial migration was run,
+you should execute the following piece of code (a migration or script/console are both fine):
+  
+```ruby 
+
+  NewModel.find(:all).each {|i| i.create_fulltext_record}
+
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/acts_as_fulltextable.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'acts_as_fulltextable/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "acts_as_fulltextable"
+  gem.version       = ActsAsFulltextable::VERSION
+  gem.authors       = ["Anthony Figueroa"]
+  gem.email         = ["afigueroa@toptierlabs.com"]
+  gem.description   = %q{Creates an auxiliary table in order to be used with full-text searches}
+  gem.summary       = %q{It allows you to create an auxiliary to be used for full-text searches. It behaves like a polymorphic association, so it can be used with any ActiveRecord model.}
+  gem.homepage      = "https://github.com/toptierlabs/acts_as_fulltextable"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/lib/acts_as_fulltextable.rb

@@ -0,0 +1,114 @@
+require "acts_as_fulltextable/version"
+require "fulltext_row"
+
+module ActsAsFulltextable
+	extend ActiveSupport::Concern
+
+	module ClassMethods
+	    # Makes a model searchable.
+	    # Takes a list of fields to use to create the index. It also take an option (:check_for_changes,
+	    # which defaults to true) to tell the engine wether it should check if the value of a given
+	    # instance has changed before it actually updates the associated fulltext row.
+	    # If option :parent_id is not nulled, it is used as the field to be used as the parent of the record,
+	    # which is useful if you want to limit your queries to a scope.
+	    # If option :conditions is given, it should be a string containing a ruby expression that 
+	    # equates to true or nil/false. Records are tested with this condition and only those that return true
+	    # add/update the FullTextRow. A record returning false that is already in FullTextRow is removed.
+	    #
+	    def acts_as_fulltextable(*attr_names)
+        puts '///////////////////////////'
+        puts attr_names
+	      configuration = { :check_for_changes => true, :parent_id => nil, :conditions => "true" }
+	      configuration.update(attr_names.pop) while attr_names.last.is_a?(Hash)
+	      configuration[:fields] = attr_names.flatten.uniq.compact
+	      puts 'Going to add act as fields'
+        class_attribute :fulltext_options
+        self.fulltext_options = configuration
+        
+        extend  FulltextableClassMethods
+	      include FulltextableInstanceMethods
+	      self.send('after_create', :create_fulltext_record)
+	      self.send('after_update', :update_fulltext_record)
+	      self.send('has_one', :fulltext_row, :as => :fulltextable, :dependent => :delete)
+	    end
+  end
+  
+  module FulltextableClassMethods
+    
+    def fulltext_fields
+      self.fulltext_options[:fields]
+    end
+
+    # Performs full-text search for objects of this class.
+    # It takes three options:
+    # * limit: maximum number of rows to return. Defaults to 10.
+    # * offset: offset to apply to query. Defaults to 0.
+    # * page: only available with will_paginate plugin installed.
+    # * active_record: wether a ActiveRecord objects should be returned or an Array of [class_name, id]
+    #
+    def find_fulltext(query, options = {})
+      default_options = {:active_record => true}
+      options = default_options.merge(options)
+      unless options[:page]
+        options = {:limit => 10, :offset => 0}.merge(options)
+      end
+      options[:only] = self.to_s.underscore.to_sym # Only look for object belonging to this class
+      # Pass from what class search is invoked.
+      options[:search_class] = Kernel.const_get(self.to_s)
+
+      FulltextRow.search(query, options)
+    end
+  end
+  
+  def self.included(receiver)
+    receiver.extend(ClassMethods)
+  end
+  
+  module FulltextableInstanceMethods
+    # Creates the fulltext_row record for self
+    #
+    def create_fulltext_record
+      puts '=================='
+      puts self.class.to_s
+      puts self.id
+      puts self.fulltext_value
+      puts self.parent_id_value
+      FulltextRow.create(:fulltextable_type => self.class.to_s, :fulltextable_id => self.id, :value => self.fulltext_value, :parent_id => self.parent_id_value) if eval self.class.fulltext_options[:conditions]
+    end
+    
+    # Returns the parent_id value or nil if it wasn't set.
+    #
+    def parent_id_value
+      self.class.fulltext_options[:parent_id].nil? ? nil : self.send(self.class.fulltext_options[:parent_id])
+    end
+    
+    # Updates self's fulltext_row record
+    #
+    def update_fulltext_record
+      if eval self.class.fulltext_options[:conditions]
+        if self.class.fulltext_options[:check_for_changes]
+          row = FulltextRow.find_by_fulltextable_type_and_fulltextable_id(self.class.to_s, self.id) 
+          # If we haven't got a row for the record, yet, create it instead of updating it.
+          if row.nil?
+            self.create_fulltext_record
+            return
+          end
+        end
+        FulltextRow.update_all(["value = ?, parent_id = ?", self.fulltext_value, self.parent_id_value], ["fulltextable_type = ? AND fulltextable_id = ?", self.class.to_s, self.id]) if !(self.class.fulltext_options[:check_for_changes]) || (row.value != self.fulltext_value) || (self.parent_id_value != row.parent_id)
+      else
+
+        row = FulltextRow.find_by_fulltextable_type_and_fulltextable_id(self.class.to_s, self.id)
+        row.destroy unless row.nil?
+      end
+    end  
+    
+    # Returns self's value created by concatenating fulltext fields for its class
+    #
+    def fulltext_value
+      full_value = self.class.fulltext_fields.map {|f| self.send(f)}.join("\n")
+      full_value
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, ActsAsFulltextable

data/lib/acts_as_fulltextable/version.rb

@@ -0,0 +1,3 @@
+module ActsAsFulltextable
+  VERSION = "0.1"
+end

data/lib/fulltext_row.rb

@@ -0,0 +1,162 @@
+# FulltextRow
+#
+# 2008-03-07
+#   Patched by Artūras Šlajus <x11@arturaz.net> for will_paginate support
+# 2008-06-19
+#   Fixed a bug, see acts_as_fulltextable.rb
+class FulltextRow < ActiveRecord::Base
+  attr_accessible :fulltextable_type, :fulltextable_id, :value, :parent_id
+
+  # If FULLTEXT_ROW_TABLE is set, use it as the table name
+  begin
+    set_table_name FULLTEXT_ROW_TABLE if Object.const_get('FULLTEXT_ROW_TABLE')
+  rescue
+  end
+  @@use_advanced_search = false
+  @@use_and_search = false
+  @@use_phrase_search = false
+  
+  belongs_to  :fulltextable,
+              :polymorphic => true
+  validates_presence_of   :fulltextable_type, :fulltextable_id
+  validates_uniqueness_of :fulltextable_id,
+                          :scope => :fulltextable_type
+  # Performs full-text search.
+  # It takes four options:
+  # * limit: maximum number of rows to return (use 0 for all). Defaults to 10.
+  # * offset: offset to apply to query. Defaults to 0.
+  # * page: only available with will_paginate.
+  # * active_record: wether a ActiveRecord objects should be returned or an Array of [class_name, id]
+  # * only: limit search to these classes. Defaults to all classes. (should be a symbol or an Array of symbols)
+  #
+  def self.search(query, options = {})
+    default_options = {:active_record => true, :parent_id => nil}
+    options = default_options.merge(options)
+    unless options[:page]
+      options = {:limit => 10, :offset => 0}.merge(options)
+      options[:offset] = 0 if options[:offset] < 0
+      unless options[:limit].nil?
+        options[:limit] = 10 if options[:limit] < 0
+        options[:limit] = nil if options[:limit] == 0
+      end
+    end
+    options[:only] = [options[:only]] unless options[:only].nil? || options[:only].is_a?(Array)
+    options[:only] = options[:only].map {|o| o.to_s.camelize}.uniq.compact unless options[:only].nil?
+
+    rows = raw_search(query, options[:only], options[:limit], 
+      options[:offset], options[:parent_id], options[:page], 
+      options[:search_class])
+    if options[:active_record]
+      types = {}
+      rows.each {|r| types.include?(r.fulltextable_type) ? (types[r.fulltextable_type] << r.fulltextable_id) : (types[r.fulltextable_type] = [r.fulltextable_id])}
+      objects = {}
+      types.each {|k, v| objects[k] = Object.const_get(k).find_all_by_id(v)}
+      objects.each {|k, v| v.sort! {|x, y| types[k].index(x.id) <=> types[k].index(y.id)}}
+
+      if defined?(WillPaginate) && options[:page]
+        result = WillPaginate::Collection.new(
+          rows.current_page,
+          rows.per_page,
+          rows.total_entries
+        )
+      else
+        result = []
+      end
+
+      rows.each {|r| result << objects[r.fulltextable_type].shift}
+      return result
+    else
+      return rows.map {|r| [r.fulltextable_type, r.fulltextable_id]}
+    end
+  end
+  
+  # Use advanced search mechanism, instead of pure fulltext search.
+  #
+  def self.use_advanced_search!
+    @@use_advanced_search = true
+  end
+  
+  # Force usage of AND search instead of OR. Works only when advanced search
+  # is enabled.
+  #
+  def self.use_and_search!
+    @@use_and_search = true
+  end
+  
+  # Force usage of phrase search instead of OR search. Doesn't work when
+  # advanced search is enabled.
+  #
+  def self.use_phrase_search!
+    @@use_phrase_search = true
+  end
+private
+  # Performs a raw full-text search.
+  # * query: string to be searched
+  # * only: limit search to these classes. Defaults to all classes.
+  # * limit: maximum number of rows to return (use 0 for all). Defaults to 10.
+  # * offset: offset to apply to query. Defaults to 0.
+  # * parent_id: limit query to record with passed parent_id. An Array of ids is fine.
+  # * page: overrides limit and offset, only available with will_paginate.
+  # * search_class: from what class should we take .per_page? Only with will_paginate
+  #
+  def self.raw_search(query, only, limit, offset, parent_id = nil, page = nil, search_class = nil)
+    unless only.nil? || only.empty?
+      only_condition = " AND fulltextable_type IN (#{only.map {|c| (/\A\w+\Z/ === c.to_s) ? "'#{c.to_s}'" : nil}.uniq.compact.join(',')})"
+    else
+      only_condition = ''
+    end
+    unless parent_id.nil?
+      if parent_id.is_a?(Array)
+        only_condition += " AND parent_id IN (#{parent_id.join(',')})"
+      else
+        only_condition += " AND parent_id = #{parent_id.to_i}"
+      end
+    end
+    
+    if @@use_advanced_search
+      query_parts = query.gsub(/[\*\+\-]/, '').split(' ')
+      if @@use_and_search
+        search_query = query_parts.map {|w| "+#{w}*"}.join(' ')
+      else
+        search_query = query_parts.map {|w| "#{w}"}.join(' ')
+      end
+      matches = []
+      matches << [query_parts.map {|w| "+#{w}"}.join(' '), 5] # match_all_exact
+      if @@use_and_search
+        matches << [query_parts.map {|w| "+#{w}*"}.join(' '), query_parts.size > 3 ? 2 : 1] # match_all_wildcard
+      else
+        matches << [query_parts.map {|w| "#{w}"}.join(' '), query_parts.size <= 3 ? 2.5 : 1] # match_some_exact
+      end
+      #matches << [search_query, 0.5] # match_some_wildcard
+      
+      relevancy = matches.map {|m| sanitize_sql(["(match(`value`) against(? in boolean mode) * #{m[1]})", m[0]])}.join(' + ')
+      
+      search_options = {
+        :conditions => [("match(value) against(? in boolean mode)" + only_condition), search_query],
+        :select => "fulltext_rows.fulltextable_type, fulltext_rows.fulltextable_id, #{relevancy} AS relevancy",
+        :order => "relevancy DESC, value ASC"
+      }
+    else
+      if @@use_phrase_search
+        query = "\"#{query}\""
+      else
+        query = query.gsub(/(\S+)/, '\1*')
+      end
+      search_options = {
+        :conditions => [("match(value) against(? in boolean mode)" + only_condition), query],
+        :select => "fulltext_rows.fulltextable_type, fulltext_rows.fulltextable_id, #{sanitize_sql(["match(`value`) against(? in boolean mode) AS relevancy", query])}",
+        :order => "relevancy DESC, value ASC"
+      }
+    end
+
+    if defined?(WillPaginate) && page
+      search_options = search_options.merge(:page => page)
+      unless search_class.nil?
+        search_options = search_options.merge(:per_page => search_class.per_page)
+      end
+      self.paginate(:all, search_options)
+    else
+      self.find(:all, search_options.merge(:limit => limit, :offset => offset))
+    end
+  end
+end

data/lib/generators/fulltext_rows_generator.rb

@@ -0,0 +1,33 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+
+class FulltextRowsGenerator < Rails::Generators::Base
+  include Rails::Generators::Migration
+  argument :models, :type => :array
+  source_root File.expand_path("../templates", __FILE__)
+  
+  attr_accessor :models
+ 
+  def initialize(*runtime_args)
+    super(*runtime_args)
+    #puts @models.to_json
+  end
+
+  def create_model_migrations
+    migration_template("migrate.rb", 'db/migrate/create_fulltext_rows.rb')
+
+  end
+  
+  def self.next_migration_number(path)
+    @migration_number = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i.to_s
+  end
+
+  protected 
+  def banner
+    "Usage: #{$0} [model1 model2 model3 ...]" 
+  end 
+
+    
+end
+

data/lib/generators/templates/migrate.rb

@@ -0,0 +1,22 @@
+class CreateFulltextRows < ActiveRecord::Migration
+  def self.up
+    create_table :fulltext_rows, :options => 'ENGINE=MyISAM' do |t|
+      t.column :fulltextable_type,  :string,  :null => false, :limit => 50
+      t.column :fulltextable_id,    :integer, :null => false
+      t.column :value,              :text,    :null => false, :default => ''
+      t.column :parent_id,          :integer
+    end
+    
+    [<%= @models.join(', ') %>].each do |m|
+      m.find(:all).each {|i| i.create_fulltext_record}
+    end
+    
+    execute "CREATE FULLTEXT INDEX fulltext_index ON fulltext_rows (value)"
+    add_index :fulltext_rows, :parent_id
+    add_index :fulltext_rows, [:fulltextable_type, :fulltextable_id], :unique => true
+  end
+
+  def self.down
+    drop_table :fulltext_rows
+  end
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: acts_as_fulltextable
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Anthony Figueroa
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-26 00:00:00.000000000 Z
+dependencies: []
+description: Creates an auxiliary table in order to be used with full-text searches
+email:
+- afigueroa@toptierlabs.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .DS_Store
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- acts_as_fulltextable.gemspec
+- lib/.DS_Store
+- lib/acts_as_fulltextable.rb
+- lib/acts_as_fulltextable/version.rb
+- lib/fulltext_row.rb
+- lib/generators/.DS_Store
+- lib/generators/fulltext_rows_generator.rb
+- lib/generators/templates/migrate.rb
+homepage: https://github.com/toptierlabs/acts_as_fulltextable
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: It allows you to create an auxiliary to be used for full-text searches. It
+  behaves like a polymorphic association, so it can be used with any ActiveRecord
+  model.
+test_files: []