Class: Chewy::Index::Adapter::Object

Inherits:
Base
  • Object
show all
Defined in:
lib/chewy/index/adapter/object.rb

Overview

This adapter provides an ability to import documents from any source. You can actually use any class or even a symbol as a target.

In case if a class is used - some of the additional features are available: it is possible to provide the default import data (used on reset) and source objects loading logic.

See Also:

Constant Summary

Constants inherited from Base

Base::BATCH_SIZE

Instance Attribute Summary

Attributes inherited from Base

#options, #target

Instance Method Summary collapse

Methods inherited from Base

accepts?, #type_name

Constructor Details

#initialize(target, **options) ⇒ Object

The signature of the index scope definition.

Examples:

index_scope :geoname
index_scope Geoname
index_scope -> { Geoname.all_the_places }, name: 'geoname'

Parameters:

  • target (Class, Symbol, String, Proc) —

    a source of data and everything

  • options (Hash) —

    a customizable set of options

Options Hash (**options):

  • :name (String, Symbol) —

    redefines the inferred name if necessary

  • :import_all_method (String, Symbol) —

    redefines import method name

  • :load_all_method (String, Symbol) —

    redefines batch load method name

  • :load_one_method (String, Symbol) —

    redefines per-object load method name



29
30
31
32
 
# File 'lib/chewy/index/adapter/object.rb', line 29

def initialize(target, **options)
  @target = target
  @options = options
end

Instance Method Details

#identify(collection) ⇒ Array<Object>

While for ORM adapters it returns an array of ids for the passed collection, for the object adapter it returns the collection itself.

Parameters:

  • collection (Array<Object>, Object) —

    a collection or an object

Returns:



52
53
54
 
# File 'lib/chewy/index/adapter/object.rb', line 52

def identify(collection)
  Array.wrap(collection)
end

#import(*args, &block) ⇒ true, false

This method is used internally by ‘Chewy::Index.import`.

The idea is that any object can be imported to ES if it responds to ‘#to_json` method.

If method ‘destroyed?` is defined for object (or, in case of hash object, it has `:_destroyed` or `’_destroyed’‘ key) and returns `true` or object satisfy `delete_if` option then object will be deleted from index. But in order to be destroyable, objects need to respond to `id` method or have an `id` key so ElasticSearch could know which one to delete.

If nothing is passed the method tries to call ‘import_all_method`, which is `call` by default, on target to get the default objects batch.

Examples:

class Geoname
  self < class
    def self.call
      FancyGeoAPI.all_points_collection
    end
    alias_method :import_all, :call
  end
end

# All the following variants will work:
index_scope Geoname
index_scope Geoname, import_all_method: 'import_all'
index_scope -> { FancyGeoAPI.all_points_collection }, name: 'geoname'

Parameters:

  • args (Array<#to_json>)
  • options (Hash) —

    a customizable set of options

Returns:

  • (true, false) 


88
89
90
91
 
# File 'lib/chewy/index/adapter/object.rb', line 88

def import(*args, &block)
  collection, options = import_args(*args)
  import_objects(collection, options, &block)
end

#import_fields(*args, &block) ⇒ Object

For the object adapter this method tries to fetch :id and requested fields from the passed collection or the target’s ‘import_all_method` when defined. Otherwise it tries to call the target `pluck_method`, which is configurable and `pluck` by default. The `pluck_method` have to act exactly the same way as the AR one. It returns an empty array when none of the methods are found.

Examples:

class Geoname
  self < class
    def self.pluck(*fields)
      if fields.one?
        whatever_source.map { |object| object.send(fields.first) }
      else
        whatever_source.map do |object|
          fields.map { |field| object.send(field) }
        end
      end
    end
  end
end

See Also:



116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/chewy/index/adapter/object.rb', line 116

def import_fields(*args, &block)
  return enum_for(:import_fields, *args) unless block_given?

  options = args.extract_options!
  options[:batch_size] ||= BATCH_SIZE

  if args.empty? && @target.respond_to?(pluck_method)
    @target.send(pluck_method, :id, *options[:fields]).each_slice(options[:batch_size], &block)
  elsif options[:fields].blank?
    import_references(*args, options) do |batch|
      yield batch.map { |object| object_field(object, :id) || object }
    end
  else
    import_references(*args, options) do |batch|
      batch = batch.map do |object|
        options[:fields].map { |field| object_field(object, field) }
          .unshift(object_field(object, :id) || object)
      end
      yield batch
    end
  end
end

#import_references(*args, &block) ⇒ Object

For the Object adapter returns the objects themselves in batches.

See Also:



142
143
144
145
146
147
 
# File 'lib/chewy/index/adapter/object.rb', line 142

def import_references(*args, &block)
  return enum_for(:import_references, *args) unless block_given?

  collection, options = import_args(*args)
  collection.each_slice(options[:batch_size], &block)
end

#load(ids, **options) ⇒ Array<Object>?

This method is used internally by the request DSL when the collection of ORM/ODM objects is requested.

Options usage is implemented by ‘load_all_method` and `load_one_method`.

If none of the ‘load_all_method` or `load_one_method` is implemented for the target - the method will return nil. This means that the loader will return an array `Chewy::Index` objects that actually was passed.

To use loading for objects it is obviously required to provide some meaningful ids for ES documents.

Examples:

class Geoname
  def self.load_all(wrappers, options)
    if options[:additional_data]
      wrappers.map do |wrapper|
        FancyGeoAPI.point_by_name(wrapper.name)
      end
    else
      wrappers
    end
  end
end

MyIndex.load(additional_data: true).objects

Parameters:

  • ids (Array<Hash>) —

    an array of ids from ES hits

  • options (Hash) —

    any options passed here with the request DSL ‘load` method.

Returns:



179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
 
# File 'lib/chewy/index/adapter/object.rb', line 179

def load(ids, **options)
  if target.respond_to?(load_all_method)
    if target.method(load_all_method).arity == 1
      target.send(load_all_method, ids)
    else
      target.send(load_all_method, ids, options)
    end
  elsif target.respond_to?(load_one_method)
    if target.method(load_one_method).arity == 1
      ids.map { |hit| target.send(load_one_method, hit) }
    else
      ids.map { |hit| target.send(load_one_method, hit, options) }
    end
  end
end

#name ⇒ String

Inferred from the target by default if possible.

Examples:

# defines name = Geoname
index_scope :geoname
# still defines name = Geoname
index_scope -> { Geoname.all_the_places }, name: 'geoname'

Returns:

  • (String) 


43
44
45
 
# File 'lib/chewy/index/adapter/object.rb', line 43

def name
  @name ||= (options[:name] || @target).to_s.camelize.demodulize
end