elastic-rails 0.5.0 → 0.6.0

data/lib/elastic/nodes/agg/terms.rb

@@ -20,11 +20,11 @@ module Elastic::Nodes::Agg
       prepare_clone(super)
     end
 
-    def render
-      options = { 'field' => @field.to_s }
-      options['size'] = @size if @size
+    def render(_options = {})
+      hash = { 'field' => @field.to_s }
+      hash['size'] = @size if @size
 
-      render_aggs 'terms' => options
+      render_aggs({ 'terms' => hash }, _options)
     end
 
     private

data/lib/elastic/nodes/agg/top_hits.rb

@@ -2,15 +2,15 @@ module Elastic::Nodes
   class TopHits < BaseAgg
     include Concerns::HitProvider
 
-    def render
-      options = {}
-      render_hit_options options
+    def render(_options = {})
+      hash = {}
+      render_hit_options hash
 
-      { 'top_hits' => options }
+      { 'top_hits' => hash }
     end
 
-    def handle_result(_raw)
-      hits = _raw['hits'] ? _raw['hits']['hits'].map { |h| Elastic::Results::Hit.new h } : []
+    def handle_result(_raw, _formatter)
+      hits = _raw['hits'] ? prepare_hits(_raw['hits']['hits'], _formatter) : []
       Elastic::Results::HitCollection.new(hits)
     end
   end

data/lib/elastic/nodes/and.rb

@@ -27,8 +27,8 @@ module Elastic::Nodes
       prepare_clone(super, new_children)
     end
 
-    def render
-      { operation => @children.map(&:render) }
+    def render(_options = {})
+      { operation => @children.map { |c| c.render(_options) } }
     end
 
     private

data/lib/elastic/nodes/base.rb

@@ -10,7 +10,7 @@ module Elastic::Nodes
       _block.call(self)
     end
 
-    def render
+    def render(_options = {})
       raise NotImplementedError, 'render must be implemented by each node'
     end
 
@@ -22,8 +22,8 @@ module Elastic::Nodes
       self.class.new
     end
 
-    def handle_result(_raw)
-      nil
+    def handle_result(_raw, _formatter)
+      _raw
     end
   end
 end
@@ -32,3 +32,5 @@ require "elastic/nodes/concerns/hit_provider"
 require "elastic/nodes/concerns/aggregable"
 require "elastic/nodes/concerns/bucketed"
 require "elastic/nodes/concerns/boostable"
+require "elastic/nodes/concerns/field_query"
+

data/lib/elastic/nodes/base_agg.rb

@@ -7,11 +7,11 @@ module Elastic::Nodes
     end
 
     def initialize
-      @name = 'default'
+      @name = :default
     end
 
     def name=(_value)
-      @name = _value.to_s
+      @name = _value.to_sym
     end
 
     def clone

data/lib/elastic/nodes/boolean.rb

@@ -16,6 +16,8 @@ module Elastic::Nodes
       super
       @musts = []
       @shoulds = []
+      @filters = []
+      @disable_coord = !Elastic::Configuration.coord_similarity
     end
 
     def must(_node)
@@ -26,6 +28,10 @@ module Elastic::Nodes
       @shoulds << _node
     end
 
+    def filter(_node)
+      @filters << _node
+    end
+
     def musts=(_nodes)
       @musts = _nodes.dup.to_a
     end
@@ -42,43 +48,57 @@ module Elastic::Nodes
       @shoulds.each
     end
 
+    def filters=(_nodes)
+      @filters = _nodes.dup.to_a
+    end
+
+    def filters
+      @filters.each
+    end
+
     def traverse(&_block)
       super
       @shoulds.each { |c| c.traverse(&_block) }
       @musts.each { |c| c.traverse(&_block) }
     end
 
-    def render
-      options = {}.tap do |boolean|
-        boolean['must'] = @musts.map(&:render) if !@musts.empty?
-        boolean['should'] = @shoulds.map(&:render) if !@shoulds.empty?
-        boolean['minimum_should_match'] = minimum_should_match unless minimum_should_match.nil?
-        boolean['disable_coord'] = true if disable_coord
-        render_boost(boolean)
-      end
+    def render(_options = {})
+      hash = {}
+      hash['must'] = @musts.map { |n| n.render(_options) } if !@musts.empty?
+      hash['should'] = @shoulds.map { |n| n.render(_options) } if !@shoulds.empty?
+      hash['filters'] = @filters.map { |n| n.render(_options) } if !@filters.empty?
+      hash['minimum_should_match'] = minimum_should_match unless minimum_should_match.nil?
+      hash['disable_coord'] = true if disable_coord
+      render_boost(hash)
 
