tire-erez 0.5.4

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

@@ -0,0 +1,156 @@
+module Tire
+  module Results
+
+    class Collection
+      include Enumerable
+      include Pagination
+
+      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 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]
+            __get_results_without_load(hits)
+          else
+            __get_results_with_load(hits)
+          end
+        end
+      end
+
+      # Iterates over the `results` collection
+      #
+      def each(&block)
+        results.each(&block)
+      end
+
+      # Iterates over the `results` collection and yields
+      # the `result` object (Item or model instance) and the
+      # `hit` -- raw Elasticsearch response parsed as a Hash
+      #
+      def each_with_hit(&block)
+        results.zip(@response['hits']['hits']).each(&block)
+      end
+
+      def empty?
+        results.empty?
+      end
+
+      def size
+        results.size
+      end
+      alias :length :size
+
+      def slice(*args)
+        results.slice(*args)
+      end
+      alias :[] :slice
+
+      def to_ary
+        self
+      end
+
+      def as_json(options=nil)
+        to_a.map { |item| item.as_json(options) }
+      end
+
+      def error
+        @response['error']
+      end
+
+      def success?
+        error.to_s.empty?
+      end
+
+      def failure?
+        ! success?
+      end
+
+      # Handles _source prefixed fields properly: strips the prefix and converts fields to nested Hashes
+      #
+      def __parse_fields__(fields={})
+        ( fields ||= {} ).clone.each_pair do |key,value|
+          next unless key.to_s =~ /_source/                 # Skip regular JSON immediately
+
+          keys = key.to_s.split('.').reject { |n| n == '_source' }
+          fields.delete(key)
+
+          result = {}
+          path = []
+
+          keys.each do |name|
+            path << name
+            eval "result[:#{path.join('][:')}] ||= {}"
+            eval "result[:#{path.join('][:')}] = #{value.inspect}" if keys.last == name
+          end
+          fields.update result
+        end
+        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
+end

data/lib/tire/results/item.rb

@@ -0,0 +1,94 @@
+module Tire
+  module Results
+
+    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|
+          if value.is_a?(Array)
+            @attributes[key.to_sym] = value.map { |item| @attributes[key.to_sym] = item.is_a?(Hash) ? Item.new(item.to_hash) : item }
+          else
+            @attributes[key.to_sym] = value.is_a?(Hash) ? Item.new(value.to_hash) : value
+          end
+        end
+      end
+
+      # Delegate method to a key in underlying hash, if present, otherwise return +nil+.
+      #
+      def method_missing(method_name, *arguments)
+        @attributes[method_name.to_sym]
+      end
+
+      def respond_to?(method_name, include_private = false)
+        @attributes.has_key?(method_name.to_sym) || super
+      end
+
+      def [](key)
+        @attributes[key.to_sym]
+      end
+
+      def id
+        @attributes[:_id]   || @attributes[:id]
+      end
+
+      def type
+        @attributes[:_type] || @attributes[:type]
+      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.reduce({}) do |sum, item|
+          sum[ item.first ] = item.last.respond_to?(:to_hash) ? item.last.to_hash : item.last
+          sum
+        end
+      end
+
+      def as_json(options=nil)
+        hash = to_hash
+        hash.respond_to?(:with_indifferent_access) ? hash.with_indifferent_access.as_json(options) : hash.as_json(options)
+      end
+
+      def to_json(options=nil)
+        as_json.to_json(options)
+      end
+      alias_method :to_indexed_json, :to_json
+
+      # Let's pretend we're someone else in Rails
+      #
+      def class
+        defined?(::Rails) && @attributes[:_type] ? @attributes[:_type].camelize.constantize : super
+      rescue NameError
+        super
+      end
+
+      def inspect
+        s = []; @attributes.each { |k,v| s << "#{k}: #{v.inspect}" }
+        %Q|<Item#{self.class.to_s == 'Tire::Results::Item' ? '' : " (#{self.class})"} #{s.join(', ')}>|
+      end
+
+    end
+
+  end
+end