esse 0.0.2

data/lib/esse/index/descendants.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Esse
+  class Index
+    module ClassMethods
+      def descendants # :nodoc:
+        descendants = []
+        ObjectSpace.each_object(singleton_class) do |k|
+          descendants.unshift k unless k == self
+        end
+        descendants.uniq
+      end
+    end
+
+    extend ClassMethods
+  end
+end

data/lib/esse/index/inheritance.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Esse
+  class Index
+    module ClassMethods
+      # Set this to +true+ if this is an abstract class
+      attr_accessor :abstract_class
+
+      def abstract_class?
+        return @abstract_class == true if defined?(@abstract_class)
+
+        !index_name?
+      end
+    end
+
+    extend ClassMethods
+  end
+end

data/lib/esse/index/mappings.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# The es 7.6 deprecate the mapping definition under the type level. That's why we have option
+# to define mappings under both Type and Index. If the index mapping is defined. All the Type
+# mapping will be ignored.
+# Source: https://www.elastic.co/guide/en/elasticsearch/reference/7.6/removal-of-types.html
+module Esse
+  class Index
+    module ClassMethods
+      MAPPING_ROOT_KEY = 'mappings'
+
+      # This is the actually content that will be passed through the ES api
+      def mappings_hash
+        { 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)
+        return unless block_given?
+
+        @mapping.define_singleton_method(:as_json, &block)
+      end
+
+      private
+
+      def mapping
+        @mapping ||= Esse::IndexMapping.new(paths: template_dirs)
+      end
+
+      def index_mapping
+        return if mapping.empty?
+
+        hash = mapping.body
+        hash.key?(MAPPING_ROOT_KEY) ? hash[MAPPING_ROOT_KEY] : hash
+      end
+
+      def type_mapping
+        return {} if type_hash.empty?
+
+        type_hash.values.map(&:mappings_hash).reduce(&:merge)
+      end
+    end
+
+    extend ClassMethods
+  end
+end

data/lib/esse/index/naming.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Esse
+  class Index
+    module ClassMethods
+      TEMPLATE_DIRS = [
+        '%<dirname>s/templates',
+        '%<dirname>s'
+      ].freeze
+
+      def index_name=(value)
+        @index_name = index_prefixed_name(value)
+      end
+
+      def index_name
+        @index_name || index_prefixed_name(normalized_name)
+      end
+
+      def index_name?
+        !index_name.nil?
+      end
+
+      def index_version=(value)
+        @index_version = Hstring.new(value.to_s).underscore.presence
+      end
+
+      def index_version
+        @index_version
+      end
+
+      def uname
+        Hstring.new(name).underscore.presence
+      end
+
+      def index_directory
+        return unless uname
+        return if uname == 'Esse::Index'
+
+        Esse.config.indices_directory.join(uname).to_s
+      end
+
+      def template_dirs
+        return [] unless index_directory
+
+        TEMPLATE_DIRS.map { |term| format(term, dirname: index_directory) }
+      end
+
+      protected
+
+      def index_prefixed_name(value)
+        return if value == '' || value.nil?
+        return value.to_s unless cluster.index_prefix
+
+        [cluster.index_prefix, value].join('_')
+      end
+
+      def normalized_name
+        Hstring.new(name).demodulize.underscore.sub(/_(index)$/, '')
+      end
+    end
+
+    extend ClassMethods
+  end
+end

