textacular 3.0.0

data/lib/textacular.rb

@@ -0,0 +1,227 @@
+require 'active_record'
+
+require 'textacular/version'
+
+module Textacular
+  def self.searchable_language
+    'english'
+  end
+
+  def search(query = "", exclusive = true)
+    basic_search(query, exclusive)
+  end
+
+  def basic_search(query = "", exclusive = true)
+    exclusive, query = munge_exclusive_and_query(exclusive, query)
+    parsed_query_hash = parse_query_hash(query)
+    similarities, conditions = basic_similarities_and_conditions(parsed_query_hash)
+    assemble_query(similarities, conditions, exclusive)
+  end
+
+  def advanced_search(query = "", exclusive = true)
+    exclusive, query = munge_exclusive_and_query(exclusive, query)
+    parsed_query_hash = parse_query_hash(query)
+    similarities, conditions = advanced_similarities_and_conditions(parsed_query_hash)
+    assemble_query(similarities, conditions, exclusive)
+  end
+
+  def fuzzy_search(query = '', exclusive = true)
+    exclusive, query = munge_exclusive_and_query(exclusive, query)
+    parsed_query_hash = parse_query_hash(query)
+    similarities, conditions = fuzzy_similarities_and_conditions(parsed_query_hash)
+    assemble_query(similarities, conditions, exclusive)
+  end
+
+  def method_missing(method, *search_terms)
+    return super if self == ActiveRecord::Base
+    if Helper.dynamic_search_method?(method, self.columns)
+      exclusive = Helper.exclusive_dynamic_search_method?(method, self.columns)
+      columns = exclusive ? Helper.exclusive_dynamic_search_columns(method) : Helper.inclusive_dynamic_search_columns(method)
+      metaclass = class << self; self; end
+      metaclass.__send__(:define_method, method) do |*args|
+        query = columns.inject({}) do |query, column|
+          query.merge column => args.shift
+        end
+        self.send(Helper.search_type(method), query, exclusive)
+      end
+      __send__(method, *search_terms, exclusive)
+    else
+      super
+    end
+  rescue ActiveRecord::StatementInvalid
+    super
+  end
+
+  def respond_to?(method, include_private = false)
+    return super if self == ActiveRecord::Base
+    Helper.dynamic_search_method?(method, self.columns) or super
+  rescue StandardError
+    super
+  end
+
+  private
+
+  def munge_exclusive_and_query(exclusive, query)
+    unless query.is_a?(Hash)
+      exclusive = false
+      query = searchable_columns.inject({}) do |terms, column|
+        terms.merge column => query.to_s
+      end
+    end
+
+    [exclusive, query]
+  end
+
+  def parse_query_hash(query, table_name = quoted_table_name)
+    table_name = connection.quote_table_name(table_name)
+
+    results = []
+
+    query.each do |column_or_table, search_term|
+      if search_term.is_a?(Hash)
+        results += parse_query_hash(search_term, column_or_table)
+      else
+        column = connection.quote_column_name(column_or_table)
+        search_term = connection.quote normalize(Helper.normalize(search_term))
+
+        results << [table_name, column, search_term]
+      end
+    end
+
+    results
+  end
+
+  def basic_similarities_and_conditions(parsed_query_hash)
+    parsed_query_hash.inject([[], []]) do |(similarities, conditions), query_args|
+      similarities << basic_similarity_string(*query_args)
+      conditions << basic_condition_string(*query_args)
+
+      [similarities, conditions]
+    end
+  end
+
+  def basic_similarity_string(table_name, column, search_term)
+    "ts_rank(to_tsvector(#{quoted_language}, #{table_name}.#{column}::text), plainto_tsquery(#{quoted_language}, #{search_term}::text))"
+  end
+
+  def basic_condition_string(table_name, column, search_term)
+    "to_tsvector(#{quoted_language}, #{table_name}.#{column}::text) @@ plainto_tsquery(#{quoted_language}, #{search_term}::text)"
+  end
+
+  def advanced_similarities_and_conditions(parsed_query_hash)
+    parsed_query_hash.inject([[], []]) do |(similarities, conditions), query_args|
+      similarities << advanced_similarity_string(*query_args)
+      conditions << advanced_condition_string(*query_args)
+
+      [similarities, conditions]
+    end
+  end
+
+  def advanced_similarity_string(table_name, column, search_term)
+    "ts_rank(to_tsvector(#{quoted_language}, #{table_name}.#{column}::text), to_tsquery(#{quoted_language}, #{search_term}::text))"
+  end
+
+  def advanced_condition_string(table_name, column, search_term)
+    "to_tsvector(#{quoted_language}, #{table_name}.#{column}::text) @@ to_tsquery(#{quoted_language}, #{search_term}::text)"
+  end
+
+  def fuzzy_similarities_and_conditions(parsed_query_hash)
+    parsed_query_hash.inject([[], []]) do |(similarities, conditions), query_args|
+      similarities << fuzzy_similarity_string(*query_args)
+      conditions << fuzzy_condition_string(*query_args)
+
+      [similarities, conditions]
+    end
+  end
+
+  def fuzzy_similarity_string(table_name, column, search_term)
+    "similarity(#{table_name}.#{column}, #{search_term})"
+  end
+
+  def fuzzy_condition_string(table_name, column, search_term)
+    "(#{table_name}.#{column} % #{search_term})"
+  end
+
+  def assemble_query(similarities, conditions, exclusive)
+    rank = connection.quote_column_name('rank' + rand.to_s)
+
+    select("#{quoted_table_name + '.*,' if scoped.select_values.empty?} #{similarities.join(" + ")} AS #{rank}").
+      where(conditions.join(exclusive ? " AND " : " OR ")).
+      order("#{rank} DESC")
+  end
+
+  def normalize(query)
+    query
+  end
+
+  def searchable_columns
+    columns.select {|column| [:string, :text].include? column.type }.map(&:name)
+  end
+
+  def quoted_language
+    @quoted_language ||= connection.quote(searchable_language)
+  end
+
+  def searchable_language
+    Textacular.searchable_language
+  end
+
+  module Helper
+    class << self
+      def normalize(query)
+        query.to_s.gsub(' ', '\\\\ ')
+      end
+
+      def method_name_regex
+        /^(?<search_type>((basic|advanced|fuzzy)_)?search)_by_(?<columns>[_a-zA-Z]\w*)$/
+      end
+
+      def search_type(method)
+        method.to_s.match(method_name_regex)[:search_type]
+      end
+
+      def exclusive_dynamic_search_columns(method)
+        if match = method.to_s.match(method_name_regex)
+          match[:columns].split('_and_')
+        else
+          []
+        end
+      end
+
+      def inclusive_dynamic_search_columns(method)
+        if match = method.to_s.match(method_name_regex)
+          match[:columns].split('_or_')
+        else
+          []
+        end
+      end
+
+      def exclusive_dynamic_search_method?(method, class_columns)
+        string_columns = class_columns.map(&:name)
+        columns = exclusive_dynamic_search_columns(method)
+        unless columns.empty?
+          columns.all? {|column| string_columns.include?(column) }
+        else
+          false
+        end
+      end
+
+      def inclusive_dynamic_search_method?(method, class_columns)
+        string_columns = class_columns.map(&:name)
+        columns = inclusive_dynamic_search_columns(method)
+        unless columns.empty?
+          columns.all? {|column| string_columns.include?(column) }
+        else
+          false
+        end
+      end
+
+      def dynamic_search_method?(method, class_columns)
+        exclusive_dynamic_search_method?(method, class_columns) or
+          inclusive_dynamic_search_method?(method, class_columns)
+      end
+    end
+  end
+end
+
+require File.expand_path(File.dirname(__FILE__) + '/textacular/full_text_indexer')

