load_balanced_tire 0.1

data/lib/tire/search/facet.rb

@@ -0,0 +1,74 @@
+module Tire
+  module Search
+
+    #--
+    # TODO: Implement all elastic search facets (geo, histogram, range, etc)
+    # http://elasticsearch.org/guide/reference/api/search/facets/
+    #++
+
+    class Facet
+
+      def initialize(name, options={}, &block)
+        @name    = name
+        @options = options
+        block.arity < 1 ? self.instance_eval(&block) : block.call(self) if block_given?
+      end
+
+      def terms(field, options={})
+        size      = options.delete(:size) || 10
+        all_terms = options.delete(:all_terms) || false
+        @value = if field.is_a?(Enumerable) and not field.is_a?(String)
+          { :terms => { :fields => field }.update({ :size => size, :all_terms => all_terms }).update(options) }
+        else
+          { :terms => { :field => field  }.update({ :size => size, :all_terms => all_terms }).update(options) }
+        end
+        self
+      end
+
+      def date(field, options={})
+        interval = options.delete(:interval) || 'day'
+        @value = { :date_histogram => { :field => field, :interval => interval }.update(options) }
+        self
+      end
+
+      def range(field, ranges=[], options={})
+        @value = { :range => { :field => field, :ranges => ranges }.update(options) }
+        self
+      end
+
+      def histogram(field, options={})
+        @value = { :histogram => (options.delete(:histogram) || {:field => field}.update(options)) }
+        self
+      end
+
+      def statistical(field, options={})
+        @value = { :statistical => (options.delete(:statistical) || {:field => field}.update(options)) }
+        self
+      end
+
+      def terms_stats(key_field, value_field, options={})
+        @value = { :terms_stats => {:key_field => key_field, :value_field => value_field}.update(options) }
+        self
+      end
+
+      def query(&block)
+        @value = { :query => Query.new(&block).to_hash }
+      end
+
+      def filter(field, value, options={})
+        @value = { :filter => { :term => { field => value }}.update(options) }
+        self
+      end
+
+      def to_json
+        to_hash.to_json
+      end
+
+      def to_hash
+        @value.update @options
+        { @name => @value }
+      end
+    end
+
+  end
+end

data/lib/tire/search/filter.rb

@@ -0,0 +1,28 @@
+module Tire
+  module Search
+
+    # http://www.elasticsearch.org/guide/reference/api/search/filter.html
+    # http://www.elasticsearch.org/guide/reference/query-dsl/
+    #
+    class Filter
+
+      def initialize(type, *options)
+        value = if options.size < 2
+          options.first || {}
+        else
+          options # An +or+ filter encodes multiple filters as an array
+        end
+        @hash = { type => value }
+      end
+
+      def to_json
+        to_hash.to_json
+      end
+
+      def to_hash
+        @hash
+      end
+    end
+
+  end
+end

data/lib/tire/search/highlight.rb

@@ -0,0 +1,37 @@
+module Tire
+  module Search
+
+    # http://www.elasticsearch.org/guide/reference/api/search/highlighting.html
+    #
+    class Highlight
+
+      def initialize(*args)
+        @options  = (args.last.is_a?(Hash) && args.last.delete(:options)) || {}
+        extract_highlight_tags
+        @fields   = args.inject({}) do |result, field|
+          field.is_a?(Hash) ? result.update(field) : result[field.to_sym] = {}; result
+        end
+      end
+
+      def to_json
+        to_hash.to_json
+      end
+
+      def to_hash
+        { :fields => @fields }.update @options
+      end
+
+      private
+
+      def extract_highlight_tags
+        if tag = @options.delete(:tag)
+          @options.update \
+            :pre_tags  => [tag],
+            :post_tags => [tag.to_s.gsub(/^<([a-z]+).*/, '</\1>')]
+        end
+      end
+
+    end
+
+  end
+end

data/lib/tire/search/query.rb

