activesearch 0.0.3 → 0.0.4

data/README.md

@@ -4,39 +4,42 @@ This gem allows any class to be indexed by the chosen fulltext search engine.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Depending on the chosen engine, you need to require a dependency and then activesearch on your Gemfile:
 
-    gem 'activesearch'
-
-And then execute:
+###Mongoid
 
-    $ bundle
+    gem 'mongoid'
+    gem 'activesearch'
+    
+This is not a fulltext search engine, but it's a good solution for those users that don't have access to anything else.
+It works by storing keywords taken from the specified fields and storing them in an Array field, which would be indexed.
+    
+###elasticsearch
 
-Or install it yourself as:
+    gem 'tire'
+    gem 'activesearch'
 
-    $ gem install activesearch
+##Configuration
 
-## Supported engines
+Add this to your model:
+      
+    search_by :title, :body, store: [:slug]
+    
+the :store option allows you to retrieve that value but it won't be used for search.
 
-###Mongoid
+## Querying
+  
+    ActiveSearch.search("some words").first.to_hash["title"]
+  
+You can access the stored fields with to_hash, so you don't need to fetch the real document.
 
-This is not a fulltext search engine, but it's a good solution for those users that don't have access to anything else.
-It works by storing keywords taken from the specified fields and storing them in an Array field, which would be indexed.
-search() method will return a Mongod::Criteria, so you can chain it with further scopes, like pagination.
-You won't get original documents though.
+## Testing
 
-## Usage
+Run specs with this command:
 
-    class SomeModel
-      # [...] field definitions if needed
-      include ActiveSearch::Engine # "Engine" being your chosen engine ie. "Mongoid"
-  
-      search_on :title, :body, store: [:title]
-    end
-    
-    # Access the stored fields so you don't need to fetch the real document
-    ActiveSearch.search("some words").first.stored["title"]
+    bundle exec parallel_rspec spec/
 
+Since different engines define their own version of ActiveSearch, running specs on a single process will break.
 
 ## Contributing
 

data/activesearch.gemspec

@@ -19,5 +19,8 @@ Gem::Specification.new do |gem|
   
   gem.add_development_dependency "rspec"
   gem.add_development_dependency "bson_ext"
-  gem.add_development_dependency "mongoid", "~> 2.4"
-end
+  gem.add_development_dependency "active_attr"
+  gem.add_development_dependency "mongoid", "~> 2"
+  gem.add_development_dependency "tire"
+  gem.add_development_dependency "parallel_tests"
+end

data/elasticsearch.log

@@ -0,0 +1,24 @@
+# 2012-10-31 15:41:49:965 [HEAD] ("elastic_search_models")
+#
+curl -I "http://localhost:9200/elastic_search_models"
+
+# 2012-10-31 15:41:49:988 [200]
+#
+# ""
+
+# 2012-10-31 15:41:50:002 [HEAD] ("another_elastic_search_models")
+#
+curl -I "http://localhost:9200/another_elastic_search_models"
+
+# 2012-10-31 15:41:50:002 [200]
+#
+# ""
+
+# 2012-10-31 15:41:50:007 [_search] (["_all"])
+#
+curl -X GET "http://localhost:9200/_all/_search?query%5Bstring%5D=findable&pretty=true" -d '{}'
+
+# 2012-10-31 15:41:50:008 [200] (1 msec)
+#
+# {"took":1,"timed_out":false,"_shards":{"total":10,"successful":10,"failed":0},"hits":{"total":0,"max_score":null,"hits":[]}}
+

data/lib/activesearch/elastic_search/proxy.rb

@@ -0,0 +1,26 @@
+require "activesearch/result"
+
+module ActiveSearch
+  module ElasticSearch
+    class Proxy
+      include Enumerable
+      
+      def initialize(text)
+        @text = text
+      end
+      
+      def each(&block)
+        search.results.each { |result| block.call(Result.new(result)) }
+      end
+      
+      protected
+      def search
+        @search ||= Tire.search('_all') do |search|
+          search.query do |query|
+            query.text("_all", @text)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/activesearch/elastic_search.rb

@@ -0,0 +1,30 @@
+require "active_support/core_ext"
+require "activesearch/elastic_search/proxy"
+
+module ActiveSearch
+  
+  def self.search(text)
+    ElasticSearch::Proxy.new(text)
+  end
+  
+  module ElasticSearch
+    def self.included(base)
+      base.extend ClassMethods
+    end
+  end
+  
+  module ClassMethods
+    def search_by(*fields)
+      options = fields.pop if fields.last.is_a?(Hash)
+      include Tire::Model::Search
+      include Tire::Model::Callbacks
+      
+      mapping do
+        indexes :type
+        indexes :id, as: :original_id
+        fields.each { |f| indexes f }
+        (Array(options[:store]) - fields).each { |f| indexes f, :index => :no }
+      end
+    end
+  end
+end