data/lib/textacular/full_text_indexer.rb

@@ -0,0 +1,79 @@
+class Textacular::FullTextIndexer
+  def generate_migration(model_name)
+    stream_output do |io|
+      io.puts(<<-MIGRATION)
+class #{model_name}FullTextSearch < ActiveRecord::Migration
+  def self.up
+    execute(<<-SQL.strip)
+      #{up_migration(model_name)}
+    SQL
+  end
+
+  def self.down
+    execute(<<-SQL.strip)
+      #{down_migration(model_name)}
+    SQL
+  end
+end
+MIGRATION
+    end
+  end
+
+  def stream_output(now = Time.now.utc, &block)
+    if !@output_stream && defined?(Rails)
+      File.open(migration_file_name(now), 'w', &block)
+    else
+      @output_stream ||= $stdout
+
+      yield @output_stream
+    end
+  end
+
+  private
+
+  def migration_file_name(now = Time.now.utc)
+    File.join(Rails.root, 'db', 'migrate',"#{now.strftime('%Y%m%d%H%M%S')}_full_text_search.rb")
+  end
+
+  def up_migration(model_name)
+    migration_with_type(model_name, :up)
+  end
+
+  def down_migration(model_name)
+    migration_with_type(model_name, :down)
+  end
+
+  def migration_with_type(model_name, type)
+    sql_lines = ''
+
+    model = Kernel.const_get(model_name)
+    model.indexable_columns.each do |column|
+      sql_lines << drop_index_sql_for(model, column)
+      sql_lines << create_index_sql_for(model, column) if type == :up
+    end
+
+    sql_lines.strip.gsub("\n","\n      ")
+  end
+
+  def drop_index_sql_for(model, column)
+    "DROP index IF EXISTS #{index_name_for(model, column)};\n"
+  end
+
+  def create_index_sql_for(model, column)
+    # The spacing gets sort of wonky in here.
+
+    <<-SQL
+CREATE index #{index_name_for(model, column)}
+  ON #{model.table_name}
+  USING gin(to_tsvector("#{dictionary}", "#{model.table_name}"."#{column}"::text));
+SQL
+  end
+
+  def index_name_for(model, column)
+    "#{model.table_name}_#{column}_fts_idx"
+  end
+
+  def dictionary
+    Textacular.searchable_language
+  end
+end

