mongomodel 0.5.5 → 0.5.6

data/lib/mongomodel/concerns/attribute_methods.rb

@@ -1,9 +1,9 @@
 module MongoModel
   module AttributeMethods
     extend ActiveSupport::Concern
-    
+
     include ActiveModel::AttributeMethods
-    
+
     module ClassMethods
       # Generates all the attribute related methods for defined properties
       # accessors, mutators and query methods.
@@ -13,22 +13,22 @@ module MongoModel
         super(properties.keys)
         @attribute_methods_generated = true
       end
-      
+
       def attribute_methods_generated?
         @attribute_methods_generated ||= false
       end
-      
+
       def undefine_attribute_methods(*args)
         super
         @attribute_methods_generated = false
       end
-      
+
       def property(*args)
         property = super
         undefine_attribute_methods
         property
       end
-    
+
     protected
       def instance_method_already_implemented?(method_name)
         method_defined?(method_name) ||
@@ -36,7 +36,7 @@ module MongoModel
           super
       end
     end
-    
+
     def method_missing(method, *args, &block)
       unless self.class.attribute_methods_generated?
         self.class.define_attribute_methods
@@ -50,19 +50,19 @@ module MongoModel
         super
       end
     end
-    
+
     def respond_to?(*args)
       self.class.define_attribute_methods unless self.class.attribute_methods_generated?
       super
     end
-    
+
     def clone_attribute_value(attribute_name)
       value = read_attribute(attribute_name)
       value.duplicable? ? value.clone : value
     rescue TypeError, NoMethodError
       value
     end
-    
+
   protected
     def attribute_method?(attr_name)
       properties.has_key?(attr_name)

data/lib/mongomodel/concerns/attribute_methods/before_type_cast.rb

@@ -2,16 +2,16 @@ module MongoModel
   module AttributeMethods
     module BeforeTypeCast
       extend ActiveSupport::Concern
-      
+
       included do
         attribute_method_suffix "_before_type_cast"
       end
-      
+
       # Returns an attribute value before typecasting.
       def read_attribute_before_type_cast(name)
         attributes.before_type_cast(name.to_sym)
       end
-      
+
       # Returns a hash of attributes before typecasting.
       def attributes_before_type_cast
         attributes.keys.inject({}) do |result, key|
@@ -19,7 +19,7 @@ module MongoModel
           result
         end
       end
-      
+
     private
       def attribute_before_type_cast(attribute_name)
         read_attribute_before_type_cast(attribute_name)

data/lib/mongomodel/concerns/attribute_methods/dirty.rb

@@ -2,17 +2,62 @@ module MongoModel
   module AttributeMethods
     module Dirty
       extend ActiveSupport::Concern
-      
-      include ActiveModel::Dirty
-      
+
+      include ActiveModel::AttributeMethods
+
+      OPTION_NOT_GIVEN = Object.new
+      private_constant :OPTION_NOT_GIVEN
+
       included do
+        attribute_method_suffix "_changed?", "_change", "_will_change!", "_was"
+        attribute_method_suffix "_previously_changed?", "_previous_change"
+        attribute_method_affix prefix: "restore_", suffix: "!"
+
         before_save { @previously_changed = changes }
         after_save { changed_attributes.clear }
       end
-      
+
+      def changed?
+        changed_attributes.present?
+      end
+
+      def changed
+        changed_attributes.keys
+      end
+
+      def changes
+        ActiveSupport::HashWithIndifferentAccess[changed.map { |attr| [attr, attribute_change(attr)] }]
+      end
+
+      def previous_changes
+        @previously_changed ||= ActiveSupport::HashWithIndifferentAccess.new
+      end
+
+      def changed_attributes
+        @changed_attributes ||= ActiveSupport::HashWithIndifferentAccess.new
+      end
+
+      def attribute_changed?(attr, from: OPTION_NOT_GIVEN, to: OPTION_NOT_GIVEN)
+        !!changes_include?(attr) &&
+          (to == OPTION_NOT_GIVEN || to == __send__(attr)) &&
+          (from == OPTION_NOT_GIVEN || from == changed_attributes[attr])
+      end
+
+      def attribute_was(attr)
+        attribute_changed?(attr) ? changed_attributes[attr] : __send__(attr)
+      end
+
+      def attribute_previously_changed?(attr)
+        previous_changes.include?(attr)
+      end
+
+      def restore_attributes(attributes = changed)
+        attributes.each { |attr| restore_attribute! attr }
+      end
+
       def write_attribute(key, value)
         attr = key.to_sym
