drtom-textacular 4.0.0.alpha.20160302

data/lib/textacular.rb

@@ -0,0 +1,160 @@
+require 'active_record'
+
+require 'textacular/version'
+
+module Textacular
+  autoload :FullTextIndexer,         'textacular/full_text_indexer'
+  autoload :PostgresModuleInstaller, 'textacular/postgres_module_installer'
+  autoload :TrigramInstaller,        'textacular/trigram_installer'
+  autoload :MigrationGenerator,      'textacular/migration_generator'
+
+  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
+
+  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 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)
+    "COALESCE(ts_rank(to_tsvector(#{quoted_language}, #{table_name}.#{column}::text), plainto_tsquery(#{quoted_language}, #{search_term}::text)), 0)"
+  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)
+    "COALESCE(ts_rank(to_tsvector(#{quoted_language}, #{table_name}.#{column}::text), to_tsquery(#{quoted_language}, #{search_term}::text)), 0)"
+  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)
+    "COALESCE(similarity(#{table_name}.#{column}, #{search_term}), 0)"
+  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(100000000000000000).to_s)
+
+    select("#{quoted_table_name + '.*,' if select_values.empty?} #{similarities.join(" + ")} AS #{rank}").
+      where(conditions.join(exclusive ? " AND " : " OR ")).
+      order("#{rank} DESC")
+  end
+
+  def select_values
+    if ActiveRecord::VERSION::MAJOR >= 4
+      all.select_values
+    else
+      scoped.select_values
+    end
+  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(/\s(?![\&|\!|\|])/, '\\\\ ')
+      end
+    end
+  end
+end
+
+require 'textacular/rails' if defined?(::Rails)

data/lib/textacular/full_text_indexer.rb

@@ -0,0 +1,66 @@
+class Textacular::FullTextIndexer
+  def generate_migration(model_name)
+    content = <<-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
+    filename = "#{model_name.underscore}_full_text_search"
+    generator = Textacular::MigrationGenerator.new(content, filename)
+    generator.generate_migration
+  end
+
+  private
+
+  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/migration_generator.rb

@@ -0,0 +1,31 @@
+require 'fileutils'
+
+class Textacular::MigrationGenerator
+  def initialize(filename, content)
+    @filename = filename
+    @content = content
+  end
+
+  def generate_migration
+    stream_output do |io|
+      io.puts(@content)
+    end
+  end
+
+  def stream_output(now = Time.now.utc, &block)
+    if !@output_stream && defined?(Rails)
+      FileUtils.mkdir_p(File.dirname(migration_file_name(now)))
+      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')}_#{@filename}.rb")
+  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,14 @@
+# 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
+
+    rake_tasks do
+      load 'textacular/tasks.rb'
+    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,23 @@
+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
+
+  desc "Create trigram installer migration"
+  task :create_trigram_migration => [:environment] do
+    installer = Textacular::TrigramInstaller.new.generate_migration
+  end
+end

data/lib/textacular/trigram_installer.rb

@@ -0,0 +1,18 @@
+class Textacular::TrigramInstaller
+  def generate_migration
+    content = <<-MIGRATION
+class InstallTrigram < ActiveRecord::Migration
+  def self.up
+    ActiveRecord::Base.connection.execute("CREATE EXTENSION IF NOT EXISTS pg_trgm;")
+  end
+
+  def self.down
+    ActiveRecord::Base.connection.execute("DROP EXTENSION pg_trgm;")
+  end
+end
+MIGRATION
+    filename = "install_trigram"
+    generator = Textacular::MigrationGenerator.new(filename, content)
+    generator.generate_migration
+  end
+end

data/lib/textacular/version.rb

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

data/spec/config.travis.yml

@@ -0,0 +1,8 @@
+pool: 5
+timeout: 5000
+host: localhost
+adapter: postgresql
+username: postgres
+password:
+database: textacular_test
+min_messages: ERROR

data/spec/config.yml.example

@@ -0,0 +1,5 @@
+database: textacular
+username: <%= ENV[ 'USER' ] %>
+pool: 5
+timeout: 5000
+adapter: postgresql

data/spec/spec_helper.rb

@@ -0,0 +1,104 @@
+require 'pry'
+require 'textacular'
+require 'database_cleaner'
+require 'yaml'
+
+config = YAML.load_file File.expand_path(File.dirname(__FILE__) + '/config.yml')
+ActiveRecord::Base.establish_connection config.merge(:adapter => :postgresql)
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  # if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    # config.default_formatter = 'doc'
+  # end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  # config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.around(:each) do |example|
+    DatabaseCleaner.cleaning do
+      example.run
+    end
+  end
+end