chewy 0.9.0 → 5.2.0

data/lib/chewy/errors.rb

@@ -14,8 +14,8 @@ module Chewy
   class UndefinedUpdateStrategy < Error
     def initialize(_type)
       super <<-MESSAGE
-Index update strategy is undefined in current context.
-Please wrap your code with `Chewy.strategy(:strategy_name) block.`
+  Index update strategy is undefined for current context.
+  Please wrap your code with `Chewy.strategy(:strategy_name) block.`
       MESSAGE
     end
   end

data/lib/chewy/fields/base.rb

@@ -4,36 +4,65 @@ module Chewy
       attr_reader :name, :options, :value, :children
       attr_accessor :parent
 
-      def initialize(name, options = {})
+      def initialize(name, value: nil, **options)
         @name = name.to_sym
-        @options = options.deep_symbolize_keys
-        @value = @options.delete(:value)
+        @options = {}
+        update_options!(**options)
+        @value = value
         @children = []
       end
 
+      def update_options!(**options)
+        @options = options
+      end
+
       def multi_field?
         children.present? && !object_field?
       end
 
       def object_field?
-        (children.present? && options[:type].blank?) || %w(object nested).include?(options[:type].to_s)
+        (children.present? && options[:type].blank?) || %w[object nested].include?(options[:type].to_s)
       end
 
       def mappings_hash
-        mapping = if children.present?
-          { (multi_field? ? :fields : :properties) => children.map(&:mappings_hash).inject(:merge) }
-        else
-          {}
-        end
+        mapping =
+          if children.present?
+            {(multi_field? ? :fields : :properties) => children.map(&:mappings_hash).inject(:merge)}
+          else
+            {}
+          end
         mapping.reverse_merge!(options)
-        mapping.reverse_merge!(type: (children.present? ? 'object' : 'string'))
-        { name => mapping }
+        mapping.reverse_merge!(type: (children.present? ? 'object' : Chewy.default_field_type))
+
+        # This is done to support ES2 journaling and will be removed soon
+        if mapping[:type] == 'keyword' && Chewy::Runtime.version < '5.0'
+          mapping[:type] = 'string'
+          mapping[:index] = 'not_analyzed'
+        end
+
+        {name => mapping}
+      end
+
+      def compose(*objects)
+        result = evaluate(objects)
+
+        if children.present? && !multi_field?
+          result = if result.respond_to?(:to_ary)
+            result.to_ary.map { |item| compose_children(item, *objects) }
+          else
+            compose_children(result, *objects)
+          end
+        end
+
+        {name => result}
       end
 
-      def compose(object, *parent_objects)
-        objects = ([object] + parent_objects.flatten).uniq
+    private
+
+      def evaluate(objects)
+        object = objects.first
 
-        result = if value && value.is_a?(Proc)
+        if value.is_a?(Proc)
           if value.arity.zero?
             object.instance_exec(&value)
           elsif value.arity < 0
@@ -41,31 +70,27 @@ module Chewy
           else
             value.call(*objects.first(value.arity))
           end
-        elsif object.is_a?(Hash)
-          if object.key?(name)
-            object[name]
-          else
-            object[name.to_s]
-          end
         else
-          object.send(name)
-        end
+          message = value.is_a?(Symbol) || value.is_a?(String) ? value.to_sym : name
 
-        if children.present? && !multi_field?
-          result = if result.respond_to?(:to_ary)
-            result.to_ary.map { |item| compose_children(item, *objects) }
+          if object.is_a?(Hash)
+            if object.key?(message)
+              object[message]
+            else
+              object[message.to_s]
+            end
           else
-            compose_children(result, *objects)
+            object.send(message)
           end
         end
-
-        { name => result }
       end
 
-    private
-
       def compose_children(value, *parent_objects)
-        children.map { |field| field.compose(value, *parent_objects) }.compact.inject(:merge) if value
+        return unless value
+
+        children.each_with_object({}) do |field, result|
+          result.merge!(field.compose(value, *parent_objects) || {})
+        end
       end
     end
   end

data/lib/chewy/fields/root.rb

@@ -6,19 +6,18 @@ module Chewy
       attr_reader :parent
       attr_reader :parent_id
 
-      def initialize(*args)
-        super(*args)
+      def initialize(name, **options)
+        super(name, **options)
 
