elasticated 2.5.5 → 3.0.0

data/lib/elasticated/mapping/object_builder.rb

@@ -2,12 +2,46 @@ module Elasticated
   module Mapping
     class ObjectBuilder < FieldsBuilder
 
+      attr_accessor :object_attributes
+
+      def initialize(*args)
+        super
+        self.object_attributes = Hash.new
+      end
+
+      def add_attribute(name, value)
+        object_attributes[name] = value
+      end
+
+      def base_body
+        { type: :object }
+      end
+
       # override
       def build_body
-        {
-          type: :object,
-          properties: super
-        }
+        ret = base_body
+        properties = super
+        ret.merge! properties: properties unless properties.empty?
+        ret.merge! object_attributes unless object_attributes.empty?
+        ret
+      end
+
+      # 'dynamic' attribute
+
+      def dynamic(value)
+        add_attribute :dynamic, value
+      end
+
+      def strict
+        dynamic Enum::Mapping::Dynamic::STRICT
+      end
+
+      def ignore_new_fields
+        dynamic Enum::Mapping::Dynamic::IGNORE_NEW_FIELDS
+      end
+
+      def accept_new_fields
+        dynamic Enum::Mapping::Dynamic::ACCEPT_NEW_FIELDS
       end
 
     end

data/lib/elasticated/mapping/type_builder.rb

@@ -1,12 +1,10 @@
 module Elasticated
   module Mapping
-    class TypeBuilder < FieldsBuilder
+    class TypeBuilder < ObjectBuilder
 
       # override
-      def build_body
-        {
-          properties: super
-        }
+      def base_body
+        Hash.new
       end
 
     end

data/lib/elasticated/mixins/block_evaluation.rb

@@ -0,0 +1,17 @@
+module Elasticated
+  module Mixins
+    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
+end

data/lib/elasticated/mixins/clonable.rb

@@ -0,0 +1,60 @@
+module Elasticated
+  module Mixins
+    module Clonable
+
+      def clone
+        ret = super
+        instance_variables.each do |instance_variable|
+          value = instance_variable_get instance_variable
+          value = case value.class
+          when Array
+            clone_array value
+          when Hash
+            Helpers.hash_deep_dup value
+          else
+            value.clone
+          end
+          ret.instance_variable_set instance_variable, value
+        end
+        ret
+      end
+
+      def ==(other_entity)
+        other_entity.class == self.class &&
+        instance_variables.all? do |instance_variable|
+          next true if instance_variable == :@_subaggregations # Subaggregated
+          value = instance_variable_get instance_variable
+          other_value = other_entity.instance_variable_get instance_variable
+          case other_value.class
+          when Array
+            compare_arrays value, other_value
+          else
+            other_value == value
+          end
+        end
+      end
+
+      private
+
+      def clone_array(array)
+        array.map do |element|
+          case element.class
+          when Hash
+            Helpers.hash_deep_dup element
+          when Array
+            clone_array element
+          else
+            element.clone
+          end
+        end
+      end
+
+      def compare_arrays(array_a, array_b)
+        array_a.all? do |element|
+          array_b.include? element
+        end && array_a.size == array_b.size
+      end
+
+    end
+  end
+end

data/lib/elasticated/mixins/configurable.rb

@@ -0,0 +1,22 @@
+module Elasticated
+  module Mixins
+    module Configurable
+
+      def self.delegated(attr_name)
+        define_method attr_name do
+          instance_variable_get("@#{attr_name}") || Configuration.send(attr_name)
+        end
+        define_method "#{attr_name}=" do |value|
+          instance_variable_set "@#{attr_name}", value
+        end
+      end
+
+      delegated :logger
+      alias_method :log, :logger
+      delegated :scroll_expiration_time
+      delegated :scroll_page_size
+      delegated :search_page_size
+
+    end
+  end
+end

data/lib/elasticated/mixins/inspectionable.rb

@@ -0,0 +1,16 @@
+module Elasticated
+  module Mixins
+    module Inspectionable
+
+      def inspect(show_original=false)
+        return super() if show_original
+        "#<#{self.class.name}:#{text_for_inspect}>"
+      end
+
+      def text_for_inspect
+        build.to_json # default implementation
+      end
+
+    end
+  end
+end

