couch_potato 1.1.4 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f8f5c231fcf0ed9657baf832752652a1b04ec331
-  data.tar.gz: 1918a304d3b741fe970677e9ce4da467df692f11
+  metadata.gz: 2771fb2d4e5b08e8ce5a50afa1d6747a54682807
+  data.tar.gz: 1009498ac99d3d0b5e2bba6a7a5a4624ff5759be
 SHA512:
-  metadata.gz: a10c00c94ef2642ff0c458a223e56a14e913d7202c07555e308266600ecfffaffec1f2595b09460da30ee22acc4cac132451b4292a6282bdb65f1468e994f5b6
-  data.tar.gz: c9714c1620976ea921df67afe9e59058415c4e16006e71203b012eade16c09bcfecb1541c28960a7703deafee6135c401bddec7298c753734fa0d92dcd287a0c
+  metadata.gz: 665f44a87cc9d5f96b1c0ba3dc416849e6fc1b02888a96658e94e7a295601aa4e81d81423df6a8362e87c4feb41f1a738fa1bd08d18fe716a7d655b03714eff7
+  data.tar.gz: c53f3dba7f3fd8208182ecfc54a8e6d747af55d316ea2097df26762ab70e3544676575e36594922caf1b85033c9b6631e79d2876105b37c901a100f3ce6608f2

data/.travis.yml

@@ -1,8 +1,7 @@
 rvm:
   - 1.9.3
   - 2.0.0
-  - 2.1.0
-  - 2.1.1
+  - 2.1.2
   - jruby-19mode
   - rbx-2.1.1
 gemfile:

data/CHANGES.md

@@ -1,5 +1,10 @@
 ## Changes
 
+### 1.2.0
+
+* adds optional deep dirty tracking (andymorris)
+* fixes an exception when deleting an already deleted document (Alexander Lang)
+
 ### 1.1.4
 
 * Removes the dependency to json/add/core (cstettner)

data/README.md

@@ -224,6 +224,49 @@ You can also force a dirty state:
     user.name_changed? # => false
     CouchPotato.database.save_document user # does nothing as no attributes are dirty
 
