tire 0.1.16 → 0.2.0

data/lib/tire/model/callbacks.rb

@@ -9,7 +9,7 @@ module Tire
           base.send :after_destroy, :update_elastic_search_index
         end
 
-        if base.respond_to?(:before_destroy) && !base.instance_methods.include?('destroyed?')
+        if base.respond_to?(:before_destroy) && !base.instance_methods.map(&:to_sym).include?(:destroyed?)
           base.class_eval do
             before_destroy  { @destroyed = true }
             def destroyed?; !!@destroyed; end

data/lib/tire/model/search.rb

@@ -28,36 +28,67 @@ module Tire
             self.serializable_hash
           end unless instance_methods.map(&:to_sym).include?(:to_hash)
         end
+
+        Results::Item.send :include, Loader
       end
 
       module ClassMethods
 
-        def search(query=nil, options={}, &block)
-          old_wrapper = Tire::Configuration.wrapper
-          Tire::Configuration.wrapper self
-
-          sort    = Array( options[:order] || options[:sort] )
-          options = {:type => document_type}.update(options)
+        # Returns search results for a given query.
+        #
+        # Query can be passed simply as a String:
+        #
+        #   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'
+        #
+        # 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
+        #
+        # You can pass options as the first argument, in this case:
+        #
+        #   Article.search :per_page => 25, :page => 2 do
+        #     query { string 'love' }
+        #   end
+        #
+        #
+        def search(*args, &block)
+          default_options = {:type => document_type}
 
-          unless block_given?
-            s = Tire::Search::Search.new(elasticsearch_index.name, options)
-            s.query { string query }
-            s.sort do
-              sort.each do |t|
-                field_name, direction = t.split(' ')
-                by field_name, direction
-              end
-            end unless sort.empty?
-            s.size( options[:per_page].to_i ) if options[:per_page]
-            s.from( options[:page].to_i <= 1 ? 0 : (options[:per_page].to_i * (options[:page].to_i-1)) ) if options[:page] && options[:per_page]
-            s.perform.results
+          if block_given?
+            options = args.shift || {}
           else
-            s = Tire::Search::Search.new(elasticsearch_index.name, options)
+            query, options = args
+            options ||= {}
+          end
+
+          sort      = Array( options[:order] || options[:sort] )
+          options   = default_options.update(options)
+
+          s = Tire::Search::Search.new(elasticsearch_index.name, options)
+          s.size( options[:per_page].to_i ) if options[:per_page]
+          s.from( options[:page].to_i <= 1 ? 0 : (options[:per_page].to_i * (options[:page].to_i-1)) ) if options[:page] && options[:per_page]
+          s.sort do
+            sort.each do |t|
+              field_name, direction = t.split(' ')
+              by field_name, direction
+            end
+          end unless sort.empty?
+
+          if block_given?
             block.arity < 1 ? s.instance_eval(&block) : block.call(s)
-            s.perform.results
+          else
+            s.query { string query }
           end
-        ensure
-          Tire::Configuration.wrapper old_wrapper
+
+          s.perform.results
         end
 
         # Wrapper for the ES index for this class
@@ -76,11 +107,6 @@ module Tire
 
       module InstanceMethods
 
-        def score
-          Tire.warn "#{self.class}#score has been deprecated, please use #{self.class}#_score instead."
-          attributes['_score']
-        end
-
         def index
           self.class.elasticsearch_index
         end
@@ -114,6 +140,16 @@ module Tire
 
       end
 
+      module Loader
+
+        # Load the "real" model from the database via the corresponding model's `find` method
+        #
+        def load(options=nil)
+          options ? self.class.find(self.id, options) : self.class.find(self.id)
+        end
+
+      end
+
       extend ClassMethods
     end
 

data/lib/tire/results/collection.rb

@@ -18,26 +18,44 @@ module Tire
 
       def results
         @results ||= begin
-          @response['hits']['hits'].map do |h|
-             if @wrapper == Hash then h
-             else
-               document = {}
+          unless @options[:load]
+            @response['hits']['hits'].map do |h|
+               if @wrapper == Hash then h
+               else
+                 document = {}
 
