elasticated 1.0.0

data/lib/elasticated/aggregations/histogram_aggregation.rb

@@ -0,0 +1,34 @@
+module Elasticated
+  class HistogramAggregation < Aggregation
+    include Subaggregated
+
+    attr_accessor :interval
+
+    def initialize(field, interval, opts={}, &block)
+      self.interval = interval
+      super
+      initialize_subaggregations &block
+    end
+
+    def default_name
+      "group_by_#{field}"
+    end
+
+    def build
+      terms = { field: field, interval: interval }
+      terms.merge! extra_params
+      aggregation_struct = { histogram: terms }
+      aggregation_struct.merge! build_subaggregations
+      aggregation_struct
+    end
+
+    def parse(response)
+      response['buckets'].inject({}) do |hash, bucket|
+        bucket_hash = { 'count' => bucket['doc_count'] }
+        bucket_hash.merge! parse_subaggregations(bucket)
+        hash.merge bucket['key'] => bucket_hash
+      end
+    end
+
+  end
+end

data/lib/elasticated/aggregations/nested_aggregation.rb

@@ -0,0 +1,30 @@
+module Elasticated
+  class NestedAggregation < Aggregation
+    include Subaggregated
+
+    attr_accessor :path
+
+    def initialize(path, *args, &block)
+      self.path = path
+      super
+      initialize_subaggregations &block
+    end
+
+    def default_name
+      path
+    end
+
+    def build
+      body = { nested: { path: path } }
+      body.merge! build_subaggregations
+      body
+    end
+
+    def parse(response)
+      ret = { 'count' => response['doc_count'] }
+      ret.merge! parse_subaggregations(response)
+      ret
+    end
+
+  end
+end

data/lib/elasticated/aggregations/range_aggregation.rb

@@ -0,0 +1,35 @@
+module Elasticated
+  class RangeAggregation < Aggregation
+    include Subaggregated
+
+    attr_accessor :_conditions
+
+    def initialize(field, *args, &block)
+      super
+      initialize_subaggregations RangeAggregationEvaluator.new, &block
+    end
+
+    def default_name
+      "range_over_#{field}"
+    end
+
+    def build
+      # _subaggregations is a RangeAggregationEvaluator, so...
+      ranges = _subaggregations.build_ranges
+      body_struct = { field: field, keyed: true, ranges: ranges }
+      body_struct.merge! extra_params
+      body = { range: body_struct }
+      body.merge! build_subaggregations
+      body
+    end
+
+    def parse(response)
+      response['buckets'].inject({}) do |hash, (key_name, values)|
+        range_body = { 'count' => values['doc_count'] }
+        range_body.merge! parse_subaggregations(values)
+        hash.merge key_name => range_body
+      end
+    end
+
+  end
+end

data/lib/elasticated/aggregations/range_aggregation_evaluator.rb

@@ -0,0 +1,22 @@
+module Elasticated
+  class RangeAggregationEvaluator < QueryAggregations
+
+    include BlockEvaluation
+
+    attr_accessor :_ranges_builder
+
+    def initialize
+      super
+      self._ranges_builder = RangesBuilder.new
+    end
+
+    def ranges(&block)
+      _ranges_builder.evaluate block
+    end
+
+    def build_ranges
+      _ranges_builder.build
+    end
+
+  end
+end

data/lib/elasticated/aggregations/ranges_builder.rb

@@ -0,0 +1,35 @@
+module Elasticated
+  class RangesBuilder
+
+    include Clonable
+    include BlockEvaluation
+
+    attr_accessor :_ranges
+
+    def initialize
+      self._ranges = Array.new
+    end
+
+    def less_equal(value, range_name=nil)
+      range_name ||= "less_equal_#{value}"
+      _ranges << { key: range_name, to: value }
+    end
+    alias_method :le, :less_equal
+
+    def greater_equal(value, range_name=nil)
+      range_name ||= "greater_equal_#{value}"
+      _ranges << { key: range_name, from: value }
+    end
+    alias_method :ge, :greater_equal
+
+    def between(min_value, max_value, range_name=nil)
+      range_name ||= "between_#{min_value}_and_#{max_value}"
+      _ranges << { key: range_name, from: min_value, to: max_value }
+    end
+
+    def build
+      _ranges
+    end
+
+  end
+end

data/lib/elasticated/aggregations/single_value_aggregation.rb