-        
+
         # The attribute already has an unsaved change.
         if changed_attributes.include?(attr)
           old = changed_attributes[attr]
@@ -21,21 +66,58 @@ module MongoModel
           old = clone_attribute_value(attr)
           changed_attributes[attr] = old unless value == old
         end
-        
+
         super
       end
-      
+
       # Returns the attributes as they were before any changes were made to the document.
       def original_attributes
         {}.with_indifferent_access.merge(attributes).merge(changed_attributes)
       end
-      
-    protected
-      def changed_attributes
-        @changed_attributes ||= {}.with_indifferent_access
-      end
-    
+
     private
+      def changes_include?(attr_name)
+        attributes_changed_by_setter.include?(attr_name)
+      end
+      alias attribute_changed_by_setter? changes_include?
+
+      def attribute_change(attr)
+        [changed_attributes[attr], __send__(attr)] if attribute_changed?(attr)
+      end
+
+      def attribute_previous_change(attr)
+        previous_changes[attr] if attribute_previously_changed?(attr)
+      end
+
+      def attribute_will_change!(attr)
+        return if attribute_changed?(attr)
+
+        begin
+          value = __send__(attr)
+          value = value.duplicable? ? value.clone : value
+        rescue TypeError, NoMethodError
+        end
+
+        set_attribute_was(attr, value)
+      end
+
+      def restore_attribute!(attr)
+        if attribute_changed?(attr)
+          __send__("#{attr}=", changed_attributes[attr])
+          clear_attribute_changes([attr])
+        end
+      end
+
+      alias_method :attributes_changed_by_setter, :changed_attributes
+
+      def set_attribute_was(attr, old_value)
+        attributes_changed_by_setter[attr] = old_value
+      end
+
+      def clear_attribute_changes(attributes)
+        attributes_changed_by_setter.except!(*attributes)
+      end
+
       def clone_attribute_value(attribute_name)
         value = self[attribute_name.to_sym]
         value.duplicable? ? value.clone : value

data/lib/mongomodel/concerns/attribute_methods/forbidden.rb

@@ -4,7 +4,7 @@ module MongoModel
   module AttributeMethods
     module Forbidden
       extend ActiveSupport::Concern
-      
+
       def assign_attributes(attrs, options={})
         if attrs.respond_to?(:permitted?) && !attrs.permitted?
           raise ActiveModel::ForbiddenAttributesError

data/lib/mongomodel/concerns/attribute_methods/multi_parameter_assignment.rb

@@ -2,11 +2,11 @@ module MongoModel
   module AttributeMethods
     module MultiParameterAssignment
       extend ActiveSupport::Concern
-      
+
       def assign_attributes(attrs, options={})#:nodoc:
         super(transform_multiparameter_attributes(attrs))
       end
-    
+
     private
       # Converts multiparameter attributes into array format. For example, the parameters
       #   { "start_date(1i)" => "2010", "start_date(2i)" => "9", "start_date(3i)" => "4" }
@@ -15,20 +15,20 @@ module MongoModel
       def transform_multiparameter_attributes(attrs)
         attrs.merge(extract_multiparameter_attributes(attrs))
       end
-      
+
       def extract_multiparameter_attributes(attrs)
         multiparameter_attributes = Hash.new { |h, k| h[k] = [] }
-        
+
         attrs.each do |k, v|
           if k.to_s =~ /(.*)\((\d+)([if])?\)/
             multiparameter_attributes[$1][$2.to_i - 1] = type_cast_attribute_value($3, v)
             attrs.delete(k)
           end
         end
-        
+
         multiparameter_attributes
       end
-      
+
       def type_cast_attribute_value(type, value)
         case type
         when 'i', 'f'

data/lib/mongomodel/concerns/attribute_methods/nested.rb

@@ -2,35 +2,35 @@ module MongoModel
   module AttributeMethods
     module Nested
       extend ActiveSupport::Concern
-      
+
       included do
         class_attribute :nested_attributes_options, :instance_writer => false
         self.nested_attributes_options = {}
       end
-      
+
       module ClassMethods
         def accepts_nested_attributes_for(*attr_names)
           options = attr_names.extract_options!
-          
+
           attr_names.each do |attr_name|
             type = property_type(attr_name)
-            
+
             nested_attributes_options = self.nested_attributes_options.dup
             nested_attributes_options[attr_name.to_sym] = options
             self.nested_attributes_options = nested_attributes_options