-               # Update the document with content and ID
-               document = h['_source'] ? document.update( h['_source'] || {} ) : document.update( __parse_fields__(h['fields']) )
-               document.update( {'id' => h['_id']} )
+                 # Update the document with content and ID
+                 document = h['_source'] ? document.update( h['_source'] || {} ) : document.update( __parse_fields__(h['fields']) )
+                 document.update( {'id' => h['_id']} )
 
-               # Update the document with meta information
-               ['_score', '_type', '_index', '_version', 'sort', 'highlight'].each { |key| document.update( {key => h[key]} || {} ) }
+                 # Update the document with meta information
+                 ['_score', '_type', '_index', '_version', 'sort', 'highlight'].each { |key| document.update( {key => h[key]} || {} ) }
 
-               # for instantiating ActiveRecord with arbitrary attributes and setting @new_record etc.
-               if @wrapper.respond_to?(:instantiate, true)
-                 @wrapper.send(:instantiate, document)
-               else
+                 # Return an instance of the "wrapper" class
                  @wrapper.new(document)
                end
-             end
-           end
+            end
+          else
+            begin
+              return [] if @response['hits']['total'] == 0
+
+              type  = @response['hits']['hits'].first['_type']
+              raise NoMethodError, "You have tried to eager load the model instances, " +
+                                   "but Tire cannot find the model class because " +
+                                   "document has no _type property." unless type
+
+              klass = type.camelize.constantize
+              ids   = @response['hits']['hits'].map { |h| h['_id'] }
+              records =  @options[:load] === true ? klass.find(ids) : klass.find(ids, @options[:load])
+
+              # Reorder records to preserve order from search results
+              ids.map { |id| records.detect { |record| record.id.to_s == id.to_s } }
+            rescue NameError => e
+              raise NameError, "You have tried to eager load the model instances, but" +
+                               "Tire cannot find the model class '#{type.camelize}' " +
+                               "based on _type '#{type}'.", e.backtrace
+            end
+          end
         end
       end
 

data/lib/tire/results/item.rb

@@ -1,15 +1,22 @@
 module Tire
   module Results
 
-    class Item < Hash
+    class Item
+      extend  ActiveModel::Naming
+      include ActiveModel::Conversion
 
       # Create new instance, recursively converting all Hashes to Item
       # and leaving everything else alone.
       #
       def initialize(args={})
         raise ArgumentError, "Please pass a Hash-like object" unless args.respond_to?(:each_pair)
+        @attributes = {}
         args.each_pair do |key, value|
-          self[key.to_sym] = value.is_a?(Hash) ? self.class.new(value.to_hash) : value
+          if value.is_a?(Array)
+            @attributes[key.to_sym] = value.map { |item| @attributes[key.to_sym] = item.is_a?(Hash) ? self.class.new(item.to_hash) : item }
+          else
+            @attributes[key.to_sym] = value.is_a?(Hash) ? self.class.new(value.to_hash) : value
+          end
         end
       end
 
@@ -17,20 +24,51 @@ module Tire
       # otherwise return +nil+.
       #
       def method_missing(method_name, *arguments)
-        self.has_key?(method_name.to_sym) ? self[method_name.to_sym] : nil
+        @attributes.has_key?(method_name.to_sym) ? @attributes[method_name.to_sym] : nil
+      end
+
+      def [](key)
+        @attributes[key]
       end
 
-      # Get ID
-      #
       def id
-        self[:id]
+        @attributes[:_id] || @attributes[:id]
+      end
+
+      def persisted?
+        !!id
+      end
+
+      def errors
+        ActiveModel::Errors.new(self)
+      end
+
+      def valid?
+        true
+      end
+
+      def to_key
+        persisted? ? [id] : nil
+      end
+
+      def to_hash
+        @attributes
+      end
+
+      # Let's pretend we're someone else in Rails
+      #
+      def class
+        defined?(::Rails) && @attributes[:_type] ? @attributes[:_type].camelize.constantize : super
       end
 
       def inspect
-        s = []; self.each { |k,v| s << "#{k}: #{v.inspect}" }
-        %Q|<Item #{s.join(', ')}>|
+        s = []; @attributes.each { |k,v| s << "#{k}: #{v.inspect}" }
+        %Q|<Item#{self.class.to_s == 'Tire::Results::Item' ? '' : " (#{self.class})"} #{s.join(', ')}>|
       end
 
+      def to_json(options=nil)
+        @attributes.to_json(options)
+      end
       alias_method :to_indexed_json, :to_json
 
     end

