mongoid-fts 0.5.0 → 1.0.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZjY5OWU1OTAxM2YzZDFiZmUzNTVhODFmMGM5NjNjNjI3OTgyODE1OQ==
+    YzRkOTk2NjNkYmQ5ZjM2NjU3YzkxYTM3N2I1MzRhNTFjZjAzMzAwMA==
   data.tar.gz: !binary |-
-    YzkwMGEzM2Q3OTM3NDg5OWI3OWVkM2IxYjJhOTFjYTQ1Y2MzYTBhOQ==
+    YjUzZGEyOWE2YWViZGRmZmQ4NWJjNTgxZTc4ZGM1MjUyYWI3MDBjMw==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    MWQzYTQ0ZmRhYWJjYThlNDJlOTFhNjgyNDYxYzVlZWI0NjJjYzc0MzNhZjhi
-    ODliMTRjYmRjMWRmOWYwYjgyYjc0YjlhZTM2ZWIxYWRlMTgxZjRiNDIzMmJm
-    NDIzMDllYjMwMzJkMjMxMGUyYjc5NjJiMWQ3OGFjZDA3ZDM4ODQ=
+    YTEyMWRkYmQ1NWM5YTVmZmJlOGUzOGI4NmFiZmU3M2UzNzRjNjg2MmE5NDEx
+    NjUxODE1YzE3NDJmMjJmNTZkZjFhZTljMzkzMDNmZDhmY2NkNDAyNTJhZmMy
+    MzM0MmFjNGFkMGMwZmYxNDU2MmRkNWVjM2JkMDM0MWFjMTY5OWQ=
   data.tar.gz: !binary |-
-    YjY2ZWM0YTgwMGViZjRmMDU2ZjFkODQxZmY1MTUzMTdkMTJiN2MwY2ZlMjJi
-    N2VjZTVmMDA1YzAwNjFjYThkZWRhY2I2ZDIyNTk5MzdjYmZkOTMwYjJmM2Yz
-    MGNjZWM2YTcyNWIzNmUwZGVhNTZjN2QyYjg1MGQwNjBhMmI5ZDg=
+    NWE3OGY3MDcwNTE1ZDQ0MmVmYWFhZGE5YmJjZDJlMzFlZGRjM2ZiNTM5ODQw
+    MmVhMmNhMGQ5NWJiNmYwOTAwYWY4NzgwNzNhNGRiYzUxY2NjZGU2NzI2OTBi
+    NzczZjA2OWQzYWMwN2UwODBjZTJmNzY1NTMzYmFjZjk2YTVhYjY=

data/README.md

@@ -4,8 +4,14 @@ NAME
 
 DESCRIPTION
 
-  enable mongodb's new fulltext simply and quickly on your mongoid models, including pagination.
+  enable mongodb's new fulltext simply and quickly on your mongoid models.
 
+  supports
+    * pagination
+    * strict literal searching (including stopwords)
+    * cross models searching
+    * index is automatically kept in sync
+    * customize ranking with #to_search
 
 INSTALL
 
@@ -59,7 +65,7 @@ SYNOPSIS
     field(:c)
 
     def to_search
-      {:title => a, :keywords => (b + ['foobar']), :fulltext => c}
+      {:literals => [id, sku], :title => a, :keywords => (b + ['foobar']), :fulltext => c}
     end
   end
 
@@ -92,6 +98,10 @@ SYNOPSIS
 
   Mongoid::FTS::Index.reset!   # completely drop/create indexes - lose all objects
 
+  Mongoid::FTS.index(model)    # add an object to the fts index
+
+  Mongoid::FTS.unindex(model)  # remove and object from the fts index
+
 ````
 
 the implementation has a temporary work around for pagination, see
@@ -100,7 +110,6 @@ the implementation has a temporary work around for pagination, see
 
 for details
 
-
 regardless, the *interface* of this mixin is uber simple and should be quite
 future proof.  as the mongodb teams moves search forward i'll track the new
 implementation and preserve the current interface.  until it settles down,

data/lib/mongoid-fts.rb

@@ -1,7 +1,7 @@
 module Mongoid
   module FTS
   #
-    const_set(:Version, '0.5.0') unless const_defined?(:Version)
+    const_set(:Version, '1.0.0') unless const_defined?(:Version)
 
     class << FTS
       def version
@@ -70,7 +70,10 @@ module Mongoid
     def FTS._search(*args)
       options = Map.options_for!(args)
 
