couchrest_model 2.1.0.rc1 → 2.2.0.beta1

data/lib/couchrest/model/dirty.rb

@@ -1,39 +1,113 @@
-# encoding: utf-8
-
-I18n.load_path << File.join(
-  File.dirname(__FILE__), "validations", "locale", "en.yml"
-)
-
 module CouchRest
   module Model
 
     # This applies to both Model::Base and Model::CastedModel
     module Dirty
       extend ActiveSupport::Concern
-      include ActiveModel::Dirty
 
       included do
-        # internal dirty setting - overrides global setting.
-        # this is used to temporarily disable dirty tracking when setting 
-        # attributes directly, for performance reasons.
-        self.send(:attr_accessor, :disable_dirty)
+        # The original attributes data hash, used for comparing changes.
+        self.send(:attr_reader, :original_change_data)
       end
 
       def use_dirty?
-        doc = base_doc
-        doc && !doc.disable_dirty
+        # Use the configuration option.
+        !disable_dirty_tracking
+      end
+
+      # Provide an array of changes according to the hashdiff gem of the raw
+      # json hash data.
+      # If dirty tracking is disabled, this will always return nil.
+      def changes
+        if original_change_data.nil?
+          nil
+        else
+          HashDiff.diff(original_change_data, current_change_data)
+        end
       end
 
-      def couchrest_attribute_will_change!(attr)
-        return if attr.nil? || !use_dirty?
-        attribute_will_change!(attr)
-        couchrest_parent_will_change!
+      # Has this model changed? If dirty tracking is disabled, this method
+      # will always return true.
+      def changed?
+        diff = changes
+        diff.nil? || !diff.empty?
       end
 
-      def couchrest_parent_will_change!
-        casted_by.couchrest_attribute_will_change!(casted_by_property.name) if casted_by_property
+      def clear_changes_information
+        if use_dirty?
+          # Recursively clear all change information
+          self.class.properties.each do |property|
+            val = read_attribute(property)
+            if val.respond_to?(:clear_changes_information)
+              val.clear_changes_information
+            end
+          end
+          @original_change_data = current_change_data
+        else
+          @original_change_data = nil
+        end
+      end
+
+      protected
+
+      def current_change_data
+        as_couch_json.as_json
       end
 
+      module ClassMethods
+
+        def create_dirty_property_methods(property)
+          create_dirty_property_change_method(property)
+          create_dirty_property_changed_method(property)
+          create_dirty_property_was_method(property)
+        end
+
+        # For #property_change.
+        # Tries to be a bit more efficient by directly comparing the properties
+        # current value with that stored in the original change data. This also
+        # maintains compatibility with ActiveModel change results.
+        def create_dirty_property_change_method(property)
+          define_method("#{property.name}_change") do
+            val = read_attribute(property.name)
+            if val.respond_to?(:changes)
+              val.changes
+            else
+              if original_change_data.nil?
+                nil
+              else
+                orig = original_change_data[property.name]
+                cur = val.as_json
+                if orig != cur
+                  [orig, cur]
+                else
+                  []
+                end
+              end
+            end
+          end
+        end
+
+        # For #property_was value.
+        # Uses the original raw value, if available.
+        def create_dirty_property_was_method(property)
+          define_method("#{property.name}_was") do
+            if original_change_data.nil?
+              nil
+            else
+              original_change_data[property.name]
+            end
+          end
+        end
+
+        # For #property_changed?
+        def create_dirty_property_changed_method(property)
+          define_method("#{property.name}_changed?") do
+            changes = send("#{property.name}_change")
+            changes.nil? || !changes.empty?
+          end
+        end
+
+      end
     end
   end
 end

data/lib/couchrest/model/embeddable.rb

@@ -21,16 +21,15 @@ module CouchRest::Model
         def base_doc?
           false # Can never be base doc!
         end
-
       end
     end
 
     # Initialize a new Casted Model. Accepts the same
     # options as CouchRest::Model::Base for preparing and initializing
     # attributes.
-    def initialize(keys = {}, options = {})
+    def initialize(attributes = {}, options = {})
       super()
-      prepare_all_attributes(keys, options)
+      write_attributes_for_initialization(attributes, options)
       run_callbacks(:initialize) { self }
     end
 
@@ -54,17 +53,6 @@ module CouchRest::Model
     alias :to_key :id
     alias :to_param :id
 
-    # Sets the attributes from a hash
-    def update_attributes_without_saving(hash)
-      hash.each do |k, v|
-        raise NoMethodError, "#{k}= method not available, use property :#{k}" unless self.respond_to?("#{k}=")
-      end      
-      hash.each do |k, v|
-        self.send("#{k}=",v)
-      end
-    end
-    alias :attributes= :update_attributes_without_saving
-
   end # End Embeddable
 
   # Provide backwards compatability with previous versions (pre 1.1.0)

data/lib/couchrest/model/extended_attachments.rb

@@ -9,7 +9,7 @@ module CouchRest
         raise ArgumentError unless args[:file] && args[:name]
         return if has_attachment?(args[:name])
         set_attachment_attr(args)