-            
+
             class_eval <<-EORUBY, __FILE__, __LINE__ + 1
               if method_defined?(:#{attr_name}_attributes=)
                 remove_method(:#{attr_name}_attributes=)
               end
-              
+
               def #{attr_name}_attributes=(attributes)
                 assign_nested_attributes_for_#{type}(:#{attr_name}, attributes)
               end
             EORUBY
           end
         end
-      
+
       private
         def property_type(attr_name)
           if property = properties[attr_name]
@@ -40,7 +40,7 @@ module MongoModel
           end
         end
       end
-    
+
     private
       def assign_nested_attributes_for_property(property, attributes)
         if obj = send(property)
@@ -49,18 +49,18 @@ module MongoModel
           send("#{property}=", attributes)
         end
       end
-      
+
       def assign_nested_attributes_for_collection(property, attributes_collection)
         attributes_collection = convert_to_array(attributes_collection)
         options = self.nested_attributes_options[property]
-        
+
         if options[:limit] && attributes_collection.size > options[:limit]
           raise TooManyDocuments, "Maximum #{options[:limit]} documents are allowed. Got #{attributes_collection.size} documents instead."
         end
-        
+
         collection = send(property)
         collection.clear if options[:clear]
-        
+
         attributes_collection.each_with_index do |attributes, index|
           if collection[index]
             collection[index].attributes = attributes
@@ -69,7 +69,7 @@ module MongoModel
           end
         end
       end
-      
+
       def assign_nested_attributes_for_association(association, attributes)
         if obj = send(association)
           obj.attributes = attributes
@@ -77,23 +77,23 @@ module MongoModel
           send("build_#{association}", attributes)
         end
       end
-      
+
       def assign_nested_attributes_for_association_collection(association, attributes_collection)
         attributes_collection = convert_to_array(attributes_collection)
         options = self.nested_attributes_options[association]
-        
+
         if options[:limit] && attributes_collection.size > options[:limit]
           raise TooManyDocuments, "Maximum #{options[:limit]} documents are allowed. Got #{attributes_collection.size} documents instead."
         end
-        
+
         association = send(association)
         association.clear if options[:clear]
-        
+
         attributes_collection.each do |attributes|
           association.build(attributes)
         end
       end
-      
+
       def convert_to_array(params)
         case params
         when Hash

data/lib/mongomodel/concerns/attribute_methods/protected.rb

@@ -2,7 +2,7 @@ module MongoModel
   module AttributeMethods
     module Protected
       extend ActiveSupport::Concern
-      
+
       include ActiveModel::MassAssignmentSecurity
 
       module ClassMethods
@@ -11,11 +11,11 @@ module MongoModel
 
           attr_protected(name) if property.options[:protected]
           attr_accessible(name) if property.options[:accessible]
-        
+
           property
         end
       end
-    
+
       def assign_attributes(attrs, options={})
         if options[:without_protection]
           super

data/lib/mongomodel/concerns/attribute_methods/query.rb

@@ -2,16 +2,16 @@ module MongoModel
   module AttributeMethods
     module Query
       extend ActiveSupport::Concern
-      
+
       included do
         attribute_method_suffix "?"
       end
-      
+
       # Returns true if the attribute is not blank (i.e. it has some value). Otherwise returns false.
       def query_attribute(name)
         attributes.has?(name.to_sym)
       end
-      
+
     private
       # Handle *? for method_missing.
       def attribute?(attribute_name)

data/lib/mongomodel/concerns/attribute_methods/read.rb

@@ -2,27 +2,27 @@ module MongoModel
   module AttributeMethods
     module Read
       extend ActiveSupport::Concern
-      
+
       # ActiveModel 3.2 defines the non-prefixed attribute name automatically
       if ActiveModel::VERSION::STRING <= "3.2"
         included do
           attribute_method_suffix ""
         end
       end
-      
+
       # Returns the value of the attribute identified by +name+ after it has been typecast (for example,
       # "2004-12-12" in a date property is cast to a date object, like Date.new(2004, 12, 12)).
       def read_attribute(name)
         attributes[name.to_sym]
       end
-      
+
       # Returns the value of the attribute identified by <tt>name</tt> after it has been typecast (for example,
       # "2004-12-12" in a date property is cast to a date object, like Date.new(2004, 12, 12)).
       # (Alias for read_attribute).
       def [](name)
         read_attribute(name)
       end
-    
+
     private
       def attribute(attribute_name)
         read_attribute(attribute_name)