historical 0.2.0

data/.gitignore

@@ -0,0 +1,5 @@
+
+*.db
+*.log
+previous_failures.txt
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Marcel Jackwerth
+
+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,17 @@
+= historical2
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Marcel Jackwerth. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "historical"
+    gem.summary = %Q{DRY and serialization-free versioning for ActiveRecord}
+    gem.description = %Q{Rewrite of the original historical-plugin using MongoDB}
+    gem.email = "marcel@northdocks.com"
+    gem.homepage = "http://github.com/sirlantis/historical"
+    gem.authors = ["Marcel Jackwerth"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "historical #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.2.0

data/historical.gemspec

@@ -0,0 +1,61 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{historical}
+  s.version = "0.2.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Marcel Jackwerth"]
+  s.date = %q{2010-08-16}
+  s.description = %q{Rewrite of the original historical-plugin using MongoDB}
+  s.email = %q{marcel@northdocks.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "historical.gemspec",
+     "lib/historical.rb",
+     "lib/historical/active_record.rb",
+     "lib/historical/model_history.rb",
+     "lib/historical/models/attribute_diff.rb",
+     "lib/historical/models/model_diff.rb",
+     "lib/historical/models/model_version.rb",
+     "lib/historical/mongo_mapper_enhancements.rb",
+     "rails/init.rb",
+     "spec/historical_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/sirlantis/historical}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{DRY and serialization-free versioning for ActiveRecord}
+  s.test_files = [
+    "spec/historical_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+    else
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+  end
+end
+

data/lib/historical.rb

@@ -0,0 +1,33 @@
+module Historical
+  IGNORED_ATTRIBUTES = [:id, :created_at, :updated_at]
+  
+  autoload :ModelHistory, "historical/model_history"
+  autoload :ActiveRecord, "historical/active_record"
+  autoload :MongoMapperEnhancements, "historical/mongo_mapper_enhancements"
+  
+  module Models
+    module Pool
+      # cached classes are stored here
+      
+      def self.pooled(name)
+        @@class_pool ||= {}
+        return @@class_pool[name] if @@class_pool[name]
+        
+        cls = yield
+        
+        Historical::Models::Pool::const_set(name, cls)
+        @@class_pool[name] = cls
+        
+        cls
+      end
+      
+      def self.pooled_name(specialized_for, parent)
+        "#{specialized_for.name.demodulize}#{parent.name.demodulize}"
+      end
+    end
+    
+    autoload :AttributeDiff,  'historical/models/attribute_diff'
+    autoload :ModelDiff,      'historical/models/model_diff'
+    autoload :ModelVersion,   'historical/models/model_version'
+  end
+end

data/lib/historical/active_record.rb

@@ -0,0 +1,67 @@
+module Historical
+  module ActiveRecord
+    def self.sql_to_type(type)
+      case type.to_sym
+      when :datetime then "Time"
+      when :text then "String"
+      when :decimal then "Float"
+      when :timestamp then "Time"
+      else
+        type.to_s.classify
+      end
+    end
+    
+    def is_historical(&block)
+      class_eval do
+        cattr_accessor :historical_customizations, :historical_installed
+        attr_accessor :historical_differences, :historical_creation, :historical_version
+        
+        # dirty attributes a removed after save, so we need to check it here
+        before_update do |record|
+          record.historical_differences = !record.changes.empty?
+          true
+        end
+        
+        # new_record flag is removed after save, so we need to check it here
+        before_save do |record|
+          record.historical_creation = record.new_record?
+          true
+        end
+        
+        after_save do |record|
+          next unless record.historical_creation or record.historical_differences
+          
+          Historical::Models::ModelVersion.for_class(record.class).new.tap do |v|
+            v._record_id    = record.id
+            v._record_type  = record.class.name
+            
+            record.attribute_names.each do |attr_name|
+              attr = attr_name.to_sym
+              next if Historical::IGNORED_ATTRIBUTES.include? attr
+              v.send("#{attr}=", record[attr])
+            end
+            
+            v.diff = Historical::Models::ModelDiff.from_versions(v.previous, v)
+            v.save!
+          end
+        end
+        
+        def history
+          @history ||= Historical::ModelHistory.new(self)
+        end
+        
+        def version
+          historical_version || history.own_version.version_index
+        end
+      end
+      
+      self.historical_installed         = true
+      self.historical_customizations    ||= []
+      self.historical_customizations    << block if block_given?
+      
+      # generate pooled classes
+      Historical::Models::ModelDiff.for_class(self)
+      Historical::Models::ModelVersion.for_class(self)
+    end
+  end
+end

data/lib/historical/model_history.rb

@@ -0,0 +1,92 @@
+module Historical
+  class ModelHistory
+    attr_reader :record
+    
+    def initialize(record)
+      @record = record
+      @base_version = record.historical_version
+      @base_version ||= -1 if record.new_record?
+      @base_version ||= versions.count - 1
+    end
+  
+    def versions
+      Models::ModelVersion.for_record(record).sort(:created_at.asc, :id.asc)
+    end
+    
+    def own_version
+      own = versions.skip(@base_version).limit(1).first
+      raise "couldn't find myself (base_version: #{@base_version}, versions: #{versions.count})" unless own
+      own
+    end
+    
+    def previous_version
+      own_version.previous
+    end
+    
+    def next_version
+      own_version.next
+    end
+  
+    def latest_version
+      versions.last
+    end
+  
+    def original_version
+      versions.first
+    end
+  
+    def creation
+      versions.where("diff.diff_type" => "creation").first
+    end
+  
+    def updates
+      versions.where("diff.diff_type" => "update")
+    end
+    
+    def find_version(position)
+      versions.skip(position).limit(1).first
+    end
+    
+    def version_by_query(query)
+      case query
+      when Numeric                then find_version(query)
+      when Symbol                 then send(query)
+      when Models::ModelVersion   then query
+      else
+        nil
+      end
+    end
+    
+    def restore(version_query)
+      version = version_by_query(version_query)
+      
+      raise ::ActiveRecord::RecordNotFound, "version does not exist" unless version
+      
+      record.clone.tap do |r|
+        r.id = record.id
+        
+        r.class.columns.each do |c|
+          attr = c.name.to_sym
+          next if Historical::IGNORED_ATTRIBUTES.include? attr
+          
+          r[attr] = version.send(attr)
+        end
+        
+        r.historical_version = version.version_index
+        r.clear_association_cache
+      end
+    end
+    
+    def restore_with_protection(*args)
+      restore_without_protection(*args).tap do |r|
+        r.readonly!
+      end
+    end
+    
+    alias_method_chain :restore, :protection
+    
+    %w(original latest previous next).each do |k|
+      alias_method k, "#{k}_version"
+    end
+  end
+end

data/lib/historical/models/attribute_diff.rb

@@ -0,0 +1,70 @@
+module Historical::Models
+  class AttributeDiff
+    include MongoMapper::EmbeddedDocument
+    extend Historical::MongoMapperEnhancements
+  
+    key :_type,           String
+    
+    key :attribute,       String, :required => true
+    key :attribute_type,  String, :required => true
+    
+    key :_old_value,      Object
+    key :_new_value,      Object
+  
+    attr_accessor :parent
+  
+    alias_method :old_value, :_old_value
+    alias_method :new_value, :_new_value    
+
+    protected :_old_value=, :_new_value=, :_old_value, :_new_value
+    
+    def self.specialized_for(parent, attribute)
+      type = detect_attribute_type(parent, attribute)
+      Historical::Models.const_get(specialized_class_name(type))
+    end
+    
+    def self.specialized_class_name(type)
+      ruby_type = Historical::ActiveRecord.sql_to_type(type)
+      "#{ruby_type}#{simple_name}"
+    end
+    
+    def self.simple_name
+      name.to_s.demodulize
+    end
+  
+    def old_value=(value)
+      self._old_value = cast_value(value)
+    end
+  
+    def new_value=(value)
+      self._new_value = cast_value(value)
+    end
+  
+    def self.detect_attribute_type(parent, attribute)
+      model_class = parent.record.class
+      
+      column = model_class.columns.select do |c|
+        c.name.to_s == attribute.to_s
+      end.first
+    
+      column ? column.type.to_s : nil
+    end
+    
+    protected
+    
+    def cast_value(value)
+      value
+    end
+  end
+  
+  %w{Date String Time Boolean Integer Float Binary}.each do |type|
+    superclass = AttributeDiff
+    diff_class = Class.new(superclass)
+    type_class = type.constantize
+    
+    diff_class.send :key, :_old_value, type_class
+    diff_class.send :key, :_new_value, type_class
+    
+    self.const_set "#{type}#{superclass.simple_name}", diff_class
+  end
+end

data/lib/historical/models/model_diff.rb

@@ -0,0 +1,90 @@
+module Historical::Models
+  class ModelDiff
+    include MongoMapper::EmbeddedDocument
+    extend Historical::MongoMapperEnhancements
+    class_inheritable_accessor :historical_callbacks
+
+    validates_associated :changes
+
+    key   :_type,       String
+    key   :diff_type,   String,   :required => true
+    many  :changes,     :class_name => "Historical::Models::AttributeDiff"
+    
+    delegate :creation?, :update?, :to => :diff_type_inquirer
+  
+    def record
+      new_version.record
+    end
+  
+    def new_version
+      @parent || _parent_document
+    end
+  
+    def old_version
+      new_version.previous
+    end
+
+    def self.from_versions(from, to)
+      return from_creation(to) if from.nil?
+      
+      generate_from_version(from, 'update').tap do |d|
+        from.record.attribute_names.each do |attr_name|
+          attr = attr_name.to_sym
+          next if Historical::IGNORED_ATTRIBUTES.include? attr
+    
+          old_value, new_value = from[attr], to[attr]
+         
+          Historical::Models::AttributeDiff.specialized_for(d, attr).new.tap do |ad|
+            ad.attribute_type = Historical::Models::AttributeDiff.detect_attribute_type(d, attr)
+            ad.parent = d
+            ad.old_value = old_value
+            ad.new_value = new_value
+            ad.attribute = attr.to_s
+            d.changes << ad
+          end if old_value != new_value
+        end
+      end
+    end
+
+    def self.from_creation(to)
+      generate_from_version(to)
+    end
+  
+    protected
+    
+    def diff_type_inquirer
+      ActiveSupport::StringInquirer.new(diff_type)
+    end
+    
+    def self.historical_callback(&block)
+      raise "no block given" unless block_given?
+
+      self.historical_callbacks ||= []
+      self.historical_callbacks << block
+    end
+    
+  
+    def self.generate_from_version(version, type = 'creation')
+      for_class(version.record.class).new.tap do |d|
+        d.diff_type   = type
+        d.instance_variable_set :@parent, version
+        
+        if cbs = d.class.historical_callbacks
+          cbs.each do |c|
+            c.call(d)
+          end
+        end
+      end
+    end
+    
+    def self.for_class(source_class)
+      Historical::Models::Pool.pooled(Historical::Models::Pool.pooled_name(source_class, self)) do
+        Class.new(self).tap do |cls|
+          source_class.historical_customizations.each do |customization|
+            cls.instance_eval(&customization)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/historical/models/model_version.rb

@@ -0,0 +1,70 @@
+module Historical::Models  
+  class ModelVersion
+    include MongoMapper::Document
+    extend Historical::MongoMapperEnhancements
+    
+    validate :validate_diff
+
+    key :_type,           String
+    
+    belongs_to_active_record :_record, :polymorphic => true, :required => true
+    
+    timestamps!
+  
+    one :diff, :class_name => "Historical::Models::ModelDiff"
+    
+    alias_method :record, :_record
+  
+    def siblings
+      self.class.for_record(_record_id, _record_type)
+    end
+  
+    def previous_versions
+      (new? ? siblings : siblings.where(:created_at.lte => created_at, :_id.lt => _id)).sort(:created_at.desc)
+    end
+  
+    def previous
+      previous_versions.first
+    end
+  
+    def next_versions
+      siblings.where(:created_at.gte => created_at, :_id.gt => _id).sort(:created_at.asc)
+    end
+  
+    def next
+      next_versions.first
+    end
+    
+    def version_index
+      previous_versions.count
+    end
+    
+    def self.for_record(record_or_id, type = nil)
+      if type
+        ModelVersion.where(:_record_id => record_or_id, :_record_type => type)
+      else
+        ModelVersion.where(:_record_id => record_or_id.id, :_record_type => record_or_id.class.name)
+      end
+    end
+    
+    def self.for_class(source_class)
+      Historical::Models::Pool.pooled(Historical::Models::Pool.pooled_name(source_class, self)) do
+        Class.new(self).tap do |cls|
+          source_class.columns.each do |col|
+            next if Historical::IGNORED_ATTRIBUTES.include? col.name.to_sym
+            type = Historical::ActiveRecord.sql_to_type(col.type)
+            cls.send :key, col.name, type.constantize
+          end
+        end
+      end
+    end
+    
+    protected
+    
+    def validate_diff
+      if diff.present? and !diff.valid?
+        errors.add(:diff, "not valid")
+      end
+    end
+  end
+end

data/lib/historical/mongo_mapper_enhancements.rb

@@ -0,0 +1,49 @@
+module Historical
+  module MongoMapperEnhancements
+    def belongs_to_active_record(name, options = {})
+      ar_id_field   = "#{name}_id"
+      ar_type_field = "#{name}_type"
+      
+      polymorphic   = options.delete(:polymorphic)
+      class_name    = options.delete(:class_name)
+      model_class   = nil
+      
+      unless polymorphic
+        if class_name
+          model_class = class_name.is_a?(Class) ? class_name.name : class_name.classify
+        else
+          model_class = name.to_s.classify
+        end
+      end
+      
+      key ar_id_field,    Integer,  options
+      key ar_type_field,  String,   options if polymorphic
+      
+      define_method name do
+        if id = send(ar_id_field)
+          if polymorphic
+            type_class = send(ar_type_field)
+            type_class ? type_class.constantize.find(id) : nil
+          else
+            model_class.constantize.find(id)
+          end
+        else
+          nil
+        end
+      end
+      
+      define_method "#{name}=" do |val|
+        id = type = nil
+        
+        if val
+          raise "expected an instace of ActiveRecord::Base, got: #{val.class.name}" unless val.is_a?(::ActiveRecord::Base)
+          type  = val.class.name
+          id    = val.id
+        end
+        
+        send("#{ar_id_field}=",   id)
+        send("#{ar_type_field}=", type) if polymorphic
+      end
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1,3 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'historical')
+
+ActiveRecord::Base.send(:extend, Historical::ActiveRecord)

data/spec/historical_spec.rb

@@ -0,0 +1,289 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "A historical model" do
+  class User < ActiveRecord::Base
+    set_table_name "users"
+  end
+  
+  class Message < ActiveRecord::Base
+    extend Historical::ActiveRecord
+    is_historical
+  end
+  
+  context "when created" do
+    it "should persist" do
+      msg = Message.new(:title => "Hello")
+      msg.save.should be_true
+    end
+    
+    it "should create a creation-diff" do
+      msg = Message.create(:title => "Hello")
+      
+      msg.history.tap do |h|
+        h.versions.count.should   be(1)
+        h.updates.should          be_empty
+        
+        h.creation.should_not             be_nil
+        h.creation.diff.diff_type.should  == "creation"
+        h.creation.diff.should            be_creation
+      end
+    end
+  end
+  
+  context "when not modified" do
+    before :each do
+      @msg = Message.create(:title => "Hello")
+      @msg.title += "Different"
+      @msg.save!
+    end
+    
+    it "should not create new versions" do
+      version_count = lambda { @msg.history.versions.count }
+  
+      lambda do
+        @msg.save!
+      end.should_not change(version_count, :call)
+    end
+  end
+  
+  context "when modified" do
+    it "should keep the correct value-types" do
+      m = Message.create
+      
+      time = Time.now.utc
+      date = Date.today.advance(:days => 5)
+      
+      m.title = "Hello there!"
+      m.body = "I am no spambot."
+      m.votes = 42
+      m.read = true
+      m.donated = 13.37
+      m.published_at = time
+      m.stamped_on = date
+      m.save!
+      
+      m.history.updates.count.should == 1
+      change = m.history.updates.last.diff
+      changes = change.changes
+      grouped = {}
+      
+      changes.each do |c|
+        grouped[c.attribute.to_sym] = c
+      end
+      
+      grouped[:title].new_value.should == "Hello there!"
+      grouped[:title].old_value.should == nil
+      
+      grouped[:body].new_value.should == "I am no spambot."
+      grouped[:body].old_value.should == nil
+      
+      grouped[:votes].new_value.should == 42
+      grouped[:votes].old_value.should == nil
+      
+      grouped[:read].new_value.should == true
+      grouped[:read].old_value.should == false
+      
+      grouped[:published_at].new_value.class.should == Time
+      grouped[:published_at].new_value.should == Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec)
+      grouped[:published_at].old_value.should == nil
+      
+      grouped[:stamped_on].new_value.class.should == Date
+      grouped[:stamped_on].new_value.should == date
+      grouped[:stamped_on].old_value.should == nil
+    end
+    
+    context "on a single field" do
+      before :each do
+        @first_title = "Hello"
+        @new_title = "Hello World"
+        @msg = Message.create(:title => @first_title)
+        @msg.title = @new_title
+        @msg.save!
+      end
+    
+      it "should create new versions" do
+        @msg.history.tap do |h|
+          h.versions.count.should         == 2
+          h.original_version.title.should == @first_title
+          h.previous.title.should         == @first_title
+          h.latest_version.title.should   == @new_title
+        end
+      end
+    
+      it "should create an update-diff" do
+        @msg.history.tap do |h|
+          h.updates.count.should                == 1
+          h.updates.first.diff.diff_type.should == "update"
+          h.updates.first.diff.should           be_update
+        
+          h.creation.diff.should       == h.versions.first.diff
+          h.updates.first.diff.should  == h.versions.last.diff
+        end
+      end
+    
+      it "should create attribute-diffs in update-diff" do
+        @msg.history.tap do |h|
+          model_diff = h.updates.first.diff
+          model_diff.changes.count.should == 1
+  
+          model_diff.changes.first.tap do |diff|  
+            diff.attribute.should == "title"
+            diff.old_value.should == @first_title
+            diff.new_value.should == @new_title
+          end
+        end
+      end
+    end
+    
+    context "on multiple fields" do
+      it "should create multiple attribute-diffs in update-diff" do
+        @msg = Message.create
+        
+        @msg.title = "Foo"
+        @msg.read = true
+        @msg.save!
+        
+        @msg.history.versions.count.should == 2
+        @msg.history.updates.count.should == 1
+        
+        @msg.history.tap do |h|
+          changes = h.updates.first.diff.changes
+          changes.count.should == 2
+  
+          attributes_changed = changes.collect do |change|
+            change.attribute.to_s
+          end
+          
+          Set.new(attributes_changed).should == Set.new(%w(title read))
+        end
+      end
+    end
+  end
+  
+  context "when restored" do
+    before :each do
+      @message = Message.create(:title => "one")
+      @message.title = "two"
+      @message.save!
+
+      @restored = @message.history.restore(@message.history.original_version)
+    end
+    
+    it "should contain the previous values" do
+      r = @restored
+      r.should_not    be_nil
+      r.should        be_kind_of(Message)
+      r.title.should  == "one"
+    end
+    
+    it "should not modifiy the original" do
+      @message.title.should == "two"
+    end
+    
+    it "should be read-only" do
+      lambda { @restored.save! }.should raise_exception(ActiveRecord::ReadOnlyRecord)
+    end
+  end
+  
+  it "should also accept a version number for restoration" do
+    @message = Message.create(:title => "one")
+    @message.update_attributes(:title => "two").should be_true
+    @message.update_attributes(:title => "three").should be_true
+    
+    @restored = @message.history.restore(0)
+    @restored.title.should == "one"
+    
+    @restored = @message.history.restore(1)
+    @restored.title.should == "two"
+    
+    @restored = @message.history.restore(2)
+    @restored.title.should == "three"
+  end
+  
+  it "should raise an exception for invalid version numbers" do
+    @message = Message.create(:title => "one")
+    @message.history.versions.count.should == 1
+    
+    lambda{ @message.history.restore(-1) }.should raise_exception
+    lambda{ @message.history.restore(1)  }.should raise_exception(ActiveRecord::RecordNotFound)
+  end
+  
+  it "should allow handy queryies for restoration" do
+    @message = Message.create(:title => "one")
+    @message.update_attributes(:title => "two").should be_true
+    
+    @message.history.restore(:original).title.should == "one"
+  end
+  
+  it "should find version-neighbors" do
+    @message = Message.create(:title => "one")
+    @message.update_attributes(:title => "two").should be_true
+    @message.update_attributes(:title => "three").should be_true
+    
+    mid = @message.history.versions.skip(1).limit(1).first
+    mid.title.should == "two"
+    
+    mid.previous_versions.count.should  == 1
+    mid.next_versions.count.should      == 1
+    mid.previous.should                 == @message.history.versions.skip(0).limit(1).first
+    mid.next.should                     == @message.history.versions.skip(2).limit(1).first
+  end
+  
+  it "should not break handy queries for chained restorations" do
+    @message = Message.create(:title => "one")
+    @message.update_attributes(:title => "two").should be_true
+    @message.history.own_version.version_index.should == 1
+    @message.version.should == 1
+    
+    previous = @message.history.restore(:previous)
+    previous.history.own_version.version_index.should == 0
+    previous.version.should == 0
+    
+    identity = previous.history.restore(:next)
+    identity.history.own_version.version_index.should == 1
+    identity.version.should == 1
+    
+    identity.should_not     be_nil
+    identity.title.should   == "two"
+  end
+  
+  context "with customization" do
+    class AuditedMessage < ActiveRecord::Base
+      set_table_name "messages"
+      
+      cattr_accessor :current_user
+
+      extend Historical::ActiveRecord
+      is_historical do
+        belongs_to_active_record :author, :required => true, :class_name => "User"
+
+        historical_callback do |diff|
+          diff.author = AuditedMessage.current_user
+        end
+      end
+    end
+    
+    before :each do
+      AuditedMessage.current_user = nil
+    end
+    
+    it "should create custom keys on ModelDiffs" do
+      user = User.create(:name => "Jane Doe")
+      AuditedMessage.current_user = user
+      
+      msg = AuditedMessage.create(:title => "one")
+      
+      author = msg.history.versions.first.diff.author
+      author.should == user
+      author.id.should == user.id
+    end
+    
+    it "should validate requirements" do
+      # no author is set
+      
+      lambda do
+        AuditedMessage.create(:title => "one")
+      end.should raise_exception(MongoMapper::DocumentNotValid)
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,9 @@
+--color
+--format
+nested
+--loadby
+mtime
+--reverse
+--timeout
+20
+--diff

