tire 0.2.1 → 0.3.0

data/README.markdown

@@ -434,9 +434,53 @@ In this case, just wrap the `mapping` method in a `settings` one, passing it the
 ```
 
 It may well be reasonable to wrap the index creation logic declared with `Tire.index('urls').create`
-in a class method of your model, in a module method, etc, so have better control on index creation when bootstrapping your application with Rake tasks or when setting up the test suite.
+in a class method of your model, in a module method, etc, so have better control on index creation when
+bootstrapping your application with Rake tasks or when setting up the test suite.
 _Tire_ will not hold that against you.
 
+You may have just stopped wondering: what if I have my own `settings` class method defined?
+Or what if some other gem defines `settings`, or some other _Tire_ method, such as `update_index`?
+Things will break, right? No, they won't.
+
+In fact, all this time you've been using only _proxies_ to the real _Tire_ methods, which live in the `tire`
+class and instance methods of your model. Only when not trampling on someone's foot — which is the majority
+of cases —, will _Tire_ bring its methods to the namespace of your class.
+
+So, instead of writing `Article.search`, you could write `Article.tire.search`, and instead of
+`@article.update_index` you could write `@article.tire.update_index`, to be on the safe side.
+Let's have a look on an example with the `mapping` method:
+
+```ruby
+    class Article < ActiveRecord::Base
+      include Tire::Model::Search
+      include Tire::Model::Callbacks
+
+      tire.mapping do
+        indexes :id, :type => 'string', :index => :not_analyzed
+        # ...
+      end
+    end
+```
+
+Of course, you could also use the block form:
+
+```ruby
+    class Article < ActiveRecord::Base
+      include Tire::Model::Search
+      include Tire::Model::Callbacks
+
+      tire do
+        mapping do
+          indexes :id, :type => 'string', :index => :not_analyzed
+          # ...
+        end
+      end
+    end
+```
+
+Internally, _Tire_ uses these proxy methods exclusively. When you run into issues,
+use the proxied method, eg. `Article.tire.mapping`, directly.
+
 When you want a tight grip on how the attributes are added to the index, just
 implement the `to_indexed_json` method in your model.
 
@@ -529,7 +573,7 @@ so you can pass all the usual parameters to the `search` method in the controlle
 OK. Chances are, you have lots of records stored in your database. How will you get them to _ElasticSearch_? Easy:
 
 ```ruby
