elastic_searchable 0.3.1 → 0.4.0

data/README.rdoc

@@ -1,6 +1,31 @@
 = elastic_searchable
 
-Description goes here.
+Integrate the elasticsearch library into Rails.
+
+== Usage
+  class Blog < ActiveRecord::Base
+    elastic_searchable
+  end
+
+  results = Blog.search 'foo'
+
+== Features
+
+* fast. fast! FAST! 30% faster than rubberband on average.
+* active record callbacks automatically keep search index up to date as your data changes
+* out of the box background indexing of data using backgrounded.  Don't lock up a foreground process waiting on a background job!
+* integrates with will_paginate library for easy pagination of search results
+
+== Installation
+  #Gemfile
+  gem 'elastic_searchable'
+
+== Configuration
+
+  #config/initializers/elastic_searchable.rb
+  #customize elasticsearch host
+  #defaults to localhost:9200
+  ElasticSearchable.base_uri = 'server:9200'
 
 == Contributing to elastic_searchable
  

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.4.0

data/elastic_searchable.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{elastic_searchable}
-  s.version = "0.3.1"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ryan Sonnek"]
-  s.date = %q{2011-02-03}
+  s.date = %q{2011-02-22}
   s.description = %q{integrate the elastic search engine with rails}
   s.email = %q{ryan@codecrate.com}
   s.extra_rdoc_files = [
@@ -36,7 +36,7 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/wireframe/elastic_searchable}
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.5.0}
+  s.rubygems_version = %q{1.5.2}
   s.summary = %q{elastic search for activerecord}
   s.test_files = [
     "test/helper.rb",

data/lib/elastic_searchable/active_record.rb

@@ -26,51 +26,22 @@ module ElasticSearchable
         options.symbolize_keys!
         self.elastic_options = options
 
-        extend ElasticSearchable::ActiveRecord::Index
+        extend ElasticSearchable::Indexing::ClassMethods
         extend ElasticSearchable::Queries
 
-        include ElasticSearchable::ActiveRecord::InstanceMethods
-        include ElasticSearchable::Callbacks
+        include ElasticSearchable::Indexing::InstanceMethods
+        include ElasticSearchable::Callbacks::InstanceMethods
 
-        add_indexing_callbacks
-      end
-    end
-
-    module InstanceMethods
-      def indexed_json_document
-        self.as_json self.class.elastic_options[:json]
-      end
-      def index_in_elastic_search(lifecycle = nil)
-        ElasticSearchable.request :put, self.class.index_type_path(self.id), :body => self.indexed_json_document.to_json
-
-        self.run_callbacks("after_index_on_#{lifecycle}".to_sym) if lifecycle
-        self.run_callbacks(:after_index)
-      end
-      def should_index?
-        [self.class.elastic_options[:if]].flatten.compact.all? { |m| evaluate_elastic_condition(m) } &&
-        ![self.class.elastic_options[:unless]].flatten.compact.any? { |m| evaluate_elastic_condition(m) }
-      end
-
-      private
-      #ripped from activesupport
-      def evaluate_elastic_condition(method)
-        case method
-          when Symbol
-            self.send method
-          when String
-            eval(method, self.instance_eval { binding })
-          when Proc, Method
-            method.call
-          else
-            if method.respond_to?(kind)
-              method.send kind
-            else
-              raise ArgumentError,
-                "Callbacks must be a symbol denoting the method to call, a string to be evaluated, " +
-                "a block to be invoked, or an object responding to the callback method."
-            end
+        backgrounded :update_index_on_create => ElasticSearchable::Callbacks.backgrounded_options, :update_index_on_update => ElasticSearchable::Callbacks.backgrounded_options
+        class << self
+          backgrounded :delete_id_from_index => ElasticSearchable::Callbacks.backgrounded_options
         end
+
+        define_callbacks :after_index_on_create, :after_index_on_update, :after_index
+        after_commit_on_create :update_index_on_create_backgrounded, :if => :should_index?
+        after_commit_on_update :update_index_on_update_backgrounded, :if => :should_index?
+        after_commit_on_destroy :delete_from_index
       end
     end
   end
-end
+end

data/lib/elastic_searchable/callbacks.rb

@@ -1,31 +1,22 @@
 module ElasticSearchable
   module Callbacks
-    def self.included(base)
-      base.send :extend, ClassMethods
-    end
-    def self.backgrounded_options
-      {:queue => 'elasticsearch'}
-    end
-
-    module ClassMethods
-      def add_indexing_callbacks
-        backgrounded :update_index_on_create => ElasticSearchable::Callbacks.backgrounded_options, :update_index_on_update => ElasticSearchable::Callbacks.backgrounded_options
-        class << self
-          backgrounded :delete_id_from_index => ElasticSearchable::Callbacks.backgrounded_options
-        end
-
-        define_callbacks :after_index_on_create, :after_index_on_update, :after_index
-        after_commit_on_create :update_index_on_create_backgrounded, :if => :should_index?
-        after_commit_on_update :update_index_on_update_backgrounded, :if => :should_index?
-        after_commit_on_destroy Proc.new {|o| o.class.delete_id_from_index_backgrounded(o.id) }
+    class << self
+      def backgrounded_options
+        {:queue => 'elasticsearch'}
       end
     end
 
-    def update_index_on_create
-      index_in_elastic_search :create
-    end
-    def update_index_on_update
-      index_in_elastic_search :update
+    module InstanceMethods
+      private
+      def delete_from_index
+        self.class.delete_id_from_index_backgrounded self.id
+      end
+      def update_index_on_create
+        index_in_elastic_search :create
+      end
+      def update_index_on_update
+        index_in_elastic_search :update
+      end
     end
   end
 end

data/lib/elastic_searchable/index.rb

@@ -1,17 +1,6 @@
 module ElasticSearchable
-  module ActiveRecord
-    module Index
-
-      # helper method to clean out existing index and reindex all objects
-      def rebuild_index
-        self.clean_index
-        self.update_index_mapping
-        self.find_each do |record|
-          record.index_in_elastic_search if record.should_index?
-        end
-        self.refresh_index
-      end
-
+  module Indexing
+    module ClassMethods
       # delete all documents of this type in the index
       # http://www.elasticsearch.com/docs/elasticsearch/rest_api/admin/indices/delete_mapping/
       def clean_index
@@ -29,7 +18,9 @@ module ElasticSearchable
       # create the index
       # http://www.elasticsearch.com/docs/elasticsearch/rest_api/admin/indices/create_index/
       def create_index
-        ElasticSearchable.request :put, index_path
+        options = self.elastic_options[:index_options] ? self.elastic_options[:index_options].to_json : ''
+        ElasticSearchable.request :put, index_path, :body => options
+        self.update_index_mapping
       end
 
       # explicitly refresh the index, making all operations performed since the last refresh
@@ -70,5 +61,61 @@ module ElasticSearchable
         self.elastic_options[:type] || self.table_name
       end
     end
+
+    module InstanceMethods
+      # index the object in elasticsearch
+      # fire after_index callbacks after operation is complete 
+      # see http://www.elasticsearch.org/guide/reference/api/index_.html
+      def index_in_elastic_search(lifecycle = nil)
+        query = {}
+        query.merge! :percolate => "*" if self.class.elastic_options[:percolate]
+        response = ElasticSearchable.request :put, self.class.index_type_path(self.id), :query => query, :body => self.indexed_json_document.to_json
+
+        self.run_callbacks("after_index_on_#{lifecycle}".to_sym) if lifecycle
+        self.run_callbacks(:after_index)
+
+        if percolate_callback = self.class.elastic_options[:percolate]
+          matches = response['matches']
+          self.send percolate_callback, matches if matches.any?
+        end
+      end
+      # document to index in elasticsearch
+      def indexed_json_document
+        self.as_json self.class.elastic_options[:json]
+      end
+      def should_index?
+        [self.class.elastic_options[:if]].flatten.compact.all? { |m| evaluate_elastic_condition(m) } &&
+        ![self.class.elastic_options[:unless]].flatten.compact.any? { |m| evaluate_elastic_condition(m) }
+      end
+      # percolate this object to see what registered searches match
+      # can be done on transient/non-persisted objects!
+      # can be done automatically when indexing using :percolate => true config option
+      # http://www.elasticsearch.org/blog/2011/02/08/percolator.html
+      def percolate
+        response = ElasticSearchable.request :get, self.class.index_type_path('_percolate'), :body => {:doc => self.indexed_json_document}.to_json
+        response['matches']
+      end
+
+      private
+      # ripped from activesupport
+      def evaluate_elastic_condition(method)
+        case method
+          when Symbol
+            self.send method
+          when String
+            eval(method, self.instance_eval { binding })
+          when Proc, Method
+            method.call
+          else
+            if method.respond_to?(kind)
+              method.send kind
+            else
+              raise ArgumentError,
+                "Callbacks must be a symbol denoting the method to call, a string to be evaluated, " +
+                "a block to be invoked, or an object responding to the callback method."
+            end
+        end
+      end
+    end
   end
 end

data/lib/elastic_searchable.rb

@@ -23,14 +23,16 @@ module ElasticSearchable
     def request(method, url, options = {})
       response = self.send(method, url, options)
       #puts "elasticsearch request: #{method} #{url} #{" finished in #{response['took']}ms" if response['took']}"
-      assert_ok_response response
+      validate_response response
       response
     end
 
     private
-    def assert_ok_response(response)
+    # all elasticsearch rest calls return a json response when an error occurs.  ex:
+    # {error: 'an error occurred' }
+    def validate_response(response)
       error = response['error'] || "Error executing request: #{response.inspect}"
-      raise ElasticSearchable::ElasticError.new(error) if response['error'] || !response.response.is_a?(Net::HTTPOK)
+      raise ElasticSearchable::ElasticError.new(error) if response['error'] || ![Net::HTTPOK, Net::HTTPCreated].include?(response.response.class)
     end
   end
 end

data/test/helper.rb

@@ -20,4 +20,7 @@ ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
 ActiveRecord::Base.establish_connection(config[ENV['DB'] || 'sqlite'])
 
 class Test::Unit::TestCase
+  def delete_index
+    ElasticSearchable.delete '/elastic_searchable' rescue nil
+  end
 end

data/test/test_elastic_searchable.rb

@@ -1,24 +1,5 @@
 require File.join(File.dirname(__FILE__), 'helper')
 
-module ElasticSearch
-  class Client
-    def index_mapping(*args)
-      options = args.last.is_a?(Hash) ? args.pop : {}
-      indices = args.empty? ? [(default_index || :all)] : args.flatten
-      indices.collect! { |i| [:all].include?(i) ? "_#{i}" : i }
-      execute(:index_mapping, indices, options)
-    end
-  end
-  module Transport
-    class HTTP
-      def index_mapping(index_list, options={})
-        standard_request(:get, {:index => index_list, :op => "_mapping"})
-      end
-    end
-  end
-end
-
-
 class TestElasticSearchable < Test::Unit::TestCase
   ActiveRecord::Schema.define(:version => 1) do
     create_table :posts, :force => true do |t|
@@ -36,10 +17,19 @@ class TestElasticSearchable < Test::Unit::TestCase
       t.column :name, :string
       t.column :favorite_color, :string
     end
+    create_table :books, :force => true do |t|
+      t.column :title, :string
+    end
   end
 
+  def setup
+    delete_index
+  end
+  def teardown
+    delete_index
+  end
   class Post < ActiveRecord::Base
-    elastic_searchable
+    elastic_searchable :index_options => { "analysis.analyzer.default.tokenizer" => 'standard', "analysis.analyzer.default.filter" => ["standard", "lowercase", 'porterStem'] }
     after_index :indexed
     after_index_on_create :indexed_on_create
     def indexed
@@ -67,7 +57,7 @@ class TestElasticSearchable < Test::Unit::TestCase
     end
   end
 
-  context 'requesting invalid url' do
+  context 'ElasticSearchable.request with invalid url' do
     should 'raise error' do
       assert_raises ElasticSearchable::ElasticError do
         ElasticSearchable.request :get, '/elastic_searchable/foobar/notfound'
@@ -75,22 +65,31 @@ class TestElasticSearchable < Test::Unit::TestCase
     end
   end
 
-  context 'with empty index' do
+  context 'Post.create_index' do
     setup do
-      begin
-        ElasticSearchable.delete '/elastic_searchable'
-      rescue ElasticSearchable::ElasticError
-        #already deleted
-      end
+      Post.create_index
+      @status = ElasticSearchable.request :get, '/elastic_searchable/_status'
+    end
+    should 'have created index' do
+      assert @status['ok']
+    end
+    should 'have used custom index_options' do
+      expected = {
+        "index.number_of_replicas" => "1",
+        "index.number_of_shards" => "5",
+        "index.analysis.analyzer.default.tokenizer" => "standard",
+        "index.analysis.analyzer.default.filter.0" => "standard",
+        "index.analysis.analyzer.default.filter.1" => "lowercase",
+        "index.analysis.analyzer.default.filter.2" => "porterStem"
+      }
+      assert_equal expected, @status['indices']['elastic_searchable']['settings'], @status.inspect
     end
+  end
 
-    context 'Post.create_index' do
-      setup do
-        Post.create_index
-        @status = ElasticSearchable.request :get, '/elastic_searchable/_status'
-      end
-      should 'have created index' do
-        assert @status['ok']
+  context 'deleting object that does not exist in search index' do
+    should 'raise error' do
+      assert_raises ElasticSearchable::ElasticError do
+        Post.delete_id_from_index 123
       end
     end
   end
@@ -109,10 +108,9 @@ class TestElasticSearchable < Test::Unit::TestCase
 
   context 'with index containing multiple results' do
     setup do
-      Post.delete_all
+      Post.create_index
       @first_post = Post.create :title => 'foo', :body => "first bar"
       @second_post = Post.create :title => 'foo', :body => "second bar"
-      Post.rebuild_index
       Post.refresh_index
     end
 
@@ -121,7 +119,7 @@ class TestElasticSearchable < Test::Unit::TestCase
         @results = Post.search 'first'
       end
       should 'find created object' do
-        assert_equal @first_post, @results.first
+        assert_contains @results, @first_post
       end
       should 'be paginated' do
         assert_equal 1, @results.current_page
@@ -135,8 +133,11 @@ class TestElasticSearchable < Test::Unit::TestCase
       setup do
         @results = Post.search 'foo', :page => 2, :per_page => 1, :sort => 'id'
       end
-      should 'find object' do
-        assert_equal @second_post, @results.first
+      should 'not find objects from first page' do
+        assert_does_not_contain @results, @first_post
+      end
+      should 'find second object' do
+        assert_contains @results, @second_post
       end
       should 'be paginated' do
         assert_equal 2, @results.current_page
@@ -152,6 +153,7 @@ class TestElasticSearchable < Test::Unit::TestCase
       end
       should 'sort results correctly' do
         assert_equal @second_post, @results.first
+        assert_equal @first_post, @results.last
       end
     end
 
@@ -174,21 +176,17 @@ class TestElasticSearchable < Test::Unit::TestCase
       false
     end
   end
-  context 'activerecord class with :if=>proc' do
+  context 'activerecord class with optional :if=>proc configuration' do
     context 'when creating new instance' do
       setup do
         Blog.any_instance.expects(:index_in_elastic_search).never
-        Blog.create! :title => 'foo'
+        @blog = Blog.create! :title => 'foo'
       end
       should 'not index record' do end #see expectations
-    end
-    context 'rebuilding new index' do
-      setup do
-        Blog.any_instance.expects(:index_in_elastic_search).never
-        Blog.create! :title => 'foo'
-        Blog.rebuild_index
+      should 'not be found in elasticsearch' do
+        @request = ElasticSearchable.get "/elastic_searchable/blogs/#{@blog.id}"
+        assert @request.response.is_a?(Net::HTTPNotFound), @request.inspect
       end
-      should 'not index record' do end #see expectations
     end
   end
 
@@ -198,7 +196,7 @@ class TestElasticSearchable < Test::Unit::TestCase
   context 'activerecord class with :mapping=>{}' do
     context 'creating index' do
       setup do
-        User.update_index_mapping
+        User.create_index
         @status = ElasticSearchable.request :get, '/elastic_searchable/users/_mapping'
       end
       should 'have set mapping' do
@@ -217,15 +215,15 @@ class TestElasticSearchable < Test::Unit::TestCase
   class Friend < ActiveRecord::Base
     elastic_searchable :json => {:only => [:name]}
   end
-  context 'activerecord class with :json=>{}' do
+  context 'activerecord class with optiona :json config' do
     context 'creating index' do
       setup do
-        Friend.delete_all
+        Friend.create_index
         @friend = Friend.create! :name => 'bob', :favorite_color => 'red'
-        Friend.rebuild_index
+        Friend.refresh_index
       end
       should 'index json with configuration' do
-        @response = ElasticSearchable.request :get, "/friends/friends/#{@friend.id}"
+        @response = ElasticSearchable.request :get, "/elastic_searchable/friends/#{@friend.id}"
         expected = {
           "name" => 'bob' #favorite_color should not be indexed
         }
@@ -245,4 +243,44 @@ class TestElasticSearchable < Test::Unit::TestCase
       assert_equal 'my_new_index', ElasticSearchable.default_index
     end
   end
+
+  class Book < ActiveRecord::Base
+    elastic_searchable :percolate => :on_percolated
+    def on_percolated(percolated)
+      @percolated = percolated
+    end
+    def percolated
+      @percolated
+    end
+  end
+  context 'Book class with percolate=true' do
+    context 'with created index' do
+      setup do
+        Book.create_index
+      end
+      context "when index has configured percolation" do
+        setup do
+          ElasticSearchable.request :put, '/_percolator/elastic_searchable/myfilter', :body => {:query => {:query_string => {:query => 'foo' }}}.to_json
+          ElasticSearchable.request :post, '/_percolator/_refresh'
+        end
+        context 'creating an object that matches the percolation' do
+          setup do
+            @book = Book.create :title => "foo"
+          end
+          should 'return percolated matches in the callback' do
+            assert_equal ['myfilter'], @book.percolated
+          end
+        end
+        context 'percolating a non-persisted object' do
+          setup do
+            @matches = Book.new(:title => 'foo').percolate
+          end
+          should 'return percolated matches' do
+            assert_equal ['myfilter'], @matches
+          end
+        end
+      end
+    end
+  end
 end
+

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: elastic_searchable
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 15
   prerelease: 
   segments: 
   - 0
-  - 3
-  - 1
-  version: 0.3.1
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Ryan Sonnek
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-03 00:00:00 -06:00
+date: 2011-02-22 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -243,7 +243,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.5.0
+rubygems_version: 1.5.2
 signing_key: 
 specification_version: 3
 summary: elastic search for activerecord