-        @id = @options.delete(:id) || options.delete(:_id)
-        @parent = @options.delete(:parent) || options.delete(:_parent)
-        @parent_id = @options.delete(:parent_id)
-        @value ||= ->(val) { val }
+        @value ||= -> { self }
         @dynamic_templates = []
-        @options.delete(:type)
       end
 
-      def compose(*args)
-        super.as_json
+      def update_options!(**options)
+        @id = options.fetch(:id, options.fetch(:_id, @id))
+        @parent = options.fetch(:parent, options.fetch(:_parent, @parent))
+        @parent_id = options.fetch(:parent_id, @parent_id)
+        @options.merge!(options.except(:id, :_id, :parent, :_parent, :parent_id, :type))
       end
 
       def mappings_hash
@@ -30,7 +29,7 @@ module Chewy
           mappings[name][:dynamic_templates].concat dynamic_templates
         end
 
-        mappings[name][:_parent] = parent.is_a?(Hash) ? parent : { type: parent } if parent
+        mappings[name][:_parent] = parent.is_a?(Hash) ? parent : {type: parent} if parent
         mappings
       end
 
@@ -38,7 +37,7 @@ module Chewy
         options = args.extract_options!.deep_symbolize_keys
         if args.first
           template_name = :"template_#{dynamic_templates.count.next}"
-          template = { template_name => { mapping: options } }
+          template = {template_name => {mapping: options}}
 
           template[template_name][:match_mapping_type] = args.second.to_s if args.second.present?
 
@@ -64,6 +63,40 @@ module Chewy
         return unless id
         id.arity.zero? ? object.instance_exec(&id) : id.call(object)
       end
+
+      # Converts passed object to JSON-ready hash. Used for objects import.
+      #
+      # @param object [Object] a base object for composition
+      # @param crutches [Object] any object that will be passed to every field value proc as a last argument
+      # @param fields [Array<Symbol>] a list of fields to compose, every field will be composed if empty
+      # @return [Hash] JSON-ready hash with stringified keys
+      #
+      def compose(object, crutches = nil, fields: [])
+        result = evaluate([object, crutches])
+
+        if children.present?
+          child_fields = if fields.present?
+            child_hash.slice(*fields).values
+          else
+            children
+          end
+
+          child_fields.each_with_object({}) do |field, memo|
+            memo.merge!(field.compose(result, crutches) || {})
+          end.as_json
+        elsif fields.present?
+          result.as_json(only: fields, root: false)
+        else
+          result.as_json(root: false)
+        end
+      end
+
+      # Children indexed by name as a hash.
+      #
+      # @return [Hash{Symbol => Chewy::Fields::Base}]
+      def child_hash
+        @child_hash ||= children.index_by(&:name)
+      end
     end
   end
 end

data/lib/chewy/index.rb

@@ -2,6 +2,7 @@ require 'chewy/search'
 require 'chewy/index/actions'
 require 'chewy/index/aliases'
 require 'chewy/index/settings'
+require 'chewy/index/specification'
 
 module Chewy
   class Index
@@ -17,172 +18,259 @@ module Chewy
     class_attribute :_settings
     self._settings = Chewy::Index::Settings.new
 
-    # Setups or returns ElasticSearch index name
-    #
-    #   class UsersIndex < Chewy::Index
-    #   end
-    #   UsersIndex.index_name # => 'users'
-    #
-    #   class UsersIndex < Chewy::Index
-    #     index_name 'dudes'
-    #   end
-    #   UsersIndex.index_name # => 'dudes'
-    #
-    def self.index_name(suggest = nil)
-      raise UndefinedIndex unless _index_name(suggest)
-      @index_name ||= build_index_name(_index_name, prefix: default_prefix)
-    end
+    class << self
+      # @overload index_name(suggest)
+      #   If suggested name is passed, it is set up as the new base name for
+      #   the index. Used for the index base name redefinition.
+      #
+      #   @example
+      #     class UsersIndex < Chewy::Index
+      #       index_name :legacy_users
+      #     end
+      #     UsersIndex.index_name # => 'legacy_users'
+      #
+      #   @param suggest [String, Symbol] suggested base name
+      #   @return [String] new base name
+      #
+      # @overload index_name(prefix: nil, suffix: nil)
+      #   If suggested name is not passed, returns the base name accompanied
+      #   with the prefix (if any) and suffix (if passed).
+      #
+      #   @example
+      #     class UsersIndex < Chewy::Index
+      #     end
+      #
+      #     Chewy.settings = {prefix: 'test'}
+      #     UsersIndex.index_name # => 'test_users'
+      #     UsersIndex.index_name(prefix: 'foobar') # => 'foobar_users'
+      #     UsersIndex.index_name(suffix: '2017') # => 'test_users_2017'
+      #     UsersIndex.index_name(prefix: '', suffix: '2017') # => 'users_2017'
+      #
+      #   @param prefix [String] index name prefix, uses {.prefix} method by default
+      #   @param suffix [String] index name suffix, used for creating several indexes for the same alias during the zero-downtime reset
+      #   @raise [UndefinedIndex] if the base name is blank
+      #   @return [String] result index name
+      def index_name(suggest = nil, prefix: nil, suffix: nil)
+        if suggest
+          @base_name = suggest.to_s.presence
+        else
+          [
+            prefix || prefix_with_deprecation,
+            base_name,
+            suffix
+          ].reject(&:blank?).join('_')
+        end
+      end
 
