mongoid-fts 1.1.1 → 2.0.0

data/lib/mongoid-fts/able.rb

@@ -0,0 +1,68 @@
+module Mongoid
+  module FTS
+    module Able
+      def Able.code
+        @code ||= proc do
+          class << self
+            def fts_search(*args, &block)
+              options = Map.options_for!(args)
+
+              options[:model] = self
+
+              args.push(options)
+
+              FTS.search(*args, &block)
+            end
+            alias :search :fts_search
+
+            def _fts_search(*args, &block)
+              options = Map.options_for!(args)
+
+              options[:model] = self
+
+              args.push(options)
+
+              FTS.search(*args, &block)
+            end
+            alias :_search :_fts_search
+          end
+
+          after_save do |model|
+            FTS::Index.add(model)
+          end
+
+          after_destroy do |model|
+            FTS::Index.remove(model) rescue nil
+          end
+
+          has_one(:fts_index, :as => :context, :class_name => '::Mongoid::FTS::Index')
+        end
+      end
+
+      def Able.included(other)
+        unless other.is_a?(Able)
+          begin
+            super
+          ensure
+            other.module_eval(&Able.code)
+
+            FTS.models.dup.each do |model|
+              FTS.models.delete(model) if model.name == other.name
+            end
+
+            FTS.models.push(other)
+            FTS.models.uniq!
+          end
+        end
+      end
+    end
+
+    def FTS.included(other)
+      other.send(:include, FTS::Able)
+    end
+
+    def FTS.able
+      Able
+    end
+  end
+end

data/lib/mongoid-fts/error.rb

@@ -0,0 +1,5 @@
+module Mongoid
+  module FTS
+    class Error < ::StandardError; end
+  end
+end

data/lib/mongoid-fts/index.rb

