elasticsearch-persistence 5.1.0 → 6.0.0.pre

data/lib/elasticsearch/persistence/repository/dsl.rb

@@ -0,0 +1,94 @@
+module Elasticsearch
+  module Persistence
+    module Repository
+
+      # Include this module to get class-level methods for repository configuration.
+      #
+      # @since 6.0.0
+      module DSL
+
+        def self.included(base)
+          base.send(:extend, Elasticsearch::Model::Indexing::ClassMethods)
+          base.send(:extend, ClassMethods)
+        end
+
+        # These methods are necessary to define at the class-level so that the methods available
+        # via Elasticsearch::Model::Indexing::ClassMethods have the references they depend on.
+        #
+        # @since 6.0.0
+        module ClassMethods
+
+          # Get or set the class-level document type setting.
+          #
+          # @example
+          #   MyRepository.document_type
+          #
+          # @return [ String, Symbol ] _type The repository's document type.
+          #
+          # @since 6.0.0
+          def document_type(_type = nil)
+            @document_type ||= (_type || DEFAULT_DOC_TYPE)
+          end
+
+          # Get or set the class-level index name setting.
+          #
+          # @example
+          #   MyRepository.index_name
+          #
+          # @return [ String, Symbol ] _name The repository's index name.
+          #
+          # @since 6.0.0
+          def index_name(_name = nil)
+            @index_name ||= (_name || DEFAULT_INDEX_NAME)
+          end
+
+          # Get or set the class-level setting for the class used by the repository when deserializing.
+          #
+          # @example
+          #   MyRepository.klass
+          #
+          # @return [ Class ] _class The repository's klass for deserializing.
+          #
+          # @since 6.0.0
+          def klass(_class = nil)
+            instance_variables.include?(:@klass) ? @klass : @klass = _class
+          end
+
+          # Get or set the class-level setting for the client used by the repository.
+          #
+          # @example
+          #   MyRepository.client
+          #
+          # @return [ Class ] _client The repository's client.
+          #
+          # @since 6.0.0
+          def client(_client = nil)
+            @client ||= (_client || Elasticsearch::Client.new)
+          end
+
+          def create_index!(*args)
+            __raise_not_implemented_error(__method__)
+          end
+
+          def delete_index!(*args)
+            __raise_not_implemented_error(__method__)
+          end
+
+          def refresh_index!(*args)
+            __raise_not_implemented_error(__method__)
+          end
+
+          def index_exists?(*args)
+            __raise_not_implemented_error(__method__)
+          end
+
+          private
+
+          def __raise_not_implemented_error(_method_)
+            raise NotImplementedError, "The '#{_method_}' method is not implemented on the Repository class."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/persistence/repository/find.rb

@@ -40,19 +40,35 @@ module Elasticsearch
         #     repository.exists?(1)
         #     => true
         #
+        # @param [ String, Integer ] id The id to search.
+        # @param [ Hash ] options The options.
+        #
         # @return [true, false]
         #
         def exists?(id, options={})
-          type     = document_type || (klass ? __get_type_from_class(klass) : '_all')
-          client.exists( { index: index_name, type: type, id: id }.merge(options) )
+          request = { index: index_name, id: id }
+          request[:type] = document_type if document_type
+          client.exists(request.merge(options))
         end
 
+        private
+
+        # The key for accessing the document found and returned from an
+        #   Elasticsearch _mget query.
+        #
+        DOCS = 'docs'.freeze
+
+        # The key for the boolean value indicating whether a particular id
+        #   has been successfully found in an Elasticsearch _mget query.
+        #
+        FOUND = 'found'.freeze
+
         # @api private
         #
         def __find_one(id, options={})
-          type     = document_type || (klass ? __get_type_from_class(klass) : '_all')
-          document = client.get( { index: index_name, type: type, id: id }.merge(options) )
-
+          request = { index: index_name, id: id }
+          request[:type] = document_type if document_type
+          document = client.get(request.merge(options))
           deserialize(document)
         rescue Elasticsearch::Transport::Transport::Errors::NotFound => e
           raise DocumentNotFound, e.message, caller
