elasticated 1.0.0

data/lib/elasticated/document.rb

@@ -0,0 +1,46 @@
+module Elasticated
+  class Document
+
+    class << self
+
+      def create(opts={}, &block)
+        raise if block && !opts.empty?
+        ret = new
+        if opts.empty?
+          ret.evaluate block
+        else
+          opts.each{ |k, v| ret.send "#{k}=", v if v }
+        end
+        ret
+      end
+
+      def from_elasticsearch_hit(hit)
+        document = new hit['_source']
+        document.id = hit['_id']
+        document.type = hit['_type']
+        document.index = hit['_index']
+        document.score = hit['_score']
+        document.version = hit['_version']
+        document
+      end
+
+    end
+
+    include BlockEvaluation
+
+    attr_accessor :id, :type, :index, :score, :version, :document_source
+
+    def initialize(source=nil)
+      self.source = source if source
+    end
+
+    def source=(hash)
+      self.document_source = Hash::Accessible.new hash
+    end
+
+    def source
+      self.document_source ||= Hash::Accessible.new
+    end
+
+  end
+end

data/lib/elasticated/helpers.rb

@@ -0,0 +1,28 @@
+module Elasticated
+  module Helpers
+
+    def self.string_to_agg_name(element)
+      element.to_s.gsub /(?![a-zA-Z0-9])./, '_'
+    end
+
+    def self.string_to_camel_case(string)
+      return string if string !~ /_/ && string =~ /[A-Z]+.*/
+      string.split('_').map(&:capitalize).join
+    end
+
+    def self.hash_deep_dup(hash)
+      duplicate = hash.dup
+      duplicate.each_pair do |k, v|
+        if v.is_a? Hash
+          duplicate[k] = hash_deep_dup v
+        elsif v.is_a? Array
+          duplicate[k] = v.clone
+        else
+          duplicate[k] = v
+        end
+      end
+      duplicate
+    end
+
+  end
+end

data/lib/elasticated/index_selector.rb

@@ -0,0 +1,44 @@
+module Elasticated
+  class IndexSelector
+
+    # abstract class
+    # child must implement 'delimiters()'
+    # child must implement 'strategy()'
+    # child can override 'strategy_params_for(document)'
+
+    include BlockEvaluation
+
+    def indices_for_query(query)
+      strategy_params = strategy_params_for_query query
+      indices = strategy.call strategy_params
+      raise "At least one index should be affected for a search" if indices.count < 1
+      indices
+    end
+
+    def index_for_document(document)
+      params = strategy_params_for_document document
+      indices = strategy.call params
+      raise "Only one index can be affected for a document indexation" if indices.count > 1
+      raise "At least one index should be affected for a document indexation" if indices.count < 1
+      indices.first
+    end
+
+    protected
+
+    def strategy_params_for_document(document)
+      delimiters.inject Hash.new do |params, delimiter|
+        key = delimiter.filter_name
+        value = document.source[delimiter.field_name]
+        value ? params.merge(key => value) : params
+      end
+    end
+
+    def strategy_params_for_query(query)
+      delimiters.inject Hash.new do |params, delimiter|
+        query.fill_delimiter delimiter
+        params.merge delimiter.build_strategy_params
+      end
+    end
+
+  end
+end

data/lib/elasticated/inspectionable.rb

@@ -0,0 +1,9 @@
+module Elasticated
+  module Inspectionable
+
+    def inspect
+      "#<#{self.class.name}:#{build}>"
+    end
+
+  end
+end

data/lib/elasticated/mapping.rb

@@ -0,0 +1,19 @@
+module Elasticated
+  module Mapping
+
+    class << self
+
+      def partial(&block)
+        Partial.new &block
+      end
+
+      def build(&block)
+        instance = Builder.new
+        instance.evaluate block
+        instance.build
+      end
+
+    end
+
+  end
+end

data/lib/elasticated/mapping/builder.rb

@@ -0,0 +1,36 @@
+module Elasticated
+  module Mapping
+    class Builder
+
+      class << self
+        def build(&block)
+          instance = new
+          instance.evaluate block
+          instance.build
+        end
+      end
+
+      include BlockEvaluation
+
+      attr_accessor :mapping_types
+
+
+      def initialize
+        self.mapping_types = Array.new
+      end
+
+      def type(name, &block)
+        mapping_type = TypeBuilder.new name
+        mapping_type.evaluate block
+        mapping_types << mapping_type
+      end
+
+      def build
+        mapping_types.inject({}) do |hash, mapping_type|
+          hash.merge mapping_type.build
+        end
+      end
+
+    end
+  end
+end