data/lib/elasticated/partitioned_repository.rb

@@ -13,34 +13,40 @@ module Elasticated
       client.refresh_indices affected_indices
     end
 
-    # override
-    def execute_aggregations(query, opts={})
-      super(query, {delimit_by: [:conditions, :aggregations]}.merge(opts))
+    def affected_indices_for(query)
+      index_selector.indices_for_query(query)
     end
 
-    protected
+    def affected_index_for(user_params)
+      index_params = user_params.delete(:index_for)
+      index_params || raise("The index selection parameters should be specified in the missing 'index_for' option")
+      index_selector.index_for_params index_params
+    end
+
+    def params_for_document(document, original_params={})
+      affected_index = index_selector.index_for_document document
+      original_params.merge index: affected_index
+    end
 
-    # override
-    def execute(action, query, opts={})
-      affected_indices = affected_indices_for query, opts
+    def params_for_query(query, original_params={})
+      affected_indices = affected_indices_for query
       affected_indices = affected_indices*','
-      super action, query, opts.merge(index: affected_indices).reject { |k,_| k == :delimit_by }
+      original_params.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)
+    def params_for_source(source, original_params={})
+      affected_index = affected_index_for original_params
+      original_params.merge index: affected_index
     end
 
-    # override
-    def prepare_percolator(action, query, opts={})
-      affected_index = index_selector.index_for_percolator(query)
-      super action, query, opts.merge(index: affected_index)
+    def params_for_ids(ids, original_params={})
+      affected_index = affected_index_for original_params
+      original_params.merge index: affected_index
     end
 
-    def affected_indices_for(query, opts={})
-      index_selector.indices_for_query(query, opts)
+    def params_for_percolator(original_params={})
+      affected_index = index_selector.index_for_percolator
+      original_params.merge index: affected_index
     end
 
   end

data/lib/elasticated/query.rb

@@ -9,8 +9,9 @@ module Elasticated
       end
     end
 
-    include BlockEvaluation
-    include Clonable
+    include Mixins::Clonable
+    include Mixins::BlockEvaluation
+    include Mixins::Inspectionable
 
     attr_accessor :_conditions, :_filter_conditions, :_post_conditions
     attr_accessor :_source, :_sort, :_size, :_from
@@ -53,35 +54,38 @@ module Elasticated
     end
     alias_method :offset, :from
 
-    def custom_sort(custom_hash)
+    def sort(field, method=nil)
       self._sort ||= Array.new
-      _sort << custom_hash
+      _sort << { field => { order: method || :asc } }
       self
     end
 
-    def sort(field, method=nil)
-      custom_sort(field => { order: method || :asc })
-    end
-    alias_method :sort_by_field, :sort
-
-    def sort_by_script(script_hash)
-      custom_sort(_script: script_hash)
-    end
-
     def sort_randomly
-      sort_by_script(script: "Math.random()", type: "number")
+      self._sort ||= Array.new
+      _sort << { _script: { script: "Math.random()", type: "number" } }
+      self
     end
 
     def source(*fields_array)
-      self._source = fields_array.flatten
+      if fields_array.count == 1 && fields_array.first == false
+        no_source
+      else
+        self._source = fields_array.flatten
+      end
       self
     end
     alias_method :fields, :source
 
+    def no_source
+      self._source = false
+      self
+    end
+
     def aggregations(&block)
       _aggregations.evaluate block
       self
     end
+    alias_method :aggs, :aggregations
 
     # misc getters
 
@@ -93,7 +97,7 @@ module Elasticated
       !_size || _size > repository.search_page_size
     end
 
-    def has_offset?
+    def offset?
       _from && _from > 0
     end
 
@@ -127,7 +131,7 @@ module Elasticated
       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.merge! _source: _source unless _source.nil? # source can be false
       ret
     end
 
@@ -143,6 +147,7 @@ module Elasticated
       ret
     end
     alias_method :build, :build_for_aggregated_search
+    alias_method :to_h, :build_for_aggregated_search
 
     # parse methods
 