data/lib/esse/index/settings.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Esse
+  # https://github.com/elastic/elasticsearch-ruby/blob/master/elasticsearch-api/lib/elasticsearch/api/actions/indices/put_settings.rb
+  class Index
+    module ClassMethods
+      SETTING_ROOT_KEY = 'settings'
+
+      def settings_hash
+        hash = setting.body
+        { SETTING_ROOT_KEY => (hash.key?(SETTING_ROOT_KEY) ? hash[SETTING_ROOT_KEY] : hash) }
+      end
+
+      # Define /_settings definition by each index.
+      #
+      # +hash+: The body of the request includes the updated settings.
+      # +block+: Overwrite default :as_json from IndexSetting instance
+      #
+      # Example:
+      #
+      #   class UserIndex < Esse::Index
+      #     settings {
+      #       number_of_replicas: 4,
+      #     }
+      #   end
+      #
+      #   class UserIndex < Esse::Index
+      #     settings do
+      #       # do something to load settings..
+      #     end
+      #   end
+      def settings(hash = {}, &block)
+        @setting = Esse::IndexSetting.new(body: hash, paths: template_dirs, globals: cluster.index_settings)
+        return unless block_given?
+
+        @setting.define_singleton_method(:as_json, &block)
+      end
+
+      private
+
+      def setting
+        @setting ||= Esse::IndexSetting.new(paths: template_dirs, globals: cluster.index_settings)
+      end
+    end
+
+    extend ClassMethods
+  end
+end

data/lib/esse/index/type.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Esse
+  class Index
+    module ClassMethods
+      attr_writer :type_hash
+
+      def type_hash
+        @type_hash ||= {}
+      end
+
+      def define_type(type_name, &block)
+        type_class = Class.new(Esse::IndexType)
+
+        const_set(Hstring.new(type_name).camelize.demodulize.to_s, type_class)
+
+        index = self
+
+        type_class.send(:define_singleton_method, :index) { index }
+        type_class.send(:define_singleton_method, :type_name) { type_name.to_s }
+
+        type_class.class_eval(&block) if block
+
+        self.type_hash = type_hash.merge(type_class.type_name => type_class)
+        type_class
+      end
+    end
+
+    extend ClassMethods
+  end
+end

data/lib/esse/index_mapping.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Esse
+  class IndexMapping
+    FILENAMES = %w[mapping mappings].freeze
+
+    def initialize(body: {}, paths: [], filenames: FILENAMES)
+      @paths = Array(paths)
+      @filenames = Array(filenames)
+      @mappings = body
+    end
+
+    # This method will be overwrited when passing a block during the
+    # mapping defination
+    def as_json
+      return @mappings unless @mappings.empty?
+
+      from_template || @mappings
+    end
+
+    def body
+      as_json
+    end
+
+    def empty?
+      body.empty?
+    end
+
+    protected
+
+    def from_template
+      return if @paths.empty?
+
+      loader = Esse::TemplateLoader.new(@paths)
+      loader.read(*@filenames)
+    end
+  end
+end

data/lib/esse/index_setting.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Esse
+  # https://www.elastic.co/guide/en/elasticsearch/reference/1.7/indices.html
+  class IndexSetting
+    def initialize(body: {}, paths: [], globals: {})
+      @globals = globals || {}
+      @paths = Array(paths)
+      @settings = body
+    end
+
+    # This method will be overwrited when passing a block during the settings
+    # defination on index class.
+    #
+    # Example:
+    #   class UserIndex < Esse::Index
+    #     settings do
+    #       # do something to load settings..
+    #     end
+    #   end
+    #
+    def as_json
+      return @settings unless @settings.empty?
+
+      from_template || @settings
+    end
+
+    def body
+      @globals.merge(as_json)
+    end
+
+    protected
+
+    def from_template
+      return if @paths.empty?
+
+      loader = Esse::TemplateLoader.new(@paths)
+      loader.read('{setting,settings}')
+    end
+  end
+end

data/lib/esse/index_type.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Esse
+  class IndexType
+    require_relative 'index_type/actions'
+    require_relative 'index_type/mappings'
+    require_relative 'index_type/serializer'
+    require_relative 'index_type/backend'
+  end
+end

data/lib/esse/index_type/actions.rb

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

data/lib/esse/index_type/backend.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Esse
+  class IndexType
+    module ClassMethods
+      def backend
+        Esse::Backend::IndexType.new(self)
+      end
+    end
+
+    extend ClassMethods
+  end
+end