@@ -61,13 +77,14 @@ module Elasticsearch
         # @api private
         #
         def __find_many(ids, options={})
-          type     = document_type || (klass ? __get_type_from_class(klass) : '_all')
-          documents = client.mget( { index: index_name, type: type, body: { ids: ids } }.merge(options) )
-
-          documents['docs'].map { |document| document['found'] ? deserialize(document) : nil }
+          request = { index: index_name, body: { ids: ids } }
+          request[:type] = document_type if document_type
+          documents = client.mget(request.merge(options))
+          documents[DOCS].map do |document|
+            deserialize(document) if document[FOUND]
+          end
         end
       end
-
     end
   end
 end

data/lib/elasticsearch/persistence/repository/response/results.rb

@@ -12,6 +12,18 @@ module Elasticsearch
 
           attr_reader :repository
 
+          # The key for accessing the results in an Elasticsearch query response.
+          #
+          HITS = 'hits'.freeze
+
+          # The key for accessing the total number of hits in an Elasticsearch query response.
+          #
+          TOTAL = 'total'.freeze
+
+          # The key for accessing the maximum score in an Elasticsearch query response.
+          #
+          MAX_SCORE = 'max_score'.freeze
+
           # @param repository [Elasticsearch::Persistence::Repository::Class] The repository instance
           # @param response   [Hash]  The full response returned from the Elasticsearch client
           # @param options    [Hash]  Optional parameters
@@ -33,25 +45,25 @@ module Elasticsearch
           # The number of total hits for a query
           #
           def total
-            response['hits']['total']
+            response[HITS][TOTAL]
           end
 
           # The maximum score for a query
           #
           def max_score
-            response['hits']['max_score']
+            response[HITS][MAX_SCORE]
           end
 
           # Yields [object, hit] pairs to the block
           #
           def each_with_hit(&block)
-            results.zip(response['hits']['hits']).each(&block)
+            results.zip(response[HITS][HITS]).each(&block)
           end
 
           # Yields [object, hit] pairs and returns the result
           #
           def map_with_hit(&block)
-            results.zip(response['hits']['hits']).map(&block)
+            results.zip(response[HITS][HITS]).map(&block)
           end
 
           # Return the collection of domain objects
@@ -64,7 +76,7 @@ module Elasticsearch
           # @return [Array]
           #
           def results
-            @results ||= response['hits']['hits'].map do |document|
+            @results ||= response[HITS][HITS].map do |document|
               repository.deserialize(document.to_hash)
             end
           end

data/lib/elasticsearch/persistence/repository/search.rb

@@ -37,10 +37,13 @@ module Elasticsearch
         #     # GET http://localhost:9200/notes/note/_search
         #     # > {"query":{"match":{"title":"fox dog"}},"size":25}
         #
+        # @param [ Hash, String ] query_or_definition The query or search definition.
+        # @param [ Hash ] options The search options.
+        #
         # @return [Elasticsearch::Persistence::Repository::Response::Results]
         #
         def search(query_or_definition, options={})
-          type = document_type || (klass ? __get_type_from_class(klass) : nil  )
+          type = document_type
 
           case
           when query_or_definition.respond_to?(:to_hash)
@@ -71,11 +74,14 @@ module Elasticsearch
         #    repository.search(query: { match: { title: 'fox dog' } })
         #    # => 1
         #
+        # @param [ Hash, String ] query_or_definition The query or search definition.
+        # @param [ Hash ] options The search options.
+        #
         # @return [Integer]
         #
         def count(query_or_definition=nil, options={})
           query_or_definition ||= { query: { match_all: {} } }
-          type = document_type || (klass ? __get_type_from_class(klass) : nil  )
+          type = document_type
 
           case
           when query_or_definition.respond_to?(:to_hash)