-      search = args.join(' ')
+      search   = args.join(' ')
+      words    = search.strip.split(/\s+/)
+      literals = FTS.literals_for(*words)
+      search   = [literals, search].join(' ')
 
       text   = options.delete(:text) || Index.default_collection_name.to_s
       limit  = [Integer(options.delete(:limit) || 128), 1].max
@@ -259,18 +262,51 @@ module Mongoid
 
       belongs_to(:context, :polymorphic => true)
 
+      field(:literals, :type => Array)
+
+      field(:literal_title, :type => String)
       field(:title, :type => String)
+
+      field(:literal_keywords, :type => Array)
       field(:keywords, :type => Array)
+
       field(:fulltext, :type => String)
 
       index(
-        {:context_type => 1, :title => 'text', :keywords => 'text', :fulltext => 'text'},
-        {:weights => { :title => 100, :keywords => 50, :fulltext => 1 }, :name => 'search_index'}
+        {
+          :context_type => 1,
+          :context_id   => 1
+        },
+
+        {
+          :unique => true,
+          :sparse => true
+        }
       )
 
       index(
-        {:context_type => 1, :context_id => 1},
-        {:unique => true, :sparse => true}
+        {
+          :context_type     => 1,
+          :literals         => 'text',
+          :literal_title    => 'text',
+          :title            => 'text',
+          :literal_keywords => 'text',
+          :keywords         => 'text',
+          :fulltext         => 'text'
+        },
+
+        {
+          :name => 'search_index',
+
+          :weights => {
+            :literals         => 200,
+            :literal_title    => 100,
+            :title            => 90,
+            :literal_keywords => 60,
+            :keywords         => 50,
+            :fulltext         => 1
+          }
+        }
       )
 
       before_validation do |index|
@@ -281,6 +317,10 @@ module Mongoid
         index.normalize
       end
 
+      before_save do |index|
+        index.normalize
+      end
+
       validates_presence_of(:context_type)
 
       def normalize
@@ -292,16 +332,24 @@ module Mongoid
       def normalize!
         index = self
 
-        unless [index.keywords].join.strip.empty?
-          index.keywords = FTS.list_of_strings(index.keywords)
+        unless [index.literals].join.strip.empty?
+          index.literals = FTS.list_of_strings(index.literals)
         end
 
         unless [index.title].join.strip.empty?
           index.title = index.title.to_s.strip
         end
 
+        unless [index.literal_title].join.strip.empty?
+          index.literal_title = index.literal_title.to_s.strip
+        end
+
         unless [index.keywords].join.strip.empty?
-          index.keywords = index.keywords.map{|keyword| keyword.strip}
+          index.keywords = FTS.list_of_strings(index.keywords)
+        end
+
+        unless [index.literal_keywords].join.strip.empty?
+          index.literal_keywords = FTS.list_of_strings(index.literal_keywords)
         end
 
         unless [index.fulltext].join.strip.empty?
@@ -312,6 +360,10 @@ module Mongoid
         @normalized = true
       end
 
+      def inspect(*args, &block)
+        Map.for(as_document).inspect(*args, &block)
+      end
+
       def Index.teardown!
         Index.remove_indexes
         Index.destroy_all
@@ -342,12 +394,18 @@ module Mongoid
         models.each{|model| add(model)}
       end
 
-      def Index.add(model)
+      def Index.add!(model)
         to_search = Index.to_search(model)
 
-        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
-        fulltext = to_search.has_key?(:fulltext) ?  Coerce.string(to_search[:fulltext]) : nil
+        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
+        literal_title    = to_search.has_key?(:literal_title) ?  Coerce.string(to_search[:literal_title]) : nil
+
+        keywords         = to_search.has_key?(:keywords) ?  Coerce.list_of_strings(to_search[:keywords]) : nil
+        literal_keywords = to_search.has_key?(:literal_keywords) ?  Coerce.list_of_strings(to_search[:literal_keywords]) : nil
+
+        fulltext         = to_search.has_key?(:fulltext) ?  Coerce.string(to_search[:fulltext]) : nil
 
         context_type = model.class.name.to_s
         context_id   = model.id
@@ -358,87 +416,177 @@ module Mongoid
         }
 
         attributes = {
-          :title        => title,
-          :keywords     => keywords,
-          :fulltext     => fulltext
+          :literals         => literals,
+
+          :title            => title,
+          :literal_title    => literal_title,
+
+          :keywords         => keywords,
+          :literal_keywords => literal_keywords,
+
+          :fulltext         => fulltext
         }
 