@@ -0,0 +1,47 @@
+module Elasticated
+  class SingleValueAggregation < Aggregation
+
+    # abstract class
+    # child must implement operation()
+
+    def default_name
+      "#{operation}_#{field}"
+    end
+
+    def build
+      operation_info = { field: field }
+      operation_info.merge! extra_params
+      { operation => operation_info }
+    end
+
+    def parse(response)
+      response['value'] || 0
+    end
+
+  end
+
+  class MaxAggregation < SingleValueAggregation
+    def operation
+      :max
+    end
+  end
+
+  class MinAggregation < SingleValueAggregation
+    def operation
+      :min
+    end
+  end
+
+  class SumAggregation < SingleValueAggregation
+    def operation
+      :sum
+    end
+  end
+
+  class AvgAggregation < SingleValueAggregation
+    def operation
+      :avg
+    end
+  end
+
+end

data/lib/elasticated/aggregations/subaggregated.rb

@@ -0,0 +1,27 @@
+module Elasticated
+  module Subaggregated
+
+    attr_accessor :_subaggregations
+
+    def initialize_subaggregations(query_aggregations=nil, &block)
+      self._subaggregations = query_aggregations || QueryAggregations.new
+      _subaggregations.evaluate block if block
+    end
+
+    private
+
+    def build_subaggregations
+      hash = _subaggregations.build
+      if hash.empty?
+        {}
+      else
+        { aggs: hash }
+      end
+    end
+
+    def parse_subaggregations(response)
+      _subaggregations.parse response
+    end
+
+  end
+end

data/lib/elasticated/aggregations/sum_distinct_aggregation.rb

@@ -0,0 +1,20 @@
+module Elasticated
+  class SumDistinctAggregation < GroupAggregation
+    # warning! this "thing" extends from a multi-value aggregation but is a single-value!
+
+    attr_accessor :_operation
+
+    def initialize(group_field, operation_type, operation_field, *args)
+      super group_field, *args
+      self._operation = _subaggregations.send operation_type, operation_field
+    end
+
+    def parse(response)
+      response['buckets'].inject(0) do |total, element|
+        operation_name = _operation.name.to_s # TODO
+        total += _subaggregations.parse(element)[operation_name] || 0
+      end || 0
+    end
+
+  end
+end

data/lib/elasticated/aggregations/terms_aggregation.rb

@@ -0,0 +1,63 @@
+module Elasticated
+  class TermsAggregation < Aggregation
+
+    # abstract class
+    # child must implement 'default_name'
+    # child must implement 'parse'
+    # child should implement 'build'
+
+    # Como usar el parametro order:
+    #   Se puede ordenar por un unico criterio haciendo por ejemplo:
+    #     group :user, order: :born_date, order_method: :desc
+    #   Se puede ordenar por un unico criterio haciendo tambien:
+    #     group :user, order: { born_date: :desc }
+    #   Se puede ordenar por un unico criterio especificando el metodo en el mismo string:
+    #     group :user, order: 'born_date:desc'
+    #   Se puede ordenar por multiples criterios haciendo:
+    #     group :user, order: { born_date: :desc, first_name: :asc }
+    #   Se puede ordenar por multiples criterios especificando el metodo en el mismo string:
+    #     group :user, order: ['born_date:desc', 'first_name:asc']
+
+    attr_accessor :size, :order_field, :order_method
+
+    def initialize(field, options={})
+      self.order_field = options.delete(:order) || options.delete(:order_by)
+      self.order_method = options.delete :order_method
+      self.size = options.delete(:size) || options.delete(:limit) || options.delete(:top)
+      super
+    end
+
+    def build
+      terms = { field: field, size: (size || 0) }
+      if order_field.is_a? Hash
+        if order_field.size == 1
+          terms.merge! order: order_field
+        else
+          terms.merge! order: order_field.map{ |field, method| { field => method } }
+        end
+      elsif order_field.is_a? Array
+        terms.merge! order: order_field.map{ |e| order_criteria_from e }
+      else
+        if order_method
+          terms.merge! order: { order_field => order_method || default_order_method }
+        else
+          terms.merge! order: order_criteria_from(order_field)
+        end
+      end if order_field
+      terms.merge! extra_params
+      { terms: terms }
+    end
+
+    protected
+
+    def order_criteria_from(str_or_symbol)
+      field, method = str_or_symbol.to_s.split ':'
+      method ? { field => method } : { str_or_symbol => default_order_method }
+    end
+
+    def default_order_method
+      :desc
+    end
+
+  end
+end

data/lib/elasticated/aggregations/top_hits_aggregation.rb