@@ -150,10 +155,11 @@ module Elasticated
       _aggregations.parse response
     end
 
-    # visitor methods
-    
-    def accept_visitor(visitor)
-      visitor.visit_query(self)
+    # delimiters
+
+    def fill_delimiter(field_delimiter)
+      _conditions.fill_delimiter field_delimiter
+      _filter_conditions.fill_delimiter field_delimiter
     end
 
     # conditions & filter shorthands

data/lib/elasticated/query_aggregations.rb

@@ -4,8 +4,9 @@ module Elasticated
     extend Forwardable
     def_delegators :@_aggregations, :first, :one?, :empty?
 
-    include Clonable
-    include BlockEvaluation
+    include Mixins::Clonable
+    include Mixins::BlockEvaluation
+    include Mixins::Inspectionable
 
     attr_accessor :_aggregations
 
@@ -27,19 +28,16 @@ module Elasticated
       end
     end
 
-    def merge!(other_query_aggs)
+    def merge! other_query_aggs
       other_query_aggs._aggregations.each do |other_aggregation|
         add_aggregation other_aggregation
       end
     end
 
-    def accept_visitor(visitor)
-      visitor.visit_query_aggregations(self)
-    end
-
     private
 
     def get_aggregation_class(agg_name)
+      return GroupAggregation if agg_name.to_s == 'terms'
       camel_case_name = Helpers.string_to_camel_case agg_name.to_s
       self.class.const_get("::Elasticated::#{camel_case_name}Aggregation") rescue nil
     end

data/lib/elasticated/query_conditions.rb

@@ -1,7 +1,8 @@
 module Elasticated
   class QueryConditions
 
-    include Clonable
+    include Mixins::Clonable
+    include Mixins::Inspectionable
 
     attr_accessor :_must, :_must_not, :_should, :_minimum_should_match, :_cache
 
@@ -11,8 +12,10 @@ module Elasticated
       self._should = BooleanClause.new
     end
 
-    def accept_visitor(visitor)
-      visitor.visit_query_conditions(self)
+    # delimiters
+
+    def fill_delimiter(field_delimiter)
+      _must.fill_delimiter field_delimiter
     end
 
     # conditions

data/lib/elasticated/quick.rb

@@ -0,0 +1,7 @@
+require 'elasticated'
+
+Elasticated.configure do |config|
+  config.logger = Elasticated::Loggers::DefaultLogger.new
+end
+
+include Elasticated

data/lib/elasticated/repository.rb

@@ -1,9 +1,17 @@
 module Elasticated
   class Repository
-    include Configurable
-
-    # child can implement 'execute(action, query, opts)'
-    # child can implement 'prepare(action, document, opts)'
+    include Mixins::Configurable
+
+    # PRE-ACTION METHODS ----------------------------------------------------------
+    # child can implement params_for_document(document, original_params={}) => Hash
+    # child can implement params_for_query(query, original_params={}) => Hash
+    # child can implement params_for_source(source, original_params={}) => Hash
+    # child can implement params_for_ids(ids, original_params={}) => Hash
+    # child can implement params_for_percolator(original_params={}) => Hash
+    # POST-ACTION METHODS ---------------------------------------------------------
+    # child can implement prepare_source(source) => Hash
+    # child can implement restore_source(source) => Hash
+    # -----------------------------------------------------------------------------
 
     attr_accessor :client
 
@@ -12,76 +20,136 @@ module Elasticated
     end
 
     def execute_search(query, opts={})
-      execute :search, query, opts
+      prepare_query_action :search, query, opts
     end
 
     def execute_aggregations(query, opts={})
-      execute :aggregations, query, opts
+      prepare_query_action :aggregations, query, opts
     end
 
     def execute_count(query, opts={})
-      execute :count, query, opts
+      prepare_query_action :count, query, opts
     end
 
     def execute_aggregated_search(query, opts={})
-      execute :aggregated_search, query, opts
+      prepare_query_action :aggregated_search, query, opts
     end
 
-    def delete_by(query, opts={})
-      execute :delete, query, opts
+    def delete_by_query(query, opts={})
+      prepare_query_action :delete_by_query, query, opts
     end