@@ -86,10 +92,15 @@ module Elasticsearch
             raise ArgumentError, "[!] Pass the search definition as a Hash-like object or pass the query as a String, not as [#{query_or_definition.class}]"
           end
 
-          response['count']
+          response[COUNT]
         end
-      end
 
+        private
+
+        # The key for accessing the count in a Elasticsearch query response.
+        #
+        COUNT = 'count'.freeze
+      end
     end
   end
 end

data/lib/elasticsearch/persistence/repository/serialize.rb

@@ -2,30 +2,88 @@ module Elasticsearch
   module Persistence
     module Repository
 
-      # Provide serialization and deserialization between Ruby objects and Elasticsearch documents
+      # Provide serialization and deserialization between Ruby objects and Elasticsearch documents.
       #
       # Override these methods in your repository class to customize the logic.
       #
       module Serialize
 
-        # Serialize the object for storing it in Elasticsearch
+        # Serialize the object for storing it in Elasticsearch.
         #
         # In the default implementation, call the `to_hash` method on the passed object.
         #
+        # @param [ Object ] document The Ruby object to serialize.
+        #
+        # @return [ Hash ] The serialized document.
+        #
         def serialize(document)
           document.to_hash
         end
 
-        # Deserialize the document retrieved from Elasticsearch into a Ruby object
+        # Deserialize the document retrieved from Elasticsearch into a Ruby object.
+        # If no klass is set for the Repository then the raw document '_source' field will be returned.
+        #
+        # def deserialize(document)
+        #   Note.new document[SOURCE]
+        # end
         #
-        # Use the `klass` property, if defined, otherwise try to get the class from the document's `_type`.
+        # @param [ Hash ] document The raw document.
+        #
+        # @return [ Object ] The deserialized object.
         #
         def deserialize(document)
-          _klass = klass || __get_klass_from_type(document['_type'])
-          _klass.new document['_source']
+          klass ? klass.new(document[SOURCE]) : document[SOURCE]
         end
-      end
 
+        private
+
+        # The key for document fields in an Elasticsearch query response.
+        #
+        SOURCE = '_source'.freeze
+
+        # The key for the document type in an Elasticsearch query response.
+        #   Note that it will be removed eventually, as multiple types in a single
+        #   index are deprecated as of Elasticsearch 6.0.
+        #
+        TYPE = '_type'.freeze
+
+        IDS = [:id, 'id', :_id, '_id'].freeze
+
+        # Get a document ID from the document (assuming Hash or Hash-like object)
+        #
+        # @example
+        #     repository.__get_id_from_document title: 'Test', id: 'abc123'
+        #     => "abc123"
+        #
+        # @api private
+        #
+        def __get_id_from_document(document)
+          document[IDS.find { |id| document[id] }]
+        end
+
+        # Extract a document ID from the document (assuming Hash or Hash-like object)
+        #
+        # @note Calling this method will *remove* the `id` or `_id` key from the passed object.
+        #
+        # @example
+        #     options = { title: 'Test', id: 'abc123' }
+        #     repository.__extract_id_from_document options
+        #     # => "abc123"
+        #     options
+        #     # => { title: 'Test' }
+        #
+        # @api private
+        #
+        def __extract_id_from_document(document)
+          IDS.inject(nil) do |deleted, id|
+            if document[id]
+              document.delete(id)
+            else
+              deleted
+            end
+          end
+        end
+      end
     end
   end
 end

data/lib/elasticsearch/persistence/repository/store.rb

@@ -12,13 +12,19 @@ module Elasticsearch
         #     repository.save(myobject)
         #     => {"_index"=>"...", "_type"=>"...", "_id"=>"...", "_version"=>1, "created"=>true}
         #
-        # @return {Hash} The response from Elasticsearch
+        # @param [ Object ] document The document to save into Elasticsearch.
+        # @param [ Hash ] options The save request options.
+        #
+        # @return [ Hash ] The response from Elasticsearch
         #
         def save(document, options={})
           serialized = serialize(document)
