mongoid-history 0.0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.9.2@

data/Gemfile

@@ -0,0 +1,15 @@
+source "http://rubygems.org"
+
+gem 'easy_diff'
+gem 'mongoid', '~> 2.0.0.rc.7'
+
+group :development do
+  gem "rspec", "~> 2.3.0"
+  gem "yard", "~> 0.6.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rcov", ">= 0"
+  gem "reek", "~> 1.2.8"
+  gem "roodi", "~> 2.1.0"
+  gem "database_cleaner"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Aaron Qian
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,101 @@
+= mongoid-history
+
+In frustration of Mongoid::Versioning, I created this plugin for tracking historical changes for any document, including embedded ones. It achieves this by storing all history tracks in a single collection that you define. (See Usage for more details) Embedded documents are referenced by storing an association path, which is an array of document_name and document_id fields starting from the top most parent document and down to the embedded document that should track history.
+
+This plugin implements multi-user undo, which allows users to undo any history change in any order. Undoing a document also creates a new history track. This is great for auditing and preventing vandalism, but it is probably not suitable for use cases such as a wiki.
+
+== Install
+
+  gem install mongoid-history
+
+== Rails 3
+
+In your Gemfile:
+
+  gem 'mongoid-history'
+
+== Usage
+
+Here is a quick example on how to use this plugin. For more details, please look at spec/integration/integration_spec.rb. It offers more detailed examples on how to use Mongoid::History.
+
+  # Create a new class for tracking all histories.
+  # Must include Mongoid::History::Tracker
+  class HistoryTracker
+    include Mongoid::History::Tracker
+  end
+
+  class Post
+    include Mongoid::Document
+    include Mongoid::Timestamps
+    
+    # History tracking all Post Documents
+    # Note: Tracking will not work until #track_history is invoked
+    include Mongoid::History::Trackable
+
+    field           :title
+    field           :body
+    field           :rating
+    embeds_many     :comments
+    
+    # Telling Mongoid::History how you want to track
+    track_history   :on => [:title, :body],       # I want to track title and body fields only. Default is :all
+                    :modifier_field => :modifier, # Adds "referened_in :modifier" to track who made the change. Default is :modifier
+                    :version_field => :version,   # Adds "field :version, :type => Integer" to track current version. Default is :version
+                    :track_create   =>  false,    # Do you want to track document creation? Default is false
+  end
+
+  class Comment
+    include Mongoid::Document
+    include Mongoid::Timestamps
+    
+    # Declare that we want to track comments
+    include Mongoid::History::Trackable
+
+    field             :title
+    field             :body
+    embedded_in       :post, :inverse_of => :comments
+    
+    # Track title and body for all comments, scope it to post (the parent)
+    # Also track creation
+    track_history     :on => [:title, :body], :scope => :post, :track_create => true
+  end
+
+  # The modifier can be specified as well 
+  class User
+    include Mongoid::Document
+    include Mongoid::Timestamps
+
+    field             :name
+  end
+  
+  user = User.create(:name => "Aaron")
+  post = Post.create(:title => "Test", :body => "Post", :modifier => user)
+  comment = post.comments.create(:title => "test", :body => "comment", :modifier => user)
+  comment.history_tracks.count # should be 1
+  
+  comment.update_attributes(:title => "Test 2")
+  comment.history_tracks.count # should be 2
+  
+  track = comment.history_tracks.last
+
+  track.undo! # comment title should be "Test"
+  
+  track.redo! # comment title should be "Test 2"
+  
+  
+
+== Contributing to mongoid-history
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Aaron Qian. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "mongoid-history"
+  gem.homepage = "http://github.com/aq1018/mongoid-history"
+  gem.license = "MIT"
+  gem.summary = %Q{ history tracking, auditing, undo, redo for mongoid}
+  gem.description = %Q{In frustration of Mongoid::Versioning, I created this plugin for tracking historical changes for any document, including embedded ones. It achieves this by storing all history tracks in a single collection that you define. (See Usage for more details) Embedded documents are referenced by storing an association path, which is an array of document_name and document_id fields starting from the top most parent document and down to the embedded document that should track history.
+
+  This plugin implements multi-user undo, which allows users to undo any history change in any order. Undoing a document also creates a new history track. This is great for auditing and preventing vandalism, but it is probably not suitable for use cases such as a wiki.}
+  gem.email = "aqian@attinteractive.com"
+  gem.authors = ["Aaron Qian"]
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+  spec.rspec_opts = "--color --format progress"
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+  spec.rcov_opts = "--exclude ~\/.rvm,spec"
+end
+
+require 'reek/rake/task'
+Reek::Rake::Task.new do |t|
+  t.fail_on_error = true
+  t.verbose = false
+  t.source_files = 'lib/**/*.rb'
+end
+
+require 'roodi'
+require 'roodi_task'
+RoodiTask.new do |t|
+  t.verbose = false
+end
+
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/mongoid/history/trackable.rb

