load_balanced_tire 0.1

data/lib/tire/results/collection.rb

@@ -0,0 +1,114 @@
+module Tire
+  module Results
+
+    class Collection
+      include Enumerable
+      include Pagination
+
+      attr_reader :time, :total, :options, :facets
+
+      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
+      end
+
+      def results
+        @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
+
+          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 } }
+          end
+        end
+      end
+
+      def each(&block)
+        results.each(&block)
+      end
+
+      def empty?
+        results.empty?
+      end
+
+      def size
+        results.size
+      end
+      alias :length :size
+
+      def [](index)
+        results[index]
+      end
+
+      def to_ary
+        self
+      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
+
+    end
+
+  end
+end

data/lib/tire/results/item.rb

@@ -0,0 +1,86 @@
+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.has_key?(method_name.to_sym) ? @attributes[method_name.to_sym] : nil
+      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
+
+      # 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
+
+      def to_json(options=nil)
+        @attributes.to_json(options)
+      end
+      alias_method :to_indexed_json, :to_json
+
+    end
+
+  end
+end

data/lib/tire/results/pagination.rb

@@ -0,0 +1,54 @@
+module Tire
+  module Results
+
+    # Adds support for WillPaginate and Kaminari
+    #
+    module Pagination
+
+      def total_entries
+        @total
+      end
+
+      def per_page
+        (@options[:per_page] || @options[:size] || 10 ).to_i
+      end
+
+      def total_pages
+        ( @total.to_f / per_page ).ceil
+      end
+
+      def current_page
+        if @options[:page]
+          @options[:page].to_i
+        else
+          (per_page + @options[:from].to_i) / per_page
+        end
+      end
+
+      def previous_page
+        current_page > 1 ? (current_page - 1) : nil
+      end
+
+      def next_page
+        current_page < total_pages ? (current_page + 1) : nil
+      end
+
+      def offset
+        per_page * (current_page - 1)
+      end
+
+      def out_of_bounds?
+        current_page > total_pages
+      end
+
+      # Kaminari support
+      #
+      alias :limit_value  :per_page
+      alias :total_count  :total_entries
+      alias :num_pages    :total_pages
+      alias :offset_value :offset
+
+    end
+
+  end
+end

data/lib/tire/rubyext/hash.rb

@@ -0,0 +1,8 @@
+class Hash
+
+  def to_json(options=nil)
+    MultiJson.encode(self)
+  end unless respond_to?(:to_json)
+
+  alias_method :to_indexed_json, :to_json
+end

data/lib/tire/rubyext/ruby_1_8.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+
+# Require URI escape/unescape compatibility layer from Rack
+#
+# See <http://www.ruby-doc.org/stdlib-1.9.3/libdoc/uri/rdoc/URI.html#method-c-encode_www_form_component>
+#
+require 'rack/backports/uri/common_18'

data/lib/tire/rubyext/symbol.rb

@@ -0,0 +1,11 @@
+# ActiveModel::Serialization Ruby < 1.9.x compatibility
+
+class Symbol
+  def <=> other
+    self.to_s <=> other.to_s
+  end unless method_defined?(:'<=>')
+
+  def capitalize
+    to_s.capitalize
+  end unless method_defined?(:capitalize)
+end

data/lib/tire/search.rb