@@ -0,0 +1,293 @@
+module Mongoid
+  module FTS
+    class Index
+    #
+      include Mongoid::Document
+
+    #
+      belongs_to(:context, :polymorphic => true)
+
+    #
+      field(:literals, :type => Array)
+
+      field(:title, :type => Array)
+
+      field(:keywords, :type => Array)
+
+      field(:fuzzy, :type => Array)
+
+      field(:fulltext, :type => Array)
+
+    #
+      index(
+        {
+          :context_type => 1,
+          :context_id   => 1
+        },
+
+        {
+          :unique => true,
+          :sparse => true
+        }
+      )
+
+    # FIXME - this hack gets around https://github.com/mongoid/mongoid/issues/3080
+    #
+      index_options[
+
+        normalize_spec(
+          :context_type     => 1,
+
+          :literals         => 'text',
+
+          :title            => 'text',
+
+          :keywords         => 'text',
+
+          :fuzzy            => 'text',
+
+          :fulltext         => 'text'
+        )
+
+      ] = 
+
+        normalize_index_options(
+          :name => 'search_index',
+
+          :default_language => 'none',
+
+          :weights => {
+            :literals         => 200,
+
+            :title            => 90,
+
+            :keywords         => 50,
+
+            :fulltext         => 1
+          }
+        )
+    #
+    #
+
+      before_validation do |index|
+        index.normalize
+      end
+
+      before_upsert do |index|
+        index.normalize
+      end
+
+      before_save do |index|
+        index.normalize
+      end
+
+      validates_presence_of(:context_type)
+
+      def normalize
+        if !defined?(@normalized) or !@normalized
+          normalize!
+        end
+      end
+
+      def normalize!
+        index = self
+
+        %w( literals title keywords fulltext ).each do |attr|
+          index[attr] = FTS.list_of_strings(index[attr])
+        end
+      ensure
+        @normalized = true
+      end
+
+      def inspect(*args, &block)
+        Map.for(as_document).inspect(*args, &block)
+      end
+
+      def Index.teardown!
+        Index.remove_indexes
+        Index.destroy_all
+      end
+
+      def Index.setup!
+        Index.create_indexes
+      end
+
+      def Index.reset!
+        teardown!
+        setup!
+      end
+
+      def Index.rebuild!
+        batches = Hash.new{|h,k| h[k] = []}
+
+        each do |index|
+          context_type, context_id = index.context_type, index.context_id
+          next unless context_type && context_id
+          (batches[context_type] ||= []).push(context_id)
+        end
+
+        models = FTS.find_in_batches(batches)
+
+        reset!
+
+        models.each{|model| add(model)}
+      end
+
+      def Index.add!(model)
+        to_search = Index.to_search(model)
+
+        literals         = to_search.has_key?(:literals) ?  Coerce.list_of_strings(to_search[:literals]) : nil
+
+        title            = to_search.has_key?(:title) ?  Coerce.string(to_search[:title]) : nil
+
+        keywords         = to_search.has_key?(:keywords) ?  Coerce.list_of_strings(to_search[:keywords]) : nil
+
+        fuzzy            = to_search.has_key?(:fuzzy) ?  Coerce.list_of_strings(to_search[:fuzzy]) : nil
+
+        fulltext         = to_search.has_key?(:fulltext) ?  Coerce.string(to_search[:fulltext]) : nil
+
+        context_type = model.class.name.to_s
+        context_id   = model.id
+
+        conditions = {
+          :context_type => context_type,
+          :context_id   => context_id
+        }
+
+        attributes = {
+          :literals         => literals,
+          :title            => title,
+          :keywords         => keywords,
+          :fuzzy            => fuzzy,
+          :fulltext         => fulltext
+        }
+
+        index = nil
+        n = 42
+
+        n.times do |i|
+          index = where(conditions).first
+          break if index
+
+          begin
+            index = create!(conditions)
+            break if index
+          rescue Object
+            nil
+          end
+
+          sleep(rand) if i < (n - 1)
+        end
+
+        if index
+          begin
+            index.update_attributes!(attributes)
+          rescue Object
+            raise Error.new("failed to update index for #{ conditions.inspect }")
+          end
+        else
+          raise Error.new("failed to create index for #{ conditions.inspect }")
+        end
+
+        index
+      end
+
+      def Index.add(*args, &block)
+        add!(*args, &block)
+      end
+
+      def Index.remove!(*args, &block)
+        options = args.extract_options!.to_options!
+        models = args.flatten.compact
+
+        model_ids = {}
+
+        models.each do |model|
+          model_name = model.class.name.to_s
+          model_ids[model_name] ||= []
+          model_ids[model_name].push(model.id)
+        end
+
+        conditions = model_ids.map do |model_name, model_ids|
+          {:context_type => model_name, :context_id.in => model_ids}
+        end
+
+        any_of(conditions).destroy_all
+      end
+
+      def Index.remove(*args, &block)
+        remove!(*args, &block)
+      end
+
+      def Index.to_search(model)
+      #
+        to_search = nil
+
+      #
+        if model.respond_to?(:to_search)
+          to_search = Map.for(model.to_search)
+        else
+          to_search = Map.new
+
+          to_search[:literals] =
+            %w( id ).map do |attr|
+              model.send(attr) if model.respond_to?(attr)
+            end
+
+          to_search[:title] =
+            %w( title ).map do |attr|
+              model.send(attr) if model.respond_to?(attr)
+            end
+
+          to_search[:keywords] =
+            %w( keywords tags ).map do |attr|
+              model.send(attr) if model.respond_to?(attr)
+            end
+
+          to_search[:fulltext] =
+            %w( fulltext text content body description ).map do |attr|
+              model.send(attr) if model.respond_to?(attr)
+            end
+        end
+
+      #
+        required = %w( literals title keywords fuzzy fulltext )
+        actual = to_search.keys
+
+=begin
+        missing = required - actual
+        unless missing.empty?
+          raise ArgumentError, "#{ model.class.inspect }#to_search missing keys #{ missing.inspect }"
+        end
+=end
+
+        invalid = actual - required
+        unless invalid.empty?
+          raise ArgumentError, "#{ model.class.inspect }#to_search invalid keys #{ invalid.inspect }"
+        end
+
+      #
+        literals = FTS.normalized_array(to_search[:literals])
+        title    = FTS.normalized_array(to_search[:title])
+        keywords = FTS.normalized_array(to_search[:keywords])
+        fuzzy    = FTS.normalized_array(to_search[:fuzzy])
+        fulltext = FTS.normalized_array(to_search[:fulltext])
+
+      #
+        if to_search[:fuzzy].nil?
+          fuzzy = [title, keywords]
+        end
+
+      #
+        to_search[:literals]         = FTS.literals_for(literals).uniq
+        to_search[:title]            = (title + FTS.terms_for(title)).uniq
+        to_search[:keywords]         = (keywords + FTS.terms_for(keywords)).uniq
+        to_search[:fuzzy]            = FTS.fuzzy_for(fuzzy).uniq
+        to_search[:fulltext]         = (FTS.terms_for(fulltext, :subterms => true)).uniq
+
+      #
+        to_search
+      end
+    end
+  end
+end

data/lib/mongoid-fts/rails.rb

@@ -0,0 +1,11 @@
+module Mongoid
+  module FTS
+    class Engine < ::Rails::Engine
+      paths['app/models'] = ::File.dirname(__FILE__)
+
+      config.before_initialize do
+        Mongoid::FTS.enable!(:warn => true)
+      end
+    end
+  end
+end