-      { "bool" => options }
+      { "bool" => hash }
     end
 
     def clone
-      prepare_clone super, @musts.map(&:clone), @shoulds.map(&:clone)
+      prepare_clone super, @musts.map(&:clone), @shoulds.map(&:clone), @filters.map(&:clone)
     end
 
     def simplify
       new_must = @musts.map(&:simplify)
       new_should = @shoulds.map(&:simplify)
+      new_filter = @filters.map(&:simplify)
 
-      return new_must.first if new_must.length == 1 && new_should.empty?
-      return new_should.first if new_should.length == 1 && new_must.empty? # at least 1 should match
+      # TODO: detect must elements with boost = 0 and move them to "filter"
+
+      if boost.nil? && (new_must.length + new_should.length + new_filter.length) == 1
+        return new_must.first unless new_must.empty?
+        return new_should.first unless new_should.empty? # at least 1 should match
+      end
 
-      prepare_clone(super, new_must, new_should)
+      prepare_clone(super, new_must, new_should, new_filter)
     end
 
     private
 
-    def prepare_clone(_clone, _musts, _shoulds)
+    def prepare_clone(_clone, _musts, _shoulds, _filters)
       _clone.musts = _musts
       _clone.shoulds = _shoulds
+      _clone.filters = _filters
       _clone.minimum_should_match = @minimum_should_match
       _clone.disable_coord = @disable_coord
       _clone

data/lib/elastic/nodes/concerns/aggregable.rb

@@ -1,13 +1,17 @@
 module Elastic::Nodes::Concerns
   module Aggregable
-    def has_aggs?
+    def has_aggregations?
       aggs.count > 0
     end
 
-    def aggs=(_aggs)
+    def aggregations=(_aggs)
       @aggs = _aggs.dup.to_a
     end
 
+    def aggregations
+      @aggs.each
+    end
+
     def aggregate(_node)
       raise ArgumentError, 'node must provide a name' unless _node.name
       aggs << _node
@@ -20,13 +24,13 @@ module Elastic::Nodes::Concerns
 
     def clone
       node = super
-      node.aggs = aggs.map(&:clone)
+      node.aggregations = aggs.map(&:clone)
       node
     end
 
     def simplify
       node = super
-      node.aggs = aggs.map(&:simplify)
+      node.aggregations = aggs.map(&:simplify)
       node
     end
 
@@ -36,15 +40,15 @@ module Elastic::Nodes::Concerns
       @aggs ||= []
     end
 
-    def render_aggs(_into)
-      _into['aggs'] = Hash[aggs.map { |a| [a.name, a.render] }] if has_aggs?
+    def render_aggs(_into, _options)
+      _into['aggs'] = Hash[aggs.map { |a| [a.name.to_s, a.render(_options)] }] if has_aggregations?
       _into
     end
 
-    def load_aggs_results(_raw)
+    def load_aggs_results(_raw, _formatter)
       {}.tap do |result|
         aggs.each do |node|
-          result[node.name] = node.handle_result(_raw[node.name])
+          result[node.name] = node.handle_result(_raw[node.name.to_s], _formatter)
         end
       end
     end

data/lib/elastic/nodes/concerns/bucketed.rb

@@ -1,14 +1,11 @@
 module Elastic::Nodes::Concerns
   module Bucketed
-    def handle_result(_raw)
+    def handle_result(_raw, _formatter)
       buckets = _raw['buckets'].map do |raw_bucket|
-        aggs = load_aggs_results(raw_bucket)
+        key = _formatter.format_field(field, raw_bucket['key'])
+        aggs = load_aggs_results(raw_bucket, _formatter)
 
-        # TODO: allow bucket aggregation to return single nested aggregation if node is
-        # configured that way
-        # return Elastic::Results::SimpleBucket.new(raw_bucket['key'], aggs.first) if blebliblu
-
-        Elastic::Results::Bucket.new(raw_bucket['key'], aggs)
+        Elastic::Results::Bucket.new(key, raw_bucket['doc_count'], aggs)
       end
 
       Elastic::Results::BucketCollection.new buckets

