tire 0.4.3 → 0.5.0

data/lib/tire/multi_search.rb

@@ -0,0 +1,263 @@
+module Tire
+  module Search
+
+    module Multi
+
+      # Wraps the search definitions for Tire::Multi::Search
+      #
+      class SearchDefinitions
+        include Enumerable
+
+        attr_reader :names
+
+        def initialize
+          @names    = []
+          @searches = []
+        end
+
+        def << value
+          @names    << value[:name]
+          @searches << value[:search]
+        end
+
+        def [] name
+          @searches[ @names.index(name) ]
+        end
+
+        def each(&block)
+          @searches.each(&block)
+        end
+
+        def size
+          @searches.size
+        end
+
+        def to_a
+          @searches
+        end
+      end
+
+      # Wraps the search result sets for Tire::Multi::Search
+      #
+      class Results
+        include Enumerable
+
+        def initialize(searches, results)
+          @searches = searches
+          @results  = results
+          @collection = @results.zip(@searches.to_a).map do |results, search|
+            Tire::Results::Collection.new(results, search.options)
+          end
+        end
+
+        # Return a specific result sets
+        def [] name
+          if index = @searches.names.index(name)
+            @collection[ index ]
+          end
+        end
+
+        def each(&block)
+          @collection.each(&block)
+        end
+
+        def each_pair(&block)
+          @searches.names.zip(@collection).each(&block)
+        end
+
+        def size
+          @results.size
+        end
+
+        # Returns the multi-search result sets as a Hash with the search name
+        # as key and the results as value.
+        #
+        def to_hash
+          result = {}
+          each_pair { |name,results| result[name] = results }
+          result
+        end
+      end
+
+      # Build and perform a [multi-search](http://elasticsearch.org/guide/reference/api/multi-search.html)
+      # request.
+      #
+      #     s = Tire::Search::Multi::Search.new 'my-index' do
+      #           search :names do
+      #             query { match :name, 'john' }
+      #           end
+      #           search :counts, search_type: 'count' do
+      #             query { match :_all, 'john' }
+      #           end
+      #           search :other, index: 'other-index' do
+      #             query { string "first_name:john" }
+      #           end
+      #         end
+      #
+      # You can optionally pass an index and type to the constructor, using them as defaults
+      # for searches which don't define them.
+      #
+      # Use the {#search} method to add a search definition to the request, passing it search options
+      # as a Hash and the search definition itself using Tire's DSL.
+      #
+      class Search
+
+        attr_reader :indices, :types, :path
+
+        def initialize(indices=nil, options={}, &block)
+          @indices  = Array(indices)
+          @types    = Array(options.delete(:type)).map { |type| Utils.escape(type) }
+          @options  = options
+          @path     = ['/', @indices.join(','), @types.join(','), '_msearch'].compact.join('/').squeeze('/')
+          @searches = Tire::Search::Multi::SearchDefinitions.new
+
+          block.arity < 1 ? instance_eval(&block) : block.call(self) if block_given?
+        end
+
+        # Add a search definition to the multi-search request.
+        #
+        # The usual search options such as `search_type`, `routing`, etc. can be passed as a Hash,
+        # and the search definition itself should be passed as a block using the Tire DSL.
+        #
+        def search(*args, &block)
+          name_or_options = args.pop
+
+          if name_or_options.is_a?(Hash)
+            options = name_or_options
+            name    = args.pop
+          else
+            name    = name_or_options
+          end
+
+          name    ||= @searches.size
+          options ||= {}
+          indices   = options.delete(:index) || options.delete(:indices)
+
+          @searches << { :name => name, :search => Tire::Search::Search.new(indices, options, &block) }
+        end
+
+        # Without argument, returns the collection of search definitions.
+        # With argument, returns a search definition by name or order.
+        #
+        def searches(name=nil)
+          name ? @searches[ name ] : @searches
+        end
+
+        # Returns and array of search definition names
+        #
+        def names
+          @searches.names
+        end
+
+        # Serializes the search definitions as an array of JSON definitions
+        #
+        def to_array
+          @searches.map do |search|
+            header = {}
+            header.update(:index => search.indices.join(',')) unless search.indices.empty?
+            header.update(:type  => search.types.join(','))   unless search.types.empty?
+            header.update(:search_type => search.options[:search_type]) if search.options[:search_type]
+            header.update(:routing     => search.options[:routing])     if search.options[:routing]
+            header.update(:preference  => search.options[:preference])  if search.options[:preference]
+            body   = search.to_hash
+            [ header, body ]
+          end.flatten
+        end
+
+        # Serializes the search definitions as a multi-line string payload
+        #
+        def to_payload
+          to_array.map { |line| MultiJson.encode(line) }.join("\n") + "\n"
+        end
+
+        # Returns the request URL
+        #
+        def url
+          [ Configuration.url, @path ].join
+        end
+
+        # Serializes the request URL parameters
+        #
+        def params
+          options = @options.dup
+          options.empty? ? '' : '?' + options.to_param
+        end
+
+        # Returns an enumerable collection of result sets.
+        #
+        # You can simply iterate over them:
+        #
+        #     search.results.each do |results|
+        #       puts results.each.map(&:name)
+        #     end
+        #
+        # To iterate over named result sets, use the `each_pair` method:
+        #
+        #     search.results.each_pair do |name,results|
+        #       puts "Search #{name} got #{results.size} results"
+        #     end
+        #
+        # To get a specific result set:
+        #
+        #     search.results[:myname]
+        #
+        def results
+          @results  || perform and @results
+        end
+
+        # Returns the HTTP response
+        #
+        def response
+          @response || perform and @response
+        end
+
+        # Returns the raw JSON as a Hash
+        #
+        def json
+          @json     || perform and @json
+        end
+
+        def perform
+          @responses = Configuration.client.get(url + params, to_payload)
+          if @responses.failure?
+            STDERR.puts "[REQUEST FAILED] #{to_curl}\n"
+            raise SearchRequestFailed, @responses.to_s
+          end
+          @json     = MultiJson.decode(@responses.body)
+          @results  = Tire::Search::Multi::Results.new @searches, @json['responses']
+          return self
+        ensure
+          logged
+        end
+
+        def to_curl
+          %Q|curl -X GET '#{url}#{params.empty? ? '?' : params.to_s + '&'}pretty' -d '\n#{to_payload}'|
+        end
+
+        def logged(endpoint='_msearch')
+          if Configuration.logger
+
+            Configuration.logger.log_request endpoint, indices, to_curl
+
+            took = @json['took']  rescue nil
+            code = @response.code rescue nil
+
+            if Configuration.logger.level.to_s == 'debug'
+              body = if @json
+                MultiJson.encode( @json, :pretty => Configuration.pretty)
+              else
+                MultiJson.encode( MultiJson.load(@response.body), :pretty => Configuration.pretty) rescue ''
+              end
+            else
+              body = ''
+            end
+
+            Configuration.logger.log_response code || 'N/A', took || 'N/A', body || 'N/A'
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/tire/results/collection.rb

