elastic-rails 0.1.0 → 0.5.0

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

@@ -0,0 +1,42 @@
+module Elastic::Nodes::Agg
+  class BaseMetric < Elastic::Nodes::BaseAgg
+    def self.build(_name, _field, missing: nil)
+      super(_name).tap do |node|
+        node.field = _field
+        node.missing = missing
+      end
+    end
+
+    attr_accessor :field, :missing
+
+    def clone
+      prepare_clone super
+    end
+
+    def simplify
+      prepare_clone super
+    end
+
+    def render
+      options = { 'field' => @field.to_s }
+      options['missing'] = @missing if @missing
+
+      { metric => options }
+    end
+
+    def handle_result(_raw)
+      Elastic::Results::Metric.new _raw['value']
+    end
+
+    private
+
+    def metric
+    end
+
+    def prepare_clone(_clone)
+      _clone.field = @field
+      _clone.missing = @missing
+      _clone
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Elastic::Nodes::Agg
+  class DateHistogram < Elastic::Nodes::BaseAgg
+    include Elastic::Nodes::Concerns::Aggregable
+    include Elastic::Nodes::Concerns::Bucketed
+
+    def self.build(_name, _field, interval: nil)
+      super(_name).tap do |node|
+        node.field = _field
+        node.interval = interval
+      end
+    end
+
+    attr_accessor :field
+    attr_reader :interval
+
+    def interval=(_value)
+      raise ArgumentError, 'invalid interval' if _value && !valid_interval?(_value)
+      @interval = _value
+    end
+
+    def clone
+      prepare_clone(super)
+    end
+
+    def simplify
+      prepare_clone(super)
+    end
+
+    def render
+      options = { 'field' => @field.to_s }
+      options['interval'] = @interval if @interval
+
+      render_aggs 'date_histogram' => options
+    end
+
+    private
+
+    def prepare_clone(_clone)
+      _clone.field = @field
+      _clone.interval = @interval
+      _clone
+    end
+
+    def valid_interval?(_value)
+      /^\d+(\.\d+)?(y|M|w|d|h|m|s)$/ === _value
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Elastic::Nodes::Agg
+  class Maximum < BaseMetric
+    private def metric
+      'max'
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Elastic::Nodes::Agg
+  class Minimum < BaseMetric
+    private def metric
+      'min'
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Elastic::Nodes::Agg
+  class Stats < BaseMetric
+    private def metric
+      'stats'
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Elastic::Nodes::Agg
+  class Sum < BaseMetric
+    private def metric
+      'sum'
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Elastic::Nodes::Agg
+  class Terms < Elastic::Nodes::BaseAgg
+    include Elastic::Nodes::Concerns::Aggregable
+    include Elastic::Nodes::Concerns::Bucketed
+
+    def self.build(_name, _field, size: nil)
+      super(_name).tap do |node|
+        node.field = _field
+        node.size = size
+      end
+    end
+
+    attr_accessor :field, :size
+
+    def clone
+      prepare_clone(super)
+    end
+
+    def simplify
+      prepare_clone(super)
+    end
+
+    def render
+      options = { 'field' => @field.to_s }
+      options['size'] = @size if @size
+
+      render_aggs 'terms' => options
+    end
+
+    private
+
+    def prepare_clone(_clone)
+      _clone.field = @field
+      _clone.size = @size
+      _clone
+    end
+  end
+end

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

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

data/lib/elastic/nodes/and.rb

@@ -0,0 +1,45 @@
+module Elastic::Nodes
+  class And < Base
+    def self.build(_children)
+      new.tap { |node| node.children = _children }
+    end
+
+    def add_child(_child)
+      @children << _child
+    end
+
+    def children=(_value)
+      @children = _value.dup.to_a
+    end
+
+    def traverse(&_block)
+      super
+      @children.each { |c| c.traverse(&_block) }
+    end
+
+    def clone
+      prepare_clone super, @children.map(&:clone)
+    end
+
+    def simplify
+      new_children = @children.map(&:simplify)
+      return new_children.first if new_children.count == 1
+      prepare_clone(super, new_children)
+    end
+
+    def render
+      { operation => @children.map(&:render) }
+    end
+
+    private
+
+    def prepare_clone(_clone, _children)
+      _clone.children = _children
+      _clone
+    end
+
+    def operation
+      'and'
+    end
+  end
+end

data/lib/elastic/nodes/base.rb

@@ -0,0 +1,34 @@
+module Elastic::Nodes
+  class Base
+    include Elastic::Support::Traversable
+
+    def ==(_node)
+      render == _node.render
+    end
+
+    def traverse(&_block)
+      _block.call(self)
+    end
+
+    def render
+      raise NotImplementedError, 'render must be implemented by each node'
+    end
+
+    def clone
+      self.class.new
+    end
+
+    def simplify
+      self.class.new
+    end
+
+    def handle_result(_raw)
+      nil
+    end
+  end
+end
+
+require "elastic/nodes/concerns/hit_provider"
+require "elastic/nodes/concerns/aggregable"
+require "elastic/nodes/concerns/bucketed"
+require "elastic/nodes/concerns/boostable"

