Module: ActsAsSolr::ActsMethods

Defined in:
lib/acts_methods.rb

Instance Method Summary collapse

Instance Method Details

#acts_as_solr(options = {}, solr_options = {}) ⇒ 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



161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
 
# File 'lib/acts_methods.rb', line 161

def acts_as_solr(options={}, solr_options={})
  
  extend ClassMethods
  include InstanceMethods
  include CommonMethods
  include ParserMethods
  
  cattr_accessor :configuration
  cattr_accessor :solr_configuration
  
  self.configuration = { 
    :fields => nil,
    :additional_fields => nil,
    :exclude_fields => [],
    :auto_commit => true,
    :include => nil,
    :facets => nil,
    :boost => nil,
    :if => "true",
    :offline => false
  }  
  self.solr_configuration = {
    :type_field => "type_s",
    :primary_key_field => "pk_i",
    :default_boost => 1.0
  }
  
  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] = {}
  
  after_save    :solr_save
  after_destroy :solr_destroy

  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

  if configuration[:include].respond_to?(:each)
    process_includes(configuration[:include])
  end
  
  unless @already_solr_magic
    alias_method_chain :method_missing, :solr_magic
    @already_solr_magic = true
  end
rescue ActiveRecord::StatementInvalid  
  @acts_as_solr_needs_reload = true
end

#acts_as_solr_needs_reload? ⇒ Boolean

Returns:

  • (Boolean) 


217
218
219
 
# File 'lib/acts_methods.rb', line 217

def acts_as_solr_needs_reload?
  @acts_as_solr_needs_reload
end