data/spec/spec_helper.rb

@@ -0,0 +1,47 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'historical'
+require 'spec'
+require 'spec/autorun'
+
+require 'rubygems'
+
+gem "rails", "= 2.3.8"
+
+require 'active_support'
+require 'active_support/test_case'
+require 'active_record'
+require 'mongo_mapper'
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+ActiveRecord::Base.logger ||= Logger.new(STDOUT)  
+ActiveRecord::Base.logger.level = Logger::WARN
+
+ActiveRecord::Base.silence do
+  ActiveRecord::Schema.define(:version => 1) do
+    self.verbose = false
+    
+    create_table :messages do |t|
+      t.string    :title
+      t.text      :body
+      t.integer   :votes
+      t.datetime  :published_at
+      t.date      :stamped_on
+      t.decimal   :donated,       :precision => 10, :scale => 2
+      t.boolean   :read,          :null => false, :default => false
+      t.timestamps
+    end
+    
+    create_table :users do |t|
+      t.string :name
+      t.timestamps
+    end
+  end
+end
+
+MongoMapper.database = "historical-test"
+MongoMapper.database.collections.each(&:remove)
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification 
+name: historical
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- Marcel Jackwerth
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-16 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id001
+description: Rewrite of the original historical-plugin using MongoDB
+email: marcel@northdocks.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- historical.gemspec
+- lib/historical.rb
+- lib/historical/active_record.rb
+- lib/historical/model_history.rb
+- lib/historical/models/attribute_diff.rb
+- lib/historical/models/model_diff.rb
+- lib/historical/models/model_version.rb
+- lib/historical/mongo_mapper_enhancements.rb
+- rails/init.rb
+- spec/historical_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/sirlantis/historical
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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.3.7
+signing_key: 
+specification_version: 3
+summary: DRY and serialization-free versioning for ActiveRecord
+test_files: 
+- spec/historical_spec.rb
+- spec/spec_helper.rb