data/lib/elastic/nodes/base_agg.rb

@@ -0,0 +1,32 @@
+module Elastic::Nodes
+  class BaseAgg < Base
+    attr_reader :name
+
+    def self.build(_name)
+      new.tap { |n| n.name = _name }
+    end
+
+    def initialize
+      @name = 'default'
+    end
+
+    def name=(_value)
+      @name = _value.to_s
+    end
+
+    def clone
+      copy_name super
+    end
+
+    def simplify
+      copy_name super
+    end
+
+    private
+
+    def copy_name(_clone)
+      _clone.name = @name
+      _clone
+    end
+  end
+end

data/lib/elastic/nodes/boolean.rb

@@ -0,0 +1,87 @@
+module Elastic::Nodes
+  class Boolean < Base
+    include Concerns::Boostable
+
+    def self.build_and(_nodes)
+      new.tap { |n| n.musts = _nodes }
+    end
+
+    def self.build_or(_nodes)
+      new.tap { |n| n.shoulds = _nodes }
+    end
+
+    attr_accessor :minimum_should_match, :disable_coord
+
+    def initialize
+      super
+      @musts = []
+      @shoulds = []
+    end
+
+    def must(_node)
+      @musts << _node
+    end
+
+    def should(_node)
+      @shoulds << _node
+    end
+
+    def musts=(_nodes)
+      @musts = _nodes.dup.to_a
+    end
+
+    def musts
+      @musts.each
+    end
+
+    def shoulds=(_nodes)
+      @shoulds = _nodes.dup.to_a
+    end
+
+    def shoulds
+      @shoulds.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
+
+      { "bool" => options }
+    end
+
+    def clone
+      prepare_clone super, @musts.map(&:clone), @shoulds.map(&:clone)
+    end
+
+    def simplify
+      new_must = @musts.map(&:simplify)
+      new_should = @shoulds.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
+
+      prepare_clone(super, new_must, new_should)
+    end
+
+    private
+
+    def prepare_clone(_clone, _musts, _shoulds)
+      _clone.musts = _musts
+      _clone.shoulds = _shoulds
+      _clone.minimum_should_match = @minimum_should_match
+      _clone.disable_coord = @disable_coord
+      _clone
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Elastic::Nodes::Concerns
+  module Aggregable
+    def has_aggs?
+      aggs.count > 0
+    end
+
+    def aggs=(_aggs)
+      @aggs = _aggs.dup.to_a
+    end
+
+    def aggregate(_node)
+      raise ArgumentError, 'node must provide a name' unless _node.name
+      aggs << _node
+    end
+
+    def traverse(&_block)
+      super
+      aggs.each { |a| a.traverse(&_block) }
+    end
+
+    def clone
+      node = super
+      node.aggs = aggs.map(&:clone)
+      node
+    end
+
+    def simplify
+      node = super
+      node.aggs = aggs.map(&:simplify)
+      node
+    end
+
+    private
+
+    def aggs
+      @aggs ||= []
+    end
+
+    def render_aggs(_into)
+      _into['aggs'] = Hash[aggs.map { |a| [a.name, a.render] }] if has_aggs?
+      _into
+    end
+
+    def load_aggs_results(_raw)
+      {}.tap do |result|
+        aggs.each do |node|
+          result[node.name] = node.handle_result(_raw[node.name])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Elastic::Nodes::Concerns
+  module Boostable
+    attr_accessor :boost
+
+    def clone
+      copy_boost super
+    end
+
+    def simplify
+      copy_boost super
+    end
+
+    private
+
+    def copy_boost(_clone)
+      _clone.boost = @boost
+      _clone
+    end
+
+    def render_boost(_hash)
+      _hash['boost'] = @boost.to_f unless @boost.nil?
+      _hash
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Elastic::Nodes::Concerns
+  module Bucketed
+    def handle_result(_raw)
+      buckets = _raw['buckets'].map do |raw_bucket|
+        aggs = load_aggs_results(raw_bucket)
+
+        # 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)
+      end
+
+      Elastic::Results::BucketCollection.new buckets
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Elastic::Nodes::Concerns
+  module HitProvider
+    attr_accessor :size
+    attr_reader :source
+
+    def source=(_values)
+      case _values
+      when nil, false
+        @source = _values
+      when Array, Enumerable
+        @source = _values.dup.to_a
+      else
+        raise ArgumentError, 'invalid query source value'
+      end
+    end
+
+    def clone
+      copy_hit_options super
+    end
+
+    def simplify
+      copy_hit_options super
+    end
+
+    private
+
+    def copy_hit_options(_clone)
+      _clone.size = @size
+      _clone.source = @source
+      _clone
+    end
+
+    def render_hit_options(_hash)
+      _hash['size'] = @size unless @size.nil?
+      _hash["_source"] = @source unless @source.nil?
+      _hash
+    end
+  end
+end