@@ -0,0 +1,188 @@
+module Tire
+  module Search
+    class SearchRequestFailed < StandardError; end
+
+    class Search
+
+      attr_reader :indices, :query, :facets, :filters, :options, :explain, :script_fields
+
+      def initialize(indices=nil, options={}, &block)
+        if indices.is_a?(Hash)
+          set_indices_options(indices)
+          @indices = indices.keys
+        else
+          @indices = Array(indices)
+        end
+        @types   = Array(options.delete(:type)).map { |type| Utils.escape(type) }
+        @options = options
+
+        @path    = ['/', @indices.join(','), @types.join(','), '_search'].compact.join('/').squeeze('/')
+
+        block.arity < 1 ? instance_eval(&block) : block.call(self) if block_given?
+      end
+
+
+      def set_indices_options(indices)
+        indices.each do |index, index_options|
+          if index_options[:boost]
+            @indices_boost ||= {}
+            @indices_boost[index] = index_options[:boost]
+          end
+        end
+      end
+
+      def results
+        @results  || (perform; @results)
+      end
+
+      def response
+        @response || (perform; @response)
+      end
+
+      def json
+        @json     || (perform; @json)
+      end
+
+      def url
+        Configuration.url + @path
+      end
+
+      def params
+        @options.empty? ? '' : '?' + @options.to_param
+      end
+
+      def query(&block)
+        @query = Query.new
+        block.arity < 1 ? @query.instance_eval(&block) : block.call(@query)
+        self
+      end
+
+      def sort(&block)
+        @sort = Sort.new(&block).to_ary
+        self
+      end
+
+      def facet(name, options={}, &block)
+        @facets ||= {}
+        @facets.update Facet.new(name, options, &block).to_hash
+        self
+      end
+
+      def filter(type, *options)
+        @filters ||= []
+        @filters << Filter.new(type, *options).to_hash
+        self
+      end
+
+      def script_field(name, options={})
+        @script_fields ||= {}
+        @script_fields.merge! ScriptField.new(name, options).to_hash
+        self
+      end
+
+      def highlight(*args)
+        unless args.empty?
+          @highlight = Highlight.new(*args)
+          self
+        else
+          @highlight
+        end
+      end
+
+      def from(value)
+        @from = value
+        @options[:from] = value
+        self
+      end
+
+      def size(value)
+        @size = value
+        @options[:size] = value
+        self
+      end
+
+      def fields(*fields)
+        @fields = Array(fields.flatten)
+        self
+      end
+
+      def explain(value)
+        @explain = value
+        self
+      end
+
+      def version(value)
+        @version = value
+        self
+      end
+
+      def perform
+        @response = Configuration.client.get(self.url + self.params, self.to_json)
+        if @response.failure?
+          STDERR.puts "[REQUEST FAILED] #{self.to_curl}\n"
+          raise SearchRequestFailed, @response.to_s
+        end
+        @json     = MultiJson.decode(@response.body)
+        @results  = Results::Collection.new(@json, @options)
+        return self
+      ensure
+        logged
+      end
+
+      def to_curl
+        %Q|curl -X GET "#{url}#{params.empty? ? '?' : params.to_s + '&'}pretty=true" -d '#{to_json}'|
+      end
+
+      def to_hash
+        @options.delete(:payload) || begin
+          request = {}
+          request.update( { :indices_boost => @indices_boost } ) if @indices_boost
+          request.update( { :query  => @query.to_hash } )    if @query
+          request.update( { :sort   => @sort.to_ary   } )    if @sort
+          request.update( { :facets => @facets.to_hash } )   if @facets
+          request.update( { :filter => @filters.first.to_hash } ) if @filters && @filters.size == 1
+          request.update( { :filter => { :and => @filters.map {|filter| filter.to_hash} } } ) if  @filters && @filters.size > 1
+          request.update( { :highlight => @highlight.to_hash } ) if @highlight
+          request.update( { :size => @size } )               if @size
+          request.update( { :from => @from } )               if @from
+          request.update( { :fields => @fields } )           if @fields
+          request.update( { :script_fields => @script_fields } ) if @script_fields
+          request.update( { :version => @version } )         if @version
+          request.update( { :explain => @explain } )         if @explain
+          request
+        end
+      end
+
+      def to_json
+        payload = to_hash
+        # TODO: Remove when deprecated interface is removed
+        payload.is_a?(String) ? payload : payload.to_json
+      end
+
+      def logged(error=nil)
+        if Configuration.logger
+
+          Configuration.logger.log_request '_search', indices, to_curl
+
+          took = @json['took']  rescue nil
+          code = @response.code rescue nil
+
+          if Configuration.logger.level.to_s == 'debug'
+            # FIXME: Depends on RestClient implementation
+            body = if @json
+              defined?(Yajl) ? Yajl::Encoder.encode(@json, :pretty => true) : MultiJson.encode(@json)
+            else
+              @response.body rescue nil
+            end
+          else
+            body = ''
+          end
+
+          Configuration.logger.log_response code || 'N/A', took || 'N/A', body || 'N/A'
+        end
+      end
+
+    end
+
+  end
+end