lib/preferences.rb in preferences-0.4.0 vs lib/preferences.rb in preferences-0.4.1

@@ -49,19 +49,22 @@
     # preferences are assumed to have a boolean data type, so all values will
     # be typecasted to true/false based on ActiveRecord rules.
     # 
     # Configuration options:
     # * <tt>:default</tt> - The default value for the preference. Default is nil.
+    # * <tt>:group_defaults</tt> - Defines the default values to use for various
+    #   groups.  This should map group_name -> defaults.  For ActiveRecord groups,
+    #   use the class name. 
     # 
     # == Examples
     # 
     # The example below shows the various ways to define a preference for a
     # particular model.
     # 
     #   class User < ActiveRecord::Base
     #     preference :notifications, :default => false
-    #     preference :color, :string, :default => 'red'
+    #     preference :color, :string, :default => 'red', :group_defaults => {:car => 'black'}
     #     preference :favorite_number, :integer
     #     preference :data, :any # Allows any data type to be stored
     #   end
     # 
     # All preferences are also inherited by subclasses.
@@ -150,13 +153,10 @@
     def preference(name, *args)
       unless included_modules.include?(InstanceMethods)
         class_inheritable_hash :preference_definitions
         self.preference_definitions = {}
         
-        class_inheritable_hash :default_preferences
-        self.default_preferences = {}
-        
         has_many :stored_preferences, :as => :owner, :class_name => 'Preference'
         
         after_save :update_preferences
         
         # Named scopes
@@ -169,11 +169,10 @@
       
       # Create the definition
       name = name.to_s
       definition = PreferenceDefinition.new(name, *args)
       self.preference_definitions[name] = definition
-      self.default_preferences[name] = definition.default_value
       
       # Create short-hand accessor methods, making sure that the name
       # is method-safe in terms of what characters are allowed
       name = name.gsub(/[^A-Za-z0-9_-]/, '').underscore
       
@@ -247,15 +246,16 @@
         end
         result
       end
       
       preferences.each do |(group, preference), value|
+        group_id, group_type = Preference.split_group(group)
         preference = preference.to_s
-        value = preference_definitions[preference.to_s].type_cast(value)
-        is_default = default_preferences[preference.to_s] == value
+        definition = preference_definitions[preference.to_s]
+        value = definition.type_cast(value)
+        is_default = definition.default_value(group_type) == value
         
-        group_id, group_type = Preference.split_group(group)
         table = "preferences_#{group_id}_#{group_type}_#{preference}"
         
         # Since each preference is a different record, they need their own
         # join so that the proper conditions can be set
         joins << "LEFT JOIN preferences AS #{table} ON #{table}.owner_id = #{table_name}.#{primary_key} AND " + sanitize_sql(
@@ -301,23 +301,25 @@
     # 
     #   user.preferred_color = 'red', :cars
     #   user.preferences(:cars)
     #   => {"language=>"English", "color"=>"red"}
     def preferences(group = nil)
+      preferences = preferences_group(group)
+      
       unless preferences_group_loaded?(group)
-        preferences = preferences_group(group)
-        
         group_id, group_type = Preference.split_group(group)
         find_preferences(:group_id => group_id, :group_type => group_type).each do |preference|
-          preferences[preference.name] ||= preference.value
+          preferences[preference.name] = preference.value unless preferences.include?(preference.name)
         end
         
         # Add defaults
-        preferences.reverse_merge!(self.class.default_preferences.dup)
+        preference_definitions.each do |name, definition|
+          preferences[name] = definition.default_value(group_type) unless preferences.include?(name)
+        end
       end
       
-      preferences_group(group).dup
+      preferences.dup
     end
     
     # Queries whether or not a value is present for the given preference.
     # This is dependent on how the value is type-casted.
     # 
@@ -372,10 +374,10 @@
       else
         # Grab the first preference; if it doesn't exist, use the default value
         group_id, group_type = Preference.split_group(group)
         preference = find_preferences(:name => name, :group_id => group_id, :group_type => group_type).first unless preferences_group_loaded?(group)
         
-        value = preference ? preference.value : preference_definitions[name].default_value
+        value = preference ? preference.value : preference_definitions[name].default_value(group_type)
         preferences_group(group)[name] = value
       end
       
       definition = preference_definitions[name]
       value = definition.type_cast(value) unless value.nil?