data/lib/elasticated/mapping/fields_builder.rb

@@ -0,0 +1,148 @@
+module Elasticated
+  module Mapping
+    class FieldsBuilder
+
+      include BlockEvaluation
+
+      attr_accessor :hash, :name, :sub_objects, :nesteds
+
+      def initialize(name)
+        self.hash = Hash.new
+        self.sub_objects = Array.new
+        self.nesteds = Array.new
+        self.name = name
+      end
+
+      def date(field_name)
+        hash[field_name] = build_date_field
+      end
+
+      def string(field_name)
+        hash[field_name] = build_string_field
+      end
+
+      def float(field_name)
+        hash[field_name] = build_float_field
+      end
+
+      def double(field_name)
+        hash[field_name] = build_double_field
+      end
+
+      def integer(field_name)
+        hash[field_name] = build_integer_field
+      end
+
+      def long(field_name)
+        hash[field_name] = build_long_field
+      end
+
+      def analyzed_string(field_name)
+        hash[field_name] = build_analyzed_string_field field_name
+      end
+
+      def bool(field_name)
+        hash[field_name] = build_bool_field
+      end
+
+      def object(object_name, &block)
+        sub_object = ObjectBuilder.new object_name
+        sub_object.evaluate block
+        sub_objects << sub_object
+      end
+
+      def nested(nested_name, &block)
+        nested = NestedBuilder.new nested_name
+        nested.evaluate block
+        nesteds << nested
+      end
+
+      def partial(partial_mapping)
+        partial_mapping.apply_over self
+      end
+
+      def build_body
+        ret = hash
+        sub_objects.each do |sub_object|
+          ret.merge! sub_object.build
+        end
+        nesteds.each do |nested|
+          ret.merge! nested.build
+        end
+        ret
+      end
+
+      def build
+        { name => build_body }
+      end
+
+      private
+
+      def build_date_field
+        {
+          type: :date,
+          fielddata: { format: :doc_values }
+        }
+      end
+
+      def build_string_field
+        {
+          type: :string,
+          index: :not_analyzed,
+          fielddata: { format: :doc_values }
+        }
+      end
+
+      def build_integer_field
+        {
+          type: :integer,
+          fielddata: { format: :doc_values }
+        }
+      end
+
+      def build_float_field
+        {
+          type: :float,
+          fielddata: { format: :doc_values }
+        }
+      end
+
+      def build_double_field
+        {
+          type: :double,
+          fielddata: { format: :doc_values }
+        }
+      end
+
+      def build_long_field
+        {
+          type: :long,
+          fielddata: { format: :doc_values }
+        }
+      end
+
+      def build_analyzed_string_field(field_name)
+        {
+          type: :multi_field,
+          fields: {
+            field_name => {
+              type: :string,
+              index: :not_analyzed,
+              fielddata: { format: :doc_values }
+            },
+            analyzed: {
+              type: :string
+            }
+          }
+        }
+      end
+
+      def build_bool_field
+        {
+          type: :boolean
+        }
+      end
+
+    end
+  end
+end

data/lib/elasticated/mapping/nested_builder.rb

@@ -0,0 +1,15 @@
+module Elasticated
+  module Mapping
+    class NestedBuilder < FieldsBuilder
+
+      # override
+      def build_body
+        {
+          type: :nested,
+          properties: super
+        }
+      end
+
+    end
+  end
+end

data/lib/elasticated/mapping/object_builder.rb

@@ -0,0 +1,15 @@
+module Elasticated
+  module Mapping
+    class ObjectBuilder < FieldsBuilder
+
+      # override
+      def build_body
+        {
+          type: :object,
+          properties: super
+        }
+      end
+
+    end
+  end
+end

data/lib/elasticated/mapping/partial.rb

@@ -0,0 +1,11 @@
+module Elasticated
+  module Mapping
+    class Partial < Proc
+
+      def apply_over(mapping_builder)
+        call mapping_builder
+      end
+
+    end
+  end
+end

data/lib/elasticated/mapping/type_builder.rb

@@ -0,0 +1,14 @@
+module Elasticated
+  module Mapping
+    class TypeBuilder < FieldsBuilder
+
+      # override
+      def build_body
+        {
+          properties: super
+        }
+      end
+
+    end
+  end
+end

data/lib/elasticated/partitioned_repository.rb