-          id   = __get_id_from_document(serialized)
-          type = document_type || __get_type_from_class(klass || document.class)
-          client.index( { index: index_name, type: type, id: id, body: serialized }.merge(options) )
+          id = __get_id_from_document(serialized)
+          request = { index: index_name,
+                      id: id,
+                      body: serialized }
+          request[:type] = document_type if document_type
+          client.index(request.merge(options))
         end
 
         # Update the serialized object in Elasticsearch with partial data or script
@@ -33,39 +39,27 @@ module Elasticsearch
         #     repository.update 1, script: 'ctx._source.views += 1'
         #     # => {"_index"=>"...", "_type"=>"...", "_id"=>"1", "_version"=>3}
         #
-        # @return {Hash} The response from Elasticsearch
+        # @param [ Object ] document_or_id The document to update or the id of the document to update.
+        # @param [ Hash ] options The update request options.
         #
-        def update(document, options={})
-          case
-            when document.is_a?(String) || document.is_a?(Integer)
-              id = document
-            when document.respond_to?(:to_hash)
-              serialized = document.to_hash
-              id = __extract_id_from_document(serialized)
-            else
-              raise ArgumentError, "Expected a document ID or a Hash-like object, #{document.class} given"
-          end
-
-          type = options.delete(:type) || \
-                 (defined?(serialized) && serialized && serialized.delete(:type)) || \
-                 document_type || \
-                 __get_type_from_class(klass)
-
-          if defined?(serialized) && serialized
-            body = if serialized[:script]
-                       serialized.select { |k, v| [:script, :params, :upsert].include? k }
-                     else
-                       { doc: serialized }
-                   end
+        # @return [ Hash ] The response from Elasticsearch
+        #
+        def update(document_or_id, options = {})
+          if document_or_id.is_a?(String) || document_or_id.is_a?(Integer)
+            id = document_or_id
+            body = options
+            type = document_type
           else
-            body = {}
-            body.update( doc: options.delete(:doc)) if options[:doc]
-            body.update( script: options.delete(:script)) if options[:script]
-            body.update( params: options.delete(:params)) if options[:params]
-            body.update( upsert: options.delete(:upsert)) if options[:upsert]
+            document = serialize(document_or_id)
+            id = __extract_id_from_document(document)
+            if options[:script]
+              body = options
+            else
+              body = { doc: document }.merge(options)
+            end
+            type = document.delete(:type) || document_type
           end
-
-          client.update( { index: index_name, type: type, id: id, body: body }.merge(options) )
+          client.update(index: index_name, id: id, type: type, body: body)
         end
 
         # Remove the serialized object or document with specified ID from Elasticsearch
@@ -75,21 +69,21 @@ module Elasticsearch
         #     repository.delete(1)
         #     # => {"_index"=>"...", "_type"=>"...", "_id"=>"1", "_version"=>4}
         #
-        # @return {Hash} The response from Elasticsearch
+        # @param [ Object ] document_or_id The document to delete or the id of the document to delete.
+        # @param [ Hash ] options The delete request options.
         #
-        def delete(document, options={})
-          if document.is_a?(String) || document.is_a?(Integer)
-            id   = document
-            type = document_type || __get_type_from_class(klass)
+        # @return [ Hash ] The response from Elasticsearch
+        #
+        def delete(document_or_id, options = {})
+          if document_or_id.is_a?(String) || document_or_id.is_a?(Integer)
+            id = document_or_id
           else
-            serialized = serialize(document)
-            id   = __get_id_from_document(serialized)
-            type = document_type || __get_type_from_class(klass || document.class)
+            serialized = serialize(document_or_id)
+            id = __get_id_from_document(serialized)
           end
-          client.delete( { index: index_name, type: type, id: id }.merge(options) )
+          client.delete({ index: index_name, type: document_type, id: id }.merge(options))
         end
       end
-
     end
   end
 end