+    alias_method :delete_by, :delete_by_query
 
     def exists?(query, opts={})
       execute_count(query, opts) > 0
     end
 
     def index_document(document, opts={})
-      prepare :index, document, opts
+      prepare_document_action :index_document, document, opts
     end
 
-    def update_document(document, opts={})
-      prepare :update, document, opts
+    def update_document(document_id, opts={})
+      source = opts.delete(:source) || raise("No body specified for partial update")
+      prepare_source_action :update_document, source, opts.merge(id: document_id)
     end
 
     def create_percolator(query, opts={})
-      prepare_percolator :create_percolator, query, opts
+      prepare_query_action :prepare_percolator_action, query, opts
+    end
+
+    def percolate_document(document, opts={})
+      prepare_document_action :prepare_percolator_action, document, opts
+    end
+
+    def get_document(document_id_or_ids, opts={})
+      prepare_ids_action :variable_get, Array(document_id_or_ids), opts
     end
+    alias_method :get_documents, :get_document
 
-    def percolate(document, opts={})
-      prepare_percolator :percolate, document, opts
+    def delete_document(document_id, opts={})
+      prepare_ids_action :delete_document, Array(document_id), opts
     end
 
     def prepare_search(query, opts={})
-      execute :prepare_search, query, opts
+      prepare_query_action :prepare_search, query, opts
     end
 
     def restore_search(scroll_id)
       ResumableSearch.from_scroll_id self, scroll_id
     end
 
-    protected
+    def prepare_bulk(&block)
+      BulkRequest.build_over(self, &block)
+    end
 
-    # write actions
+    def execute_bulk(bulk_request)
+      result = client.bulk bulk_request.build
+      bulk_request.parse result
+    end
+
+    # params preparation
+
+    def params_for_document(document, original_params={})
+      original_params
+    end
 
-    def _exec_index(document, opts={})
-      _exec_upsert :index, document, opts
+    def params_for_query(query, original_params={})
+      original_params
     end
 
-    def _exec_update(document, opts={})
-      _exec_upsert :update, document, opts
+    def params_for_source(source, original_params={})
+      original_params
     end
 
-    def _exec_upsert(method, document, opts={})
+    def params_for_ids(ids, original_params={})
+      original_params
+    end
+
+    def params_for_percolator(original_params={})
+      original_params
+    end
+
+    # document translation
+
+    def prepare_source(source)
+      source
+    end
+
+    def restore_source(source)
+      source
+    end
+
+    def prepare_document(document)
+      params = params_for_document document
+      translated_document = document.clone
+      translated_document.source = prepare_source Helpers.hash_deep_dup document.source
+      translated_document.index = params[:index] if params[:index]
+      translated_document.type = params[:type] if params[:type]
+      translated_document
+    end
+
+    protected
+
+    # write actions
+
+    def _exec_index_document(document, opts={})
       opts.merge! id: document.id if document.id
       opts.merge! type: document.type unless opts[:type]
       opts.merge! index: document.index unless opts[:index]
-      document.index = opts[:index]
-      document.type = opts[:type]
-      client.send "#{method}_document", document.source, opts
+      document.index = opts[:index] || raise("A target index should be specified in a indexation")
+      document.type = opts[:type] || raise("A target type should be specified in a indexation")
+      client.index_document document.source, opts
+    end
+
+    def _exec_update_document(source, opts={})
+      opts[:index] || raise("A target index should be specified in a partial update")
+      opts[:type] || raise("A target type should be specified in a partial update")
+      opts[:id] || raise("A target document id should be specified in a partial update")
+      client.update_document source, opts
     end
 
     def _exec_create_percolator(query, opts={})
-      query_source = query.build.fetch(:query)
+      query_source = query.build_for_count
       client.create_percolator query_source, opts
     end
 
@@ -107,8 +175,9 @@ module Elasticated
       _exec_paginated_search query, query.aggregated?, opts
     end
 