@@ -0,0 +1,25 @@
+module Elasticated
+  class TopHitsAggregation < Aggregation
+
+    attr_accessor :query
+
+    def initialize(name, *args, &block)
+      super
+      self.query = Query.new
+      query.evaluate block
+    end
+
+    def build
+      { top_hits: query.build_for_top_hits }
+    end
+
+    def parse(response)
+      # total = response['hits']['total']
+      # max_score = response['hits']['max_score']
+      # hits = response['hits']['hits'].map{ |hit| Document.from_elasticsearch_hit hit }
+      # HitsInfo.new total, max_score, hits
+      response['hits']['hits'].map{ |hit| Document.from_elasticsearch_hit hit }
+    end
+
+  end
+end

data/lib/elasticated/block_evaluation.rb

@@ -0,0 +1,15 @@
+module Elasticated
+  module BlockEvaluation
+
+    def evaluate(block=nil, obj=nil)
+      return unless block
+      obj ||= self
+      if block.parameters.empty?
+        obj.instance_exec &block
+      else
+        block.call obj
+      end
+    end
+
+  end
+end

data/lib/elasticated/boolean_clause.rb

@@ -0,0 +1,43 @@
+module Elasticated
+  class BooleanClause
+
+    include Clonable
+
+    attr_accessor :conditions
+
+    def initialize
+      self.conditions = Array.new
+    end
+
+    # delimiters
+
+    def fill_delimiter(field_delimiter)
+      conditions.each{ |condition| condition.fill_delimiter field_delimiter }
+    end
+
+    # conditions
+
+    def add(condition)
+      conditions << condition
+    end
+
+    include ConditionsBuilder
+
+    def count
+      conditions.count
+    end
+
+    def empty?
+      count == 0
+    end
+
+    def build
+      conditions.map &:build
+    end
+
+    def build_first
+      conditions.first.build
+    end
+
+  end
+end

data/lib/elasticated/client.rb

@@ -0,0 +1,84 @@
+module Elasticated
+  class Client
+    include Configurable
+
+    attr_accessor :transport
+
+    def initialize(opts={})
+      self.transport = ::Elasticsearch::Client.new opts
+    end
+
+    def index_document(document_source, opts={})
+      transport.index opts.merge body: document_source
+    end
+
+    def update_document(document_source, opts={})
+      transport.update opts.merge body: { doc: document_source }
+    end
+
+    def index_exists?(index_name)
+      transport.indices.exists index: index_name
+    end
+
+    def create_index(index_name, opts={})
+      args = { index: index_name }
+      shards = opts[:shards]
+      mapping = opts[:mapping]
+      body = Hash.new
+      body.merge!(settings: { number_of_shards: shards }) if shards
+      body.merge!(mappings: mapping) if mapping
+      args.merge! body: body unless body.empty?
+      log.info "Creating index #{index_name}"
+      transport.indices.create args
+      log.info "Index #{index_name} created"
+    end
+
+    def create_alias(index_name, new_alias)
+      log.info "Putting alias #{new_alias} to index #{index_name}"
+      transport.indices.put_alias index: index_name, name: new_alias
+      log.info "Alias #{new_alias} for index #{index_name} created"
+    end
+
+    def remove_aliases(index_name)
+      aliases = transport.indices.get_aliases[index_name]['aliases'].map(&:first) rescue Array.new
+      aliases.each do |alias_name|
+        transport.indices.delete_alias index: index_name, name: alias_name
+      end
+    end
+
+    def remove_alias(index_name, index_alias)
+      log.info "Alias #{index_alias} removed from index #{index_name}"
+      transport.indices.delete_alias index: index_name, name: index_alias
+    end
+
+    def refresh_index(index_name)
+      log.debug "Refreshing #{index_name}"
+      transport.indices.refresh index: index_name
+    end
+
+    def refresh
+      transport.indices.refresh
+    end
+
+    def count(body, opts={})
+      log.debug "Elasticsearch count #{body.to_json}"
+      transport.count opts.merge body: body
+    end
+
+    def search(body, opts={})
+      log.debug "Elasticsearch query #{body.to_json}"
+      transport.search opts.merge body: body
+    end
+
+    def scroll(scroll_id, opts={})
+      log.debug "Elasticsearch scroll #{scroll_id}"
+      transport.scroll opts.merge scroll_id: scroll_id
+    end
+
+    def delete(body, opts={})
+      log.debug "Elasticsearch delete #{body.to_json}"
+      transport.delete_by_query opts.merge body: body
+    end
+
+  end
+end