-    def self._index_name(suggest = nil)
-      if suggest
-        @_index_name = suggest
-      elsif name
-        @_index_name ||= name.sub(/Index\Z/, '').demodulize.underscore
+      # Base name for the index. Uses the default value inferred from the
+      # class name unless redefined.
+      #
+      # @example
+      #   class Namespace::UsersIndex < Chewy::Index
+      #   end
+      #   UsersIndex.index_name # => 'users'
+      #
+      #   Class.new(Chewy::Index).base_name # => raises UndefinedIndex
+      #
+      # @raise [UndefinedIndex] when the base name is blank
+      # @return [String] current base name
+      def base_name
+        @base_name ||= name.sub(/Index\z/, '').demodulize.underscore if name
+        raise UndefinedIndex if @base_name.blank?
+        @base_name
       end
-      @_index_name
-    end
 
-    def self.derivable_index_name
-      @_derivable_index_name ||= name.sub(/Index\Z/, '').underscore
-    end
+      # Similar to the {.base_name} but respects the class namespace, also,
+      # can't be redefined. Used to reference index with the string identifier
+      #
+      # @example
+      #   class Namespace::UsersIndex < Chewy::Index
+      #   end
+      #   UsersIndex.derivable_name # => 'namespace/users'
+      #
+      #   Class.new(Chewy::Index).derivable_name # => nil
+      #
+      # @return [String, nil] derivable name or nil when it is impossible to calculate
+      def derivable_name
+        @derivable_name ||= name.sub(/Index\z/, '').underscore if name
+      end
 
-    # Setups or returns pure Elasticsearch index name
-    # without any prefixes/suffixes
-    def self.default_prefix
-      Chewy.configuration[:prefix]
-    end
+      # Used as a default value for {.index_name}. Return prefix from the configuration
+      # but can be redefined per-index to be more dynamic.
+      #
+      # @example
+      #   class UsersIndex < Chewy::Index
+      #     def self.prefix
+      #       'foobar'
+      #     end
+      #   end
+      #   UsersIndex.index_name # => 'foobar_users'
+      #
+      # @return [String] prefix
+      def prefix
+        Chewy.configuration[:prefix]
+      end
+
+      # Defines type for the index. Arguments depends on adapter used. For
+      # ActiveRecord you can pass model or scope and options
+      #
+      #   class CarsIndex < Chewy::Index
+      #     define_type Car do
+      #       ...
+      #     end # defines VehiclesIndex::Car type
+      #   end
+      #
+      # Type name might be passed in complicated cases:
+      #
+      #   class VehiclesIndex < Chewy::Index
+      #     define_type Vehicle.cars.includes(:manufacturer), name: 'cars' do
+      #        ...
+      #     end # defines VehiclesIndex::Cars type
+      #
+      #     define_type Vehicle.motocycles.includes(:manufacturer), name: 'motocycles' do
+      #        ...
+      #     end # defines VehiclesIndex::Motocycles type
+      #   end
+      #
+      # For plain objects:
+      #
+      #   class PlanesIndex < Chewy::Index
+      #     define_type :plane do
+      #       ...
+      #     end # defines PlanesIndex::Plane type
+      #   end
+      #
+      # The main difference between using plain objects or ActiveRecord models for indexing
+      # is import. If you will call `CarsIndex::Car.import` - it will import all the cars
+      # automatically, while `PlanesIndex::Plane.import(my_planes)` requires import data to be
+      # passed.
+      #
+      def define_type(target, options = {}, &block)
+        type_class = Chewy.create_type(self, target, options, &block)
+        self.type_hash = type_hash.merge(type_class.type_name => type_class)
+      end
 