@@ -5,62 +5,26 @@ module Tire
       include Enumerable
       include Pagination
 
-      attr_reader :time, :total, :options, :facets
+      attr_reader :time, :total, :options, :facets, :max_score
 
       def initialize(response, options={})
-        @response = response
-        @options  = options
-        @time     = response['took'].to_i
-        @total    = response['hits']['total'].to_i
-        @facets   = response['facets']
-        @wrapper  = options[:wrapper] || Configuration.wrapper
+        @response  = response
+        @options   = options
+        @time      = response['took'].to_i
+        @total     = response['hits']['total'].to_i rescue nil
+        @facets    = response['facets']
+        @max_score = response['hits']['max_score'].to_f rescue nil
+        @wrapper   = options[:wrapper] || Configuration.wrapper
       end
 
       def results
+        return [] if failure?
         @results ||= begin
           hits = @response['hits']['hits'].map { |d| d.update '_type' => Utils.unescape(d['_type']) }
-
           unless @options[:load]
-            if @wrapper == Hash
-              hits
-            else
-              hits.map do |h|
-                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 meta information
-                ['_score', '_type', '_index', '_version', 'sort', 'highlight', '_explanation'].each { |key| document.update( {key => h[key]} || {} ) }
-
-                # Return an instance of the "wrapper" class
-                @wrapper.new(document)
-              end
-            end
-
+            __get_results_without_load(hits)
           else