@@ -0,0 +1,150 @@
+module Mongoid::History
+  module Trackable
+    extend ActiveSupport::Concern
+    
+    module ClassMethods
+      def track_history(options={})
+        model_name = self.name.tableize.singularize.to_sym
+        default_options = {
+          :on             =>  :all,
+          :except         =>  [:created_at, :updated_at],
+          :modifier_field =>  :modifier,
+          :version_field  =>  :version,
+          :scope          =>  model_name,
+          :track_create   =>  false
+        }
+
+        options = default_options.merge(options)
+        
+        # normalize except fields
+        # manually ensure _id, id, version will not be tracked in history
+        options[:except] = [options[:except]] unless options[:except].is_a? Array
+        options[:except] << options[:version_field]
+        options[:except] << "#{options[:modifier_field]}_id".to_sym
+        options[:except] += [:_id, :id]
+        options[:except] = options[:except].map(&:to_s).flatten.compact.uniq
+        options[:except].map(&:to_s)
+        
+        # normalize fields to track to either :all or an array of strings
+        if options[:on] != :all
+          options[:on] = [options[:on]] unless options[:on].is_a? Array
+          options[:on] = options[:on].map(&:to_s).flatten.uniq
+        end
+        
+        field options[:version_field].to_sym, :type => Integer
+        referenced_in options[:modifier_field].to_sym, :class_name => Mongoid::History.modifer_class_name
+        
+        include InstanceMethods
+        extend SingletonMethods
+        
+        delegate :history_trackable_options, :to => 'self.class'
+
+        before_update :track_update
+        before_create :track_create if options[:track_create]
+
+        
+        Mongoid::History.trackable_classes ||= []
+        Mongoid::History.trackable_classes << self
+        Mongoid::History.trackable_class_options ||= {}
+        Mongoid::History.trackable_class_options[model_name] = options
+      end
+      
+    end
+    
+    module InstanceMethods
+      def history_tracks
+        @history_tracks ||= Mongoid::History.tracker_class.where(:scope => history_trackable_options[:scope], :association_chain => triverse_association_chain)
+      end
+      
+    private
+      def should_track_update?
+        !modified_attributes_for_update.blank?
+      end
+      
+      def triverse_association_chain(node=self)
+        list = node._parent ? triverse_association_chain(node._parent) : []
+        list << { 'name' => node.class.name, 'id' => node.id }
+        list
+      end
+      
+      def modified_attributes_for_update
+        @modified_attributes_for_update ||= if history_trackable_options[:on] == :all
+          changes
+        else
+          changes.reject do |k, v|
+            !history_trackable_options[:on].include?(k)
+          end.reject do |k, v|
+            history_trackable_options[:except].include?(k)
+          end
+        end
+      end
+      
+      def modified_attributes_for_create
+        @modified_attributes_for_create ||= attributes.inject({}) do |h, pair|
+          k,v =  pair
+          h[k] = [nil, v]
+          h
+        end.reject do |k, v|
+          history_trackable_options[:except].include?(k)
+        end
+      end
+
+      def history_tracker_attributes
+        return @history_tracker_attributes if @history_tracker_attributes
+        
+        @history_tracker_attributes = {
+          :association_chain  => triverse_association_chain,
+          :scope              => history_trackable_options[:scope],
+          :modifier        => send(history_trackable_options[:modifier_field])
+        }
+        
+        original, modified = transform_changes((new_record? ? modified_attributes_for_create : modified_attributes_for_update))
+        @history_tracker_attributes[:original] = original
+        @history_tracker_attributes[:modified] = modified
+        @history_tracker_attributes
+      end
+      
+      def track_update
+        return unless should_track_update?
+        current_version = (self.send(history_trackable_options[:version_field]) || 0 ) + 1
+        self.send("#{history_trackable_options[:version_field]}=", current_version)
+        Mongoid::History.tracker_class.create!(history_tracker_attributes.merge(:version => current_version))
+        clear_memoization
+      end
+      
+      def track_create
+        current_version = (self.send(history_trackable_options[:version_field]) || 0 ) + 1
+        self.send("#{history_trackable_options[:version_field]}=", current_version)
+        Mongoid::History.tracker_class.create!(history_tracker_attributes.merge(:version => current_version))
+        clear_memoization
+      end
+      
+      def clear_memoization
+        @history_tracker_attributes =  nil
+        @modified_attributes_for_create = nil
+        @modified_attributes_for_update = nil
+        @history_tracks = nil
+      end
+      
+      def transform_changes(changes)
+        original = {}
+        modified = {}
+        changes.each_pair do |k, v|
+          o, m = v
+          original[k] = o if o
+          modified[k] = m if m
+        end
+        
+        return original.easy_diff modified
+      end
+      
+    end
+    
+    module SingletonMethods
+      def history_trackable_options
+        @history_trackable_options ||= Mongoid::History.trackable_class_options[self.name.tableize.singularize.to_sym]
+      end
+    end
+    
+  end
+end