data/lib/tire/search.rb

@@ -6,9 +6,6 @@ module Tire
       attr_reader :indices, :url, :results, :response, :json, :query, :facets, :filters, :options
 
       def initialize(indices=nil, options = {}, &block)
-        Tire.warn "Passing indices as multiple arguments to the `Search.new` method " +
-                  "has been deprecated, please pass them as an Array: " +
-                  "Search.new([#{indices}, #{options}])" if options.is_a?(String)
         @indices = Array(indices)
         @options = options
         @type    = @options[:type]
@@ -64,8 +61,8 @@ module Tire
         self
       end
 
-      def fields(fields=[])
-        @fields = fields
+      def fields(*fields)
+        @fields = Array(fields.flatten)
         self
       end
 

data/lib/tire/search/sort.rb

@@ -12,13 +12,6 @@ module Tire
         self
       end
 
-      def method_missing(id, *args, &block)
-        Tire.warn "Using methods when sorting has been deprecated, please use the `by` method: " +
-                  "sort { by :#{id}#{ args.empty? ? '' : ', ' + args.first.inspect } }"
-
-        by id, args.shift
-      end
-
       def to_ary
         @value
       end

data/lib/tire/version.rb

@@ -1,13 +1,13 @@
 module Tire
-  VERSION   = "0.1.16"
+  VERSION   = "0.2.0"
 
   CHANGELOG =<<-END
     IMPORTANT CHANGES LATELY:
 
-    # Defined mapping for nested fields [#56]
-    # Mapping type is optional and defaults to "string"
-    # Fixed handling of fields returned prefixed by _source from ES [#31]
-    # Allow passing the type to search and added that model passes `document_type` to search [@jonkarna, #38]
-    # Allow leaving index name empty for searching the whole server
+    # By default, results are wrapped in Item class (05a1331)
+    # Completely rewritten ActiveModel/ActiveRecord support
+    # Added method to items for loading the "real" model from database (f9273bc)
+    # Added the ':load' option to eagerly load results from database (1e34cde)
+    # Deprecated the dynamic sort methods, use the 'sort { by :field_name }' syntax
   END
 end

data/test/integration/active_model_searchable_test.rb

@@ -16,7 +16,7 @@ module Tire
       SupermodelArticle.delete_all
     end
 
-    context "ActiveModel" do
+    context "ActiveModel integration" do
 
       setup    do
         Tire.index('supermodel_articles').delete
@@ -42,7 +42,6 @@ module Tire
         end
 
         a.index.refresh
-        sleep(1.5)
 
         # The index should contain 2 documents
         assert_equal 2, Tire.search('supermodel_articles') { query { all } }.results.size
@@ -52,7 +51,7 @@ module Tire
         # The model should find only 1 document
         assert_equal 1, results.count
 
-        assert_instance_of SupermodelArticle, results.first
+        assert_instance_of Results::Item, results.first
         assert_equal       'Test', results.first.title
         assert_not_nil     results.first._score
         assert_equal       id, results.first.id
@@ -61,11 +60,12 @@ module Tire
       should "remove document from index on destroy" do
         a = SupermodelArticle.new :title => 'Test'
         a.save
+        assert_equal 1, SupermodelArticle.all.size
+
         a.destroy
+        assert_equal 0, SupermodelArticle.all.size
 
         a.index.refresh
-        sleep(1.25)
-
         results = SupermodelArticle.search 'test'
         
         assert_equal 0, results.count
@@ -84,6 +84,27 @@ module Tire
         assert_equal 'abc123', results.first.id
       end
 
+      context "within Rails" do
+
+        setup do
+          module ::Rails; end
+        end
+
+        should "load the underlying model" do
+          a = SupermodelArticle.new :title => 'Test'
+          a.save
+          a.index.refresh
+
+          results = SupermodelArticle.search 'test'
+
+          assert_instance_of Results::Item, results.first
+          assert_instance_of SupermodelArticle, results.first.load
+
+          assert_equal 'Test', results.first.load.title
+        end
+
+      end
+
     end
 
   end

data/test/integration/active_record_searchable_test.rb

@@ -15,19 +15,25 @@ module Tire
           t.string   :title
           t.datetime :created_at, :default => 'NOW()'
         end
+        create_table :active_record_comments do |t|
+          t.string     :author
+          t.text       :body
+          t.references :article
+          t.timestamps
+        end
+        create_table :active_record_stats do |t|
+          t.integer    :pageviews
+          t.string     :period
+          t.references :article
+        end
       end
     end
 
-    def teardown
-      super
-      File.delete fixtures_path.join('articles.db') rescue nil
-    end
-
     context "ActiveRecord integration" do
 
       setup    do
         Tire.index('active_record_articles').delete
-        load File.expand_path('../../models/active_record_article.rb', __FILE__)
+        load File.expand_path('../../models/active_record_models.rb', __FILE__)
       end
       teardown { Tire.index('active_record_articles').delete }
 
@@ -44,24 +50,65 @@ module Tire
         id = a.id
 
         a.index.refresh
-        sleep(1.5) # Leave ES some breathing room here...
 
         results = ActiveRecordArticle.search 'test'
 
+        assert       results.any?
         assert_equal 1, results.count
 
-        assert_instance_of ActiveRecordArticle, results.first
+        assert_instance_of Results::Item, results.first
         assert_not_nil results.first.id
-        assert_equal   id, results.first.id
+        assert_equal   id.to_s, results.first.id.to_s
         assert         results.first.persisted?, "Record should be persisted"
         assert_not_nil results.first._score
         assert_equal   'Test', results.first.title
       end
 
+      context "with eager loading" do
+        setup do
+          ActiveRecordArticle.destroy_all
+          5.times { |n| ActiveRecordArticle.create! :title => "Test #{n+1}" }
+          ActiveRecordArticle.elasticsearch_index.refresh
+        end
+
+        should "load records on query search" do
+          results = ActiveRecordArticle.search '"Test 1"', :load => true
+
+          assert       results.any?
+          assert_equal ActiveRecordArticle.find(1), results.first
+        end
+
+        should "load records on block search" do
+          results = ActiveRecordArticle.search :load => true do
+            query { string '"Test 1"' }
+          end
+
+          assert_equal ActiveRecordArticle.find(1), results.first
+        end
+
+        should "load records with options on query search" do
+          assert_equal ActiveRecordArticle.find(['1', '2'], :include => 'comments'),
+                       ActiveRecordArticle.search('"Test 1" OR "Test 2"', :load => { :include => 'comments' }).results
+        end
+
+        should "return empty collection for nonmatching query" do
+          assert_nothing_raised do
+            results = ActiveRecordArticle.search :load => true do
+              query { string '"Hic Sunt Leones"' }
+            end
+            assert_equal 0, results.size
+            assert ! results.any?
+          end
+        end
+      end
+
       should "remove document from index on destroy" do
         a = ActiveRecordArticle.new :title => 'Test'
         a.save!
+        assert_equal 1, ActiveRecordArticle.count
+
         a.destroy
+        assert_equal 0, SupermodelArticle.all.size
 
         a.index.refresh
         results = ActiveRecordArticle.search 'test'
@@ -184,6 +231,44 @@ module Tire
 
       end
 
+      context "within Rails" do
+
+        setup do
+          module ::Rails; end
+
+          a = ActiveRecordArticle.new :title => 'Test'
+          a.comments.build :author => 'fool', :body => 'Works!'
+          a.stats.build    :pageviews  => 12, :period => '2011-08'
+          a.save!
+          @id = a.id.to_s
+
+          a.index.refresh
+          @item = ActiveRecordArticle.search('test').first
+        end
+
+        should "have access to indexed properties" do
+          assert_equal 'Test', @item.title
+          assert_equal 'fool', @item.comments.first.author
+          assert_equal 12,     @item.stats.first.pageviews
+        end
+
+        should "load the underlying models" do
+          assert_instance_of Results::Item, @item
+          assert_instance_of ActiveRecordArticle, @item.load
+          assert_equal      'Test', @item.load.title
+
+          assert_instance_of Results::Item, @item.comments.first
+          assert_instance_of ActiveRecordComment, @item.comments.first.load
+          assert_equal      'fool', @item.comments.first.load.author
+        end
+
+        should "load the underlying model with options" do
+          ActiveRecordArticle.expects(:find).with(@id, :include => 'comments')
+          @item.load(:include => 'comments')
+        end
+
+      end
+
     end
 
   end