-        begin
-          new(conditions).upsert
-        rescue Object => e
-          warn "#{ e.message } (#{ e.class })"
-
-          4.times do
-            begin
-              break if create(conditions)
-            rescue Object => e
-              warn "#{ e.message } (#{ e.class })"
-              nil
-            end
+        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
-        end
 
-      # FIXME - go BOOM here if none found...
-      #
-        index = where(conditions).first
+          sleep(rand) if i < (n - 1)
+        end
 
         if index
-          index.update_attributes(attributes)
+          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.remove(model)
-        context_type = model.class.name.to_s
-        context_id = model.id
+      def Index.add(*args, &block)
+        begin
+          add!(*args, &block)
+        rescue Object
+          false
+        end
+      end
 
-        conditions = {
-          :context_type => context_type,
-          :context_id   => context_id
-        }
+      def Index.remove!(*args, &block)
+        options = args.extract_options!.to_options!
+        models = args.flatten.compact
 
-        where(conditions).first.tap do |index|
-          if index
-            index.destroy rescue nil
-          end
+        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)
+        begin
+          remove!(*args, &block)
+        rescue Object
+          false
         end
       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.compact.join(' ')
+            end
 
           to_search[:keywords] =
             %w( keywords tags ).map do |attr|
               model.send(attr) if model.respond_to?(attr)
-            end.compact
+            end
 
           to_search[:fulltext] =
             %w( fulltext text content body description ).map do |attr|
               model.send(attr) if model.respond_to?(attr)
-            end.compact.join(' ')
+            end
         end
 
-        unless %w( title keywords fulltext ).detect{|key| to_search.has_key?(key)}
+      #
+        unless %w( literals title keywords fulltext ).detect{|key| to_search.has_key?(key)}
           raise ArgumentError, "you need to define #{ model }#to_search"
         end
 
+      #
+        literals = FTS.normalized_array(to_search[:literals])
+        title    = FTS.normalized_array(to_search[:title])
+        keywords = FTS.normalized_array(to_search[:keywords])
+        fulltext = FTS.normalized_array(to_search[:fulltext])
+
+      #
+        to_search[:literals]         = FTS.literals_for(literals)
+
+        to_search[:literal_title]    = FTS.literals_for(title).join(' ').strip
+        to_search[:title]            = title.join(' ').strip
+
+        to_search[:literal_keywords] = FTS.literals_for(keywords).join(' ').strip
+        to_search[:keywords]         = keywords.join(' ').strip
+
+        to_search[:fulltext]         = fulltext.join(' ').strip
+
+      #
         to_search
       end
     end
 
-    def FTS.index
-      Index
+    def FTS.normalized_array(*array)
+      array.flatten.map{|_| _.to_s.strip}.select{|_| !_.empty?}
+    end
+
+    def FTS.literals_for(*words)
+      words = words.join(' ').strip.split(/\s+/)
+
+      words.map do |word|
+        next if word.empty?
+        if word =~ /\A__.*__\Z/
+          word
+        else
+          without_delimeters = word.to_s.scan(/[0-9a-zA-Z]/).join
+          literal = "__#{ without_delimeters }__"
+          literal
+        end
+      end.compact
+    end
+
+    def FTS.index(*args, &block)
+      if args.empty? and block.nil?
+        Index
+      else
+        Index.add(*args, &block)
+      end
+    end
+
+    def FTS.unindex(*args, &block)
+      Index.remove(*args, &block)
+    end
+
+    def FTS.index!(*args, &block)
+      Index.add!(*args, &block)
+    end
+
+    def FTS.unindex!(*args, &block)
+      Index.remove!(*args, &block)
     end
 
   #
@@ -485,6 +633,11 @@ module Mongoid
             super
           ensure
             other.module_eval(&Mixin.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

data/mongoid-fts.gemspec

@@ -3,7 +3,7 @@
 
 Gem::Specification::new do |spec|
   spec.name = "mongoid-fts"
-  spec.version = "0.5.0"
+  spec.version = "1.0.0"
   spec.platform = Gem::Platform::RUBY
   spec.summary = "mongoid-fts"
   spec.description = "enable mongodb's new fulltext simply and quickly on your mongoid models, including pagination."

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongoid-fts
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Ara T. Howard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-01 00:00:00.000000000 Z
+date: 2013-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid