esse 0.2.0 → 0.2.3

data/lib/esse/index/indices.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Esse
+  class Index
+    module ClassMethods
+      CREATE_INDEX_RESERVED_KEYWORDS = {
+        alias: true,
+      }.freeze
+
+      # Creates index and applies mappings and settings.
+      #
+      #   UsersIndex.create_index # creates index named `<cluster.index_prefix>users<index_suffix>`
+      #
+      # @param options [Hash] Options hash
+      # @option options [Boolean] :alias Update `index_name` alias along with the new index
+      # @option options [String] :suffix The index suffix. Defaults to the `IndexClass#index_suffix` or
+      #   `Esse.timestamp`. Suffixed index names might be used for zero-downtime mapping change.
+      # @option arguments [String] :wait_for_active_shards Set the number of active shards
+      #    to wait for before the operation returns.
+      # @option arguments [Time] :timeout Explicit operation timeout
+      # @option arguments [Time] :master_timeout Specify timeout for connection to master
+      # @option arguments [Hash] :headers Custom HTTP headers
+      # @option arguments [Hash] :body The configuration for the index (`settings` and `mappings`)
+      # @raise [Esse::Transport::NotFoundError] when index already exists
+      # @return [Hash] the elasticsearch response
+      #
+      # @see http://www.elasticsearch.org/blog/changing-mapping-with-zero-downtime/
+      # @see Esse::Transport#create_index
+      def create_index(suffix: nil, **options)
+        options = CREATE_INDEX_RESERVED_KEYWORDS.merge(options)
+        name = build_real_index_name(suffix)
+        definition = [settings_hash, mappings_hash].reduce(&:merge)
+
+        if options.delete(:alias) && name != index_name
+          definition[:aliases] = { index_name => {} }
+        end
+
+        cluster.api.create_index(index: name, body: definition, **options)
+      end
+
+      # Deletes, creates and imports data to the index. Performs zero-downtime index resetting.
+      #
+      # @option options [String, nil] :suffix The index suffix. Defaults to the index_suffix.
+      #   A uniq index name will be generated if one index already exist with the given alias.
+      # @option options [Time] :timeout Explicit operation timeout
+      # @raise [Esse::Transport::ServerError]
+      #   in case of failure
+      # @return [Hash] the elasticsearch response
+      #
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-open-close.html
+      def reset_index(suffix: index_suffix, import: true, reindex: false, **options)
+        cluster.throw_error_when_readonly!
+        existing = []
+        suffix ||= Esse.timestamp
+        suffix = Esse.timestamp while index_exist?(suffix: suffix).tap { |exist| existing << suffix if exist }
+
+        create_index(**options, suffix: suffix, alias: false)
+        if index_exist? && aliases.none?
+          cluster.api.delete_index(index: index_name)
+        end
+        if import
+          import(**options, suffix: suffix)
+        elsif reindex && (_from = indices_pointing_to_alias).any?
+          # @TODO: Reindex using the reindex API
+        end
+        update_aliases(suffix: suffix)
+        existing.each { |_s| delete_index!(**options, suffix: suffix) }
+        true
+      end
+
+      # Checks the index existance. Returns true or false
+      #
+      #   UsersIndex.index_exist? #=> true
+      #
+      # @param options [Hash] Options hash
+      # @option options [String, nil] :suffix The index suffix
+      # @see Esse::Transport#index_exist?
+      def index_exist?(suffix: nil)
+        cluster.api.index_exist?(index: index_name(suffix: suffix))
+      end
+
+      # Deletes an existing index.
+      #
+      #   UsersIndex.delete_index # deletes `<cluster.index_prefix>users<index_suffix>` index
+      #
+      # @param suffix [String, nil] The index suffix Use nil if you want to delete the current index.
+      # @raise [Esse::Transport::NotFoundError] when index does not exists
+      # @return [Hash] elasticsearch response
+      def delete_index(suffix: nil, **options)
+        index = suffix ? index_name(suffix: suffix) : indices_pointing_to_alias.first
+        index ||= index_name
+        cluster.api.delete_index(**options, index: index)
+      end
+
+      # Open a previously closed index
+      #
+      # @option options [String, nil] :suffix The index suffix
+      # @see Esse::Transport#open
+      def open(suffix: nil, **options)
+        cluster.api.open(index: index_name(suffix: suffix), **options)
+      end
+
+      # Close an index (keep the data on disk, but deny operations with the index).
+      #
+      # @option options [String, nil] :suffix The index suffix
+      # @see Esse::Transport#close
+      def close(suffix: nil, **options)
+        cluster.api.close(index: index_name(suffix: suffix), **options)
+      end
+
+      # Performs the refresh operation in one or more indices.
+      #
+      # @note The refresh operation can adversely affect indexing throughput when used too frequently.
+      # @param :suffix [String, nil] :suffix The index suffix
+      # @see Esse::Transport#refresh
+      def refresh(suffix: nil, **options)
+        cluster.api.refresh(index: index_name(suffix: suffix), **options)
+      end
+
+      # Updates index mappings
+      #
+      # @param :suffix [String, nil] :suffix The index suffix
+      # @see Esse::Transport#update_mapping
+      def update_mapping(suffix: nil, **options)
+        body = mappings_hash.fetch(Esse::MAPPING_ROOT_KEY)
+        if (type = options[:type])
+          # Elasticsearch <= 5.x should submit request with type both in the path and in the body
+          # Elasticsearch 6.x should submit request with type in the path but not in the body
+          # Elasticsearch >= 7.x does not support type in the mapping
+          body = body[type.to_s] || body[type.to_sym] || body
+        end
+        cluster.api.update_mapping(index: index_name(suffix: suffix), body: body, **options)
+      end
+
+      # Updates index settings
+      #
+      # @param :suffix [String, nil] :suffix The index suffix
+      # @see Esse::Transport#update_settings
+      def update_settings(suffix: nil, **options)
+        response = nil
+
+        settings = HashUtils.deep_transform_keys(settings_hash.fetch(Esse::SETTING_ROOT_KEY), &:to_s)
+        if options[:body]
+          settings = settings.merge(HashUtils.deep_transform_keys(options.delete(:body), &:to_s))
+        end
+        settings.delete('number_of_shards') # Can't change number of shards for an index
+        settings['index']&.delete('number_of_shards')
+        analysis = settings.delete('analysis')
+
+        if settings.any?
+          response = cluster.api.update_settings(index: index_name(suffix: suffix), body: settings, **options)
+        end
+
+        if analysis
+          # It is also possible to define new analyzers for the index. But it is required to close the
+          # index first and open it after the changes are made.
+          close(suffix: suffix)
+          begin
+            response = cluster.api.update_settings(index: index_name(suffix: suffix), body: { analysis: analysis }, **options)
+          ensure
+            self.open(suffix: suffix)
+          end
+        end
+
+        response
+      end
+    end
+
+    extend ClassMethods
+  end
+end