-    # Defines type for the index. Arguments depends on adapter used. For
-    # ActiveRecord you can pass model or scope and options
-    #
-    #   class CarsIndex < Chewy::Index
-    #     define_type Car do
-    #       ...
-    #     end # defines VehiclesIndex::Car type
-    #   end
-    #
-    # Type name might be passed in complicated cases:
-    #
-    #   class VehiclesIndex < Chewy::Index
-    #     define_type Vehicle.cars.includes(:manufacturer), name: 'cars' do
-    #        ...
-    #     end # defines VehiclesIndex::Cars type
-    #
-    #     define_type Vehicle.motocycles.includes(:manufacturer), name: 'motocycles' do
-    #        ...
-    #     end # defines VehiclesIndex::Motocycles type
-    #   end
-    #
-    # For plain objects:
-    #
-    #   class PlanesIndex < Chewy::Index
-    #     define_type :plane do
-    #       ...
-    #     end # defines PlanesIndex::Plane type
-    #   end
-    #
-    # The main difference between using plain objects or ActiveRecord models for indexing
-    # is import. If you will call `CarsIndex::Car.import` - it will import all the cars
-    # automatically, while `PlanesIndex::Plane.import(my_planes)` requires import data to be
-    # passed.
-    #
-    def self.define_type(target, options = {}, &block)
-      type_class = Chewy.create_type(self, target, options, &block)
-      self.type_hash = type_hash.merge(type_class.type_name => type_class)
-
-      return if respond_to?(type_class.type_name)
-      class_eval <<-METHOD, __FILE__, __LINE__ + 1
-        def self.#{type_class.type_name}
-          ActiveSupport::Deprecation.warn("`#{self}.#{type_class.type_name}` accessor is deprecated and will be removed soon. Use `#{type_class}` directly instead.")
-          type_hash['#{type_class.type_name}']
+      # Types method has double usage.
+      # If no arguments are passed - it returns array of defined types:
+      #
+      #   UsersIndex.types # => [UsersIndex::Admin, UsersIndex::Manager, UsersIndex::User]
+      #
+      # If arguments are passed it treats like a part of chainable query DSL and
+      # adds types array for index to select.
+      #
+      #   UsersIndex.filters { name =~ 'ro' }.types(:admin, :manager)
+      #   UsersIndex.types(:admin, :manager).filters { name =~ 'ro' } # the same as the first example
+      #
+      def types(*args)
+        if args.present?
+          all.types(*args)
+        else
+          type_hash.values
         end
-      METHOD
-    end
+      end
 
-    # Types method has double usage.
-    # If no arguments are passed - it returns array of defined types:
-    #
-    #   UsersIndex.types # => [UsersIndex::Admin, UsersIndex::Manager, UsersIndex::User]
-    #
-    # If arguments are passed it treats like a part of chainable query DSL and
-    # adds types array for index to select.
-    #
-    #   UsersIndex.filters { name =~ 'ro' }.types(:admin, :manager)
-    #   UsersIndex.types(:admin, :manager).filters { name =~ 'ro' } # the same as the first example
-    #
-    def self.types(*args)
-      if args.present?
-        all.types(*args)
-      else
-        type_hash.values
+      # Returns defined types names:
+      #
+      #   UsersIndex.type_names # => ['admin', 'manager', 'user']
+      #
+      def type_names
+        type_hash.keys
       end
-    end
 
-    # Returns defined types names:
-    #
-    #   UsersIndex.type_names # => ['admin', 'manager', 'user']
-    #
-    def self.type_names
-      type_hash.keys
-    end
+      # Returns named type:
+      #
+      #    UserIndex.type('admin') # => UsersIndex::Admin
+      #
+      def type(type_name)
+        type_hash.fetch(type_name) { raise UndefinedType, "Unknown type in #{name}: #{type_name}" }
+      end
 