-    Article.elasticsearch_index.import Article.all
+    Article.index.import Article.all
 ```
 
 This way, however, all your records are loaded into memory, serialized into JSON,

data/lib/tire.rb

@@ -21,9 +21,9 @@ require 'tire/dsl'
 require 'tire/model/naming'
 require 'tire/model/callbacks'
 require 'tire/model/percolate'
-require 'tire/model/search'
 require 'tire/model/indexing'
 require 'tire/model/import'
+require 'tire/model/search'
 require 'tire/model/persistence/finders'
 require 'tire/model/persistence/attributes'
 require 'tire/model/persistence/storage'

data/lib/tire/model/callbacks.rb

@@ -1,14 +1,33 @@
 module Tire
   module Model
 
+    # Main module containing the infrastructure for automatic updating
+    # of the _ElasticSearch_ index on model instance create, update or delete.
+    #
+    # Include it in your model: `include Tire::Model::Callbacks`
+    #
+    # The model must respond to `after_save` and `after_destroy` callbacks
+    # (ActiveModel and ActiveRecord models do so, by default).
+    #
+    # By including the model, you will also have the `after_update_elasticsearch_index` and
+    # `before_update_elasticsearch_index` callbacks available.
+    # 
     module Callbacks
 
+      # A hook triggered by the `include Tire::Model::Callbacks` statement in the model.
+      #
       def self.included(base)
+
+        # Update index on model instance change or destroy.
+        #
         if base.respond_to?(:after_save) && base.respond_to?(:after_destroy)
-          base.send :after_save,    :update_elastic_search_index
-          base.send :after_destroy, :update_elastic_search_index
+          base.send :after_save,    lambda { tire.update_index }
+          base.send :after_destroy, lambda { tire.update_index }
         end
 
+        # Add neccessary infrastructure for the model, when missing in
+        # some half-baked ActiveModel implementations.
+        #
         if base.respond_to?(:before_destroy) && !base.instance_methods.map(&:to_sym).include?(:destroyed?)
           base.class_eval do
             before_destroy  { @destroyed = true }
@@ -16,8 +35,10 @@ module Tire
           end
         end
 
+        # Define _Tire's_ callbacks.
+        #
         base.class_eval do
-          define_model_callbacks(:update_elastic_search_index, :only => [:after, :before])
+          define_model_callbacks(:update_elasticsearch_index, :only => [:after, :before])
         end if base.respond_to?(:define_model_callbacks)
       end
 

data/lib/tire/model/import.rb

@@ -7,7 +7,7 @@ module Tire
 
         def import options={}, &block
           method = options.delete(:method) || 'paginate'
-          self.elasticsearch_index.import self, method, options, &block
+          index.import klass, method, options, &block
         end
 
       end

data/lib/tire/model/indexing.rb

@@ -45,8 +45,8 @@ module Tire
         end
 
         def create_elasticsearch_index
-          unless elasticsearch_index.exists?
-            elasticsearch_index.create :mappings => mapping_to_hash, :settings => settings
+          unless index.exists?
+            index.create :mappings => mapping_to_hash, :settings => settings
           end
         end
 

data/lib/tire/model/naming.rb

@@ -6,21 +6,21 @@ module Tire
       module ClassMethods
         def index_name name=nil
           @index_name = name if name
-          @index_name || model_name.plural
+          @index_name || klass.model_name.plural
         end
 
         def document_type
-          model_name.singular
+          klass.model_name.singular
         end
       end
 
       module InstanceMethods
         def index_name
-          self.class.index_name
+          instance.class.tire.index_name
         end
 
         def document_type
-          self.class.document_type
+          instance.class.tire.document_type
         end
       end
 

data/lib/tire/model/percolate.rb

@@ -11,7 +11,7 @@ module Tire
 
         def on_percolate(pattern=true,&block)
           percolate!(pattern)
-          after_update_elastic_search_index(block)
+          klass.after_update_elasticsearch_index(block)
         end
 
         def percolator
@@ -22,7 +22,7 @@ module Tire
       module InstanceMethods
 
         def percolate(&block)
-          index.percolate self, block
+          index.percolate instance, block
         end
 
         def percolate=(pattern)
@@ -30,7 +30,7 @@ module Tire
         end
 
         def percolator
-          @_percolator || self.class.percolator || nil
+          @_percolator || instance.class.tire.percolator || nil
         end
       end
 

data/lib/tire/model/persistence/storage.rb

@@ -46,7 +46,7 @@ module Tire
           def save
             return false unless valid?
             run_callbacks :save do
-              # Document#id is set in the +update_elastic_search_index+ method,
+              # Document#id is set in the +update_elasticsearch_index+ method,
               # where we have access to the JSON response
             end
             self

data/lib/tire/model/search.rb

@@ -1,66 +1,63 @@
 module Tire
   module Model
 
+    # Main module containing the search infrastructure for ActiveModel classes.
+    #
+    # By including this module, you'll provide the model with facilities to
+    # perform searches against index, define index settings and mappings,
+    # access the index object, etc.
+    #
+    # All the _Tire_ methods are accessible via the "proxy" class and instance
+    # methods of the model, named `tire`, eg. `Article.tire.search 'foo'`.
+    #
+    # When there's no clash with a method in the class (your own, defined by another gem, etc)
+    # _Tire_ will bring these methods to the top-level namespace of the class,
+    # eg. `Article.search 'foo'`.
+    #
+    # You'll find the relevant methods in the ClassMethods and InstanceMethods module.
+    #
+    #
     module Search
 
-      def self.included(base)
-        base.class_eval do
-          extend  Tire::Model::Naming::ClassMethods
-          include Tire::Model::Naming::InstanceMethods
-
-          extend  Tire::Model::Indexing::ClassMethods
-          extend  Tire::Model::Import::ClassMethods
-
-          extend  Tire::Model::Percolate::ClassMethods
-          include Tire::Model::Percolate::InstanceMethods
-
-          extend  ClassMethods
-          include InstanceMethods
-
-          ['_score', '_type', '_index', '_version', 'sort', 'highlight', 'matches'].each do |attr|
-            # TODO: Find a sane way to add attributes like _score for ActiveRecord -
-            #       `define_attribute_methods [attr]` does not work in AR.
-            define_method("#{attr}=") { |value| @attributes ||= {}; @attributes[attr] = value }
-            define_method("#{attr}")  { @attributes[attr] }
-          end
-
-          def to_hash
-            self.serializable_hash
-          end unless instance_methods.map(&:to_sym).include?(:to_hash)
-        end
-
-        Results::Item.send :include, Loader
-      end
-
       module ClassMethods
 
         # Returns search results for a given query.
         #
         # Query can be passed simply as a String:
         #
-        #   Article.search 'love'
+        #     Article.search 'love'
         #
         # Any options, such as pagination or sorting, can be passed as a second argument:
         #
-        #   Article.search 'love', :per_page => 25, :page => 2
-        #   Article.search 'love', :sort => 'title'
+        #     Article.search 'love', :per_page => 25, :page => 2
+        #     Article.search 'love', :sort => 'title'
         #
         # For more powerful query definition, use the query DSL passed as a block:
         #
-        #   Article.search do
-        #     query { terms :tags, ['ruby', 'python'] }
-        #     facet 'tags' { terms :tags }
-        #   end
+        #     Article.search do
+        #       query { terms :tags, ['ruby', 'python'] }
+        #       facet 'tags' { terms :tags }
+        #     end
         #
         # You can pass options as the first argument, in this case:
         #
-        #   Article.search :per_page => 25, :page => 2 do
-        #     query { string 'love' }
-        #   end
+        #     Article.search :per_page => 25, :page => 2 do
+        #       query { string 'love' }
+        #     end
+        #
+        # This methods returns a Tire::Results::Collection instance, containing instances
+        # of Tire::Results::Item, populated by the data available in _ElasticSearch, by default.
+        #
+        # If you'd like to load the "real" models from the database, you may use the `:load` option:
         #
+        #     Article.search 'love', :load => true
+        #
+        # You can pass options as a Hash to the model's `find` method:
+        #
+        #     Article.search :load => { :include => 'comments' } do ... end
         #
         def search(*args, &block)
-          default_options = {:type => document_type, :index => elasticsearch_index.name}
+          default_options = {:type => document_type, :index => index.name}
 
           if block_given?
             options = args.shift || {}
@@ -91,15 +88,11 @@ module Tire
           s.perform.results
         end
 
-        # Wrapper for the ES index for this class
-        #
-        # TODO: Implement some "forwardable" object named +tire+ for Tire mixins,
-        #       and proxy everything via this object. If we're not stepping on
-        #       other libs toes, extend/include also to the top level.
+        # Returns a Tire::Index instance for this model.
         #
-        #       The original culprit is Mongoid here, see https://github.com/karmi/tire/issues/7
+        # Example usage: `Article.index.refresh`.
         #
-        def elasticsearch_index
+        def index
           @index = Index.new(index_name)
         end
 
@@ -107,33 +100,54 @@ module Tire
 
       module InstanceMethods
 
+        # Returns a Tire::Index instance for this instance of the model.
+        #
+        # Example usage: `@article.index.refresh`.
+        #
         def index
-          self.class.elasticsearch_index
+          instance.class.tire.index
         end
 
-        def update_elastic_search_index
-          _run_update_elastic_search_index_callbacks do
-            if destroyed?
-              index.remove self
+        # Updates the index in _ElasticSearch_.
+        #
+        # On model instance create or update, it will store its serialized representation in the index.
+        #
+        # On model destroy, it will remove the corresponding document from the index.
+        #
+        # It will also call the `<after|before>_update_elasticsearch_index` callbacks,
+        # if defined by the model.
+        #
+        def update_index
+          instance.send :_run_update_elasticsearch_index_callbacks do
+            if instance.destroyed?
+              index.remove instance
             else
-              response  = index.store( self, {:percolate => self.percolator} )
-              self.id ||= response['_id'] if self.respond_to?(:id=)
-              self._index   = response['_index']
-              self._type    = response['_type']
-              self._version = response['_version']
-              self.matches  = response['matches']
+              response  = index.store( instance, {:percolate => percolator} )
+              instance.id     ||= response['_id']      if instance.respond_to?(:id=)
+              instance._index   = response['_index']   if instance.respond_to?(:_index=)
+              instance._type    = response['_type']    if instance.respond_to?(:_type=)
+              instance._version = response['_version'] if instance.respond_to?(:_version=)
+              instance.matches  = response['matches']  if instance.respond_to?(:matches=)
               self
             end
           end
         end
-        alias :update_elasticsearch_index :update_elastic_search_index
+        alias :update_elasticsearch_index  :update_index
+        alias :update_elastic_search_index :update_index
 
+        # The default JSON serialization of the model, based on its `#to_hash` representation.
+        #
+        # If you don't define any mapping, the model is serialized as-is.
+        #
+        # If you do define the mapping for _ElasticSearch_, only attributes
+        # declared in the mapping are serialized.
+        #
         def to_indexed_json