data/lib/esse/index/inheritance.rb

@@ -11,6 +11,36 @@ module Esse
 
         !index_name?
       end
+
+      def inherited(subclass)
+        super
+
+        inherited_instance_variables.each do |variable_name, should_duplicate|
+          if (variable_value = instance_variable_get(variable_name)) && should_duplicate
+            value = case variable_value
+            when Hash
+              h = {}
+              variable_value.each { |k, v| h[k] = v.dup }
+              h
+            else
+              variable_value.dup
+            end
+          end
+          subclass.instance_variable_set(variable_name, value)
+        end
+      end
+
+      private
+
+      def inherited_instance_variables
+        {
+          :@repo_hash => nil,
+          :@setting => nil,
+          :@mapping => nil,
+          :@cluster_id => :dup,
+          :@plugins => :dup,
+        }
+      end
     end
 
     extend ClassMethods

data/lib/esse/index/mappings.rb

@@ -7,36 +7,23 @@
 module Esse
   class Index
     module ClassMethods
-      # This is the actually content that will be passed through the ES api
-      def mappings_hash
-        { Esse::MAPPING_ROOT_KEY => (index_mapping || type_mapping) }
-      end
-
       # This method is only used to define mapping
       def mappings(hash = {}, &block)
-        @mapping = Esse::IndexMapping.new(body: hash, paths: template_dirs)
+        @mapping = Esse::IndexMapping.new(body: hash, paths: template_dirs, globals: -> { cluster.mappings })
         return unless block
 
         @mapping.define_singleton_method(:to_h, &block)
       end
 