-    def _exec_delete(query, opts={})
-      client.delete query, opts
+    def _exec_delete_by_query(query, opts={})
+      body = query.build_for_count
+      client.delete_by_query body, opts
     end
 
     def _exec_paginated_search(query, aggregated, opts={})
@@ -134,30 +203,105 @@ module Elasticated
 
     def _exec_prepare_search(query, opts={})
       raise "The query for a resumable search should not have the parameter 'size'" if query.limited? || opts[:size]
-      raise "The query for a resumable search should not have the parameter 'from'" if query.has_offset? || opts[:from]
+      raise "The query for a resumable search should not have the parameter 'from'" if query.offset? || opts[:from]
       ResumableSearch.new self, query, false, opts
     end
 
-    def _exec_percolate(document, opts={})
-      document_source = document.document_source
+    def _exec_percolate_document(document, opts={})
+      document_source = document.source
       client.percolate document_source, opts
     end
 
-    # abstract methods
+    def _exec_get_document(document_id, opts={})
+      result = client.get_document document_id, opts
+      return nil unless result['found']
+      document = Document.parse result
+      prepare_served_document document
+    end
+
+    def _exec_get_documents(documents_ids, opts={})
+      result = client.get_documents documents_ids, opts
+      result['docs'].map do |e|
+        document = Document.parse e
+        prepare_served_document document
+      end
+    end
+
+    def _exec_variable_get(documents_ids, opts={})
+      if documents_ids.empty?
+        raise "At least one document id must be specified for a get"
+      elsif documents_ids.count == 1
+        _exec_get_document documents_ids.first, opts
+      else
+        _exec_get_documents documents_ids, opts
+      end
+    end
+
+    def _exec_delete_document(documents_ids, opts={})
+      raise "Not more than one document delete per time allowed" unless documents_ids.count == 1
+      client.delete_document documents_ids.first, opts
+    end
+
+    # pre-action methods
+
+    def prepare_source_action(action, source, opts={})
+      # child's implementation here
+      # child's implementation must end with a 'super' call
+      prepared_source = prepare_source Helpers.hash_deep_dup source
+      prepared_params = params_for_source source, opts
+      send "_exec_#{action}", prepared_source, prepared_params
+    end
+
+    def prepare_ids_action(action, documents_ids, opts={})
+      # child's implementation here
+      # child's implementation must end with a 'super' call
+      prepared_params = params_for_ids documents_ids, opts
+      send "_exec_#{action}", documents_ids, prepared_params
+    end
+
+    def prepare_query_action(action, query, opts={})
+      # child's implementation here
+      # child's implementation must end with a 'super' call
+      prepared_params = params_for_query query, opts
+      return prepare_percolator_action(:create_percolator, query, prepared_params) if percolator_action?(action)
+      send "_exec_#{action}", query, prepared_params
+    end
+
+    def prepare_document_action(action, document, opts={})
+      # child's implementation here
+      # child's implementation must end with a 'super' call
+      prepared_params = params_for_document document, opts
+      prepared_document = prepare_document document
+      return prepare_percolator_action :percolate_document, prepared_document, prepared_params if percolator_action? action
+      send "_exec_#{action}", prepared_document, prepared_params
+    end
 
-    def execute(action, query, opts={})
+    def prepare_percolator_action(action, doc_or_query, opts={})
       # child's implementation here
-      send "_exec_#{action}", query, opts
+      # child's implementation must end with a 'super' call
+      # DO NOT TOUCH THE DOC OR QUERY HERE! use prepare_query_action or prepare_document_action
+      prepared_params = params_for_percolator opts
+      send "_exec_#{action}", doc_or_query, prepared_params
     end
 
-    def prepare(action, document, opts={})
+    # post-action methods
+
+    def prepare_served_document(document)
       # child's implementation here
-      send "_exec_#{action}", document, opts
+      document.source = restore_source document.source
+      document
     end
 
-    def prepare_percolator(action, query, opts={})
+    def prepare_served_results(results)
       # child's implementation here
-      send "_exec_#{action}", query, opts
+      results.documents.each{ |document| prepare_served_document document }
+      results
+    end
+
+    # misc
+
+    def percolator_action?(action)
+      action == :prepare_percolator_action
     end
 
   end