+#### Optional Deep Dirty Tracking
+
+In addition to standard dirty tracking, you can opt-in to more advanced dirty tracking for deeply structured documents by including the ```CouchPotato::DeepDirtyAttributes``` module in your models. This provides two benefits:
+
+1. Dirty checking for array and embedded document properties is more reliable, such that modifying elements in an array (by any means) or changing a property of an embedded document will make the root document be ```changed?```. With standard dirty checking, the ```#{property}=``` method must be called on the root document for it to be ```changed?```.
+2. It gives more useful and detailed change tracking for embedded documents, arrays of simple values, and arrays of embedded documents.
+
+The ```#{property}_changed?``` and ```#{property}_was``` methods work the same as basic dirty checking, and the ```_was``` values are always deep clones of the original/previous value. The ```#{property}_change``` and ```changes``` methods differ from basic dirty checking for embedded documents and arrays, giving richer details of the changes instead of just the previous and current values. This makes generating detailed, human friendly audit trails of documents easy.
+
+Tracking changes in embedded documents gives easy access to the changes in that document:
+
+    book = Book.new(:cover => Cover.new(:color => "red"))
+    book.cover.color = "blue"
+    book.cover_changed? # => true
+    book.cover_was # => <deep clone of original state of book.cover>
+    book.cover_change # => [<deep clone of original state of book.cover>, {:color => ["red", "blue"]}]
+
+Tracking changes in arrays of simple properties gives easy access to added and removed items:
+
+    book = Book.new(:authors => ["Sarah", "Jane"])
+    book.authors.delete "Jane"
+    book.authors << "Sue"
+    book.authors_changed? # => true
+    book.authors_was # => ["Sarah", "Jane"]
+    book.authors_change # => [["Sarah", "Jane"], {:added => ["Sue"], :removed => ["Jane"]}]
+
+Tracking changes in an array of embedded documents also gives changed items:
+
+    book = Book.new(:pages => [Page.new(:number => 1), Page.new(:number => 2)]
+    book.pages[0].title = "New title"
+    book.pages.delete_at 1
+    book.pages << Page.new(:number => 3)
+    book.pages_changed? # => true
+    book.pages_was # => <deep clone of original pages array>
+    book.pages_change[0] # => <deep clone of original pages array>
+    book.pages_change[1] # => {:added => [<page 3>], :removed => [<page 2>], :changed => [[<deep clone of original page 1>, {:title => [nil, "New title"]}]]}
+
+For change tracking in nested documents and document arrays to work, the embedded documents **must** have unique ```_id``` values. This can be accomplished easily in your embedded CouchPotato models by overriding ```initialize```:
+
+    def initialize(*args)
+      self._id = SecureRandom.uuid
+      super
+    end
 
 #### Object validations
 

data/lib/couch_potato/database.rb

@@ -102,8 +102,7 @@ module CouchPotato
       begin
         destroy_document_without_conflict_handling document
       rescue RestClient::Conflict
-        document = document.reload
-        retry
+        retry if document = document.reload
       end
     end
     alias_method :destroy, :destroy_document

data/lib/couch_potato/persistence/deep_dirty_attributes.rb

@@ -0,0 +1,180 @@
+module CouchPotato
+  module Persistence
+    module DeepDirtyAttributes
+
+      def self.included(base) #:nodoc:
+        base.send :extend, ClassMethods
+      end
+
+      def initialize(*args, &block)
+        super(*args, &block)
+        reset_deep_dirty_attributes
+      end
+
+      def changed?
+        super || self.class.deep_tracked_properties.any? do |property|
+          send("#{property.name}_changed?")
+        end
+      end
+
+      def changes
+        changes = super
+        if @original_deep_values
+          self.class.deep_tracked_properties.each do |property|
+            if send("#{property.name}_changed?")
+              changes[property.name] = send("#{property.name}_change")
+            else
+              changes.delete property.name
+            end
+          end
+        end
+        changes
+      end
+
+      private
+
+      def reset_dirty_attributes
+        super
+        reset_deep_dirty_attributes
+      end
+
+      def reset_deep_dirty_attributes
+        @original_deep_values = HashWithIndifferentAccess.new
+        self.class.deep_tracked_properties.each do |property|
+          value = send(property.name)
+          if value
+            if doc?(value)
+              value.send(:reset_dirty_attributes)
+            elsif value.respond_to?(:each)
+              value.each do |item|
+                item.send(:reset_dirty_attributes) if doc?(item)
+              end
+            end
+          end
+          @original_deep_values[property.name] = clone_attribute(value)
+        end
+      end
+
+      def doc_changed?(name)
+        old, new = @original_deep_values[name], send(name)
+        if old.nil? && new.nil?
+          false
+        elsif old.nil? ^ new.nil?
+          true
+        else
+          (doc?(new) && new.changed?) || old.to_hash != new.to_hash
+        end
+      end
+
+      def simple_array_changed?(name)
+        @original_deep_values[name] != send(name)
+      end
+
+      def doc_array_changed?(name)
+        old, new = @original_deep_values[name], send(name)
+        if old.blank? && new.blank?
+          false
+        elsif old.blank? ^ new.blank?
+          true
+        else
+          old != new || old.map(&:to_hash) != new.map(&:to_hash)
+        end
+      end
+
+      def doc?(value)
+        value && value.respond_to?(:changed?)
+      end
+
+      def doc_change(name)
+        old, new = @original_deep_values[name], send(name)
+        if !old || !new || old != new
+          [old, new]
+        else
+          [old, doc_diff(old, new)]
+        end
+      end
+
+      def doc_diff(old, new)
+        clone = clone_attribute(old)
+        clone.attributes = new.attributes
+        clone.changes
+      end
+
+      def simple_array_change(name)
+        value = send(name) || []
+        old = @original_deep_values[name] || []
+        changes = HashWithIndifferentAccess.new :added => value - old, :removed => old - value
+        [old, changes]
+      end
+
+      def doc_array_change(name)
+        old = @original_deep_values[name] || []
+        value = send(name)
+
+        added = value - old
+        removed = old - value
+        changed = value.map do |value_item|
+          old_item = old.detect {|i| i == value_item}
+          if old_item
+            changes = doc_diff(old_item, value_item)
+            unless changes.empty?
+              [old_item, changes]
+            end
+          end
+        end.compact
+        changes = HashWithIndifferentAccess.new(:added => added, :removed => removed, :changed => changed)
+
+        [old, changes]
+      end
+
+      module ClassMethods #:nodoc:
+        def property(name, options = {})
+          super
+          if deep_trackable_type?(options[:type])
+            index = properties.find_index {|p| p.name == name}
+            properties.list[index] = DeepTrackedProperty.new(self, name, options)
+          end
+          remove_attribute_dirty_methods_from_activesupport_module
+        end
+
+        def remove_attribute_dirty_methods_from_activesupport_module
+          methods = deep_tracked_property_names.flat_map {|n| ["#{n}_changed?", "#{n}_change", "#{n}_was"]}.map(&:to_sym)
+          activesupport_modules = ancestors.select {|m| m.name.nil? && (methods - m.instance_methods).empty?}
+          activesupport_modules.each do |mod|
+            methods.each do |method|
+              mod.send :remove_method, method if mod.instance_methods.include?(method)
+            end
+          end
+        end
+
+        def doc_array_type?(type)
+          type && type.is_a?(Array) && doc_type?(type[0])
+        end
+
+        def simple_array_type?(type)
+          type && type.is_a?(Array) && !doc_type?(type[0])
+        end
+
+        def doc_type?(type)
+          type &&
+            type.respond_to?(:included_modules) &&
+            type.included_modules.include?(DirtyAttributes)
+        end
+
+        def deep_trackable_type?(type)
+          type && type.is_a?(Array) || doc_type?(type)
+        end
+
+        def deep_tracked_properties
+          properties.select do |property|
+            property.is_a? DeepTrackedProperty
+          end
+        end
+
+        def deep_tracked_property_names
+          deep_tracked_properties.map(&:name)
+        end
+      end
+    end
+  end
+end

data/lib/couch_potato/persistence/deep_tracked_property.rb

@@ -0,0 +1,56 @@
+module CouchPotato
+  module Persistence
+    class DeepTrackedProperty < SimpleProperty
+
+      def initialize(owner_clazz, name, options = {})
+        super
+        define_accessors deep_accessors_module_for(owner_clazz), name, options
+      end
+
+      private
+
+      def deep_accessors_module_for(clazz)
+        module_for(clazz, "DeepAccessorMethods")
+      end
+
+      def define_accessors(base, name, options)
+        base.class_eval do
+          define_method "#{name}=" do |value|
+            typecasted_value = type_caster.cast(value, options[:type])
+            self.instance_variable_set("@#{name}", typecasted_value)
+          end
+
+          define_method "#{name}_changed?" do
+            if self.class.doc_array_type?(options[:type])
+              doc_array_changed?(name)
+            elsif self.class.simple_array_type?(options[:type])
+              simple_array_changed?(name)
+            elsif self.class.doc_type?(options[:type])
+              doc_changed?(name)
+            else
+              super()
+            end
+          end
+
+          define_method "#{name}_was" do
+            @original_deep_values[name] if send("#{name}_changed?")
+          end
+
+          define_method "#{name}_change" do
+            if !send("#{name}_changed?")
+              nil
+            elsif self.class.doc_array_type?(options[:type])
+              doc_array_change(name)
+            elsif self.class.simple_array_type?(options[:type])
+              simple_array_change(name)
+            elsif self.class.doc_type?(options[:type])
+              doc_change(name)
+            else
+              super()
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/couch_potato/persistence/dirty_attributes.rb

@@ -10,10 +10,6 @@ module CouchPotato
         end
       end
 
-      def initialize(attributes = {})
-        super
-      end
-
       # returns true if a model has dirty attributes, i.e. their value has changed since the last save
       def dirty?
         changed? || @forced_dirty

data/lib/couch_potato/persistence/properties.rb

@@ -1,4 +1,5 @@
 require File.dirname(__FILE__) + '/simple_property'
+require File.dirname(__FILE__) + '/deep_tracked_property'
 
 module CouchPotato
   module Persistence

data/lib/couch_potato/persistence/simple_property.rb

@@ -42,8 +42,8 @@ module CouchPotato
 
       private
 
-      def accessors_module_for(clazz)
-        module_name = "#{clazz.name.to_s.gsub('::', '__')}AccessorMethods"
+      def module_for(clazz, module_name)
+        module_name = "#{clazz.name.to_s.gsub('::', '__')}#{module_name}"
         unless clazz.const_defined?(module_name)
           accessors_module = clazz.const_set(module_name, Module.new)
           clazz.send(:include, accessors_module)
@@ -51,6 +51,10 @@ module CouchPotato
         clazz.const_get(module_name)
       end
 
+      def accessors_module_for(clazz)
+        module_for(clazz, "AccessorMethods")
+      end
+
       def define_accessors(base, name, options)
         base.class_eval do
           define_method "#{name}" do

data/lib/couch_potato/persistence.rb

@@ -6,6 +6,7 @@ require File.dirname(__FILE__) + '/persistence/magic_timestamps'
 require File.dirname(__FILE__) + '/persistence/callbacks'
 require File.dirname(__FILE__) + '/persistence/json'
 require File.dirname(__FILE__) + '/persistence/dirty_attributes'
+require File.dirname(__FILE__) + '/persistence/deep_dirty_attributes'
 require File.dirname(__FILE__) + '/persistence/ghost_attributes'
 require File.dirname(__FILE__) + '/persistence/attachments'
 require File.dirname(__FILE__) + '/persistence/type_caster'

data/lib/couch_potato/rspec/stub_db.rb

@@ -40,7 +40,7 @@ module CouchPotato::RSpec
 
   module StubDb
     def stub_db(options = {})
-      db = stub('db', options)
+      db = double('db', options)
       db.extend CouchPotato::RSpec::StubView
       CouchPotato.stub(:database => db)
       db

data/lib/couch_potato/version.rb

@@ -1,3 +1,3 @@
 module CouchPotato
-  VERSION = "1.1.4"
+  VERSION = "1.2.0"
 end

data/spec/unit/database_spec.rb

@@ -419,3 +419,17 @@ describe CouchPotato::Database, 'view' do
     @db.view(@spec)
   end
 end
+
+describe CouchPotato::Database, '#destroy' do
+  it 'does not try to delete an already deleted document' do
+    couchrest_db = double(:couchrest_db)
+    couchrest_db.stub(:delete_doc).and_raise(RestClient::Conflict)
+    db = CouchPotato::Database.new couchrest_db
+    document = double(:document, reload: nil).as_null_object
+    document.stub(:run_callbacks).and_yield
+
+    expect {
+      db.destroy document
+    }.to_not raise_error
+  end
+end

data/spec/unit/deep_dirty_attributes_spec.rb

@@ -0,0 +1,434 @@
+require 'spec_helper'
+
+class Cover
+  include CouchPotato::Persistence
+
+  def initialize(*args)
+    self._id = SecureRandom.uuid
+    super
+  end
+
+  property :color
+end
+
+class Page
+  include CouchPotato::Persistence
+
+  def initialize(*args)
+    self._id = SecureRandom.uuid
+    super
+  end
+
+  property :number
+  property :headline
+end
+
+class Book
+  include CouchPotato::Persistence
+  include CouchPotato::Persistence::DeepDirtyAttributes
+
+  property :title
+  property :cover, :type => Cover
+  property :authors, :type => [String]
+  property :pages, :type => [Page]
+end
+
+class TextBook < Book
+  property :edition
+end
+
+describe "deep dirty attribute tracking" do
+  describe "standard dirty checking" do
+    describe "_changed?" do
+      it "should return true if only root simple properties have changed" do
+        book = Book.new(:title => "A")
+        book.title = "B"
+        book.should be_title_changed
+        book.should be_changed
+      end
+    end
+
+    describe "_was" do
+      it "gives access to old values of simple root properties" do
+        book = Book.new(:title => "A")
+        book.title = "B"
+        book.title_was.should == "A"
+        book.title_change.should == ["A", "B"]
+      end
+    end
+
+    describe "_change" do
+      it "returns standard _change" do
+        book = Book.new(:title => "A")
+        book.title = "B"
+        book.title_change.should == ["A", "B"]
+      end
+    end
+  end
+
+  describe "single nested document" do
+    describe "_changed?" do
+      it "should return true if a nested attribute has changed" do
+        book = Book.new(:cover => Cover.new(:color => "red"))
+        book.cover.color = "blue"
+        book.should be_cover_changed
+        book.should be_changed
+      end
+
+      it "should return true if changed to a different document" do
+        book = Book.new(:cover => Cover.new(:color => "red"))
+        book.cover = Cover.new(:color => "blue")
+        book.should be_cover_changed
+        book.should be_changed
+      end
+
+      it "should return false if changed to a clone of the original document" do
+        book = Book.new(:cover => Cover.new(:color => "red"))
+        book.cover = book.cover.clone
+        book.should_not be_cover_changed
+        book.should_not be_changed
+      end
+
+      it "should return false if set to nil and unchanged" do
+        book = Book.new
+        book.should_not be_cover_changed
+        book.should_not be_changed
+      end
+
+      it "should return true when reassigned with changes but the same _id" do
+        book = Book.new(:cover => Cover.new(:_id => "cid", :color => "red"))
+        book.cover = Cover.new(:_id => "cid", :color => "blue")
+        book.should be_cover_changed
+        book.should be_changed
+      end
+    end
+
+    describe "_was" do
+      it "gives access to the old value" do
+        book = Book.new(:cover => Cover.new(:color => "red"))
+        book.cover.color = "blue"
+        book.cover_was.color.should == "red"
+      end
+    end
+
+    describe "_change" do
+      it "should return the standard changes when a nested document is reassigned" do
+        book = Book.new(:cover => Cover.new(:color => "red"))
+        book.cover = Cover.new(:color => "blue")
+        book.cover_change[0].should be_a Cover
+        book.cover_change[0].color.should == "red"
+        book.cover_change[1].should be_a Cover
+        book.cover_change[1].color.should == "blue"
+      end
+
+      it "should return the standard changes when a nested document is reassigned from nil" do
+        book = Book.new
+        book.cover = Cover.new
+        book.cover_change[0].should == nil
+        book.cover_change[1].should == book.cover
+      end
+
+      it "should return the standard changes when a nested document is reassigned to nil" do
+        cover = Cover.new
+        book = Book.new(:cover => cover)
+        book.cover = nil
+        book.cover_change[0].should == cover
+        book.cover_change[1].should == nil
+      end
+
+      it "should return the nested changes when a nested document is changed" do
+        book = Book.new(:cover => Cover.new(:color => "red"))
+        book.cover.color = "blue"
+        book.cover_change[0].should be_a Cover
+        book.cover_change[0].color.should == "red"
+        book.cover_change[1].should == book.cover.changes
+      end
+
+      it "should return the nested changes when reassigned with changes but the same _id" do
+        book = Book.new(:cover => Cover.new(:_id => "cid", :color => "red"))
+        book.cover = Cover.new(:_id => "cid", :color => "blue")
+        book.cover_change[0].should be_a Cover
+        book.cover_change[0].color.should == "red"
+        book.cover_change[1].should == {"color" => ["red", "blue"]}
+      end
+    end
+  end
+
+  describe "simple array" do
+    describe "_changed?" do
+      it "returns true if the array is reassigned" do
+        book = Book.new(:authors => ["Sarah"])
+        book.authors = ["Jane"]
+        book.should be_authors_changed
+      end
+
+      it "returns true if an item is added" do
+        book = Book.new(:authors => ["Jane"])
+        book.authors << "Sue"
+        book.should be_authors_changed
+        book.should be_changed
+      end
+
+      it "returns true if an item is removed" do
+        book = Book.new(:authors => ["Sue"])
+        book.authors.delete "Sue"
+        book.should be_authors_changed
+        book.should be_changed
+      end
+
+      it "returns false if an empty array is unchanged" do
+        book = Book.new(:authors => [])
+        book.authors = []
+        book.should_not be_authors_changed
+        book.should_not be_changed
+      end
+    end
+
+    describe "_was" do
+      it "gives access to the old values" do
+        book = Book.new(:authors => ["Jane"])
+        book.authors << "Sue"
+        book.authors_was.should == ["Jane"]
+      end
+    end
+
+    describe "_change" do
+      it "returns a hash of added and removed items" do
+        book = Book.new(:authors => ["Jane"])
+        book.authors << "Sue"
+        book.authors.delete "Jane"
+        book.authors_change[0].should == ["Jane"]
+        book.authors_change[1].should be_a HashWithIndifferentAccess
+        book.authors_change[1][:added].should == ["Sue"]
+        book.authors_change[1][:removed].should == ["Jane"]
+      end
+
+      it "returns a hash of added and removed items when the array is reassigned" do
+        book = Book.new(:authors => ["Jane"])
+        book.authors = ["Sue"]
+        book.authors_change[0].should == ["Jane"]
+        book.authors_change[1].should be_a HashWithIndifferentAccess
+        book.authors_change[1][:added].should == ["Sue"]
+        book.authors_change[1][:removed].should == ["Jane"]
+      end
+
+      it "returns a hash of added items when the value is changed from nil to an array" do
+        book = Book.new
+        book.authors = ["Sue"]
+        book.authors_change[0].should == []
+        book.authors_change[1].should be_a HashWithIndifferentAccess
+        book.authors_change[1][:added].should == ["Sue"]
+        book.authors_change[1][:removed].should == []
+      end
+
+      it "returns a hash of removed items when the value is changed from an array to nil" do
+        book = Book.new(:authors => ["Jane"])
+        book.authors = nil
+        book.authors_change[0].should == ["Jane"]
+        book.authors_change[1].should be_a HashWithIndifferentAccess
+        book.authors_change[1][:added].should == []
+        book.authors_change[1][:removed].should == ["Jane"]
+      end
+    end
+  end
+
+  describe "document array" do
+    describe "_changed?" do
+      it "returns true if an item is changed" do
+        book = Book.new(:pages => [Page.new(:number => 1)])
+        book.pages[0].number = 2
+        book.should be_pages_changed
+        book.should be_changed
+      end
+
+      it "returns true if an item is added" do
+        book = Book.new(:pages => [Page.new(:number => 1)])
+        book.pages << Page.new(:number => 2)
+        book.should be_pages_changed
+        book.should be_changed
+      end
+
+      it "returns true if an items is removed" do
+        book = Book.new(:pages => [Page.new(:number => 1)])
+        book.pages.delete_at 0
+        book.should be_pages_changed
+        book.should be_changed
+      end
+
+      it "returns true if an item is replaced" do
+        book = Book.new(:pages => [Page.new(:number => 1)])
+        book.pages[0] = Page.new(:number => 2)
+        book.should be_pages_changed
+        book.should be_changed
+      end
+
+      it "returns false if an item is replaced with a clone" do
+        book = Book.new(:pages => [Page.new(:number => 1)])
+        book.pages[0] = book.pages[0].clone
+        book.should_not be_pages_changed
+        book.should_not be_changed
+      end
+
+      it "returns true if an item is replaced with changes but the same _id" do
+        book = Book.new(:pages => [Page.new(:_id => "pid", :number => 1)])
+        book.pages[0] = Page.new(:_id => "pid", :number => 2)
+        book.should be_pages_changed
+        book.should be_changed
+      end
+
+      it "returns false if an empty array is unchanged" do
+        book = Book.new(:pages => [])
+        book.pages = []
+        book.should_not be_authors_changed
+        book.should_not be_changed
+      end
+    end
+
+    describe "_was" do
+      it "gives access to the old values" do
+        book = Book.new(:pages => [Page.new(:number => 1)])
+        book.pages[0].number = 2
+        book.pages_was[0].number.should == 1
+      end
+    end
+
+    describe "_change" do
+      it "returns a changes hash with added, removed, and changed items" do
+        p1 = Page.new
+        p2 = Page.new(:headline => "A")
+        p3 = Page.new
+        book = Book.new(:pages => [p1, p2])
+        pages = book.pages.clone
+        book.pages = [p2]
+        p2.headline = "B"
+        book.pages << p3
+        book.pages_change[0].should == pages
+        book.pages_change[1].should be_a HashWithIndifferentAccess
+        book.pages_change[1][:added].should == [p3]
+        book.pages_change[1][:removed].should == [p1]
+        book.pages_change[1][:changed][0][0].should be_a Page
+        book.pages_change[1][:changed][0][0].headline.should == "A"
+        book.pages_change[1][:changed][0][1].should == p2.changes
+      end
+
+      it "returns added items when changing from nil to an array" do
+        p1 = Page.new
+        p2 = Page.new(:headline => "A")
+        book = Book.new
+        book.pages = [p1, p2]
+        book.pages_change[0].should == []
+        book.pages_change[1].should be_a HashWithIndifferentAccess
+        book.pages_change[1][:added].should == [p1, p2]
+        book.pages_change[1][:removed].should == []
+        book.pages_change[1][:changed].should == []
+      end
+
+      it "does not return unchanged cloned items as changes" do
+        book = Book.new(:pages => [Page.new(:number => 1)])
+        book.pages[0] = book.pages[0].clone
+        book.pages_change.should be_nil
+      end
+
+      it "returns changes if an item is replaced with changes but the same _id" do
+        book = Book.new(:pages => [Page.new(:_id => "pid", :number => 1)])
+        pages = book.pages.clone
+        book.pages[0] = Page.new(:_id => "pid", :number => 2)
+        book.pages_change[0].should == pages
+        book.pages_change[1].should be_a HashWithIndifferentAccess
+        book.pages_change[1][:added].should == []
+        book.pages_change[1][:removed].should == []
+        book.pages_change[1][:changed].should == [[pages[0], {"number" => [1, 2]}]]
+      end
+    end
+  end
+
+  describe "changes" do
+    it "includes simple property changes" do
+      book = Book.new(:title => "Title A")
+      book.title = "Title B"
+      book.changes[:title].should == book.title_change
+    end
+
+    it "includes embedded document changes" do
+      book = Book.new(:cover => Cover.new(:color => "red"))
+      cover = book.cover.clone
+      book.cover.color = "blue"
+      book.changes[:cover].should == book.cover_change
+    end
+
+    it "does not include unchanged embedded documents" do
+      book = Book.new(:cover => Cover.new(:color => "red"))
+      book.changes.should_not have_key :cover
+    end
+
+    it "includes simple array changes" do
+      book = Book.new(:authors => ["Sarah"])
+      book.authors = ["Jane"]
+      book.changes[:authors].should == book.authors_change
+    end
+
+    it "does not include unchanged simple arrays" do
+      book = Book.new(:authors => ["Sarah"])
+      book.changes.should_not have_key :authors
+    end
+
+    it "includes document array changes" do
+      book = Book.new(:pages => [Page.new(:number => 1)])
+      book.pages = [Page.new(:number => 2)]
+      book.changes[:pages].should == book.pages_change
+    end
+
+    it "does not include unchanged document arrays" do
+      book = Book.new(:pages => [Page.new(:number => 1)])
+      book.changes.should_not have_key :pages
+    end
+  end
+
+  describe "after save" do
+    before :each do
+      book = Book.json_create(:_id => "1", :title => "A", :cover => {:color => "red"}, :pages => [{:_id => "p1", :number => 1}, {:_id => "p2", :number => 2}])
+      @couchrest_db = stub('database', :info => nil, :save_doc => {}, :get => book)
+      @db = CouchPotato::Database.new(@couchrest_db)
+      @book = @db.load_document "1"
+    end
+
+    it "should reset all attributes to not dirty" do
+      @book.title = "B"
+      @book.cover.color = "blue"
+      @db.save! @book
+      @book.should_not be_dirty
+      @book.cover.should_not be_dirty
+    end
+
+    it "should reset all elements in a document array" do
+      @book.pages.each(&:is_dirty)
+      @db.save! @book
+      @book.should_not be_dirty
+      @book.pages.each do |page|
+        page.should_not be_dirty
+      end
+    end
+
+    it "should reset a forced dirty state" do
+      @book.is_dirty
+      @db.save! @book
+      @book.should_not be_dirty
+    end
+
+    it "clears old values" do
+      @book.cover.color = "blue"
+      @db.save! @book
+      @book.cover_was.should be_nil
+      @book.cover_change.should be_nil
+    end
+  end
+
+  describe "on inherited models" do
+    it "still uses deep dirty tracking" do
+      book = TextBook.new(:pages => [Page.new(:number => 1)])
+      book.pages[0].number = 2
+      book.should be_pages_changed
+      book.should be_changed
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: couch_potato
 version: !ruby/object:Gem::Version
-  version: 1.1.4
+  version: 1.2.0
 platform: ruby
 authors:
 - Alexander Lang
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-24 00:00:00.000000000 Z
+date: 2014-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -135,6 +135,8 @@ files:
 - lib/couch_potato/persistence/active_model_compliance.rb
 - lib/couch_potato/persistence/attachments.rb
 - lib/couch_potato/persistence/callbacks.rb
+- lib/couch_potato/persistence/deep_dirty_attributes.rb
+- lib/couch_potato/persistence/deep_tracked_property.rb
 - lib/couch_potato/persistence/dirty_attributes.rb
 - lib/couch_potato/persistence/ghost_attributes.rb
 - lib/couch_potato/persistence/json.rb
@@ -186,6 +188,7 @@ files:
 - spec/unit/custom_views_spec.rb
 - spec/unit/database_spec.rb
 - spec/unit/date_spec.rb
+- spec/unit/deep_dirty_attributes_spec.rb
 - spec/unit/dirty_attributes_spec.rb
 - spec/unit/forbidden_attributes_protection_spec.rb
 - spec/unit/initialize_spec.rb
@@ -251,6 +254,7 @@ test_files:
 - spec/unit/custom_views_spec.rb
 - spec/unit/database_spec.rb
 - spec/unit/date_spec.rb
+- spec/unit/deep_dirty_attributes_spec.rb
 - spec/unit/dirty_attributes_spec.rb
 - spec/unit/forbidden_attributes_protection_spec.rb
 - spec/unit/initialize_spec.rb