Module: Preferences::InstanceMethods

Defined in:
lib/preferences.rb

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.included(base) ⇒ Object

:nodoc:



165
166
167
168
169
 
# File 'lib/preferences.rb', line 165

def self.included(base) #:nodoc:
  base.class_eval do
    alias_method :prefs, :preferences
  end
end

Instance Method Details

#preferences(*args) ⇒ Object

Finds all preferences, including defaults, for the current record. If any custom group preferences have been stored, then this will include all default preferences within that particular group.

Examples

A user with no stored values:

user = User.find(:first)
user.preferences
=> {"language"=>"English", "color"=>nil}

A user with stored values for a particular group:

user.preferred_color = 'red', 'cars'
user.preferences
=> {"language"=>"English", "color"=>nil, "cars"=>{"language=>"English", "color"=>"red"}}

Getting preference values just for the owning record (i.e. excluding groups):

user.preferences(nil)
=> {"language"=>"English", "color"=>nil}

Getting preference values for a particular group:

user.preferences('cars')
=> {"language"=>"English", "color"=>"red"}



198
199
200
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
 
# File 'lib/preferences.rb', line 198

def preferences(*args)
  if args.empty?
    group = nil
    conditions = {}
  else
    group = args.first
    
    # Split the actual group into its different parts (id/type) in case
    # a record is passed in
    group_id, group_type = Preference.split_group(group)
    conditions = {:group_id => group_id, :group_type => group_type}
  end
  
  # Find all of the stored preferences
  stored_preferences = self.stored_preferences.find(:all, :conditions => conditions)
  
  # Hashify name -> value or group -> name -> value
  stored_preferences.inject(self.class.default_preferences.dup) do |all_preferences, preference|
    if !group && (preference_group = preference.group)
      preferences = all_preferences[preference_group] ||= self.class.default_preferences.dup
    else
      preferences = all_preferences
    end
    
    preferences[preference.name] = preference.value
    all_preferences
  end
end

#preferred(name, group = nil) ⇒ Object Also known as: prefers

Gets the actual value stored for the given preference, or the default value if nothing is present.

Examples

class User < ActiveRecord::Base
  preference :color, :string, :default => 'red'
end

user = User.create
user.preferred(:color)            # => "red"
user.preferred(:color, 'cars')    # => "red"
user.preferred(:color, Car.first) # => "red"

user.set_preference(:color, 'blue')
user.preferred(:color)            # => "blue"



269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
 
# File 'lib/preferences.rb', line 269

def preferred(name, group = nil)
  name = name.to_s
  
  if @preference_values && @preference_values[group] && @preference_values[group].include?(name)
    # Value for this group/name has been written, but not saved yet:
    # grab from the pending values
    value = @preference_values[group][name]
  else
    # Split the group being filtered
    group_id, group_type = Preference.split_group(group)
    
    # Grab the first preference; if it doesn't exist, use the default value
    preference = stored_preferences.find(:first, :conditions => {:name => name, :group_id => group_id, :group_type => group_type})
    value = preference ? preference.value : preference_definitions[name].default_value
  end
  
  value
end

#preferred?(name, group = nil) ⇒ Boolean Also known as: prefers?

Queries whether or not a value is present for the given preference. This is dependent on how the value is type-casted.

Examples

class User < ActiveRecord::Base
  preference :color, :string, :default => 'red'
end

user = User.create
user.preferred(:color)              # => "red"
user.preferred?(:color)             # => true
user.preferred?(:color, 'cars')     # => true
user.preferred?(:color, Car.first)  # => true

user.set_preference(:color, nil)
user.preferred(:color)              # => nil
user.preferred?(:color)             # => false

Returns:

  • (Boolean) 


245
246
247
248
249
250
 
# File 'lib/preferences.rb', line 245

def preferred?(name, group = nil)
  name = name.to_s
  
  value = preferred(name, group)
  preference_definitions[name].query(value)
end

#set_preference(name, value, group = nil) ⇒ Object

Sets a new value for the given preference. The actual Preference record is not created until this record is saved. In this way, preferences act exactly the same as attributes. They can be written to and validated against, but won’t actually be written to the database until the record is saved.

Examples

user = User.find(:first)
user.set_preference(:color, 'red')              # => "red"
user.save!

user.set_preference(:color, 'blue', Car.first)  # => "blue"
user.save!



303
304
305
306
307
308
309
310
311
 
# File 'lib/preferences.rb', line 303

def set_preference(name, value, group = nil)
  name = name.to_s
  
  @preference_values ||= {}
  @preference_values[group] ||= {}
  @preference_values[group][name] = value
  
  value
end