pg_search 0.0.2

data/lib/pg_search/configuration.rb

@@ -0,0 +1,73 @@
+require "pg_search/configuration/column"
+
+module PgSearch
+  class Configuration
+    def initialize(options, model)
+      options = options.reverse_merge(default_options)
+      assert_valid_options(options)
+      @options = options
+      @model = model
+    end
+
+    def columns
+      regular_columns + associated_columns
+    end
+
+    def regular_columns
+      Array(@options[:against]).map do |column_name, weight|
+        Column.new(column_name, weight, @model)
+      end
+    end
+
+    def associated_columns
+      return [] unless @options[:associated_against]
+      @options[:associated_against].map do |association, against|
+        Array(against).map do |column_name, weight|
+          Column.new(column_name, weight, @model, association)
+        end
+      end.flatten
+    end
+
+    def query
+      @options[:query].to_s
+    end
+
+    def normalizations
+      Array.wrap(@options[:normalizing])
+    end
+
+    def ranking_sql
+      @options[:ranked_by]
+    end
+
+    def features
+      Array(@options[:using])
+    end
+
+    private
+
+    def default_options
+      {:using => :tsearch}
+    end
+
+    def assert_valid_options(options)
+      valid_keys = [:against, :ranked_by, :normalizing, :using, :query, :associated_against]
+      valid_values = {
+        :normalizing => [:diacritics]
+      }
+
+      raise ArgumentError, "the search scope #{@name} must have :against in its options" unless options[:against]
+      raise ArgumentError, ":associated_against requires ActiveRecord 3 or later" if options[:associated_against] && !defined?(ActiveRecord::Relation)
+
+      options.assert_valid_keys(valid_keys)
+
+      valid_values.each do |key, values_for_key|
+        Array.wrap(options[key]).each do |value|
+          unless values_for_key.include?(value)
+            raise ArgumentError, ":#{key} cannot accept #{value}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pg_search/configuration/column.rb

@@ -0,0 +1,43 @@
+module PgSearch
+  class Configuration
+    class Column
+      attr_reader :weight, :association
+
+      def initialize(column_name, weight, model, association = nil)
+        @column_name = column_name.to_s
+        @weight = weight
+        @model = model
+        @association = association
+      end
+
+      def table
+        foreign? ? @model.reflect_on_association(association).table_name : @model.table_name
+      end
+
+      def full_name
+        "#{@model.connection.quote_table_name(table)}.#{@model.connection.quote_column_name(@column_name)}"
+      end
+
+      def to_sql
+        name = if foreign?
+                 "#{self.subselect_alias}.#{self.alias}"
+               else
+                 full_name
+               end
+        "coalesce(#{name}, '')"
+      end
+
+      def foreign?
+        @association.present?
+      end
+
+      def alias
+        ["pg_search", table, association, @column_name].compact.join('_')
+      end
+
+      def subselect_alias
+        "#{self.alias}_subselect"
+      end
+    end
+  end
+end

data/lib/pg_search/features.rb

@@ -0,0 +1,7 @@
+module PgSearch
+  module Features
+  end
+end
+require 'pg_search/features/dmetaphone'
+require 'pg_search/features/trigram'
+require 'pg_search/features/tsearch'

data/lib/pg_search/features/dmetaphone.rb

@@ -0,0 +1,28 @@
+require "active_support/core_ext/module/delegation"
+
+module PgSearch
+  module Features
+    class DMetaphone
+      delegate :conditions, :rank, :to => :'@tsearch'
+
+      # config is temporary as we refactor
+      def initialize(query, options, config, model, normalizer)
+        dmetaphone_normalizer = Normalizer.new(normalizer)
+        options = (options || {}).merge(:dictionary => 'simple')
+        @tsearch = TSearch.new(query, options, config, model, dmetaphone_normalizer)
+      end
+
+      # Decorates a normalizer with dmetaphone processing.
+      class Normalizer
+        def initialize(normalizer_to_wrap)
+          @decorated_normalizer = normalizer_to_wrap
+        end
+
+        def add_normalization(original_sql)
+          otherwise_normalized_sql = @decorated_normalizer.add_normalization(original_sql)
+          "pg_search_dmetaphone(#{otherwise_normalized_sql})"
+        end
+      end
+    end
+  end
+end

data/lib/pg_search/features/trigram.rb