data/lib/textacular/postgres_module_installer.rb

@@ -0,0 +1,57 @@
+module Textacular
+  class PostgresModuleInstaller
+    def install_module(module_name)
+      major, minor, patch = postgres_version.split('.')
+
+      if major.to_i >= 9 && minor.to_i >= 1
+        install_postgres_91_module(module_name)
+      else
+        install_postgres_90_module(module_name)
+      end
+    end
+
+    def db_name
+      @db_name ||= ActiveRecord::Base.connection.current_database
+    end
+
+    private
+
+    def postgres_version
+      @postgres_version ||= ask_pg_config('version').match(/PostgreSQL ([0-9]+(\.[0-9]+)*)/)[1]
+    end
+
+    def postgres_share_dir
+      @share_dir ||= ask_pg_config('sharedir')
+    end
+
+    def ask_pg_config(argument)
+      result = `pg_config --#{argument}`.chomp
+
+      raise RuntimeError, "Cannot find Postgres's #{argument}." unless $?.success?
+
+      result
+    end
+
+    def install_postgres_90_module(module_name)
+      module_location = "#{postgres_share_dir}/contrib/#{module_name}.sql"
+
+      unless system("ls #{module_location}")
+        raise RuntimeError, "Cannot find the #{module_name} module. Was it compiled and installed?"
+      end
+
+      unless system("psql -d #{db_name} -f #{module_location}")
+        raise RuntimeError, "`psql -d #{db_name} -f #{module_location}` cannot complete successfully."
+      end
+    end
+
+    def install_postgres_91_module(module_name)
+      module_location = "#{postgres_share_dir}/extension/#{module_name}.control"
+
+      unless system("ls #{module_location}")
+        raise RuntimeError, "Cannot find the #{module_name} module. Was it compiled and installed?"
+      end
+
+      ActiveRecord::Base.connection.execute("CREATE EXTENSION #{module_name};")
+    end
+  end
+end

data/lib/textacular/rails.rb

@@ -0,0 +1,10 @@
+# Module used to conform to Rails 3 plugin API
+require File.expand_path(File.dirname(__FILE__) + '/../textacular')
+
+module Textacular
+  class Railtie < Rails::Railtie
+    initializer "textacular.configure_rails_initialization" do
+      ActiveRecord::Base.extend(Textacular)
+    end
+  end
+end

data/lib/textacular/searchable.rb

@@ -0,0 +1,20 @@
+require 'textacular'
+
+def Searchable(*searchable_columns)
+  Module.new do
+
+    include Textacular
+
+    define_method(:searchable_columns) do
+      searchable_columns.map(&:to_s)
+    end
+
+    private :searchable_columns
+
+    def indexable_columns
+      searchable_columns.to_enum
+    end
+  end
+end
+
+Searchable = Textacular

data/lib/textacular/tasks.rb

@@ -0,0 +1,18 @@
+require 'rake'
+require 'textacular'
+
+namespace :textacular do
+  desc 'Create full text search index migration, give the model for which you want to create the indexes'
+  task :create_index_migration, [:model_name] => :environment do |task, args|
+    raise 'A model name is required' unless args[:model_name]
+    Textacular::FullTextIndexer.new.generate_migration(args[:model_name])
+  end
+
+  desc "Install trigram text search module"
+  task :install_trigram => [:environment] do
+    installer = Textacular::PostgresModuleInstaller.new
+    installer.install_module('pg_trgm')
+
+    puts "Trigram text search module successfully installed into '#{installer.db_name}' database."
+  end
+end

data/lib/textacular/version.rb

@@ -0,0 +1,7 @@
+module Textacular
+  VERSION = '3.0.0'
+
+  def self.version
+    VERSION
+  end
+end

data/spec/config.yml.example

@@ -0,0 +1,4 @@
+database: textacular
+username: <username>
+pool: 5
+timeout: 5000

data/spec/fixtures/game.rb

@@ -0,0 +1,9 @@
+require 'active_record'
+
+class Game < ActiveRecord::Base
+  # string :system
+  # string :title
+  # text :description
+end
+
+class GameFail < Game; end

data/spec/fixtures/webcomic.rb

@@ -0,0 +1,9 @@
+require 'active_record'
+
+class WebComic < ActiveRecord::Base
+  # string :name
+  # string :author
+  # integer :id
+
+  has_many :characters
+end