tire-erez 0.5.4

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(options={})
+        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(options={})
+        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/queries/match.rb

@@ -0,0 +1,40 @@
+module Tire
+  module Search
+    class Query
+
+      def match(field, value, options={})
+        if @value.empty?
+          @value = MatchQuery.new(field, value, options).to_hash
+        else
+          MatchQuery.add(self, field, value, options)
+        end
+        @value
+      end
+    end
+
+    class MatchQuery
+      def initialize(field, value, options={})
+        query_options = { :query => value }.merge(options)
+
+        if field.is_a?(Array)
+          @value = { :multi_match => query_options.merge( :fields => field ) }
+        else
+          @value = { :match => { field => query_options } }
+        end
+      end
+
+      def self.add(query, field, value, options={})
+        unless query.value[:bool]
+          original_value = query.value.dup
+          query.value = { :bool => {} }
+          (query.value[:bool][:must] ||= []) << original_value
+        end
+        query.value[:bool][:must] << MatchQuery.new(field, value, options).to_hash
+      end
+
+      def to_hash
+        @value
+      end
+    end
+  end
+end

data/lib/tire/search/query.rb

@@ -0,0 +1,250 @@
+module Tire
+  module Search
+
+    class Query
+      attr_accessor :value
+
+      def initialize(&block)
+        @value = {}
+        block.arity < 1 ? self.instance_eval(&block) : block.call(self) if block_given?
+      end
+
+      def term(field, value, options={})
+        query = if value.is_a?(Hash)
+          { field => value.to_hash }
+        else
+          { field => { :term => value }.update(options) }
+        end
+        @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={})
+        Tire.warn "The 'text' query has been deprecated, please use a 'match' query."
+        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 nested(options={}, &block)
+        @nested = NestedQuery.new(options)
+        block.arity < 1 ? @nested.instance_eval(&block) : block.call(@nested) if block_given?
+        @value[:nested] = @nested.to_hash
+        @value
+      end
+
+      def all(options = {})
+        @value = { :match_all => options }
+        @value
+      end
+
+      def ids(values, type)
+        @value = { :ids => { :values => values, :type => type }  }
+      end
+
+      def boosting(options={}, &block)
+        @boosting ||= BoostingQuery.new(options)
+        block.arity < 1 ? @boosting.instance_eval(&block) : block.call(@boosting) if block_given?
+        @value[:boosting] = @boosting.to_hash
+        @value
+      end
+
+      def to_hash
+        @value
+      end
+
+      def to_json(options={})
+        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(options={})
+        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(options={})
+        to_hash.to_json
+      end
+    end
+
+    class NestedQuery
+      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[:query] = Query.new(&block).to_hash
+        @value
+      end
+
+      def to_hash
+        @value.update(@options)
+      end
+
+      def to_json
+        to_hash.to_json
+      end
+    end
+
+    class BoostingQuery
+      def initialize(options={}, &block)
+        @options = options
+        @value   = {}
+        block.arity < 1 ? self.instance_eval(&block) : block.call(self) if block_given?
+      end
+
+      def positive(&block)
+        (@value[:positive] ||= []) << Query.new(&block).to_hash
+        @value
+      end
+
+      def negative(&block)
+        (@value[:negative] ||= []) << Query.new(&block).to_hash
+        @value
+      end
+
+      def to_hash
+        @value.update(@options)
+      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' -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