Module: ActsAsSolr::ActsMethods

Defined in:
lib/acts_as_solr/acts_methods.rb

Instance Method Summary collapse

Instance Method Details

#acts_as_solr(options = {}, solr_options = {}, &deferred_solr_configuration) ⇒ Object

declares a class as solr-searchable

options:

fields

This option can be used to specify only the fields you'd like to index. If not given, all the attributes from the class will be indexed. You can also use this option to include methods that should be indexed as fields

class Movie < ActiveRecord::Base
  acts_as_solr :fields => [:name, :description, :current_time]
  def current_time
    Time.now.to_s
  end
end

Each field passed can also be a hash with the value being a field type

class Electronic < ActiveRecord::Base
  acts_as_solr :fields => [{:price => :range_float}]
  def current_time
    Time.now
  end
end

The field types accepted are:

:float

Index the field value as a float (ie.: 12.87)

:integer

Index the field value as an integer (ie.: 31)

:boolean

Index the field value as a boolean (ie.: true/false)

:date

Index the field value as a date (ie.: Wed Nov 15 23:13:03 PST 2006)

:string

Index the field value as a text string, not applying the same indexing filters as a regular text field

:range_integer

Index the field value for integer range queries (ie.:[5 TO 20])

:range_float

Index the field value for float range queries (ie.:[14.56 TO 19.99])

Setting the field type preserves its original type when indexed

The field may also be passed with a hash value containing options

class Author < ActiveRecord::Base

acts_as_solr :fields => [{:full_name => {:type => :text, :as => :name}}]
def full_name
  self.first_name + ' ' + self.last_name
end

end

The options accepted are:

:type

Index the field using the specified type

:as

Index the field using the specified field name

additional_fields

This option takes fields to be include in the index in addition to those derived from the database. You can also use this option to include custom fields derived from methods you define. This option will be ignored if the :fields option is given. It also accepts the same field types as the option above

class Movie < ActiveRecord::Base
 acts_as_solr :additional_fields => [:current_time]
 def current_time
   Time.now.to_s
 end
end
exclude_fields

This option taks an array of fields that should be ignored from indexing:

class User < ActiveRecord::Base
  acts_as_solr :exclude_fields => [:password, :login, :credit_card_number]
end
include

This option can be used for association indexing, which means you can include any :has_one, :has_many, :belongs_to and :has_and_belongs_to_many association to be indexed:

class Category < ActiveRecord::Base
  has_many :books
  acts_as_solr :include => [:books]
end

Each association may also be specified as a hash with an option hash as a value

class Book < ActiveRecord::Base

belongs_to :author
has_many :distribution_companies
has_many :copyright_dates
has_many :media_types
acts_as_solr(
  :fields => [:name, :description],
  :include => [
    {:author => {:using => :fullname, :as => :name}},
    {:media_types => {:using => lambda{|media| type_lookup(media.id)}}}
    {:distribution_companies => {:as => :distributor, :multivalued => true}},
    {:copyright_dates => {:as => :copyright, :type => :date}}
  ]
]

The options accepted are:

:type

Index the associated objects using the specified type

:as

Index the associated objects using the specified field name

:using

Index the associated objects using the value returned by the specified method or proc. If a method symbol is supplied, it will be sent to each object to look up the value to index; if a proc is supplied, it will be called once for each object with the object as the only argument

:multivalued

Index the associated objects using one field for each object rather than joining them all into a single field

facets

This option can be used to specify the fields you'd like to index as facet fields

class Electronic < ActiveRecord::Base
  acts_as_solr :facets => [:category, :manufacturer]
end
boost

You can pass a boost (float) value that will be used to boost the document and/or a field. To specify a more boost for the document, you can either pass a block or a symbol. The block will be called with the record as an argument, a symbol will result in the according method being called:

class Electronic < ActiveRecord::Base
  acts_as_solr :fields => [{:price => {:boost => 5.0}}], :boost => 10.0
end

class Electronic < ActiveRecord::Base
  acts_as_solr :fields => [{:price => {:boost => 5.0}}], :boost => proc {|record| record.id + 120*37}
end

class Electronic < ActiveRecord::Base
  acts_as_solr :fields => [{:price => {:boost => :price_rating}}], :boost => 10.0
end
if