-    # Returns named type:
-    #
-    #    UserIndex.type('admin') # => UsersIndex::Admin
-    #
-    def self.type(type_name)
-      type_hash.fetch(type_name) { raise UndefinedType, "Unknown type in #{name}: #{type_name}" }
-    end
+      # Used as a part of index definition DSL. Defines settings:
+      #
+      #   class UsersIndex < Chewy::Index
+      #     settings analysis: {
+      #       analyzer: {
+      #         name: {
+      #           tokenizer: 'standard',
+      #           filter: ['lowercase', 'icu_folding', 'names_nysiis']
+      #         }
+      #       }
+      #     }
+      #   end
+      #
+      # See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-update-settings.html
+      # for more details
+      #
+      # It is possible to store analyzers settings in Chewy repositories
+      # and link them form index class. See `Chewy::Index::Settings` for details.
+      #
+      def settings(params = {}, &block)
+        self._settings = Chewy::Index::Settings.new(params, &block)
+      end
 
-    # Used as a part of index definition DSL. Defines settings:
-    #
-    #   class UsersIndex < Chewy::Index
-    #     settings analysis: {
-    #       analyzer: {
-    #         name: {
-    #           tokenizer: 'standard',
-    #           filter: ['lowercase', 'icu_folding', 'names_nysiis']
-    #         }
-    #       }
-    #     }
-    #   end
-    #
-    # See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-update-settings.html
-    # for more details
-    #
-    # It is possible to store analyzers settings in Chewy repositories
-    # and link them form index class. See `Chewy::Index::Settings` for details.
-    #
-    def self.settings(params)
-      self._settings = Chewy::Index::Settings.new params
-    end
+      # Returns list of public class methods defined in current index
+      #
+      def scopes
+        public_methods - Chewy::Index.public_methods
+      end
 
-    # Returns list of public class methods defined in current index
-    #
-    def self.scopes
-      public_methods - Chewy::Index.public_methods - type_names.map(&:to_sym)
-    end
+      def settings_hash
+        _settings.to_hash
+      end
 
-    def self.journal?
-      types.any?(&:journal?)
-    end
+      def mappings_hash
+        mappings = types.map(&:mappings_hash).inject(:merge)
+        mappings.present? ? {mappings: mappings} : {}
+      end
 
-    def self.build_index_name(*args)
-      options = args.extract_options!
-      [options[:prefix], args.first || index_name, options[:suffix]].reject(&:blank?).join('_')
-    end
+      # Returns a hash containing the index settings and mappings
+      # Used for the ES index creation as body.
+      #
+      # @see Chewy::Index::Specification
+      # @return [Hash] specification as a hash
+      def specification_hash
+        [settings_hash, mappings_hash].inject(:merge)
+      end
 
-    def self.settings_hash
-      _settings.to_hash
-    end
+      def index_params
+        ActiveSupport::Deprecation.warn '`Chewy::Index.index_params` is deprecated and will be removed soon, use `Chewy::Index.specification_hash`'
+        specification_hash
+      end
 
-    def self.mappings_hash
-      mappings = types.map(&:mappings_hash).inject(:merge)
-      mappings.present? ? { mappings: mappings } : {}
-    end
+      # @see Chewy::Index::Specification
+      # @return [Chewy::Index::Specification] a specification object instance for this particular index
+      def specification
+        @specification ||= Specification.new(self)
+      end
 
-    def self.index_params
-      [settings_hash, mappings_hash].inject(:merge)
+      def derivable_index_name
+        ActiveSupport::Deprecation.warn '`Chewy::Index.derivable_index_name` is deprecated and will be removed soon, use `Chewy::Index.derivable_name` instead'
+        derivable_name
+      end
+
+      # Handling old default_prefix if it is not defined.
+      def method_missing(name, *args, &block) # rubocop:disable Style/MethodMissing
+        if name == :default_prefix
+          ActiveSupport::Deprecation.warn '`Chewy::Index.default_prefix` is deprecated and will be removed soon, use `Chewy::Index.prefix` instead'
+          prefix
+        else
+          super
+        end
+      end
+
+      def prefix_with_deprecation
+        if respond_to?(:default_prefix)
+          ActiveSupport::Deprecation.warn '`Chewy::Index.default_prefix` is deprecated and will be removed soon, define `Chewy::Index.prefix` method instead'
+          default_prefix
+        else
+          prefix
+        end
+      end
+
+      def build_index_name(*args)
+        ActiveSupport::Deprecation.warn '`Chewy::Index.build_index_name` is deprecated and will be removed soon, use `Chewy::Index.index_name` instead'
+        index_name(args.extract_options!)
+      end
     end
   end
 end