-      private
-
-      def mapping
-        @mapping ||= Esse::IndexMapping.new(paths: template_dirs)
-      end
-
-      def index_mapping
-        return if mapping.empty?
-
+      def mappings_hash
         hash = mapping.body
-        hash.key?(Esse::MAPPING_ROOT_KEY) ? hash[Esse::MAPPING_ROOT_KEY] : hash
+        { Esse::MAPPING_ROOT_KEY => (hash.key?(Esse::MAPPING_ROOT_KEY) ? hash[Esse::MAPPING_ROOT_KEY] : hash) }
       end
 
-      def type_mapping
-        return {} if type_hash.empty?
+      private
 
-        type_hash.values.map(&:mappings_hash).reduce(&:merge)
+      def mapping
+        @mapping ||= Esse::IndexMapping.new(paths: template_dirs, globals: -> { cluster.mappings })
       end
     end
 

data/lib/esse/index/object_document_mapper.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Esse
+  class Index
+    module ObjectDocumentMapper
+      # Wrap collection data into serialized batches
+      #
+      # @param [String, NilClass] repo_name The repository identifier
+      # @param [Hash] kwargs The context
+      # @return [Enumerator] The enumerator
+      # @yield [Array, **context] serialized collection and the optional context from the collection
+      def each_serialized_batch(repo_name = nil, **kwargs, &block)
+        (repo_name ? [repo(repo_name)] : repo_hash.values).each do |repo|
+          repo.each_serialized_batch(**kwargs, &block)
+        end
+      end
+
+      # Wrap collection data into serialized documents
+      #
+      # Example:
+      #    GeosIndex.documents(id: 1).first
+      #
+      # @param [String, NilClass] repo_name The repository identifier
+      # @return [Enumerator] All serialized entries
+      def documents(repo_name = nil, **kwargs)
+        Enumerator.new do |yielder|
+          each_serialized_batch(repo_name, **kwargs) do |documents, **_collection_kargs|
+            documents.each { |document| yielder.yield(document) }
+          end
+        end
+      end
+    end
+
+    extend ObjectDocumentMapper
+  end
+end

data/lib/esse/index/plugins.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Esse
+  class Index
+    module ClassMethods
+      attr_reader :plugins
+
+      def plugin(plugin, **kwargs, &block)
+        mod = plugin.is_a?(Module) ? plugin : load_plugin_module(plugin)
+
+        unless @plugins.include?(mod)
+          @plugins << mod
+          mod.apply(self, **kwargs, &block) if mod.respond_to?(:apply)
+          extend(mod::IndexClassMethods) if mod.const_defined?(:IndexClassMethods, false)
+          if mod.const_defined?(:RepositoryClassMethods, false)
+            repo_hash.each_value.each { |repo| repository_plugin_extend(repo, mod::RepositoryClassMethods) }
+          end
+        end
+
+        mod.configure(self, **kwargs, &block) if mod.respond_to?(:configure)
+      end
+
+      private
+
+      def repository_plugin_extend(repo_class, mod)
+        return if repo_class.singleton_class.included_modules.include?(mod)
+
+        repo_class.extend(mod)
+      end
+
+      def load_plugin_module(name)
+        module_name = Hstring.new(name)
+        unless Esse::Plugins.const_defined?(module_name.camelize.to_s, false)
+          require "esse/plugins/#{module_name.underscore}"
+        end
+        Esse::Plugins.const_get(module_name.camelize.to_s)
+      end
+    end
+
+    extend ClassMethods
+  end
+end