@@ -0,0 +1,186 @@
+module Tire
+  module Search
+
+    class Query
+      def initialize(&block)
+        @value = {}
+        block.arity < 1 ? self.instance_eval(&block) : block.call(self) if block_given?
+      end
+
+      def term(field, value, options={})
+        query = { field => { :term => value }.update(options) }
+        @value = { :term => query }
+      end
+
+      def terms(field, value, options={})
+        @value = { :terms => { field => value } }
+        @value[:terms].update( { :minimum_match => options[:minimum_match] } ) if options[:minimum_match]
+        @value
+      end
+
+      def range(field, value)
+        @value = { :range => { field => value } }
+      end
+
+      def text(field, value, options={})
+        query_options = { :query => value }.update(options)
+        @value = { :text => { field => query_options } }
+        @value
+      end
+
+      def string(value, options={})
+        @value = { :query_string => { :query => value } }
+        @value[:query_string].update(options)
+        @value
+      end
+
+      def prefix(field, value, options={})
+        if options[:boost]
+          @value = { :prefix => { field => { :prefix => value, :boost => options[:boost] } } }
+        else
+          @value = { :prefix => { field => value } }
+        end
+      end
+
+      def custom_score(options={}, &block)
+        @custom_score ||= Query.new(&block)
+        @value[:custom_score] = options
+        @value[:custom_score].update({:query => @custom_score.to_hash})
+        @value
+      end
+
+      def fuzzy(field, value, options={})
+        query = { field => { :term => value }.update(options) }
+        @value = { :fuzzy => query }
+      end
+
+      def boolean(options={}, &block)
+        @boolean ||= BooleanQuery.new(options)
+        block.arity < 1 ? @boolean.instance_eval(&block) : block.call(@boolean) if block_given?
+        @value[:bool] = @boolean.to_hash
+        @value
+      end
+
+      def filtered(&block)
+        @filtered = FilteredQuery.new
+        block.arity < 1 ? @filtered.instance_eval(&block) : block.call(@filtered) if block_given?
+        @value[:filtered] = @filtered.to_hash
+        @value
+      end
+
+      def dis_max(options={}, &block)
+        @dis_max ||= DisMaxQuery.new(options)
+        block.arity < 1 ? @dis_max.instance_eval(&block) : block.call(@dis_max) if block_given?
+        @value[:dis_max] = @dis_max.to_hash
+        @value
+      end
+
+      def all
+        @value = { :match_all => {} }
+        @value
+      end
+
+      def ids(values, type)
+        @value = { :ids => { :values => values, :type => type }  }
+      end
+
+      def to_hash
+        @value
+      end
+
+      def to_json
+        to_hash.to_json
+      end
+
+    end
+
+    class BooleanQuery
+
+      # TODO: Try to get rid of multiple `should`, `must`, etc invocations, and wrap queries directly:
+      #
+      #       boolean do
+      #         should do
+      #           string 'foo'
+      #           string 'bar'
+      #         end
+      #       end
+      #
+      # Inherit from Query, implement `encode` method there, and overload it here, so it puts
+      # queries in an Array instead of hash.
+
+      def initialize(options={}, &block)
+        @options = options
+        @value   = {}
+        block.arity < 1 ? self.instance_eval(&block) : block.call(self) if block_given?
+      end
+
+      def must(&block)
+        (@value[:must] ||= []) << Query.new(&block).to_hash
+        @value
+      end
+
+      def must_not(&block)
+        (@value[:must_not] ||= []) << Query.new(&block).to_hash
+        @value
+      end
+
+      def should(&block)
+        (@value[:should] ||= []) << Query.new(&block).to_hash
+        @value
+      end
+
+      def to_hash
+        @value.update(@options)
+      end
+    end
+
+    class FilteredQuery
+      def initialize(&block)
+        @value = {}
+        block.arity < 1 ? self.instance_eval(&block) : block.call(self) if block_given?
+      end
+
+      def query(options={}, &block)
+        @value[:query] = Query.new(&block).to_hash
+        @value
+      end
+
+      def filter(type, *options)
+        @value[:filter] ||= {}
+        @value[:filter][:and] ||= []
+        @value[:filter][:and] << Filter.new(type, *options).to_hash
+        @value
+      end
+
+      def to_hash
+        @value
+      end
+
+      def to_json
+        to_hash.to_json
+      end
+    end
+
+    class DisMaxQuery
+      def initialize(options={}, &block)
+        @options = options
+        @value   = {}
+        block.arity < 1 ? self.instance_eval(&block) : block.call(self) if block_given?
+      end
+
+      def query(&block)
+        (@value[:queries] ||= []) << Query.new(&block).to_hash
+        @value
+      end
+
+      def to_hash
+        @value.update(@options)
+      end
+
+      def to_json
+        to_hash.to_json
+      end
+    end
+
+  end
+end

