Module: Chewy::Type::Mapping::ClassMethods

Defined in:
lib/chewy/type/mapping.rb

Instance Method Summary collapse

Instance Method Details

#field(*args, &block) ⇒ Object

Defines mapping field for current type

class UsersIndex < Chewy::Index
  define_type User do
    # passing all the options to field definition:
    field :full_name, type: 'string', analyzer: 'special'
  end
end

The type is optional and defaults to string if not defined:

field :full_name

Also, multiple fields might be defined with one call and with the same options:

field :first_name, :last_name, analyzer: 'special'

The only special option in the field definition is :value. If no :value specified then just corresponding method will be called for the indexed object. Also :value might be a proc or indexed object method name:

class User < ActiveRecord::Base
  def user_full_name
    [first_name, last_name].join(' ')
  end
end

field :full_name, type: 'string', value: :user_full_name

The proc evaluates inside the indexed object context if its arity is 0 and in present contexts if there is an argument:

field :full_name, type: 'string', value: -> { [first_name, last_name].join(' ') }

separator = ' '
field :full_name, type: 'string', value: ->(user) { [user.first_name, user.last_name].join(separator) }

If array was returned as value - it will be put in index as well.

field :tags, type: 'string', value: -> { tags.map(&:name) }

Fields supports nesting in case of object field type. If user.quiz will return an array of objects, then result index content will be an array of hashes, if user.quiz is not a collection association then just values hash will be put in the index.

field :quiz do
  field :question, :answer
  field :score, type: 'integer'
end

Nested fields are composed from nested objects:

field :name, value: -> { name_translations } do
  field :ru, value: ->(name) { name['ru'] }
  field :en, value: ->(name) { name['en'] }
end

Off course it is possible to define object fields contents dynamically but make sure evaluation proc returns hash:

field :name, type: 'object', value: -> { name_translations }

The special case is multi_field. If type options and block are both present field is treated as a multi-field. In that case field composition changes satisfy elasticsearch rules:

field :full_name, type: 'string', analyzer: 'name', value: ->{ full_name.try(:strip) } do
  field :sorted, analyzer: 'sorted'
end



110
111
112
113
114
115
116
117
118
119
 
# File 'lib/chewy/type/mapping.rb', line 110

def field *args, &block
  options = args.extract_options!
  build_root unless root_object

  if args.size > 1
    args.map { |name| field(name, options) }
  else
    expand_nested(Chewy::Fields::Base.new(args.first, options), &block)
  end
end

#mappings_hash ⇒ Object

Returns compiled mappings hash for current type



150
151
152
 
# File 'lib/chewy/type/mapping.rb', line 150

def mappings_hash
  root_object ? root_object.mappings_hash : {}
end

#root(options = {}, &block) ⇒ Object

Defines root object for mapping and is optional for type definition. Use it only if you need to pass options for root object mapping, such as date_detection or dynamic_date_formats

class UsersIndex < Chewy::Index
  define_type User do
    # root object defined implicitly and optionless for current type
    field :full_name, type: 'string'
  end
end

class CarsIndex < Chewy::Index
  define_type Car do
    # explicit root definition with additional options
    root dynamic_date_formats: ['yyyy-MM-dd'] do
      field :model_name, type: 'string'
    end
  end
end



32
33
34
35
 
# File 'lib/chewy/type/mapping.rb', line 32

def root options = {}, &block
  raise "Root is already defined" if root_object
  build_root(options, &block)
end

#template(*args) ⇒ Object Also known as: dynamic_template

Defines dynamic template in mapping root objests

class CarsIndex < Chewy::Index
  define_type Car do
    template 'model.*', type: 'string', analyzer: 'special'
    field 'model', type: 'object' # here we can put { ru: 'Мерседес', en: 'Mercedes' }
                                  # and template will be applyed to this field
  end
end

Name for each template is generated with the following rule: “template_#+ 1”.

template 'tit*', mapping_hash
template 'title.*', mapping_hash # dot in template causes "path_match" using
template /tit.+/, mapping_hash # using "match_pattern": "regexp"
template /title\..+/, mapping_hash # "\." - escaped dot causes "path_match" using
template /tit.+/, 'string', mapping_hash # "match_mapping_type" as the optionsl second argument
template template42: {match: 'hello*', mapping: {type: 'object'}} # or even pass a template as is



141
142
143
144
145
 
# File 'lib/chewy/type/mapping.rb', line 141

def template *args
  build_root unless root_object

  root_object.dynamic_template *args
end