data/lib/esse/index/search.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Esse
+  class Index
+    module ClassMethods
+      # @param query_or_payload [String,Hash] The search request definition or query in the Lucene query string syntax
+      # @param kwargs [Hash] The options to pass to the search.
+      def search(*args, &block)
+        query_or_payload = args.shift
+        kwargs = args.last.is_a?(Hash) ? args.pop : {}
+
+        if query_or_payload.respond_to?(:to_hash) && (hash = query_or_payload.to_hash) && (hash.key?(:body) || hash.key?('body') || hash.key?(:q) || hash.key?('q'))
+          kwargs.merge!(hash.transform_keys(&:to_sym))
+        elsif query_or_payload.respond_to?(:to_hash)
+          kwargs[:body] = query_or_payload.to_hash
+        elsif query_or_payload.is_a?(String) && query_or_payload =~ /^\s*{/
+          kwargs[:body] = MultiJson.load(query_or_payload)
+        elsif query_or_payload.is_a?(String)
+          kwargs[:q] = query_or_payload
+        end
+        cluster.search(self, **kwargs, &block)
+      end
+    end
+
+    extend ClassMethods
+  end
+end

data/lib/esse/index/settings.rb

@@ -28,7 +28,7 @@ module Esse
       #     end
       #   end
       def settings(hash = {}, &block)
-        @setting = Esse::IndexSetting.new(body: hash, paths: template_dirs, globals: -> { cluster.index_settings })
+        @setting = Esse::IndexSetting.new(body: hash, paths: template_dirs, globals: -> { cluster.settings })
         return unless block
 
         @setting.define_singleton_method(:to_h, &block)
@@ -37,7 +37,7 @@ module Esse
       private
 
       def setting
-        @setting ||= Esse::IndexSetting.new(paths: template_dirs, globals: -> { cluster.index_settings })
+        @setting ||= Esse::IndexSetting.new(paths: template_dirs, globals: -> { cluster.settings })
       end
     end
 

data/lib/esse/index/type.rb

@@ -3,26 +3,66 @@
 module Esse
   class Index
     module ClassMethods
-      attr_writer :type_hash
+      attr_writer :repo_hash
 
-      def type_hash
-        @type_hash ||= {}
+      def repo_hash
+        @repo_hash ||= {}
       end
 
-      def define_type(type_name, &block)
-        type_class = Class.new(Esse::IndexType)
+      def repo(name = nil)
+        if name.nil? && repo_hash.size == 1
+          name = repo_hash.keys.first
+        elsif name.nil? && repo_hash.size > 1
+          raise ArgumentError, "You can only call `repo' with a name when there is only one type defined."
+        end
+        name ||= DEFAULT_REPO_NAME
 
-        const_set(Hstring.new(type_name).camelize.demodulize.to_s, type_class)
+        repo_hash.fetch(name.to_s)
+      rescue KeyError
+        raise ArgumentError, <<~MSG
+          No repo named "#{name}" found. Use the `repository' method to define one:
+
+            repository :#{name} do
+              # collection ...
+              # document ...
+            end
+        MSG
+      end
+
+      def repo?(name = nil)
+        return repo_hash.size > 0 if name.nil?
+
+        repo_hash.key?(name.to_s)
+      end
+
+      def repository(repo_name, *_args, **kwargs, &block)
+        repo_class = Class.new(Esse::Repository)
+        kwargs[:const] = true unless kwargs.key?(:const) # TODO Change this to false to avoid collisions with application classes
+        kwargs[:lazy_evaluate] ||= false
+
+        if kwargs[:const]
+          const_set(Hstring.new(repo_name).camelize.demodulize.to_s, repo_class)
+        end
 
         index = self
 
-        type_class.send(:define_singleton_method, :index) { index }
-        type_class.send(:define_singleton_method, :type_name) { type_name.to_s }
+        repo_class.send(:define_singleton_method, :index) { index }
+        repo_class.send(:define_singleton_method, :repo_name) { repo_name.to_s }
+
+        plugins.each do |mod|
+          next unless mod.const_defined?(:RepositoryClassMethods, false)
+
+          repository_plugin_extend(repo_class, mod::RepositoryClassMethods)
+        end
+
+        if kwargs[:lazy_evaluate]
 
-        type_class.class_eval(&block) if block
+        elsif block
+          repo_class.class_eval(&block)
+        end
 
-        self.type_hash = type_hash.merge(type_class.type_name => type_class)
-        type_class
+        self.repo_hash = repo_hash.merge(repo_class.repo_name => repo_class)
+        repo_class
       end
     end
 

data/lib/esse/index.rb

@@ -1,22 +1,27 @@
 # frozen_string_literal: true
 
-require_relative 'object_document_mapper'
-
 module Esse
   class Index
+    @repo_hash = {}
+    @setting = {}
+    @mapping = {}
+    @plugins = []
+    @cluster_id = nil
+
+    require_relative 'index/plugins'
     require_relative 'index/base'
     require_relative 'index/inheritance'
     require_relative 'index/actions'
-    require_relative 'index/naming'
+    require_relative 'index/attributes'
     require_relative 'index/type'
     require_relative 'index/settings'
     require_relative 'index/mappings'
     require_relative 'index/descendants'
-    require_relative 'index/backend'
-    extend ObjectDocumentMapper
-
-    @cluster_id = nil
-
-    def_Index(::Esse)
+    require_relative 'index/object_document_mapper'
+    # Methods that use the cluster API
+    require_relative 'index/aliases'
+    require_relative 'index/indices'
+    require_relative 'index/search'
+    require_relative 'index/documents'
   end
 end

data/lib/esse/index_mapping.rb

@@ -4,10 +4,11 @@ module Esse
   class IndexMapping
     FILENAMES = %w[mapping mappings].freeze
 
-    def initialize(body: {}, paths: [], filenames: FILENAMES)
+    def initialize(body: {}, paths: [], filenames: FILENAMES, globals: nil)
       @paths = Array(paths)
       @filenames = Array(filenames)
       @mappings = body
+      @globals = globals || -> { {} }
     end
 
     # This method will be overwrited when passing a block during the
@@ -19,7 +20,14 @@ module Esse
     end
 
     def body
-      to_h
+      global = HashUtils.deep_transform_keys(@globals.call, &:to_sym)
+      local = HashUtils.deep_transform_keys(to_h.dup, &:to_sym)
+      dynamic_template = DynamicTemplate.new(global[:dynamic_templates])
+      dynamic_template.merge!(local.delete(:dynamic_templates))
+      if dynamic_template.any?
+        global[:dynamic_templates] = dynamic_template.to_a
+      end
+      HashUtils.deep_merge(global, local)
     end
 
     def empty?

data/lib/esse/index_setting.rb

@@ -30,7 +30,9 @@ module Esse
     end
 
     def body
-      HashUtils.deep_merge(@globals.call, to_h)
+      global = HashUtils.deep_transform_keys(@globals.call, &:to_sym)
+      local = HashUtils.deep_transform_keys(to_h, &:to_sym)
+      HashUtils.deep_merge(global, local)
     end
 
     protected

data/lib/esse/null_document.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Esse
+  class NullDocument < Esse::Document
+    def initialize
+      @object = nil
+      @options = {}
+    end
+
+    # @return [NilClass] the document ID
+    def id
+      nil
+    end
+
+    # @return [NilClass] the document type
+    def type
+      nil
+    end
+
+    # @return [NilClass] the document routing
+    def routing
+      nil
+    end
+
+    # @return [NilClass] the document meta
+    def meta
+      {}
+    end
+
+    # @return [NilClass] the document source
+    def source
+      nil
+    end
+  end
+end

data/lib/esse/plugins.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Esse
+  module Plugins
+    def self.inherited_instance_variables(mod, hash)
+      mod.send(:define_method, :inherited_instance_variables) do
+        super().merge!(hash)
+      end
+      mod.send(:private, :inherited_instance_variables)
+    end
+  end
+end

data/lib/esse/primitives/hstring.rb

@@ -9,7 +9,7 @@ module Esse
   class Hstring
     extend Forwardable
 
-    def_delegators :@value, :==, :eq, :to_s, :to_sym, :inspect, :sub, :capitalize
+    def_delegators :@value, :==, :eq, :to_s, :to_sym, :inspect, :sub, :capitalize, :tr
     attr_reader :value
 
     def self.def_conventional(bang_method, conv_method = nil)

data/lib/esse/{index_type → repository}/actions.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Esse
-  class IndexType
+  class Repository
     module ClassMethods
       def action(name, options = {}, &block)
       end

data/lib/esse/repository/documents.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Esse
+  class Repository
+    module ClassMethods
+      def import(**kwargs)
+        index.import(repo_name, **kwargs)
+      end
+    end
+
+    extend ClassMethods
+  end
+end