data/lib/esse/index_type/mappings.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Esse
+  class IndexType
+    # https://github.com/elastic/elasticsearch-ruby/blob/master/elasticsearch-api/lib/elasticsearch/api/actions/indices/put_mapping.rb
+    module ClassMethods
+      # This method is only used to define mapping
+      def mappings(hash = {}, &block)
+        @mapping = Esse::IndexMapping.new(body: hash, paths: template_dirs, filenames: mapping_filenames)
+        return unless block_given?
+
+        @mapping.define_singleton_method(:as_json, &block)
+      end
+
+      # This is the actually content that will be passed through the ES api
+      def mappings_hash
+        hash = mapping.body
+        {
+          type_name => (hash.key?('properties') ? hash : { 'properties' => hash }),
+        }
+      end
+
+      private
+
+      def mapping
+        @mapping ||= Esse::IndexMapping.new(paths: template_dirs, filenames: mapping_filenames)
+      end
+
+      def template_dirs
+        return [] unless respond_to?(:index)
+
+        index.template_dirs
+      end
+
+      def mapping_filenames
+        Esse::IndexMapping::FILENAMES.map { |str| [type_name, str].join('_') }
+      end
+    end
+
+    extend ClassMethods
+  end
+end

data/lib/esse/index_type/serializer.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Esse
+  class IndexType
+    module ClassMethods
+      # Convert ruby object to json. Arguments will be same of passed through the
+      # collection. It's allowed a block or a class with the `as_json` instance method.
+      # Example with block
+      #   serializer do |model, context = {}|
+      #     {
+      #       id: model.id,
+      #       admin: context[:is_admin],
+      #     }
+      #   end
+      # Example with serializer class
+      #   serializer UserSerializer
+      def serializer(klass = nil, &block)
+        if block_given?
+          @serializer_proc = block
+        elsif klass.is_a?(Class) && klass.instance_methods.include?(:as_json)
+          @serializer_proc = proc { |*args| klass.new(*args).as_json }
+        elsif klass.is_a?(Class) && klass.instance_methods.include?(:call)
+          @serializer_proc = proc { |*args| klass.new(*args).call }
+        else
+          msg = format('%<arg>p is not a valid serializer. The serializer should ' \
+                       'respond with `as_json` instance method.', arg: klass,)
+          raise ArgumentError, msg
+        end
+      end
+
+      def serialize(model, *args)
+        unless @serializer_proc
+          raise NotImplementedError, format('there is no serializer defined for the %<k>p index', k: to_s)
+        end
+
+        @serializer_proc.call(model, *args)
+      end
+
+      # Used to define the source of data. A block is required. And its
+      # content should yield an array of each object that should be serialized.
+      # The list of arguments will be passed throught the serializer method.
+      #
+      # Here is an example of how this should work:
+      #   collection do |conditions, &block|
+      #     User.where(conditions).find_in_batches(batch_size: 5000) do |batch|
+      #       block.call(batch, conditions)
+      #     end
+      #   end
+      def collection(&block)
+        raise(SyntaxError, 'No block given') unless block_given?
+
+        @collection_proc = block
+      end
+
+      # Used to fetch all batch of data defined on the collection model.
+      # Arguments can be anything. They will just be passed through the block.
+      # Useful when the collection depends on scope or any other conditions
+      # Example
+      #   each_batch(active: true) do |data, _opts|
+      #     puts data.size
+      #   end
+      def each_batch(*args, &block)
+        unless @collection_proc
+          raise NotImplementedError, format('there is no collection defined for the %<k>p index', k: to_s)
+        end
+
+        @collection_proc.call(*args, &block)
+      rescue LocalJumpError
+        raise(SyntaxError, 'block must be explicitly declared in the collection definition')
+      end
+
+      # Wrap collection data into serialized batches
+      #
+      # @param [*Object] Any argument is allowed here. The collection will be called with same arguments.
+      #   And the serializer will be initialized with those arguments too.
+      # @yield [Array, *Object] serialized collection and method arguments
+      def each_serialized_batch(*args, &block)
+        each_batch(*args) do |batch, *serializer_args|
+          entries = batch.map { |entry| serialize(entry, *serializer_args) }.compact
+          block.call(entries, *args)
+        end
+      end
+    end
+
+    extend ClassMethods
+  end
+end