data/lib/mongoid/history/tracker.rb

@@ -0,0 +1,67 @@
+module Mongoid::History
+  module Tracker
+    extend ActiveSupport::Concern
+
+    included do
+      include Mongoid::Document
+      include Mongoid::Timestamps
+      
+      field       :association_chain,       :type => Array,     :default => []
+      field       :modified,                :type => Hash
+      field       :original,                :type => Hash
+      field       :version,                 :type => Integer
+      field       :scope,                   :type => String
+      referenced_in :modifier,              :class_name => Mongoid::History.modifer_class_name
+
+      Mongoid::History.tracker_class_name = self.name.tableize.singularize.to_sym
+    end
+    
+    
+    module ClassMethods
+    end
+    
+    def undo!
+      undo_hash = affected.easy_unmerge(modified)
+      undo_hash.easy_merge!(original)
+      trackable.update_attributes!(undo_hash)
+    end
+    
+    def redo!
+      redo_hash = affected.easy_unmerge(original)
+      redo_hash.easy_merge!(modified)
+      trackable.update_attributes!(redo_hash)
+    end
+            
+    def trackable
+      @trackable ||= trackable_parents_and_trackable.last
+    end
+    
+    def trackable_parents
+      @trackable_parents ||= trackable_parents_and_trackable[0, -1]
+    end
+    
+    def affected
+      @affected ||= (modified.keys | original.keys).inject({}){ |h,k| h[k] = trackable.attributes[k]; h}
+    end
+    
+private
+    def trackable_parents_and_trackable
+      @trackable_parents_and_trackable ||= triverse_association_chain
+    end
+
+    def triverse_association_chain
+      chain = association_chain.dup
+      doc = nil
+      documents = []
+      begin
+        node = chain.shift
+        name = node['name']
+        col  = doc.nil? ? name.classify.constantize : doc.send(name.tableize)
+        doc  = col.where(:_id => node['id']).first
+        documents << doc
+      end while( !chain.empty? )
+      documents
+    end
+    
+  end
+end

data/lib/mongoid/history.rb

@@ -0,0 +1,12 @@
+module Mongoid
+  module History
+    mattr_accessor :tracker_class_name
+    mattr_accessor :trackable_classes
+    mattr_accessor :trackable_class_options
+    mattr_accessor :modifer_class_name
+    
+    def self.tracker_class
+      @tracker_class ||= tracker_class_name.to_s.classify.constantize
+    end
+  end
+end