data/lib/tire/search/scan.rb

@@ -0,0 +1,114 @@
+module Tire
+  module Search
+
+
+    # Performs a "scan/scroll" search request, which obtains a `scroll_id`
+    # and keeps returning documents matching the passed query (or all documents) in batches.
+    #
+    # You may want to iterate over the batches being returned:
+    #
+    #     search = Tire::Search::Scan.new('articles')
+    #     search.each do |results|
+    #       puts results.map(&:title)
+    #     end
+    #
+    # The scan object has a fully Enumerable-compatible interface, so you may
+    # call methods like `map` or `each_with_index` on it.
+    #
+    # To iterate over individual documents, use the `each_document` method:
+    #
+    #     search.each_document do |document|
+    #       puts document.title
+    #     end
+    #
+    # You may limit the result set being returned by a regular Tire DSL query
+    # (or a hash, if you prefer), passed as a second argument:
+    #
+    #     search = Tire::Search::Scan.new('articles') do
+    #       query { term 'author.exact', 'John Smith' }
+    #     end
+    #
+    # The feature is also exposed in the Tire top-level DSL:
+    #
+    #     search = Tire.scan 'articles' do
+    #       query { term 'author.exact', 'John Smith' }
+    #     end
+    #
+    # See ElasticSearch documentation for further reference:
+    #
+    # * http://www.elasticsearch.org/guide/reference/api/search/search-type.html
+    # * http://www.elasticsearch.org/guide/reference/api/search/scroll.html
+    #
+    class Scan
+      include Enumerable
+
+      attr_reader :indices, :options, :search
+
+      def initialize(indices=nil, options={}, &block)
+        @indices = Array(indices)
+        @options = options.update(:search_type => 'scan', :scroll => '10m')
+        @seen    = 0
+        @search  = Search.new(@indices, @options, &block)
+      end
+
+      def url;                Configuration.url + "/_search/scroll";                           end
+      def params;             @options.empty? ? '' : '?' + @options.to_param;                  end
+      def results;            @results  || (__perform; @results);                              end
+      def response;           @response || (__perform; @response);                             end
+      def json;               @json     || (__perform; @json);                                 end
+      def total;              @total    || (__perform; @total);                                end
+      def seen;               @seen     || (__perform; @seen);                                 end
+
+      def scroll_id
+        @scroll_id ||= @search.perform.json['_scroll_id']
+      end
+
+      def each
+        until results.empty?
+          yield results.results
+          __perform
+        end
+      end
+
+      def each_document
+        until results.empty?
+          results.each { |item| yield item }
+          __perform
+        end
+      end
+
+      def size
+        results.size
+      end
+
+      def __perform
+        @response  = Configuration.client.get [url, params].join, scroll_id
+        @json      = MultiJson.decode @response.body
+        @results   = Results::Collection.new @json, @options
+        @total     = @json['hits']['total'].to_i
+        @seen     += @results.size
+        @scroll_id = @json['_scroll_id']
+        return self
+      ensure
+        __logged
+      end
+
+      def to_a;        results; end; alias :to_ary :to_a
+      def to_curl;     %Q|curl -X GET "#{url}?pretty=true" -d '#{@scroll_id}'|; end
+
+      def __logged(error=nil)
+        if Configuration.logger
+          Configuration.logger.log_request 'scroll', nil, to_curl
+
+          took = @json['took']        rescue nil
+          code = @response.code       rescue nil
+          body = "#{@seen}/#{@total} (#{@seen/@total.to_f*100}%)" rescue nil
+
+          Configuration.logger.log_response code || 'N/A', took || 'N/A', body
+        end
+      end
+
+    end
+
+  end
+end

data/lib/tire/search/script_field.rb

@@ -0,0 +1,23 @@
+module Tire
+  module Search
+
+    # http://www.elasticsearch.org/guide/reference/api/search/script-fields.html
+    # http://www.elasticsearch.org/guide/reference/modules/scripting.html
+
+    class ScriptField
+
+      def initialize(name, options)
+        @hash = { name => options }
+      end
+
+      def to_json
+        to_hash.to_json
+      end
+
+      def to_hash
+        @hash
+      end
+    end
+
+  end
+end