Only indexes the record if the condition evaluated is true. The argument has to be either a symbol, string (to be eval'ed), proc/method, or class implementing a static validation method. It behaves the same way as ActiveRecord's :if option.

class Electronic < ActiveRecord::Base
  acts_as_solr :if => proc{|record| record.is_active?}
end
offline

Assumes that your using an outside mechanism to explicitly trigger indexing records, e.g. you only want to update your index through some asynchronous mechanism. Will accept either a boolean or a block that will be evaluated before actually contacting the index for saving or destroying a document. Defaults to false. It doesn't refer to the mechanism of an offline index in general, but just to get a centralized point where you can control indexing. Note: This is only enabled for saving records. acts_as_solr doesn't always like it, if you have a different number of results coming from the database and the index. This might be rectified in another patch to support lazy loading.

class Electronic < ActiveRecord::Base
  acts_as_solr :offline => proc {|record| record.automatic_indexing_disabled?}
end
auto_commit

The commit command will be sent to Solr only if its value is set to true:

class Author < ActiveRecord::Base
  acts_as_solr :auto_commit => false
end

dynamic_attributes: Default false. When true, requires a has_many relationship to a DynamicAttribute

 (:name, :value) model. Then, all dynamic attributes will be mapped as normal attributes
in Solr, so you can filter like this: Model.find_by_solr "#{dynamic_attribute.name}:Lorem"

taggable: Default false. When true, indexes tags with field name tag. Tags are taken from taggings.tag

spatial: Default false. When true, indexes model.local.latitude and model.local.longitude as coordinates.


172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
# File 'lib/acts_as_solr/acts_methods.rb', line 172

def acts_as_solr(options={}, solr_options={}, &deferred_solr_configuration)

  $solr_indexed_models << self

  extend ClassMethods
  include InstanceMethods
  include CommonMethods
  include ParserMethods

  define_solr_configuration_methods

  acts_as_taggable_on :tags if options[:taggable]
  has_many :dynamic_attributes, :as => "dynamicable" if options[:dynamic_attributes]
  has_one :local, :as => "localizable" if options[:spatial]

  after_save    :solr_save
  after_destroy :solr_destroy

  if deferred_solr_configuration
    self.deferred_solr_configuration = deferred_solr_configuration
  else
    process_acts_as_solr(options, solr_options)
  end
end

#after_save_reindex(associations, options = {}) ⇒ Object


304
305
306
307
308
309
310
311
312
313
314
315
# File 'lib/acts_as_solr/acts_methods.rb', line 304

def after_save_reindex(associations, options = {})
  extend ActsAsSolr::CommonMethods
  Array(associations).each do |association|
    after_save do |ar|
      if options[:with] == :delayed_job
        delay(:run_at => (Date.today+1.day).to_time+4.hours).solr_batch_add_association ar, association
      else
        solr_batch_add_association ar, association
      end
    end
  end
end

#define_solr_configuration_methodsObject


201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
# File 'lib/acts_as_solr/acts_methods.rb', line 201

def define_solr_configuration_methods
  # I'd like to use cattr_accessor, but it does not support lazy loaders and delegation to the class in the instance methods.
  # TODO: Reconcile with cattr_accessor, or a more appropriate method.
  class_eval("@@configuration = nil unless defined?(@@configuration)\[email protected]@solr_configuration = nil unless defined?(@@solr_configuration)\[email protected]@deferred_solr_configuration = nil unless defined?(@@deferred_solr_configuration)\n\ndef self.configuration\nreturn @@configuration if @@configuration\nprocess_deferred_solr_configuration\[email protected]@configuration\nend\ndef configuration\nself.class.configuration\nend\ndef self.configuration=(value)\[email protected]@configuration = value\nend\ndef configuration=(value)\nself.class.configuration = value\nend\n\ndef self.solr_configuration\nreturn @@solr_configuration if @@solr_configuration\nprocess_deferred_solr_configuration\[email protected]@solr_configuration\nend\ndef solr_configuration\nself.class.solr_configuration\nend\ndef self.solr_configuration=(value)\[email protected]@solr_configuration = value\nend\ndef solr_configuration=(value)\nself.class.solr_configuration = value\nend\n\ndef self.deferred_solr_configuration\nreturn @@deferred_solr_configuration if @@deferred_solr_configuration\[email protected]@deferred_solr_configuration\nend\ndef deferred_solr_configuration\nself.class.deferred_solr_configuration\nend\ndef self.deferred_solr_configuration=(value)\[email protected]@deferred_solr_configuration = value\nend\ndef deferred_solr_configuration=(value)\nself.class.deferred_solr_configuration = value\nend\n", __FILE__, __LINE__)
end

#process_acts_as_solr(options, solr_options) ⇒ Object


197
198
199
# File 'lib/acts_as_solr/acts_methods.rb', line 197

def process_acts_as_solr(options, solr_options)
  process_solr_options(options, solr_options)
end

#process_deferred_solr_configurationObject


255
256
257
258
259
260
# File 'lib/acts_as_solr/acts_methods.rb', line 255

def process_deferred_solr_configuration
  return unless deferred_solr_configuration
  options, solr_options = deferred_solr_configuration.call
  self.deferred_solr_configuration = nil
  self.process_solr_options(options, solr_options)
end

#process_solr_options(options = {}, solr_options = {}) ⇒ Object


262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
# File 'lib/acts_as_solr/acts_methods.rb', line 262

def process_solr_options(options={}, solr_options={})
  self.configuration = {
    :fields => nil,
    :format => :objects,
    :additional_fields => nil,
    :dynamic_attributes => false,
    :exclude_fields => [],
    :auto_commit => ['production'].include?(Rails.env) ? false : true,
    :include => nil,
    :facets => nil,
    :boost => nil,
    :if => "true",
    :offline => false,
    :spatial => false,
  }
  self.solr_configuration = {
    :type_field => "type_s",
    :primary_key_field => "pk_s",
    :default_boost => 1.0,
  }

  solr_options ||= {}
  raise "Invalid options: #{(options.keys-configuration.keys).join(',')}" unless (options.keys-configuration.keys).empty?
  raise "Invalid solr options: #{(solr_options.keys-solr_configuration.keys).join(',')}" unless (solr_options.keys-solr_configuration.keys).empty?

  configuration.update(options) if options.is_a?(Hash)
  solr_configuration.update(solr_options) if solr_options.is_a?(Hash)
  Deprecation.validate_index(configuration)

  configuration[:solr_fields] = {}
  configuration[:solr_includes] = {}

  if configuration[:fields].respond_to?(:each)
    process_fields(configuration[:fields])
  else
    process_fields(self.new.attributes.keys.map { |k| k.to_sym })
    process_fields(configuration[:additional_fields])
  end

  process_includes(configuration[:include]) if configuration[:include]
end