-      rescue ArgumentError => e
+      rescue ArgumentError
         raise ArgumentError, 'You must specify :file and :name'
       end
       
@@ -29,7 +29,7 @@ module CouchRest
         return unless has_attachment?(args[:name])
         delete_attachment(args[:name])
         set_attachment_attr(args)
-      rescue ArgumentError => e
+      rescue ArgumentError
         raise ArgumentError, 'You must specify :file and :name'
       end
 
@@ -37,7 +37,6 @@ module CouchRest
       def delete_attachment(attachment_name)
         return unless attachments
         if attachments.include?(attachment_name)
-          attribute_will_change!("_attachments")
           attachments.delete attachment_name
         end
       end
@@ -71,7 +70,6 @@ module CouchRest
           content_type = args[:content_type] ? args[:content_type] : get_mime_type(args[:file].path)
           content_type ||= (get_mime_type(args[:name]) || 'text/plain')
 
-          attribute_will_change!("_attachments")
           attachments[args[:name]] = {
             'content_type' => content_type,
             'data'         => args[:file].read

data/lib/couchrest/model/persistence.rb

@@ -10,10 +10,10 @@ module CouchRest
         return false unless perform_validations(options)
         run_callbacks :create do
           run_callbacks :save do
-            set_unique_id if new? && self.respond_to?(:set_unique_id)
+            set_unique_id if new? && respond_to?(:set_unique_id)
             result = database.save_doc(self)
             ret = (result["ok"] == true) ? self : false
-            @changed_attributes.clear if ret && @changed_attributes
+            clear_changes_information if ret
             ret
           end
         end
@@ -31,12 +31,12 @@ module CouchRest
         raise "Cannot save a destroyed document!" if destroyed?
         raise "Calling #{self.class.name}#update on document that has not been created!" if new?
         return false unless perform_validations(options)
-        return true if !self.disable_dirty && !self.changed?
+        return true unless changed?
         run_callbacks :update do
           run_callbacks :save do
             result = database.save_doc(self)
             ret = result["ok"] == true
-            @changed_attributes.clear if ret && @changed_attributes
+            clear_changes_information if ret
             ret
           end
         end
@@ -83,7 +83,7 @@ module CouchRest
       #   doc.save
       #
       def update_attributes(hash)
-        update_attributes_without_saving hash
+        write_attributes(hash)
         save
       end
 
@@ -92,7 +92,9 @@ module CouchRest
       #
       # Returns self.
       def reload
-        prepare_all_attributes(database.get(id), :directly_set_attributes => true)
+        write_attributes_for_initialization(
+          database.get(id), :write_all_attributes => true
+        )
         self
       end
 
@@ -121,7 +123,7 @@ module CouchRest
         def build_from_database(doc = {}, options = {}, &block)
           src = doc[model_type_key]
           base = (src.blank? || src == model_type_value) ? self : src.constantize
-          base.new(doc, options.merge(:directly_set_attributes => true), &block)
+          base.new(doc, options.merge(:write_all_attributes => true), &block)
         end
 
         # Defines an instance and save it directly to the database
@@ -153,16 +155,11 @@ module CouchRest
         # database, so if you'd like to scope uniqueness to this class, you
         # should use the class name as part of the unique id.
         def unique_id(method = nil, &block)
-          if method
-            define_method :set_unique_id do
-              self['_id'] ||= self.send(method)
-            end
-          elsif block
-            define_method :set_unique_id do
-              uniqid = block.call(self)
-              raise ArgumentError, "unique_id block must not return nil" if uniqid.nil?
-              self['_id'] ||= uniqid
-            end
+          return if method.nil? && !block
+          define_method :set_unique_id do
+            uniqid = method.nil? ? block.call(self) : send(method)
+            raise ArgumentError, "unique_id cannot be nil nor empty" if uniqid.blank?
+            self['_id'] ||= uniqid
           end
         end
 

data/lib/couchrest/model/properties.rb

@@ -9,7 +9,6 @@ module CouchRest
         class_attribute(:properties_by_name) unless self.respond_to?(:properties_by_name)
         self.properties ||= []
         self.properties_by_name ||= {}
-        raise "You can only mixin Properties in a class responding to [] and []=, if you tried to mixin CastedModel, make sure your class inherits from Hash or responds to the proper methods" unless (method_defined?(:[]) && method_defined?(:[]=))
       end
 
       # Provide an attribute hash ready to be sent to CouchDB but with
@@ -18,50 +17,42 @@ module CouchRest
         super.delete_if{|k,v| v.nil?}
       end
 
-      # Returns the Class properties with their values
-      #
-      # ==== Returns
-      # Array:: the list of properties with their values
-      def properties_with_values
-        props = {}
-        properties.each { |property| props[property.name] = read_attribute(property.name) }
-        props
-      end
-
       # Read the casted value of an attribute defined with a property.
-      #
-      # ==== Returns
-      # Object:: the casted attibutes value.
       def read_attribute(property)
         self[find_property!(property).to_s]
       end
 
       # Store a casted value in the current instance of an attribute defined
-      # with a property and update dirty status
+      # with a property.
       def write_attribute(property, value)
         prop = find_property!(property)
         value = prop.cast(self, value)
-        couchrest_attribute_will_change!(prop.name) if use_dirty? && self[prop.name] != value
         self[prop.name] = value
       end
 
-      # Takes a hash as argument, and applies the values by using writer methods
-      # for each key. It doesn't save the document at the end. Raises a NoMethodError if the corresponding methods are
-      # missing. In case of error, no attributes are changed.
-      def update_attributes_without_saving(hash)
-        # Remove any protected and update all the rest. Any attributes
-        # which do not have a property will simply be ignored.
-        attrs = remove_protected_attributes(hash)
-        directly_set_attributes(attrs)
+      # Returns a hash of this object's attributes with a defined property.
+      # This is effectively an accessor to the underlying CouchRest 
+      # attributes hash.
+      def read_attributes
+        @_attributes
       end
-      alias :attributes= :update_attributes_without_saving
-
-      # 'attributes' needed for Dirty
-      alias :attributes :properties_with_values
+      alias :attributes :read_attributes
 
-      def set_attributes(hash)
+      # Takes a hash as argument, and applies the values by using writer
+      # methods respecting protected properties.
+      def write_attributes(hash)
         attrs = remove_protected_attributes(hash)
         directly_set_attributes(attrs)
+        self
+      end
+      alias :attributes= :write_attributes
+
+      # Takes the provided attribute hash and sets all properties, assuming
+      # that the data is from a trusted source, such as the database.
+      def write_all_attributes(attrs = {})
+        directly_set_read_only_attributes(attrs)
+        directly_set_attributes(attrs, true)
+        self
       end
 
       protected
@@ -70,36 +61,31 @@ module CouchRest
         property.is_a?(Property) ? property : self.class.properties_by_name[property.to_s]
       end
 
-      # The following methods should be accessable by the Model::Base Class, but not by anything else!
-      def apply_all_property_defaults
-        return if self.respond_to?(:new?) && (new? == false)
-        # TODO: cache the default object
-        # Never mark default options as dirty!
-        dirty, self.disable_dirty = self.disable_dirty, true
-        self.class.properties.each do |property|
-          write_attribute(property, property.default_value)
-        end
-        self.disable_dirty = dirty
+      def find_property!(property)
+        find_property(property) or
+          raise ArgumentError, "Missing property definition for #{property.to_s}"
       end
 
-      def prepare_all_attributes(attrs = {}, options = {})
-        self.disable_dirty = !!options[:directly_set_attributes]
+      def write_attributes_for_initialization(attrs = {}, opts = {})
         apply_all_property_defaults
-        if options[:directly_set_attributes]
-          directly_set_read_only_attributes(attrs)
-          directly_set_attributes(attrs, true)
+        if opts[:write_all_attributes]
+          # Assume coming from a database, so we clear change information after
+          write_all_attributes(attrs)
+          clear_changes_information
         else
-          attrs = remove_protected_attributes(attrs)
-          directly_set_attributes(attrs)
+          # Not from a persisted source, clear the change data in advance and do
+          # not set protected or read-only attributes.
+          clear_changes_information
+          write_attributes(attrs)
         end
-        self.disable_dirty = false
-        self
       end
 
-      def find_property!(property)
-        prop = find_property(property)
-        raise ArgumentError, "Missing property definition for #{property.to_s}" if prop.nil?
-        prop
+      # Apply each property's default value to the attributes. This should
+      # only ever be called on initialization.
+      def apply_all_property_defaults
+        self.class.properties.each do |property|
+          write_attribute(property, property.default_value)
+        end
       end
 
       # Set all the attributes and return a hash with the attributes
@@ -116,12 +102,15 @@ module CouchRest
           elsif self.respond_to?("#{key}=")
             self.send("#{key}=", value) 
           elsif mass_assign || mass_assign_any_attribute
-            couchrest_attribute_will_change!(key) if use_dirty? && self[key] != value
             self[key] = value
           end
         end
 
-        assign_multiparameter_attributes(multi_parameter_attributes, hash) unless multi_parameter_attributes.empty?
+        # Handle attributes provided in an embedded object format, such
+        # as a web-form.
+        unless multi_parameter_attributes.empty?
+          assign_multiparameter_attributes(multi_parameter_attributes, hash)
+        end
       end
 
       def directly_set_read_only_attributes(hash)
@@ -214,6 +203,9 @@ module CouchRest
               validates_casted_model property.name
             end
 
+            # Dirty!
+            create_dirty_property_methods(property)
+
             properties << property
             properties_by_name[property.to_s] = property
             property

data/lib/couchrest/model/property.rb

@@ -39,9 +39,6 @@ module CouchRest::Model
         arr.reject!{ |data| data.nil? } unless allow_blank
         # allow casted_by calls to be passed up chain by wrapping in CastedArray
         CastedArray.new(arr, self, parent)
-      elsif (type == Object || type == Hash) && (value.is_a?(Hash))
-        # allow casted_by calls to be passed up chain by wrapping in CastedHash
-        CastedHash[value, self, parent]
       elsif !value.nil?
         cast_value(parent, value)
       end