data/lib/elastic/nodes/concerns/field_query.rb

@@ -0,0 +1,10 @@
+module Elastic::Nodes::Concerns
+  module FieldQuery
+    attr_accessor :field
+
+    def render_field(_options)
+      return "#{_options[:query_path]}.#{@field}" if _options.key? :query_path
+      @field.to_s
+    end
+  end
+end

data/lib/elastic/nodes/concerns/hit_provider.rb

@@ -24,6 +24,17 @@ module Elastic::Nodes::Concerns
 
     private
 
+    def prepare_hits(_hits, _formatter)
+      _hits.map do |raw_hit|
+        Elastic::Results::Hit.new(
+          raw_hit['_type'],
+          raw_hit['_id'],
+          raw_hit['_score'],
+          raw_hit['_source'] ? _formatter.format(raw_hit['_source']) : nil
+        )
+      end
+    end
+
     def copy_hit_options(_clone)
       _clone.size = @size
       _clone.source = @source

data/lib/elastic/nodes/function_score.rb

@@ -54,18 +54,19 @@ module Elastic::Nodes
       @query.traverse(&_block)
     end
 
-    def render
-      function_score = { 'query' => @query.render }
-      function_score['boost_mode'] = @boost_mode.to_s if @boost_mode && @boost_mode != :multiply
+    def render(_options = {})
+      hash = { 'query' => @query.render(_options) }
+      hash['boost_mode'] = @boost_mode.to_s if @boost_mode && @boost_mode != :multiply
 
+      # TODO: add support for the query_path option
       if @functions.length > 1
-        function_score['score_mode'] = @score_mode.to_s if @score_mode && @score_mode != :multiply
-        function_score['functions'] = @functions
+        hash['score_mode'] = @score_mode.to_s if @score_mode && @score_mode != :multiply
+        hash['functions'] = @functions
       elsif @functions.length == 1
-        function_score.merge! @functions.first
+        hash.merge! @functions.first
       end
 
-      { 'function_score' => render_boost(function_score) }
+      { 'function_score' => render_boost(hash) }
     end
 
     alias :super_clone :clone

data/lib/elastic/nodes/match.rb

@@ -1,10 +1,11 @@
 module Elastic::Nodes
   class Match < Base
     include Concerns::Boostable
+    include Concerns::FieldQuery
 
     MATCH_MODES = [:boolean, :phrase, :phrase_prefix]
 
-    attr_accessor :field, :query
+    attr_accessor :query
     attr_reader :mode
 
     def query=(_query)
@@ -26,11 +27,11 @@ module Elastic::Nodes
       prepare_clone(super)
     end
 
-    def render
-      query_options = { 'query' => @query }
-      query_options['type'] = @mode.to_s unless @mode.nil? || @mode == :boolean
+    def render(_options = {})
+      hash = { 'query' => @query }
+      hash['type'] = @mode.to_s unless @mode.nil? || @mode == :boolean
 
-      { "match" => { @field.to_s => render_boost(query_options) } }
+      { "match" => { render_field(_options) => render_boost(hash) } }
     end
 
     private

data/lib/elastic/nodes/nested.rb

@@ -1,5 +1,7 @@
 module Elastic::Nodes
   class Nested < Base
+    SCORE_MODES = [:avg, :sum, :min, :max, :none]
+
     def self.build(_path, _child)
       new.tap do |node|
         node.path = _path
@@ -8,6 +10,7 @@ module Elastic::Nodes
     end
 
     attr_accessor :path, :child
+    attr_reader :score_mode
 
     def traverse(&_block)
       super
@@ -18,17 +21,34 @@ module Elastic::Nodes
       prepare_clone super, @child.clone
     end
 
+    def score_mode=(_value)
+      raise ArgumentError, "invalid score mode #{_value}" if _value && !SCORE_MODES.include?(_value)
+      @score_mode = _value
+    end
+
     def simplify
-      prepare_clone super, @child.simplify
+      new_child = @child.simplify
+      if new_child.is_a? Nested
+        prepare_clone(super, new_child.child).tap do |clone|
+          clone.path = "#{clone.path}.#{new_child.path}"
+        end
+      else
+        prepare_clone super, new_child
+      end
     end
 