@@ -0,0 +1,27 @@
+module Elasticated
+  class PartitionedRepository < Repository
+
+    attr_accessor :index_selector
+
+    def initialize(index_selector, opts={})
+      self.index_selector = index_selector
+      super opts
+    end
+
+    protected
+
+    # override
+    def execute(action, query, opts={})
+      affected_indices = index_selector.indices_for_query(query)
+      affected_indices = affected_indices*','
+      super action, query, opts.merge(index: affected_indices)
+    end
+
+    # override
+    def prepare(action, document, opts={})
+      affected_index = index_selector.index_for_document(document)
+      super action, document, opts.merge(index: affected_index)
+    end
+
+  end
+end

data/lib/elasticated/query.rb

@@ -0,0 +1,159 @@
+module Elasticated
+  class Query
+
+    class << self
+      def build(&block)
+        q = new
+        q.evaluate block
+        q
+      end
+    end
+
+    include BlockEvaluation
+    include Clonable
+
+    attr_accessor :_conditions, :_filter_conditions, :_post_conditions
+    attr_accessor :_source, :_sort, :_size, :_from
+    attr_accessor :_aggregations
+
+    def initialize
+      self._conditions = QueryConditions.new
+      self._filter_conditions = QueryConditions.new
+      self._post_conditions = QueryConditions.new
+      self._aggregations = QueryAggregations.new
+    end
+
+    # builders & attrs
+
+    def conditions(&block)
+      _conditions.evaluate block
+      self
+    end
+
+    def filter(&block)
+      _filter_conditions.evaluate block
+      self
+    end
+
+    def post(&block)
+      _post_conditions.evaluate block
+      self
+    end
+    alias_method :post_filter, :post
+
+    def size(value)
+      self._size = value
+      self
+    end
+    alias_method :limit, :size
+
+    def from(value)
+      self._from = value
+      self
+    end
+    alias_method :offset, :from
+
+    def sort(field, method=nil)
+      self._sort ||= Array.new
+      _sort << { field => { order: method || :asc } }
+      self
+    end
+
+    def source(*fields_array)
+      self._source = fields_array.flatten
+      self
+    end
+    alias_method :fields, :source
+
+    def aggregations(&block)
+      _aggregations.evaluate block
+      self
+    end
+
+    # misc getters
+
+    def limited?
+      !!_size
+    end
+
+    def sorted?
+      !!_sort
+    end
+
+    def aggregated?
+      !_aggregations.empty?
+    end
+
+    # to_hash methods
+
+    def build_for_count
+      return { query: _conditions.build } if _filter_conditions.empty?
+      filtered = { filter: _filter_conditions.build }
+      filtered.merge!(query: _conditions.build) unless _conditions.empty?
+      { query: { filtered: filtered } }
+    end
+
+    def build_for_aggregations
+      raise "No aggregations present in query" unless aggregated?
+      ret = build_for_count
+      ret.merge! size: 0
+      ret.merge! aggs: _aggregations.build
+      ret
+    end
+
+    def build_for_top_hits
+      ret = Hash.new
+      ret.merge! sort: _sort if _sort
+      ret.merge! size: _size if _size
+      ret.merge! from: _from if _from
+      ret.merge! _source: _source if _source
+      ret
+    end
+
+    def build_for_search
+      ret = build_for_count.merge build_for_top_hits
+      ret.merge! post_filter: _post_conditions.build unless _post_conditions.empty?
+      ret
+    end
+
+    def build_for_aggregated_search
+      ret = build_for_search
+      ret.merge! aggs: _aggregations.build unless _aggregations.empty?
+      ret
+    end
+    alias_method :build, :build_for_aggregated_search
+
+    # parse methods
+
+    def parse_aggregations(response)
+      _aggregations.parse response
+    end
+
+    # delimiters
+
+    def fill_delimiter(field_delimiter)
+      _conditions.fill_delimiter field_delimiter
+      _filter_conditions.fill_delimiter field_delimiter
+    end
+
+    # conditions & filter shorthands
+
+    private
+
+    def method_missing(name, *args, &block)
+      # delegates any "filter_*" method missing to the _filter_conditions object
+      # delegates any other method missing to the _conditions object
+      conditions_obj = name.to_s.start_with?('filter_') ? _filter_conditions : _conditions
+      real_method_name = name.to_s.gsub(/^filter\_/, '').to_sym
+      super unless conditions_obj.respond_to? real_method_name
+      conditions_obj.send real_method_name, *args, &block
+      self
+    end
+
+    def respond_to_missing?(name, include_private=false)
+      real_method_name = name.to_s.gsub(/^filter\_/, '').to_sym
+      _conditions.respond_to?(real_method_name) || super
+    end
+
+  end
+end