@@ -0,0 +1,29 @@
+require "active_support/core_ext/module/delegation"
+
+module PgSearch
+  module Features
+    class Trigram
+      def initialize(query, options, columns, model, normalizer)
+        @query = query
+        @options = options
+        @columns = columns
+        @model = model
+        @normalizer = normalizer
+      end
+
+      def conditions
+        ["(#{@normalizer.add_normalization(document)}) % #{@normalizer.add_normalization(":query")}", {:query => @query}]
+      end
+
+      def rank
+        ["similarity((#{@normalizer.add_normalization(document)}), #{@normalizer.add_normalization(":query")})", {:query => @query}]
+      end
+
+      private
+
+      def document
+        @columns.map { |column| column.to_sql }.join(" || ' ' || ")
+      end
+    end
+  end
+end

data/lib/pg_search/features/tsearch.rb

@@ -0,0 +1,64 @@
+require "active_support/core_ext/module/delegation"
+
+module PgSearch
+  module Features
+    class TSearch
+      delegate :connection, :quoted_table_name, :to => :'@model'
+
+      def initialize(query, options, columns, model, normalizer)
+        @query = query
+        @options = options || {}
+        @model = model
+        @columns = columns
+        @normalizer = normalizer
+      end
+
+      def conditions
+        ["(#{tsdocument}) @@ (#{tsquery})", interpolations]
+      end
+
+      def rank
+        tsearch_rank
+      end
+
+      private
+
+      def interpolations
+        {:query => @query.to_s, :dictionary => @options[:dictionary].to_s}
+      end
+
+      def document
+        @columns.map { |column| column.to_sql }.join(" || ' ' || ")
+      end
+
+      def tsquery
+        return "''" if @query.blank?
+
+        @query.split(" ").compact.map do |term|
+          sanitized_term = term.gsub(/['?\-\\]/, " ")
+
+          term_sql = @normalizer.add_normalization(connection.quote(sanitized_term))
+
+          # After this, the SQL expression evaluates to a string containing the term surrounded by single-quotes.
+          tsquery_sql = "#{connection.quote("'")} || #{term_sql} || #{connection.quote("'")}"
+
+          # Add tsearch prefix operator if we're using a prefix search.
+          tsquery_sql = "#{tsquery_sql} || #{connection.quote(':*')}" if @options[:prefix]
+
+          "to_tsquery(#{":dictionary," if @options[:dictionary]} #{tsquery_sql})"
+        end.join(" && ")
+      end
+
+      def tsdocument
+        @columns.map do |search_column|
+          tsvector = "to_tsvector(#{":dictionary," if @options[:dictionary]} #{@normalizer.add_normalization(search_column.to_sql)})"
+          search_column.weight.nil? ? tsvector : "setweight(#{tsvector}, #{connection.quote(search_column.weight)})"
+        end.join(" || ")
+      end
+
+      def tsearch_rank
+        ["ts_rank((#{tsdocument}), (#{tsquery}))", interpolations]
+      end
+    end
+  end
+end

data/lib/pg_search/normalizer.rb

@@ -0,0 +1,13 @@
+module PgSearch
+  class Normalizer
+    def initialize(config)
+      @config = config
+    end
+
+    def add_normalization(original_sql)
+      normalized_sql = original_sql
+      normalized_sql = "unaccent(#{normalized_sql})" if @config.normalizations.include?(:diacritics)
+      normalized_sql
+    end
+  end
+end

data/lib/pg_search/railtie.rb

@@ -0,0 +1,11 @@
+require 'pg_search'
+#require 'rails'
+
+module PgSearch
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      raise
+      load "pg_search/tasks.rb"
+    end
+  end
+end

data/lib/pg_search/scope.rb

@@ -0,0 +1,31 @@
+module PgSearch
+  class Scope
+    def initialize(name, model, scope_options_or_proc)
+      @name = name
+      @model = model
+      @options_proc = build_options_proc(scope_options_or_proc)
+    end
+
+    def to_proc
+      lambda { |*args|
+        config = Configuration.new(@options_proc.call(*args), @model)
+        ScopeOptions.new(@name, @model, config).to_hash
+      }
+    end
+
+    private
+
+    def build_options_proc(scope_options_or_proc)
+      case scope_options_or_proc
+        when Proc
+          scope_options_or_proc
+        when Hash
+          lambda { |query|
+            scope_options_or_proc.reverse_merge(:query => query)
+          }
+        else
+          raise ArgumentError, "A PgSearch scope expects a Proc or Hash for its options"
+      end
+    end
+  end
+end

data/lib/pg_search/scope_options.rb

@@ -0,0 +1,75 @@
+require "active_support/core_ext/module/delegation"
+
+module PgSearch
+  class ScopeOptions
+    attr_reader :model
+
+    delegate :connection, :quoted_table_name, :sanitize_sql_array, :to => :model
+
+    def initialize(name, model, config)
+      @name = name
+      @model = model
+      @config = config
+
+      @feature_options = @config.features.inject({}) do |features_hash, (feature_name, feature_options)|
+        features_hash.merge(
+          feature_name => feature_options
+        )
+      end
+      @feature_names = @config.features.map { |feature_name, feature_options| feature_name }
+    end
+
+    def to_hash
+      {
+        :select => "#{quoted_table_name}.*, (#{rank}) AS pg_search_rank",
+        :conditions => conditions,
+        :order => "pg_search_rank DESC, #{primary_key} ASC",
+        :joins => joins
+      }
+    end
+
+    private
+
+    def conditions
+      @feature_names.map { |feature_name| "(#{sanitize_sql_array(feature_for(feature_name).conditions)})" }.join(" OR ")
+    end
+
+    def primary_key
+      "#{quoted_table_name}.#{connection.quote_column_name(model.primary_key)}"
+    end
+
+    def joins
+      @config.associated_columns.map do |column|
+        select = "string_agg(#{column.full_name}, ' ') AS #{column.alias}"
+        relation = model.joins(column.association).select("#{primary_key} AS id, #{select}").group(primary_key)
+        "LEFT OUTER JOIN (#{relation.to_sql}) #{column.subselect_alias} ON #{column.subselect_alias}.id = #{primary_key}"
+      end.join(' ')
+    end
+
+    def feature_for(feature_name)
+      feature_name = feature_name.to_sym
+
+      feature_class = {
+        :dmetaphone => Features::DMetaphone,
+        :tsearch => Features::TSearch,
+        :trigram => Features::Trigram
+      }[feature_name]
+
+      raise ArgumentError.new("Unknown feature: #{feature_name}") unless feature_class
+
+      normalizer = Normalizer.new(@config)
+
+      feature_class.new(@config.query, @feature_options[feature_name], @config.columns, @model, normalizer)
+    end
+
+    def tsearch_rank
+      sanitize_sql_array(@feature_names[Features::TSearch].rank)
+    end
+
+    def rank
+      (@config.ranking_sql || ":tsearch").gsub(/:(\w*)/) do
+        sanitize_sql_array(feature_for($1).rank)
+      end
+    end
+  end
+end

data/lib/pg_search/tasks.rb

@@ -0,0 +1,37 @@
+require 'rake'
+require 'pg_search'
+
+namespace :pg_search do
+  namespace :migration do
+    desc "Generate migration to add support functions for :dmetaphone"
+    task :dmetaphone do
+      now = Time.now.utc
+      filename = "#{now.strftime('%Y%m%d%H%M%S')}_add_pg_search_dmetaphone_support_functions.rb"
+
+      dmetaphone_sql = File.read(File.join(File.dirname(__FILE__), '..', '..', 'sql', 'dmetaphone.sql')).chomp
+      uninstall_dmetaphone_sql = File.read(File.join(File.dirname(__FILE__), '..', '..', 'sql', 'uninstall_dmetaphone.sql')).chomp
+
+      File.open(Rails.root + 'db' + 'migrate' + filename, 'wb') do |migration_file|
+        migration_file.puts <<-RUBY
+class AddPgSearchDmetaphoneSupportFunctions < ActiveRecord::Migration
+  def self.up
+    say_with_time("Adding support functions for pg_search :dmetaphone") do
+      ActiveRecord::Base.connection.execute(<<-SQL)
+        #{dmetaphone_sql}
+      SQL
+    end
+  end
+
+  def self.down
+    say_with_time("Dropping support functions for pg_search :dmetaphone") do
+      ActiveRecord::Base.connection.execute(<<-SQL)
+        #{uninstall_dmetaphone_sql}
+      SQL
+    end
+  end
+end
+        RUBY
+      end
+    end
+  end
+end

data/lib/pg_search/version.rb

@@ -0,0 +1,3 @@
+module PgSearch
+  VERSION = "0.0.2"
+end

data/pg_search.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "pg_search/version"
+
+Gem::Specification.new do |s|
+  s.name        = "pg_search"
+  s.version     = PgSearch::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Case Commons, LLC"]
+  s.email       = ["casecommons-dev@googlegroups.com"]
+  s.homepage    = "https://github.com/Casecommons/pg_search"
+  s.summary     = %q{PgSearch builds ActiveRecord named scopes that take advantage of PostgreSQL's full text search}
+  s.description = %q{PgSearch builds ActiveRecord named scopes that take advantage of PostgreSQL's full text search}
+
+  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.require_paths = ["lib"]
+end