-    def render
-      {
-        "nested" => {
-          "path" => @path,
-          "query" => @child.render
-        }
+    def render(_options = {})
+      path = @path
+      path = "#{_options[:query_path]}.#{path}" if _options.key? :query_path
+
+      hash = {
+        'path' => path,
+        'query' => @child.render(_options.merge(query_path: path))
       }
+
+      hash['score_mode'] = @score_mode.to_s if @score_mode && @score_mode != :avg
+
+      { "nested" => hash }
     end
 
     private
@@ -36,6 +56,7 @@ module Elastic::Nodes
     def prepare_clone(_clone, _child)
       _clone.path = @path
       _clone.child = _child
+      _clone.score_mode = @score_mode
       _clone
     end
   end

data/lib/elastic/nodes/range.rb

@@ -1,8 +1,9 @@
 module Elastic::Nodes
   class Range < Base
     include Concerns::Boostable
+    include Concerns::FieldQuery
 
-    attr_accessor :field, :gte, :gt, :lte, :lt
+    attr_accessor :gte, :gt, :lte, :lt
 
     def clone
       prepare_clone(super)
@@ -12,14 +13,14 @@ module Elastic::Nodes
       prepare_clone(super)
     end
 
-    def render
-      options = {}
-      options['gte'] = @gte unless @gte.nil?
-      options['gt'] = @gt unless @gt.nil?
-      options['lte'] = @lte unless @lte.nil?
-      options['lt'] = @lt unless @lt.nil?
+    def render(_options = {})
+      hash = {}
+      hash['gte'] = @gte unless @gte.nil?
+      hash['gt'] = @gt unless @gt.nil?
+      hash['lte'] = @lte unless @lte.nil?
+      hash['lt'] = @lt unless @lt.nil?
 
-      { "range" => { @field.to_s => render_boost(options) } }
+      { "range" => { render_field(_options) => render_boost(hash) } }
     end
 
     private

data/lib/elastic/nodes/search.rb

@@ -14,11 +14,11 @@ module Elastic::Nodes
       @query.traverse(&_block)
     end
 
-    def render
-      { "query" => @query.render }.tap do |options|
-        options["from"] = @offset if offset && offset > 0
-        render_hit_options(options)
-        render_aggs(options)
+    def render(_options = {})
+      { "query" => @query.render(_options) }.tap do |hash|
+        hash["from"] = @offset if offset && offset > 0
+        render_hit_options(hash)
+        render_aggs(hash, _options)
       end
     end
 
@@ -30,11 +30,12 @@ module Elastic::Nodes
       prepare_clone(super, @query.simplify)
     end
 
-    def handle_result(_raw)
-      hits = _raw['hits'] ? _raw['hits']['hits'].map { |h| Elastic::Results::Hit.new h } : []
-      aggs = _raw['aggregations'] ? load_aggs_results(_raw['aggregations']) : {}
-
-      Elastic::Results::Root.new(hits, aggs)
+    def handle_result(_raw, _formatter)
+      Elastic::Results::Root.new(
+        _raw['hits'] ? prepare_hits(_raw['hits']['hits'], _formatter) : [],
+        _raw['hits'] ? _raw['hits']['total'] : 0,
+        _raw['aggregations'] ? load_aggs_results(_raw['aggregations'], _formatter) : {}
+      )
     end
 
     private

data/lib/elastic/nodes/sort.rb

@@ -0,0 +1,82 @@
+module Elastic::Nodes
+  class Sort < Base
+    ORDER = [:asc, :desc]
+    MODES = [:min, :max, :sum, :avg, :median]
+
+    attr_accessor :child
+
+    def initialize
+      @sorts = []
+    end
+
+    def sorts
+      @sorts.dup
+    end
+
+    def add_sort(_field, order: :asc, mode: nil, missing: nil)
+      raise ArgumentError, "invalid sort order #{order}" unless ORDER.include?(order.to_sym)
+      raise ArgumentError, "invalid sort mode #{mode}" if mode && !MODES.include?(mode.to_sym)
+
+      options = { 'order' => order.to_s }
+      options['mode'] = mode.to_s if mode.present?
+      options['missing'] = missing if missing.present?
+
+      @sorts << { _field => options.freeze }.freeze
+      self
+    end
+
+    def add_score_sort(order: :desc)
+      raise ArgumentError, "invalid sort order #{order}" unless ORDER.include?(order.to_sym)
+
+      add_sort('_score', order: order)
+    end
+
+    def reset_sorts
+      @sorts = []
+      self
+    end
+
+    def clone
+      prepare_clone(super, child.try(:clone))
+    end
+
+    def simplify
+      if @sorts.empty?
+        child.try(:simplify)
+      else
+        prepare_clone(super, child.try(:simplify))
+      end
+    end
+
+    def render(_options = {})
+      hash = child.render(_options)
+      hash['sort'] = render_sorts
+      hash
+    end
+
+    def handle_result(_raw, _formatter)
+      @child.handle_result(_raw, _formatter)
+    end
+
+    def traverse(&_block)
+      super
+      @child.traverse(&_block)
+    end
+
+    protected
+
+    attr_writer :sorts
+
+    private
+
+    def prepare_clone(_clone, _child)
+      _clone.child = _child
+      _clone.sorts = @sorts.dup
+      _clone
+    end
+
+    def render_sorts
+      @sorts.dup
+    end
+  end
+end

data/lib/elastic/nodes/term.rb

@@ -1,6 +1,7 @@
 module Elastic::Nodes
   class Term < Base
     include Concerns::Boostable
+    include Concerns::FieldQuery
 
     BOOLEAN_MODE = [:any, :all]
 
@@ -30,19 +31,19 @@ module Elastic::Nodes
       prepare_clone(super)
     end
 
-    def render
-      raise ArgumentError, 'must provide at least one term' if !@terms || @terms.empty?
+    def render(_options = {})
+      raise ArgumentError, "terms not provided for #{@field}" if !@terms
 
       if @terms.length == 1
-        { 'term' => { @field.to_s => render_boost('value' => @terms.first) } }
-      elsif @mode == :all
+        { 'term' => { render_field(_options) => render_boost('value' => @terms.first) } }
+      elsif @mode == :all && !@terms.empty?
         {
           'bool' => render_boost(
-            'must' => @terms.map { |t| { 'term' => { @field.to_s => t } } }
+            'must' => @terms.map { |t| { 'term' => { render_field(_options) => t } } }
           )
         }
       else
-        { 'terms' => render_boost(@field.to_s => @terms) }
+        { 'terms' => render_boost(render_field(_options) => @terms) }
       end
     end
 

data/lib/elastic/query.rb

@@ -14,10 +14,6 @@ module Elastic
       @config = _query_config || build_base_config
     end
 
-    def coord_similarity(_enable)
-      with_clone { |config| config.root.query.disable_coord = !_enable }
-    end
-
     def limit(_size)
       with_clone { |config| config.limit = _size }
     end
@@ -27,6 +23,12 @@ module Elastic
       with_clone { |config| config.offset = _offset }
     end
 
+    def sort(*_params)
+      with_clone do |config|
+        config.sort = Commands::BuildSortFromParams.for(index: index, params: _params)
+      end
+    end
+
     def segment(*_params)
       with_clone do |config|
         config.groups << Commands::BuildAggFromParams.for(index: index, params: _params)
@@ -37,8 +39,8 @@ module Elastic
       execute assembler.assemble_ids
     end
 
-    def pluck(_field)
-      execute assembler.assemble_pluck(_field.to_s)
+    def pick(_field)
+      execute assembler.assemble_pick(_field)
     end
 
     def aggregate(_name = nil, _node = nil, &_block)
@@ -54,6 +56,10 @@ module Elastic
       @result ||= execute(assembler.assemble)
     end
 
+    def as_query_node
+      @config.query.clone
+    end
+
     def as_es_query
       assembler.assemble.render
     end
@@ -67,7 +73,7 @@ module Elastic
     end
 
     def with_bool_query(&_block)
-      with_clone { |config| _block.call(config.root.query) }
+      with_clone { |config| _block.call(config.query) }
     end
 
     def with_aggregable_for_metric(&_block)
@@ -79,15 +85,21 @@ module Elastic
       Core::QueryConfig.initial_config
     end
 
-    def assembler
-      @assembler ||= Core::QueryAssembler.new(@index, @config)
-    end
-
     def execute(_query)
-      _query.handle_result @index.adaptor.query(
+      raw = @index.adaptor.query(
         type: @index.definition.types,
         query: _query.render
       )
+
+      _query.handle_result(raw, formatter)
+    end
+
+    def assembler
+      Core::QueryAssembler.new(@index, @config)
+    end
+
+    def formatter
+      Core::SourceFormatter.new(@index.definition)
     end
 
     class AggregableAdaptor