data/lib/activesearch/mongoid/model.rb

@@ -3,24 +3,28 @@ module ActiveSearch
     class Model
       include ::Mongoid::Document
       
-      field :type, type: String
-      field :original_id, type: BSON::ObjectId
-      field :keywords
-      field :stored, type: Hash, default: {}
+      field :_original_type, type: String
+      field :_original_id, type: BSON::ObjectId
+      field :_keywords
+      field :_stored, type: Hash, default: {}
       
-      index :keywords
-      index [:type, :original_id], unique: true
+      index :_keywords
+      index [:_original_type, :_original_id], unique: true
+      
+      def to_hash
+        _stored
+      end
       
       def store_fields(original, fields, options)
         if options && options[:store]
           options[:store].each do |f|
-            self.stored[f] = original[f] if original.send("#{f}_changed?")
+            self._stored[f] = original[f] if original.send("#{f}_changed?")
           end
         end
       end
       
       def refresh_keywords(original, fields)
-        self.keywords = fields.select { |f| original.fields[f.to_s]  }.inject([]) do |memo,f|
+        self._keywords = fields.select { |f| original.fields[f.to_s]  }.inject([]) do |memo,f|
           
           if original.fields[f.to_s].localized?
             memo += original.send("#{f}_translations").map do |locale,translation|
@@ -30,11 +34,16 @@ module ActiveSearch
             original[f] ? memo += original[f].downcase.split : memo
           end
         end
-        self.keywords.uniq!
+        self._keywords.uniq!
+      end
+      
+      def self.deindex(original)
+        ActiveSearch::Mongoid::Model.where(_original_type: original.class.to_s, _original_id: original.id).destroy
       end
       
       def self.reindex(original, fields, options)
-        doc = self.find_or_initialize_by(type: original.class.to_s, original_id: original.id)
+        return unless fields.any? { |f| original.send("#{f}_changed?") }
+        doc = find_or_initialize_by(_original_type: original.class.to_s, _original_id: original.id)
         doc.store_fields(original, fields, options)
         doc.refresh_keywords(original, fields)
         doc.save

data/lib/activesearch/mongoid.rb

@@ -4,7 +4,8 @@ module ActiveSearch
   
   # TODO: Wrap this so all engines behave consistently
   def self.search(text)
-    Mongoid::Model.where(:keywords.in => text.split + text.split.map { |word| "#{I18n.locale}:#{word}"})
+    text = text.split(/\s+/)
+    Mongoid::Model.where(:_keywords.in => text + text.map { |word| "#{I18n.locale}:#{word}"})
   end
   
   module Mongoid
@@ -12,17 +13,29 @@ module ActiveSearch
       base.extend ClassMethods
     end
     
+    protected
+    def reindex
+      ActiveSearch::Mongoid::Model.reindex(self, self.class.search_fields, self.class.search_options)
+    end
+    
+    def deindex
+      ActiveSearch::Mongoid::Model.deindex(self)
+    end
+    
     module ClassMethods
-      def search_on(*fields)
-        # TODO: Use inheritable class variables, so ActiveSearch::Mongoid::Model can get fields and options from there
-        self.class_eval <<-EOV
-          after_save do
-            fields = #{fields}
-            options = fields.pop if fields.last.is_a?(Hash)
-            return unless fields.any? { |f| self.send("\#{f}_changed?") }
-            ActiveSearch::Mongoid::Model.reindex(self, fields, options)
-          end
-        EOV
+      def search_options
+        @search_options
+      end
+      
+      def search_fields
+        @search_fields
+      end
+      
+      def search_by(*fields)
+        @search_options = fields.pop if fields.last.is_a?(Hash)
+        @search_fields  = fields
+        self.after_save    :reindex
+        self.after_destroy :deindex
       end
     end
   end

data/lib/activesearch/result.rb

@@ -0,0 +1,13 @@
+module ActiveSearch
+  class Result < Hash
+    def initialize(result)
+      result.to_hash.each do |k,v|
+        self[k.to_s] = v unless v.nil?
+      end
+    end
+    
+    def attributes
+      self
+    end
+  end
+end

data/lib/activesearch/version.rb

@@ -1,3 +1,3 @@
 module ActiveSearch
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/activesearch.rb

@@ -1 +1 @@
-require "activesearch/version"
+require "activesearch/version"