data/lib/mongoid-fts/raw.rb

@@ -0,0 +1,16 @@
+module Mongoid
+  module FTS
+    class Raw < ::Array
+      attr_accessor :_search
+      attr_accessor :_text
+      attr_accessor :_limit
+      attr_accessor :_models
+
+      def initialize(_searches, options = {})
+        replace(_searches)
+      ensure
+        options.each{|k, v| send("#{ k }=", v)}
+      end
+    end
+  end
+end

data/lib/mongoid-fts/results.rb

@@ -0,0 +1,195 @@
+module Mongoid
+  module FTS
+    class Results < ::Array
+      attr_accessor :_searches
+      attr_accessor :_models
+
+      def initialize(_searches)
+        @_searches = _searches
+        @_models = []
+        _denormalize!
+        @page = 1
+        @per = size
+        @num_pages = 1
+      end
+
+      def paginate(*args)
+        results = self
+        options = Map.options_for!(args)
+
+        page = Integer(args.shift || options[:page] || @page)
+        per = args.shift || options[:per] || options[:size]
+
+        if per.nil?
+          return Promise.new(results, page)
+        else
+          per = Integer(per)
+        end
+
+        @page = [page.abs, 1].max
+        @per = [per.abs, 1].max
+        @num_pages = (size.to_f / @per).ceil
+
+        offset = (@page - 1) * @per
+        length = @per 
+
+        slice = Array(@_models[offset, length])
+
+        replace(slice)
+
+        self
+      end
+
+      class Promise
+        attr_accessor :results
+        attr_accessor :page
+
+        def initialize(results, page)
+          @results = results
+          @page = page
+        end
+
+        def per(per)
+          results.per(:page => page, :per => per)
+        end
+      end
+
+      def page(*args)
+        if args.empty?
+          return @page
+        else
+          options = Map.options_for!(args)
+          page = args.shift || options[:page]
+          options[:page] = page
+          paginate(options)
+        end
+      end
+
+      alias_method(:current_page, :page)
+
+      def per(*args)
+        if args.empty?
+          return @per
+        else
+          options = Map.options_for!(args)
+          per = args.shift || options[:per]
+          options[:per] = per
+          paginate(options)
+        end
+      end
+
+      def num_pages
+        @num_pages
+      end
+
+      def total_pages
+        num_pages
+      end
+
+  # TODO - text sorting more...
+  #
+      def _denormalize!
+      #
+        collection = self
+
+        collection.clear
+        @_models = []
+
+        return self if @_searches.empty?
+
+      #
+        _models = @_searches._models
+
+        _position = proc do |model|
+          _models.index(model) or raise("no position for #{ model.inspect }!?")
+        end
+
+        results =
+          @_searches.map do |_search|
+            _search['results'] ||= []
+
+            _search['results'].each do |result|
+              result['_model'] = _search._model
+              result['_position'] = _position[_search._model]
+            end
+
+            _search['results']
+          end
+
+        results.flatten!
+        results.compact!
+
+=begin
+        results.sort! do |a, b|
+          score = Float(b['score']) <=> Float(a['score'])
+
+          case score
+            when 0
+              a['_position'] <=> b['_position']
+            else
+              score
+          end
+        end
+=end
+
+      #
+        batches = Hash.new{|h,k| h[k] = []}
+
+        results.each do |entry|
+          obj = entry['obj']
+
+          context_type, context_id = obj['context_type'], obj['context_id']
+
+          batches[context_type].push(context_id)
+        end
+
+      #
+        models = FTS.find_in_batches(batches)
+
+      #
+        result_index = {}
+
+        results.each do |result|
+          context_type = result['obj']['context_type'].to_s
+          context_id = result['obj']['context_id'].to_s
+          key = [context_type, context_id]
+
+          result_index[key] = result
+        end
+
+      #
+        models.each do |model|
+          context_type = model.class.name.to_s
+          context_id = model.id.to_s
+          key = [context_type, context_id]
+
+          result = result_index[key]
+          model['_fts_index'] = result
+        end
+
+      #
+        models.sort! do |model_a, model_b|
+          a = model_a['_fts_index']
+          b = model_b['_fts_index']
+
+          score = Float(b['score']) <=> Float(a['score'])
+
+          case score
+            when 0
+              a['_position'] <=> b['_position']
+            else
+              score
+          end
+        end
+
+      #
+        limit = @_searches._limit
+
+      #
+        replace(@_models = models[0 ... limit])
+
+        self
+      end
+    end
+  end
+end