data/lib/elastic/nodes/function_score.rb

@@ -0,0 +1,116 @@
+module Elastic::Nodes
+  class FunctionScore < Base
+    include Concerns::Boostable
+
+    SCORE_MODES = [:multiply, :sum, :avg, :first, :max, :min]
+    BOOST_MODES = [:multiply, :replace, :sum, :avg, :max, :min]
+
+    def self.build(_query)
+      new.tap { |node| node.query = _query }
+    end
+
+    attr_accessor :query
+    attr_reader :score_mode, :boost_mode
+
+    def initialize
+      @functions = []
+    end
+
+    def functions=(_values)
+      @functions = _values.dup.to_a
+    end
+
+    def score_mode=(_value)
+      raise ArgumentError, "invalid score mode #{_value}" if _value && !SCORE_MODES.include?(_value)
+      @score_mode = _value
+    end
+
+    def boost_mode=(_value)
+      raise ArgumentError, "invalid boost mode #{_value}" if _value && !BOOST_MODES.include?(_value)
+      @boost_mode = _value
+    end
+
+    def add_weight_function(_weight, filter: nil)
+      add_function(nil, nil, filter, _weight)
+    end
+
+    def add_field_function(_field, factor: 1, modifier: :none, missing: 1, weight: nil, filter: nil)
+      params = {
+        'field' => _field,
+        'factor' => factor,
+        'modifier' => modifier,
+        'missing' => missing
+      }
+
+      add_function('field_value_factor', params, filter, weight)
+    end
+
+    def add_decay_function(_field, _options = {})
+      raise NotImplementedError, 'decay function not implemented'
+    end
+
+    def traverse(&_block)
+      super
+      @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
+
+      if @functions.length > 1
+        function_score['score_mode'] = @score_mode.to_s if @score_mode && @score_mode != :multiply
+        function_score['functions'] = @functions
+      elsif @functions.length == 1
+        function_score.merge! @functions.first
+      end
+
+      { 'function_score' => render_boost(function_score) }
+    end
+
+    alias :super_clone :clone
+    private :super_clone
+
+    def clone
+      prepare_clone super, @query.clone
+    end
+
+    def clone_with_query(_query)
+      prepare_clone super_clone, _query
+    end
+
+    def simplify
+      new_query = query.simplify
+
+      if @functions.empty?
+        return new_query if boost.nil?
+
+        if new_query.class.include?(Concerns::Boostable) && new_query.boost.nil?
+          new_query.boost = boost
+          return new_query
+        end
+      end
+
+      prepare_clone(super, new_query)
+    end
+
+    private
+
+    def add_function(_function, _params, _filter, _weight)
+      @functions << {}.tap do |hash|
+        hash[_function] = _params if _function
+        hash['weight'] = _weight unless _weight.nil?
+        hash['filter'] = _filter.render unless _filter.nil?
+      end
+      self
+    end
+
+    def prepare_clone(_clone, _query)
+      _clone.query = _query
+      _clone.functions = @functions
+      _clone.boost_mode = @boost_mode
+      _clone.score_mode = @score_mode
+      _clone
+    end
+  end
+end

data/lib/elastic/nodes/match.rb

@@ -0,0 +1,45 @@
+module Elastic::Nodes
+  class Match < Base
+    include Concerns::Boostable
+
+    MATCH_MODES = [:boolean, :phrase, :phrase_prefix]
+
+    attr_accessor :field, :query
+    attr_reader :mode
+
+    def query=(_query)
+      raise ArgumentError, 'query must be a string' unless _query.is_a? String
+      @query = _query
+    end
+
+    def mode=(_value)
+      _value = _value.try(:to_sym)
+      raise ArgumentError, 'invalid match mode' if !_value.nil? && !MATCH_MODES.include?(_value)
+      @mode = _value
+    end
+
+    def clone
+      prepare_clone(super)
+    end
+
+    def simplify
+      prepare_clone(super)
+    end
+
+    def render
+      query_options = { 'query' => @query }
+      query_options['type'] = @mode.to_s unless @mode.nil? || @mode == :boolean
+
+      { "match" => { @field.to_s => render_boost(query_options) } }
+    end
+
+    private
+
+    def prepare_clone(_clone)
+      _clone.field = @field
+      _clone.query = @query
+      _clone.mode = @mode
+      _clone
+    end
+  end
+end