-            return [] if hits.empty?
-
-            records = {}
-            @response['hits']['hits'].group_by { |item| item['_type'] }.each do |type, items|
-              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
-
-              begin
-                klass = type.camelize.constantize
-              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
-              ids = items.map { |h| h['_id'] }
-              records[type] = @options[:load] === true ? klass.find(ids) : klass.find(ids, @options[:load])
-            end
-
-            # Reorder records to preserve order from search results
-            @response['hits']['hits'].map { |item| records[item['_type']].detect { |record| record.id.to_s == item['_id'].to_s } }
+            __get_results_with_load(hits)
           end
         end
       end
@@ -78,8 +42,21 @@ module Tire
       end
       alias :length :size
 
-      def [](index)
-        results[index]
+      def slice(*args)
+        results.slice(*args)
+      end
+      alias :[] :slice
+
+      def error
+        @response['error']
+      end
+
+      def success?
+        error.to_s.empty?
+      end
+
+      def failure?
+        ! success?
       end
 
       def to_ary
@@ -108,6 +85,58 @@ module Tire
         fields
       end
 
+      def __get_results_without_load(hits)
+        if @wrapper == Hash
+          hits
+        else
+          hits.map do |h|
+            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 meta information
+            ['_score', '_type', '_index', '_version', 'sort', 'highlight', '_explanation'].each { |key| document.update( {key => h[key]} || {} ) }
+
+            # Return an instance of the "wrapper" class
+            @wrapper.new(document)
+          end
+        end
+      end
+
+      def __get_results_with_load(hits)
+        return [] if hits.empty?
+
+        records = {}
+        @response['hits']['hits'].group_by { |item| item['_type'] }.each do |type, items|
+          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
+
+          begin
+            klass = type.camelize.constantize
+          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
+
+          records[type] = __find_records_by_ids klass, items.map { |h| h['_id'] }
+        end
+
+        # Reorder records to preserve the order from search results
+        @response['hits']['hits'].map do |item|
+          records[item['_type']].detect do |record|
+            record.id.to_s == item['_id'].to_s
+          end
+        end
+      end
+
+      def __find_records_by_ids(klass, ids)
+        @options[:load] === true ? klass.find(ids) : klass.find(ids, @options[:load])
+      end
+
     end
 
   end

data/lib/tire/results/item.rb

@@ -20,11 +20,14 @@ module Tire
         end
       end
 
-      # Delegate method to a key in underlying hash, if present,
-      # otherwise return +nil+.
+      # Delegate method to a key in underlying hash, if present, otherwise return +nil+.
       #
       def method_missing(method_name, *arguments)
-        @attributes.has_key?(method_name.to_sym) ? @attributes[method_name.to_sym] : nil
+        @attributes[method_name.to_sym]
+      end
+
+      def respond_to?(method_name)
+        @attributes.has_key?(method_name.to_sym) || super
       end
 
       def [](key)

data/lib/tire/results/pagination.rb

@@ -5,12 +5,17 @@ module Tire
     #
     module Pagination
 
+      def default_per_page
+        10
+      end
+      module_function :default_per_page
+
       def total_entries
         @total
       end
 
       def per_page
-        (@options[:per_page] || @options[:size] || 10 ).to_i
+        (@options[:per_page] || @options[:size] || default_per_page ).to_i
       end
 
       def total_pages
@@ -48,6 +53,15 @@ module Tire
       alias :num_pages    :total_pages
       alias :offset_value :offset
 
+      def first_page?
+        current_page == 1
+      end
+
+      def last_page?
+        current_page == total_pages
+      end
+
+
     end
 
   end