data/lib/mongoid-history.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/mongoid/history')
+require File.expand_path(File.dirname(__FILE__) + '/mongoid/history/tracker')
+require File.expand_path(File.dirname(__FILE__) + '/mongoid/history/trackable')
+
+Mongoid::History.modifer_class_name = "User"
+Mongoid::History.trackable_classes = []
+Mongoid::History.trackable_class_options = {}

data/mongoid-history.gemspec

@@ -0,0 +1,91 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{mongoid-history}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Aaron Qian"]
+  s.date = %q{2011-03-04}
+  s.description = %q{In frustration of Mongoid::Versioning, I created this plugin for tracking historical changes for any document, including embedded ones. It achieves this by storing all history tracks in a single collection that you define. (See Usage for more details) Embedded documents are referenced by storing an association path, which is an array of document_name and document_id fields starting from the top most parent document and down to the embedded document that should track history.
+
+  This plugin implements multi-user undo, which allows users to undo any history change in any order. Undoing a document also creates a new history track. This is great for auditing and preventing vandalism, but it is probably not suitable for use cases such as a wiki.}
+  s.email = %q{aqian@attinteractive.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    ".rvmrc",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/mongoid-history.rb",
+    "lib/mongoid/history.rb",
+    "lib/mongoid/history/trackable.rb",
+    "lib/mongoid/history/tracker.rb",
+    "mongoid-history.gemspec",
+    "spec/integration/integration_spec.rb",
+    "spec/spec_helper.rb",
+    "spec/trackable_spec.rb",
+    "spec/tracker_spec.rb"
+  ]
+  s.homepage = %q{http://github.com/aq1018/mongoid-history}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.5.3}
+  s.summary = %q{history tracking, auditing, undo, redo for mongoid}
+  s.test_files = [
+    "spec/integration/integration_spec.rb",
+    "spec/spec_helper.rb",
+    "spec/trackable_spec.rb",
+    "spec/tracker_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<easy_diff>, [">= 0"])
+      s.add_runtime_dependency(%q<mongoid>, ["~> 2.0.0.rc.7"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_development_dependency(%q<yard>, ["~> 0.6.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<reek>, ["~> 1.2.8"])
+      s.add_development_dependency(%q<roodi>, ["~> 2.1.0"])
+      s.add_development_dependency(%q<database_cleaner>, [">= 0"])
+    else
+      s.add_dependency(%q<easy_diff>, [">= 0"])
+      s.add_dependency(%q<mongoid>, ["~> 2.0.0.rc.7"])
+      s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_dependency(%q<yard>, ["~> 0.6.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<reek>, ["~> 1.2.8"])
+      s.add_dependency(%q<roodi>, ["~> 2.1.0"])
+      s.add_dependency(%q<database_cleaner>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<easy_diff>, [">= 0"])
+    s.add_dependency(%q<mongoid>, ["~> 2.0.0.rc.7"])
+    s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+    s.add_dependency(%q<yard>, ["~> 0.6.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<reek>, ["~> 1.2.8"])
+    s.add_dependency(%q<roodi>, ["~> 2.1.0"])
+    s.add_dependency(%q<database_cleaner>, [">= 0"])
+  end
+end
+

data/spec/integration/integration_spec.rb

@@ -0,0 +1,264 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Mongoid::History do
+  before :all do
+    class HistoryTracker
+      include Mongoid::History::Tracker
+    end
+
+    class Post
+      include Mongoid::Document
+      include Mongoid::Timestamps
+      include Mongoid::History::Trackable
+
+      field           :title
+      field           :body
+      field           :rating
+      embeds_many     :comments
+      track_history   :on => [:title, :body]
+    end
+
+    class Comment
+      include Mongoid::Document
+      include Mongoid::Timestamps
+      include Mongoid::History::Trackable
+
+      field             :title
+      field             :body
+      embedded_in       :post, :inverse_of => :comments
+      track_history     :on => [:title, :body], :scope => :post, :track_create => true
+    end
+
+    class User
+      include Mongoid::Document
+      include Mongoid::Timestamps
+
+      field             :name
+    end
+  end
+  
+  before :each do
+    @user = User.create(:name => "Aaron")
+    @another_user = User.create(:name => "Another Guy")
+    @post = Post.create(:title => "Test", :body => "Post", :modifier => @user)
+    @comment = @post.comments.create(:title => "test", :body => "comment", :modifier => @user)
+  end
+  
+  describe "track" do
+    describe "on creation" do
+      it "should have one history track in comment" do
+        @comment.history_tracks.count.should == 1
+      end
+      
+      it "should assign title and body on modified" do
+        @comment.history_tracks.first.modified.should == {'title' => "test", 'body' =>  "comment"}
+      end
+      
+      it "should not assign title and body on original" do
+        @comment.history_tracks.first.original.should == {}
+      end
+      
+      
+      it "should assign modifier" do
+        @comment.history_tracks.first.modifier.should == @user
+      end
+      
+      it "should assigin version" do
+        @comment.history_tracks.first.version.should == 1
+      end
+      
+      it "should assigin scope" do
+        @comment.history_tracks.first.scope == "Post"
+      end
+      
+      it "should assigin association_chain" do
+        @comment.history_tracks.first.association_chain = [{:id => @post.id, :name => "Post"}, {:id => @comment.id, :name => "Comment"}]
+      end
+    end
+    
+    describe "on update non-embedded" do
+      it "should create a history track if changed attributes match tracked attributes" do
+        lambda {
+          @post.update_attributes(:title => "Another Test")
+        }.should change(HistoryTracker, :count).by(1)        
+      end
+
+      it "should not create a history track if changed attributes do not match tracked attributes" do
+        lambda {
+          @post.update_attributes(:rating => "untracked")
+        }.should change(HistoryTracker, :count).by(0)
+      end
+      
+      it "should assign modified fields" do
+        @post.update_attributes(:title => "Another Test")
+        @post.history_tracks.first.modified.should == {
+          "title" => "Another Test"
+        }
+      end
+      
+      it "should assign original fields" do
+        @post.update_attributes(:title => "Another Test")
+        @post.history_tracks.first.original.should == {
+          "title" => "Test"
+        }
+      end
+
+      it "should assign modifier" do
+        @post.update_attributes(:title => "Another Test")
+        @post.history_tracks.first.modifier.should == @user
+      end
+
+      it "should assigin version on history tracks" do
+        @post.update_attributes(:title => "Another Test")
+        @post.history_tracks.first.version.should == 1
+      end
+      
+      it "should assigin version on post" do
+        @post.update_attributes(:title => "Another Test")
+        @post.version.should == 1
+      end
+
+      it "should assigin scope" do
+        @post.update_attributes(:title => "Another Test")
+        @post.history_tracks.first.scope == "Post"
+      end
+
+      it "should assigin association_chain" do
+        @post.update_attributes(:title => "Another Test")
+        @post.history_tracks.first.association_chain = [{:id => @post.id, :name => "Post"}]
+      end
+    end
+    
+    describe "on update non-embedded twice" do
+      it "should assigin version on post" do
+        @post.update_attributes(:title => "Test2")
+        @post.update_attributes(:title => "Test3")
+        @post.version.should == 2
+      end
+
+      it "should create a history track if changed attributes match tracked attributes" do
+        lambda {
+          @post.update_attributes(:title => "Test2")
+          @post.update_attributes(:title => "Test3")
+        }.should change(HistoryTracker, :count).by(2)        
+      end
+      
+      it "should create a history track of version 2" do
+        @post.update_attributes(:title => "Test2")
+        @post.update_attributes(:title => "Test3")
+        @post.history_tracks.where(:version => 2).first.should_not be_nil
+      end
+      
+      it "should assign modified fields" do
+        @post.update_attributes(:title => "Test2")
+        @post.update_attributes(:title => "Test3")
+        @post.history_tracks.where(:version => 2).first.modified.should == {
+          "title" => "Test3"
+        }
+      end
+      
+      it "should assign original fields" do
+        @post.update_attributes(:title => "Test2")
+        @post.update_attributes(:title => "Test3")
+        @post.history_tracks.where(:version => 2).first.original.should == {
+          "title" => "Test2"
+        }
+      end
+      
+
+      it "should assign modifier" do
+        @post.update_attributes(:title => "Another Test", :modifier => @another_user)
+        @post.history_tracks.first.modifier.should == @another_user
+      end
+    end
+    
+    describe "on update embedded" do
+      it "should assigin version on comment" do
+        @comment.update_attributes(:title => "Test2")
+        @comment.version.should == 2 # first track generated on creation
+      end
+
+      it "should create a history track of version 2" do
+        @comment.update_attributes(:title => "Test2")
+        @comment.history_tracks.where(:version => 2).first.should_not be_nil
+      end
+      
+      it "should assign modified fields" do
+        @comment.update_attributes(:title => "Test2")
+        @comment.history_tracks.where(:version => 2).first.modified.should == {
+          "title" => "Test2"
+        }
+      end
+      
+      it "should assign original fields" do
+        @comment.update_attributes(:title => "Test2")
+        @comment.history_tracks.where(:version => 2).first.original.should == {
+          "title" => "test"
+        }
+      end
+
+      it "should assign modifier" do
+        @post.update_attributes(:title => "Another Test", :modifier => @another_user)
+        @post.history_tracks.first.modifier.should == @another_user
+      end
+    end
+    
+    describe "non-embedded" do
+      it "should undo changes" do
+        @post.update_attributes(:title => "Test2")
+        @post.history_tracks.where(:version => 1).first.undo!
+        @post.reload
+        @post.title.should == "Test"
+      end
+      
+      it "should create a new history track after undo" do
+        @post.update_attributes(:title => "Test2")
+        @post.history_tracks.where(:version => 1).first.undo!
+        @post.reload
+        @post.history_tracks.count.should == 2
+      end
+      
+      it "should stay the same after undo and redo" do
+        @post.update_attributes(:title => "Test2")
+        @track = @post.history_tracks.where(:version => 1).first
+        @track.undo!
+        @track.redo!
+        @post2 = Post.where(:_id => @post.id).first
+      
+        @post.title.should == @post2.title
+      end
+    end
+    
+    describe "embedded" do
+      it "should undo changes" do
+        @comment.update_attributes(:title => "Test2")
+        @comment.history_tracks.where(:version => 2).first.undo!
+        # reloading an embedded document === KAMIKAZE
+        # at least for the current release of mongoid...
+        @post.reload
+        @comment = @post.comments.first
+        @comment.title.should == "test"
+      end
+      
+      it "should create a new history track after undo" do
+        @comment.update_attributes(:title => "Test2")
+        @comment.history_tracks.where(:version => 2).first.undo!
+        @post.reload
+        @comment = @post.comments.first
+        @comment.history_tracks.count.should == 3
+      end
+      
+      it "should stay the same after undo and redo" do
+        @comment.update_attributes(:title => "Test2")
+        @track = @comment.history_tracks.where(:version => 2).first
+        @track.undo!
+        @track.redo!
+        @post2 = Post.where(:_id => @post.id).first
+        @comment2 = @post2.comments.first
+        
+        @comment.title.should == @comment2.title
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rspec'
+require 'easy_diff'
+require 'mongoid'
+require 'mongoid-history'
+require 'database_cleaner'
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :truncation
+  end
+  
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+end
+
+Mongoid.configure do |config|
+  config.master = Mongo::Connection.new.db("mongoid-history")
+end

data/spec/trackable_spec.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Mongoid::History::Trackable do
+  before :each do
+    class MyModel
+      include Mongoid::Document
+      include Mongoid::History::Trackable
+    end
+  end
+  
+  after :each do
+    Mongoid::History.trackable_classes = nil
+    Mongoid::History.trackable_class_options = nil
+  end
+
+  it "should have #track_history" do
+    MyModel.should respond_to :track_history
+  end
+  
+  it "should append trackable_classes ONLY when #track_history is called" do
+    Mongoid::History.trackable_classes.should be_blank
+    MyModel.track_history
+    Mongoid::History.trackable_classes.should == [MyModel]
+  end
+  
+  it "should append trackable_class_options ONLY when #track_history is called" do
+    Mongoid::History.trackable_class_options.should be_blank
+    MyModel.track_history
+    Mongoid::History.trackable_class_options.keys.should == [:my_model]
+  end
+  
+  describe "#track_history" do
+    before :each do
+      class MyModel
+        include Mongoid::Document
+        include Mongoid::History::Trackable
+        track_history
+      end
+      
+      @expected_option = {
+        :on             =>  :all,
+        :modifier_field =>  :modifier,
+        :version_field  =>  :version,
+        :scope          =>  :my_model,
+        :except         =>  ["created_at", "updated_at", "version", "modifier_id", "_id", "id"],
+        :track_create   =>  false
+      }
+    end
+    
+    after :each do
+      Mongoid::History.trackable_classes = nil
+      Mongoid::History.trackable_class_options = nil
+    end
+    
+    it "should have default options" do
+      Mongoid::History.trackable_class_options[:my_model].should == @expected_option
+    end
+    
+    it "should define callback function #track_update" do
+      MyModel.new.private_methods.collect(&:to_sym).should include(:track_update)
+    end
+    
+    it "should define callback function #track_create" do
+      MyModel.new.private_methods.collect(&:to_sym).should include(:track_create)
+    end
+
+    it "should define #history_trackable_options" do
+      MyModel.history_trackable_options.should == @expected_option
+    end
+  end
+end

data/spec/tracker_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Mongoid::History::Tracker do
+  before :each do
+    class MyTracker
+      include Mongoid::History::Tracker
+    end
+  end
+  
+  after :each do
+    Mongoid::History.tracker_class_name = nil
+  end
+  
+  it "should set tracker_class_name when included" do
+    Mongoid::History.tracker_class_name.should == :my_tracker
+  end
+end

metadata

@@ -0,0 +1,245 @@
+--- !ruby/object:Gem::Specification 
+name: mongoid-history
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Aaron Qian
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-04 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: easy_diff
+  version_requirements: *id001
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15424091
+        segments: 
+        - 2
+        - 0
+        - 0
+        - rc
+        - 7
+        version: 2.0.0.rc.7
+  name: mongoid
+  version_requirements: *id002
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  name: rspec
+  version_requirements: *id003
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 0
+        - 6
+        - 0
+        version: 0.6.0
+  name: yard
+  version_requirements: *id004
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  name: bundler
+  version_requirements: *id005
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  name: jeweler
+  version_requirements: *id006
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: rcov
+  version_requirements: *id007
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 2
+        - 8
+        version: 1.2.8
+  name: reek
+  version_requirements: *id008
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 2
+        - 1
+        - 0
+        version: 2.1.0
+  name: roodi
+  version_requirements: *id009
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id010 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: database_cleaner
+  version_requirements: *id010
+  prerelease: false
+description: |-
+  In frustration of Mongoid::Versioning, I created this plugin for tracking historical changes for any document, including embedded ones. It achieves this by storing all history tracks in a single collection that you define. (See Usage for more details) Embedded documents are referenced by storing an association path, which is an array of document_name and document_id fields starting from the top most parent document and down to the embedded document that should track history.
+  
+    This plugin implements multi-user undo, which allows users to undo any history change in any order. Undoing a document also creates a new history track. This is great for auditing and preventing vandalism, but it is probably not suitable for use cases such as a wiki.
+email: aqian@attinteractive.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- .rspec
+- .rvmrc
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/mongoid-history.rb
+- lib/mongoid/history.rb
+- lib/mongoid/history/trackable.rb
+- lib/mongoid/history/tracker.rb
+- mongoid-history.gemspec
+- spec/integration/integration_spec.rb
+- spec/spec_helper.rb
+- spec/trackable_spec.rb
+- spec/tracker_spec.rb
+has_rdoc: true
+homepage: http://github.com/aq1018/mongoid-history
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.3
+signing_key: 
+specification_version: 3
+summary: history tracking, auditing, undo, redo for mongoid
+test_files: 
+- spec/integration/integration_spec.rb
+- spec/spec_helper.rb
+- spec/trackable_spec.rb
+- spec/tracker_spec.rb