-          if self.class.mapping.empty?
-            to_hash.to_json
+          if instance.class.tire.mapping.empty?
+            instance.to_hash.to_json
           else
-            to_hash.
-            reject { |key, value| ! self.class.mapping.keys.map(&:to_s).include?(key.to_s) }.
+            instance.to_hash.
+            reject { |key, value| ! instance.class.tire.mapping.keys.map(&:to_s).include?(key.to_s) }.
             to_json
           end
         end
@@ -142,7 +156,10 @@ module Tire
 
       module Loader
 
-        # Load the "real" model from the database via the corresponding model's `find` method
+        # Load the "real" model from the database via the corresponding model's `find` method.
+        #
+        # Notice that there's an option to eagerly load models with the `:load` option
+        # for the search method.
         #
         def load(options=nil)
           options ? self.class.find(self.id, options) : self.class.find(self.id)
@@ -150,7 +167,106 @@ module Tire
 
       end
 
-      extend ClassMethods
+      # An object containing _Tire's_ model class methods, accessed as `Article.tire`.
+      #
+      class ClassMethodsProxy
+        include Tire::Model::Naming::ClassMethods
+        include Tire::Model::Import::ClassMethods
+        include Tire::Model::Indexing::ClassMethods
+        include Tire::Model::Percolate::ClassMethods
+        include ClassMethods
+
+        INTERFACE = public_instance_methods.map(&:to_sym) - Object.public_instance_methods.map(&:to_sym)
+
+        attr_reader :klass
+        def initialize(klass)
+          @klass = klass
+        end
+
+      end
+
+      # An object containing _Tire's_ model instance methods, accessed as `@article.tire`.
+      #
+      class InstanceMethodsProxy
+        include Tire::Model::Naming::InstanceMethods
+        include Tire::Model::Percolate::InstanceMethods
+        include InstanceMethods
+
+        ['_score', '_type', '_index', '_version', 'sort', 'highlight', 'matches'].each do |attr|
+          # TODO: Find a sane way to add attributes like _score for ActiveRecord -
+          #       `define_attribute_methods [attr]` does not work in AR.
+          define_method("#{attr}=") { |value| @attributes ||= {}; @attributes[attr] = value }
+          define_method("#{attr}")  { @attributes[attr] }
+        end
+
+        INTERFACE = public_instance_methods.map(&:to_sym) - Object.public_instance_methods.map(&:to_sym)
+
+        attr_reader :instance
+        def initialize(instance)
+          @instance = instance
+        end
+      end
+
+      # A hook triggered by the `include Tire::Model::Search` statement in the model.
+      #
+      def self.included(base)
+        base.class_eval do
+
+          # Returns proxy to the _Tire's_ class methods.
+          #
+          def self.tire &block
+            @__tire__ ||= ClassMethodsProxy.new(self)
+
+            @__tire__.instance_eval(&block) if block_given?
+            @__tire__
+          end
+
+          # Returns proxy to the _Tire's_ instance methods.
+          #
+          def tire &block
+            @__tire__ ||= InstanceMethodsProxy.new(self)
+
+            @__tire__.instance_eval(&block) if block_given?
+            @__tire__
+          end
+
+          # Serialize the model as a Hash.
+          #
+          # Uses `serializable_hash` representation of the model,
+          # unless implemented in the model already.
+          #
+          def to_hash
+            self.serializable_hash
+          end unless instance_methods.map(&:to_sym).include?(:to_hash)
+
+        end
+
+        # Alias _Tire's_ class methods in the top-level namespace of the model,
+        # unless there's a conflict with existing method.
+        #
+        ClassMethodsProxy::INTERFACE.each do |method|
+          base.class_eval <<-"end;", __FILE__, __LINE__ unless base.public_methods.map(&:to_sym).include?(method.to_sym)
+            def self.#{method}(*args, &block)                     # def search(*args, &block)
+              tire.__send__(#{method.inspect}, *args, &block)     #   tire.__send__(:search, *args, &block)
+            end                                                   # end
+          end;
+        end
+
+        # Alias _Tire's_ instance methods in the top-level namespace of the model,
+        # unless there's a conflict with existing method
+        InstanceMethodsProxy::INTERFACE.each do |method|
+          base.class_eval <<-"end;", __FILE__, __LINE__ unless base.instance_methods.map(&:to_sym).include?(method.to_sym)
+            def #{method}(*args, &block)                          # def to_indexed_json(*args, &block)
+              tire.__send__(#{method.inspect}, *args, &block)     #   tire.__send__(:to_indexed_json, *args, &block)
+            end                                                   # end
+          end;
+        end
+
+        # Include the `load` functionality in Results::Item
+        #
+        Results::Item.send :include, Loader
+      end
+
     end
 
   end

data/lib/tire/tasks.rb

@@ -44,7 +44,7 @@ namespace :tire do
     klass  = eval(ENV['CLASS'].to_s)
     params = eval(ENV['PARAMS'].to_s) || {}
 
-    index = Tire::Index.new( ENV['INDEX'] || klass.elasticsearch_index.name )
+    index = Tire::Index.new( ENV['INDEX'] || klass.tire.index.name )
 
     if ENV['FORCE']
       puts "[IMPORT] Deleting index '#{index.name}'"
@@ -52,10 +52,10 @@ namespace :tire do
     end
 
     unless index.exists?
-      mapping = defined?(Yajl) ? Yajl::Encoder.encode(klass.mapping_to_hash, :pretty => true) :
-                                 MultiJson.encode(klass.mapping_to_hash)
+      mapping = defined?(Yajl) ? Yajl::Encoder.encode(klass.tire.mapping_to_hash, :pretty => true) :
+                                 MultiJson.encode(klass.tire.mapping_to_hash)
       puts "[IMPORT] Creating index '#{index.name}' with mapping:", mapping
-      index.create :mappings => klass.mapping_to_hash
+      index.create :mappings => klass.tire.mapping_to_hash
     end
 
     STDOUT.sync = true

data/lib/tire/version.rb

@@ -1,5 +1,5 @@
 module Tire
-  VERSION   = "0.2.1"
+  VERSION   = "0.3.0"
 
   CHANGELOG =<<-END
     IMPORTANT CHANGES LATELY:
@@ -17,5 +17,12 @@ module Tire
     # Added the 'settings' method for models to define index settings
     # Fixed errors when importing data with will_paginate vs Kaminari (MongoDB)
     # Added support for histogram facets [Paco Guzman]
+
+    0.2.1
+    ---------------------------------------------------------
+    # Isolated Tire ActiveModel integration into `tire` class and instance method.
+    
+      When there's no conflict with existing methods, Tire methods are added
+      to the class namespace, as well, so the change is 100% backwards-compatible.
   END
 end

data/test/integration/active_model_searchable_test.rb

@@ -28,7 +28,7 @@ module Tire
         assert_equal 'czech', SupermodelArticle.mapping[:title][:analyzer]
         assert_equal 15,      SupermodelArticle.mapping[:title][:boost]
 
-        assert_equal 'czech', SupermodelArticle.elasticsearch_index.mapping['supermodel_article']['properties']['title']['analyzer']
+        assert_equal 'czech', SupermodelArticle.index.mapping['supermodel_article']['properties']['title']['analyzer']
       end
 
       should "save document into index on save and find it with score" do
@@ -75,7 +75,7 @@ module Tire
         SupermodelArticle.create! :title => 'foo'
         SupermodelArticle.create! :id => 'abc123', :title => 'bar'
 
-        SupermodelArticle.elasticsearch_index.refresh
+        SupermodelArticle.index.refresh
         results = SupermodelArticle.search 'foo OR bar^100'
 
         assert_equal 2, results.count

data/test/integration/active_record_searchable_test.rb

@@ -26,6 +26,9 @@ module Tire
           t.string     :period
           t.references :article
         end
+        create_table :active_record_class_with_tire_methods do |t|
+          t.string     :title
+        end
       end
     end
 
@@ -41,7 +44,7 @@ module Tire
         assert_equal 'snowball', ActiveRecordArticle.mapping[:title][:analyzer]
         assert_equal 10, ActiveRecordArticle.mapping[:title][:boost]
 
-        assert_equal 'snowball', ActiveRecordArticle.elasticsearch_index.mapping['active_record_article']['properties']['title']['analyzer']
+        assert_equal 'snowball', ActiveRecordArticle.index.mapping['active_record_article']['properties']['title']['analyzer']
       end
 
       should "save document into index on save and find it" do
@@ -68,7 +71,7 @@ module Tire
         setup do
           ActiveRecordArticle.destroy_all
           5.times { |n| ActiveRecordArticle.create! :title => "Test #{n+1}" }
-          ActiveRecordArticle.elasticsearch_index.refresh
+          ActiveRecordArticle.index.refresh
         end
 
         should "load records on query search" do
@@ -103,16 +106,15 @@ module Tire
       end
 
       should "remove document from index on destroy" do
-        a = ActiveRecordArticle.new :title => 'Test'
+        a = ActiveRecordArticle.new :title => 'Test remove...'
         a.save!
         assert_equal 1, ActiveRecordArticle.count
 
         a.destroy
-        assert_equal 0, SupermodelArticle.all.size
+        assert_equal 0, ActiveRecordArticle.all.size
 
         a.index.refresh
         results = ActiveRecordArticle.search 'test'
-      
         assert_equal 0, results.count
       end
 
@@ -120,7 +122,7 @@ module Tire
         ActiveRecordArticle.create! :title => 'foo'
         ActiveRecordArticle.create! :title => 'bar'
 
-        ActiveRecordArticle.elasticsearch_index.refresh
+        ActiveRecordArticle.index.refresh
         results = ActiveRecordArticle.search 'foo OR bar^100'
         assert_equal 2, results.count
 
@@ -130,7 +132,7 @@ module Tire
       context "with pagination" do
         setup do
           1.upto(9) { |number| ActiveRecordArticle.create :title => "Test#{number}" }
-          ActiveRecordArticle.elasticsearch_index.refresh
+          ActiveRecordArticle.index.refresh
         end
 
         context "and parameter searches" do
@@ -231,6 +233,34 @@ module Tire
 
       end
 
+      context "with proxy" do
+
+        should "allow access to Tire instance methods" do
+          a = ActiveRecordClassWithTireMethods.create :title => 'One'
+          assert_equal "THIS IS MY INDEX!", a.index
+          assert_instance_of Tire::Index, a.tire.index
+          assert a.tire.index.exists?, "Index should exist"
+        end
+
+        should "allow access to Tire class methods" do
+          class ::ActiveRecordClassWithTireMethods < ActiveRecord::Base
+            def self.search(*)
+              "THIS IS MY SEARCH!"
+            end
+          end
+
+          ActiveRecordClassWithTireMethods.create :title => 'One'
+          ActiveRecordClassWithTireMethods.tire.index.refresh
+
+          assert_equal "THIS IS MY SEARCH!", ActiveRecordClassWithTireMethods.search
+
+          results = ActiveRecordClassWithTireMethods.tire.search 'one'
+
+          assert_equal 'One', results.first.title
+        end
+
+      end
+
       context "within Rails" do
 
         setup do

data/test/integration/persistent_model_test.rb

@@ -33,7 +33,7 @@ module Tire
 
         setup do
           1.upto(9) { |number| PersistentArticle.create :title => "Test#{number}" }
-          PersistentArticle.elasticsearch_index.refresh
+          PersistentArticle.index.refresh
         end
 
         should "find first page with five results" do

data/test/models/active_record_models.rb

@@ -5,19 +5,33 @@ class ActiveRecordArticle < ActiveRecord::Base
   has_many :comments, :class_name => "ActiveRecordComment", :foreign_key => "article_id"
   has_many :stats,    :class_name => "ActiveRecordStat",    :foreign_key => "article_id"
 
+  # def index
+  #   "KEEP OFF MY INDEX!!!"
+  # end
+  #
+  # def self.settings
+  #   "KEEP OFF MY SETTINGS!!!"
+  # end
+
   include Tire::Model::Search
   include Tire::Model::Callbacks
 
-  mapping do
-    indexes :title,      :type => 'string', :boost => 10, :analyzer => 'snowball'
-    indexes :created_at, :type => 'date'
+  tire do
+    mapping do
+      indexes :title,      :type => 'string', :boost => 10, :analyzer => 'snowball'
+      indexes :created_at, :type => 'date'
 
-    indexes :comments do
-      indexes :author
-      indexes :body
+      indexes :comments do
+        indexes :author
+        indexes :body
+      end
     end
   end
 
+  # tire.mapping do
+  #   indexes :title,      :type => 'string', :boost => 10, :analyzer => 'snowball'
+  # end
+
   def to_indexed_json
     {
       :title        => title,
@@ -47,3 +61,23 @@ end
 class ActiveRecordStat < ActiveRecord::Base
   belongs_to :article, :class_name => "ActiveRecordArticle", :foreign_key => "article_id"
 end
+
+class ActiveRecordClassWithTireMethods < ActiveRecord::Base
+
+  def self.mapping
+    "THIS IS MY MAPPING!"
+  end
+
+  def index
+    "THIS IS MY INDEX!"
+  end
+
+  include Tire::Model::Search
+  include Tire::Model::Callbacks
+
+  tire do
+    mapping do
+      indexes :title, :type => 'string', :analyzer => 'snowball'
+    end
+  end
+end

data/test/test_helper.rb

@@ -51,6 +51,8 @@ module Test::Integration
                        fixtures_path.join('articles').join(f).read
     end
     ::RestClient.post "#{URL}/articles-test/_refresh", ''
+
+    Dir[File.dirname(__FILE__) + '/models/**/*.rb'].each { |m| load m }
   end
 
   def teardown

data/test/unit/index_test.rb

@@ -310,7 +310,7 @@ module Tire
           one = ActiveModelArticle.new 'title' => 'One'; one.id = '1'
           two = ActiveModelArticle.new 'title' => 'Two'; two.id = '2'
 
-          ActiveModelArticle.elasticsearch_index.bulk_store [ one, two ]
+          ActiveModelArticle.index.bulk_store [ one, two ]
 
         end
 
@@ -327,7 +327,7 @@ module Tire
           STDERR.expects(:puts).once
 
           documents = [ { :title => 'Bogus' }, { :title => 'Real', :id => 1 } ]
-          ActiveModelArticle.elasticsearch_index.bulk_store documents
+          ActiveModelArticle.index.bulk_store documents
         end
 
       end

data/test/unit/model_callbacks_test.rb

@@ -1,6 +1,7 @@
 require 'test_helper'
 
 class ModelOne
+  extend ActiveModel::Naming
   include Tire::Model::Search
   include Tire::Model::Callbacks
 
@@ -9,6 +10,7 @@ class ModelOne
 end
 
 class ModelTwo
+  extend ActiveModel::Naming
   extend  ActiveModel::Callbacks
   define_model_callbacks :save, :destroy
 
@@ -27,6 +29,7 @@ class ModelTwo
 end
 
 class ModelThree
+  extend ActiveModel::Naming
   extend  ActiveModel::Callbacks
   define_model_callbacks :save, :destroy
 
@@ -50,10 +53,11 @@ module Tire
       context "Model without ActiveModel callbacks" do
 
         should "not execute any callbacks" do
-          ModelOne.any_instance.expects(:update_elastic_search_index).never
+          m = ModelOne.new
+          m.tire.expects(:update_index).never
 
-          ModelOne.new.save
-          ModelOne.new.destroy
+          m.save
+          m.destroy
         end
 
       end
@@ -61,10 +65,11 @@ module Tire
       context "Model with ActiveModel callbacks and implemented destroyed? method" do
 
         should "execute the callbacks" do
-          ModelTwo.any_instance.expects(:update_elastic_search_index).twice
+          m = ModelTwo.new
+          m.tire.expects(:update_index).twice
 
-          ModelTwo.new.save
-          ModelTwo.new.destroy
+          m.save
+          m.destroy
         end
 
       end
@@ -76,10 +81,11 @@ module Tire
         end
 
         should "execute the callbacks" do
-          ModelThree.any_instance.expects(:update_elastic_search_index).twice
+          m = ModelThree.new
+          m.tire.expects(:update_index).twice
 
-          ModelThree.new.save
-          ModelThree.new.destroy
+          m.save
+          m.destroy
         end
 
       end

data/test/unit/model_persistence_test.rb

@@ -340,7 +340,6 @@ module Tire
             Configuration.client.expects(:post).
                                  with do |url, payload|
                                    doc = MultiJson.decode(payload)
-                                   p doc
                                    url == "#{Configuration.url}/persistent_articles/persistent_article/1" &&
                                    doc['id'] == '1' &&
                                    doc['title'] == 'Updated'

data/test/unit/model_search_test.rb

@@ -28,28 +28,12 @@ module Tire
         end
 
         should "have the search method" do
-          assert_respond_to Model::Search, :search
           assert_respond_to ActiveModelArticle, :search
         end
 
-        should "have the `update_elastic_search_index` callback methods defined" do
-          assert_respond_to ::ModelWithIndexCallbacks, :before_update_elastic_search_index
-          assert_respond_to ::ModelWithIndexCallbacks, :after_update_elastic_search_index
-        end
-
-        should_eventually "contain all Tire class/instance methods in a proxy object" do
-        end
-
-        should_eventually "include Tire class methods in class top-level namespace when they do not exist" do
-        end
-
-        should_eventually "include Tire instance methods in instance top-level namespace when they do not exist" do
-        end
-
-        should_eventually "NOT overload existing top-level class methods" do
-        end
-
-        should_eventually "NOT overload existing top-level instance methods" do
+        should "have the callback methods for update index defined" do
+          assert_respond_to ::ModelWithIndexCallbacks, :before_update_elasticsearch_index
+          assert_respond_to ::ModelWithIndexCallbacks, :after_update_elasticsearch_index
         end
 
         should "limit searching in index for documents matching the model 'document_type'" do
@@ -111,7 +95,7 @@ module Tire
         should "allow to refresh index" do
           Index.any_instance.expects(:refresh)
 
-          ActiveModelArticle.elasticsearch_index.refresh
+          ActiveModelArticle.index.refresh
         end
 
         should "wrap results in instances of the wrapper class" do
@@ -225,7 +209,7 @@ module Tire
 
         should "not set callback when hooks are missing" do
           @model = ActiveModelArticle.new
-          @model.expects(:update_elastic_search_index).never
+          @model.expects(:update_elasticsearch_index).never
 
           @model.save
         end
@@ -240,26 +224,26 @@ module Tire
 
         should "fire :after_save callbacks" do
           @model = ActiveModelArticleWithCallbacks.new
-          @model.expects(:update_elastic_search_index)
+          @model.tire.expects(:update_index)
 
           @model.save
         end
 
         should "fire :after_destroy callbacks" do
           @model = ActiveModelArticleWithCallbacks.new
-          @model.expects(:update_elastic_search_index)
+          @model.tire.expects(:update_index)
 
           @model.destroy
         end
 
-        should "store the record in index on :update_elastic_search_index when saved" do
+        should "store the record in index on :update_elasticsearch_index when saved" do
           @model = ActiveModelArticleWithCallbacks.new
           Tire::Index.any_instance.expects(:store).returns({})
 
           @model.save
         end
 
-        should "remove the record from index on :update_elastic_search_index when destroyed" do
+        should "remove the record from index on :update_elasticsearch_index when destroyed" do
           @model = ActiveModelArticleWithCallbacks.new
           i = mock('index') { expects(:remove) }
           Tire::Index.expects(:new).with('active_model_article_with_callbacks').returns(i)
@@ -373,7 +357,7 @@ module Tire
         context "with index update callbacks" do
           setup do
             class ::ModelWithIndexCallbacks
-              _update_elastic_search_index_callbacks.clear
+              _update_elasticsearch_index_callbacks.clear
               def notify; end
             end
 
@@ -385,18 +369,18 @@ module Tire
 
           should "run the callback defined as block" do
             class ::ModelWithIndexCallbacks
-              after_update_elastic_search_index { self.go! }
+              after_update_elasticsearch_index { self.go! }
             end
 
             @model = ::ModelWithIndexCallbacks.new
             @model.expects(:go!)
 
-            @model.update_elastic_search_index
+            @model.update_elasticsearch_index
           end
 
           should "run the callback defined as symbol" do
             class ::ModelWithIndexCallbacks
-              after_update_elastic_search_index :notify
+              after_update_elasticsearch_index :notify
 
               def notify; self.go!; end
             end
@@ -404,12 +388,12 @@ module Tire
             @model = ::ModelWithIndexCallbacks.new
             @model.expects(:go!)
 
-            @model.update_elastic_search_index
+            @model.update_elasticsearch_index
           end
 
           should "set the 'matches' property from percolated response" do
             @model = ::ModelWithIndexCallbacks.new
-            @model.update_elastic_search_index
+            @model.update_elasticsearch_index
 
             assert_equal ['foo'], @model.matches
           end
@@ -533,7 +517,7 @@ module Tire
               options[:percolate] == true
             end.returns(MultiJson.decode('{"ok":true,"_id":"test","matches":["alerts"]}'))
 
-            @article.update_elastic_search_index
+            @article.update_elasticsearch_index
           end
 
           should "not percolate document on index update when not set for percolation" do
@@ -542,7 +526,7 @@ module Tire
               options[:percolate] == nil
             end.returns(MultiJson.decode('{"ok":true,"_id":"test"}'))
 
-            @article.update_elastic_search_index
+            @article.update_elasticsearch_index
           end
 
           should "set the default percolator pattern" do
@@ -572,7 +556,7 @@ module Tire
             end.returns(MultiJson.decode('{"ok":true,"_id":"test","matches":["alerts"]}'))
 
             percolated = ActiveModelArticleWithPercolation.new :title => 'Percolate me!'
-            percolated.update_elastic_search_index
+            percolated.update_elasticsearch_index
           end
 
           should "execute the 'on_percolate' callback" do
@@ -589,7 +573,7 @@ module Tire
                                      end.
                                      returns(MultiJson.decode('{"ok":true,"_id":"test","matches":["alerts"]}'))
 
-            percolated.update_elastic_search_index
+            percolated.update_elasticsearch_index
 
             assert_equal ['alerts'], $test__matches
           end
@@ -608,13 +592,39 @@ module Tire
                                      end.
                                      returns(MultiJson.decode('{"ok":true,"_id":"test","matches":["alerts"]}'))
 
-            percolated.update_elastic_search_index
+            percolated.update_elasticsearch_index
 
             assert_equal ['alerts'], $test__matches
           end
 
         end
 
+        context "proxy" do
+
+          should "have the proxy to class methods" do
+            assert_respond_to ActiveModelArticle, :tire
+            assert_instance_of Tire::Model::Search::ClassMethodsProxy, ActiveModelArticle.tire
+          end
+
+          should "have the proxy to instance methods" do
+            assert_respond_to ActiveModelArticle.new, :tire
+            assert_instance_of Tire::Model::Search::InstanceMethodsProxy, ActiveModelArticle.new.tire
+          end
+
+          should "NOT overload existing top-level class methods" do
+            assert_equal "THIS IS MY MAPPING!", ActiveRecordClassWithTireMethods.mapping
+            assert_equal 'snowball', ActiveRecordClassWithTireMethods.tire.mapping[:title][:analyzer]
+          end
+
+          should "NOT overload existing top-level instance methods" do
+            ActiveRecordClassWithTireMethods.stubs(:columns).returns([])
+            assert_equal "THIS IS MY INDEX!", ActiveRecordClassWithTireMethods.new.index
+            assert_equal 'active_record_class_with_tire_methods',
+                         ActiveRecordClassWithTireMethods.new.tire.index.name
+          end
+
+        end
+
       end
 
       context "Results::Item" do

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
-  - 1
-  version: 0.2.1
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Karel Minarik
@@ -331,7 +331,14 @@ post_install_message: |
     # Fixed errors when importing data with will_paginate vs Kaminari (MongoDB)
     # Added support for histogram facets [Paco Guzman]
   
-    See the full changelog at <http://github.com/karmi/tire/commits/v0.2.1>.
+    0.2.1
+    ---------------------------------------------------------
+    # Isolated Tire ActiveModel integration into `tire` class and instance method.
+    
+      When there's no conflict with existing methods, Tire methods are added
+      to the class namespace, as well, so the change is 100% backwards-compatible.
+  
+    See the full changelog at <http://github.com/karmi/tire/commits/v0.3.0>.
   
   --------------------------------------------------------------------------------