mongomapper-versioned 0.0.1

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/README.md

@@ -0,0 +1,106 @@
+## Versioned
+
+Automatically store a version of a MongoMapper document every time it's updated. Configure a maximum number of versions you'd like to keep, or even the amount of time a particular document should keep versions around.
+
+### Setup
+
+Add the gem to your Gemfile. Add the necessary Mongo indexes: run `Version.create_indexes` in your console, or if you are using Rails run the `rake versioned:create_indexes` command.
+
+### Basic Usage
+
+Add the `versioned` declaration to the MongoMapper document models you want to keep versions of. When you make a change to a versioned document, a new version will be stored. Deleting a stored document will delete all the associated versions.
+
+````ruby
+class User
+  versioned 
+  
+  key :name, String
+  key :email, String
+end
+````
+
+### Querying
+
+Every versioned document model has an association called `versions`. It's a plain old MongoMapper one-to-many association with the `Version` model, sorted in reverse chronological order. You can query for versions using MongoMapper's standard query criteria:
+
+````ruby
+@user.versions.where(:created_at.lt > 1.day.ago)
+````
+
+### Pruning old versions
+
+Use the `max` option to specifiy the maximum number of versions you want to keep. When the document is updated, the oldest versions will be pruned away to keep no more than the maximum number you specify.
+
+````ruby
+class User
+  versioned max: 10
+  
+  key :name, String
+  key :email, String
+end
+````
+
+If you'd rather specify the amount of time the versions of a doc should be kept, implement `keep_versions_for`. It must return the number of seconds to keep each revision. Every time a new version is created, versions will be purged based on their age.
+
+This doesn't work with the `max` option.  Use one or the other.
+
+````ruby
+class User
+  versioned
+  
+  key :name, String
+  key :email, String
+  
+  def keep_versions_for
+    90.days
+  end
+end
+```` 
+
+### Auditing
+
+When a versioned document is saved, you can pass the `updater` option to the save method. The associated version will keep a reference to the document passed. This allows you to keep track of who made a change to a versioned document.
+
+````ruby
+@reginold = User.find_by_email('reggie@hotmail.com')
+@user.name = "Bob"
+@user.save(:updater => @reginold)
+@user.versions.first.updater
+=> @reginold
+````
+
+### Rolling back
+
+Each `Version` contains a copy of the document that was versioned. You can roll back to a particular version by calling the `rollback` method on the version you want. Reload the versioned document to pull the changes into the reference you're holding to the document.
+
+````ruby
+@user.versions[5].rollback
+@user.reload
+````
+
+### Version IDs
+
+A versioned document has a `version_id` key. When you update a document, the new Version document takes on the ID of the document's current `version_id` value. The document gets a new `version_id`.
+
+Rolling back to a previous revision will also roll back the `version_id` value of the document.
+
+This mechanism allows you to undo changes to a document:
+
+````ruby
+version_id = @user.version_id
+@user.name 
+=> "Roger"
+
+@user.name = "Frank"
+@user.save
+@user.name = "Bob"
+@user.save
+@user.versions.find(version_id).rollback
+
+@user.reload
+@user.name
+=> "Roger"
+@user.version_id == version_id
+=> true
+````
+

data/Rakefile

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'rake'
+
+require File.join(File.dirname(__FILE__), '/lib/versioned')
+
+require 'rake/testtask'
+namespace :test do
+  Rake::TestTask.new(:unit) do |test|
+    test.libs << 'test'
+    test.ruby_opts << '-rubygems'
+    test.pattern = 'test/unit/**/test_*.rb'
+    test.verbose = true 
+  end
+
+  Rake::TestTask.new(:performance) do |test|
+    test.libs << 'test'
+    test.ruby_opts << '-rubygems'
+    test.pattern = 'test/performance/**/*.rb'
+    test.verbose = true 
+  end
+end
+
+task :default => 'test:unit'
+
+desc 'Builds the gem'
+task :build do
+  sh 'gem build versioned.gemspec'
+  Dir.mkdir('pkg') unless File.directory?('pkg')
+  sh "mv mongomapper-versioned-#{Versioned::VERSION}.gem pkg/mongomapper-versioned-#{Versioned::VERSION}.gem"
+end
+
+desc 'Builds and Installs the gem'
+task :install => :build do
+  sh "gem install pkg/mongomapper-versioned-#{Versioned::VERSION}.gem"
+end

data/lib/mongomapper-versioned.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), 'versioned')

data/lib/tasks/versioned.rake

@@ -0,0 +1,16 @@
+namespace :versioned do
+  desc "Check MongoMapper Versioned plugin indexes"
+  task :check_indexes => :environment do
+    missing = Version.missing_indexes
+    if missing.empty?
+      puts "Indexes have already been created."
+    else
+      puts "Indexes have not been created. Run `rake versioned:create_indexes`."
+    end
+  end
+  
+  desc "Create MongoMapper Versioned plugin indexes"
+  task :create_indexes => :environment do
+    Version.create_indexes
+  end
+end

data/lib/versioned.rb

@@ -0,0 +1,20 @@
+require 'mongo_mapper'
+require File.join(File.dirname(__FILE__), 'versioned', 'meta')
+require File.join(File.dirname(__FILE__), 'versioned', 'version')
+require File.join(File.dirname(__FILE__), 'versioned', 'versioned')
+
+module Versioned  
+  if Kernel.const_defined?(:Rails) && Rails.constants.include?(:Engine)
+    class Engine < ::Rails::Engine
+      engine_name :versioned
+      initializer "versioned.initialize" do |app|
+        MongoMapper::Document.plugin(Versioned)
+      end
+      initializer 'versioned.check_indexes', :after=> :disable_dependency_loading do
+        Version.check_indexes
+      end
+    end
+  else
+    MongoMapper::Document.plugin(Versioned)
+  end
+end

data/lib/versioned/meta.rb

@@ -0,0 +1,3 @@
+module Versioned
+  VERSION = "0.0.1"
+end

data/lib/versioned/version.rb

@@ -0,0 +1,79 @@
+require 'active_support/core_ext/array/conversions'
+require 'mongomapper_id2'
+
+class Version
+  include MongoMapper::Document
+
+  auto_increment!
+  
+  key :doc, Hash
+  key :created_at, Time
+  
+  before_create :set_created_at
+  
+  belongs_to :versioned, polymorphic: true
+  belongs_to :updater, polymorphic: true
+
+  class << self
+    def check_indexes
+      unless missing_indexes.empty?
+        msg = "Indexes have not been created for MongoMapper versioned docs. Run `rake versioned:create_indexes`."
+        if Kernel.const_defined?(:IRB)
+          puts "Warning: #{msg}"
+        else
+          ::Rails.logger.warn(msg)
+        end
+      end
+    end
+    
+    def missing_indexes
+      existing_index_names = self.collection.index_information.keys
+      required_index_names = required_indexes.collect do |i| 
+        i.first.collect { |k| "#{k[0]}_#{k[1]}" }.join('_')
+      end
+      required_index_names - existing_index_names
+    end
+
+    def create_indexes
+      required_indexes.each do |index|
+        ensure_index *index
+      end
+    end
+    
+    def required_indexes
+      [
+        [[[:versioned_id, 1], [:versioned_type, 1], [:created_at, -1]], background: true ],
+        [[[:versioned_id, 1], [:versioned_type, 1], [:id2, -1]], background: true],
+        [[[:versioned_id, 1], [:versioned_type, 1], [:id2, 1]], background: true]
+      ]
+    end
+  end
+  
+  def rollback
+    versioned.rollback do
+      trouble = []
+      versioned.version_id = self.id
+      self.doc.each_pair do |attr, val|
+        mutator = "#{attr}="
+        if versioned.respond_to?(mutator)
+          versioned.send(mutator, val)
+        else
+          trouble.push(attr)
+        end
+      end
+      unless trouble.empty?
+        raise "Trying to load a #{versioned.class.name} version that has unsupported attributes: #{trouble.to_sentence}" 
+      end
+      versioned.versions.destroy_all(:id2.gte => self.id2)
+      versioned.save
+    end
+  end
+  
+  protected
+  # Update the created_at field on the Document to the current time. This is only called on create.
+  def set_created_at
+    unless self.created_at
+      self.created_at = Time.now.utc 
+    end
+  end
+end

data/lib/versioned/versioned.rb

@@ -0,0 +1,100 @@
+require 'active_support/concern'
+
+module Versioned  
+  extend ActiveSupport::Concern
+  
+  module ClassMethods
+    def versioned(opts={})
+      self.send(:include, Versioned::Document)
+      self.max_versions = opts[:max].to_i
+    end
+  end
+  
+  module Document
+    extend ActiveSupport::Concern
+    
+    included do      
+      key :version_id, ObjectId, default: proc { BSON::ObjectId.new }
+      
+      many :versions, :as => :versioned, :sort => :id2.desc
+      
+      before_update :push_version, :unless => :rolling_back?
+      after_update :prune_versions
+      after_destroy :destroy_versions
+      
+      cattr_accessor :max_versions
+      attr_accessor :updater, :version_created_at
+      attr_writer :rolling_back
+    end
+    
+    def rolling_back?
+      !!@rolling_back
+    end
+    
+    def save(options={})
+      options.assert_valid_keys(:updater, :version_created_at)
+      self.updater = options.delete(:updater)
+      self.version_created_at = options.delete(:version_created_at)
+      super
+    end
+    
+    def push_version
+      unless self.changes.empty?
+        version = self.versions.create(_id: self.version_id, doc: version_doc, updater: self.updater)
+        self.generate_version_id
+      end
+    ensure
+      self.updater = nil
+      self.version_created_at = nil
+    end
+    
+    def generate_version_id
+      version_id = BSON::ObjectId.new
+      # don't use #save; that'll generate a new version
+      self.write_attribute(:version_id, version_id)
+      self.collection.update({'_id' => self.id}, { 'version_id' => version_id })
+      self.changed_attributes.clear
+    end
+    
+    def prune_versions
+      if self.keep_versions_created_before
+        self.versions.destroy_all(:created_at.lt => self.keep_versions_created_before)
+      elsif self.class.max_versions
+        limit = self.versions.count - self.class.max_versions
+        if limit > 0
+          self.versions.destroy_all(sort: 'id2 asc', limit: limit)
+        end
+      end
+    end
+    
+    def keep_versions_created_before
+      if self.respond_to?(:keep_versions_for)
+        Time.now - self.keep_versions_for
+      end
+    end
+    
+    def destroy_versions
+      self.versions.destroy_all
+    end
+    
+    def version_doc
+      {}.tap do |doc|
+        doc.merge!(self.attributes)
+        self.changes.each_pair do |attr, vals|
+          doc[attr] = vals.first
+        end
+        doc.delete('_id')
+        doc.delete('version_id')
+      end
+    end
+    
+    def rollback
+      self.rolling_back = true
+      yield
+    ensure
+      self.rolling_back = false
+    end
+    
+
+  end
+end

data/test/config/config.rb

@@ -0,0 +1,3 @@
+require 'mongo_mapper'
+
+MongoMapper.database = YAML.load(File.read('test/config/database.yml'))[ENV['RACK_ENV']]['database'] rescue 'versioned_test'

data/test/config/database.yml

@@ -0,0 +1,5 @@
+development:
+  database: versioned_dev
+
+test:
+  database: versioned_test

data/test/models/post.rb

@@ -0,0 +1,8 @@
+class Post
+  include MongoMapper::EmbeddedDocument
+  
+  key :date, Time
+  key :body, String
+  key :title, String
+
+end

data/test/models/user.rb

@@ -0,0 +1,10 @@
+class User
+  include MongoMapper::Document
+
+  versioned
+
+  key :name, String
+  key :email, String
+
+  many :posts
+end

data/test/performance/read_write.rb

@@ -0,0 +1,65 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../lib/versioned')
+
+require 'benchmark'
+
+MongoMapper.database = 'versioned_performance'
+ 
+class Max
+  include MongoMapper::Document
+
+  versioned max: 10
+
+  key :approved, Boolean
+  key :count, Integer
+  key :approved_at, Time
+  key :expire_on, Date
+end
+Max.collection.remove
+
+class Timed
+  include MongoMapper::Document
+  
+  versioned
+
+  key :approved, Boolean
+  key :count, Integer
+  key :approved_at, Time
+  key :expire_on, Date
+  
+  def keep_versions_for
+    1.second
+  end
+end
+Timed.collection.remove
+
+class None
+  include MongoMapper::Document
+  
+  key :approved, Boolean
+  key :count, Integer
+  key :approved_at, Time
+  key :expire_on, Date
+end
+None.collection.remove
+
+Benchmark.bm(28) do |x|
+  max_ids, timed_ids, ids = [], [], []
+  x.report("write with versioning (max)  ") do
+    1000.times { |i| max_ids << Max.create(:count => 0, :approved => true, :approved_at => Time.now, :expire_on => Date.today).id }
+  end
+  x.report("write with versioning (timed)") do
+    1000.times { |i| timed_ids << Timed.create(:count => 0, :approved => true, :approved_at => Time.now, :expire_on => Date.today).id }
+  end
+  x.report("write without versioning     ") do
+    1000.times { |i| ids << None.create(:count => 0, :approved => true, :approved_at => Time.now, :expire_on => Date.today).id }
+  end
+  x.report("read with versioning (max)   ") do
+    max_ids.each { |id| Max.first(:id => id) }
+  end
+  x.report("read with versioning (timed) ") do
+    timed_ids.each { |id| Timed.first(:id => id) }
+  end
+  x.report("read without versioning      ") do
+    ids.each { |id| None.first(:id => id) }
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,29 @@
+$LOAD_PATH.unshift('.') unless $LOAD_PATH.include?('.')
+
+require File.expand_path(File.dirname(__FILE__) + '/../lib/versioned')
+require 'test/config/config'
+
+require 'pp'
+require 'shoulda'
+require 'timecop'
+
+require 'test/models/post'
+require 'test/models/user'
+
+
+def create_user
+  User.create!(
+    :name => 'Alex Wolfe', 
+    :email => 'alexkwolfe@gmail.com',
+    :posts => []
+  )
+end
+
+def cleanup
+  User.delete_all
+  Version.delete_all
+end
+
+
+
+

data/test/unit/test_versioning.rb

@@ -0,0 +1,229 @@
+require 'test_helper'
+
+class VersioningTest < ActiveSupport::TestCase
+  setup do
+    User.max_versions = nil
+    @user = create_user
+  end
+  
+  teardown do
+    cleanup
+  end
+  
+  context 'Versioned document' do
+    should 'have versions' do
+      assert @user.respond_to?(:versions)
+      assert_equal [], @user.versions
+    end
+    
+    should 'have version id' do
+      assert @user.version_id.is_a?(BSON::ObjectId)
+    end
+    
+    should 'not share version ids' do
+      assert_not_equal @user.version_id, create_user.version_id
+    end
+    
+    should 'not push version on empty update' do
+      @user.save
+      assert @user.versions.empty?
+    end
+    
+    should 'not get a new version id on empty update' do
+      version_id = @user.version_id
+      @user.save
+      assert_equal version_id, @user.version_id
+    end
+
+    context 'that has been updated' do
+      setup do
+        @version_id = @user.version_id
+        @user.name = "alex"
+        @user.save
+      end
+      
+      should 'push version' do
+        assert_equal 1, @user.versions.size
+      end
+      
+      should 'use version id' do
+        assert_equal @version_id, @user.versions.first.id
+      end
+      
+      should 'get a new version id' do
+        assert_not_equal @version_id, @user.version_id
+      end
+      
+      should 'rollback to previous version' do 
+        @user.versions.first.rollback
+        @user.reload
+        assert_equal "Alex Wolfe", @user.name
+      end
+      
+      should 'rollback version id' do
+        @user.versions.first.rollback
+        @user.reload
+        assert_equal @version_id, @user.version_id
+      end
+      
+      should 'not store doc id in version doc' do
+        doc = @user.versions.first.doc
+        assert_nil doc['id']
+        assert_nil doc['_id']
+      end
+      
+      should 'not store version_id in version doc' do
+        doc = @user.versions.first.doc
+        assert_nil doc['version_id']
+      end
+    end
+    
+    context 'that has been updated many times' do
+      setup do
+        @version_id = @user.version_id
+        # Versions: Alex 4, Alex 3, Alex 2, Alex 1, Alex Wolfe
+        (1..5).each do |i| 
+          @user.name = "Alex #{i}"
+          @user.save!
+        end
+      end
+      
+      should 'sort versions in reverse chronological order' do
+        assert_equal @user.versions.to_a.sort {|x,y| y.created_at <=> x.created_at }, @user.versions.to_a
+        assert_equal 5, @user.versions.count
+        assert_equal "Alex 4", @user.versions.first.doc['name']
+        assert_equal "Alex Wolfe", @user.versions.last.doc['name']
+      end
+      
+      should 'find by version id' do
+        version = @user.versions.find(@version_id)
+        assert_equal @version_id, version.id
+        assert_equal 'Alex Wolfe', version.doc['name']
+      end
+      
+      context 'and has been rolled back' do
+        setup do
+          # second to oldest
+          @version = @user.versions[2] 
+          @version.rollback 
+          @user.reload
+        end
+        
+        should 'have original data' do
+          assert_equal "Alex 2", @user.name
+        end
+        
+        should 'have original version id' do
+          assert_equal @version.id, @user.version_id
+        end
+        
+        should 'have correct versions' do
+          assert_equal 2, @user.versions.count
+          assert_equal 'Alex 1', @user.versions.first.doc['name']
+          assert_equal 'Alex Wolfe', @user.versions.last.doc['name']
+        end
+      end
+    end
+    
+    context 'that has been updated by a user' do
+      setup do
+        @updater = User.create!(name: 'Bobby Brown', email: 'bobbeh@brown.com')
+        @user.name = "alex"
+        @user.save(updater: @updater)
+      end
+      
+      should 'store user with version' do
+        assert_equal @updater, @user.versions.first.updater
+      end
+      
+      should 'forget user after save' do
+        assert @user.updater.nil?
+      end
+    end
+  end
+  
+  context 'Destroyed versioned document' do
+    setup do
+      (1..5).each do |i| 
+        @user.name = "#{@user.name} #{i}"
+        @user.save!
+      end
+    end
+    
+    should 'destroy versions' do
+      @user.destroy
+      assert_equal 0, Version.count
+    end
+    
+    should 'not destroy versions of other documents' do
+      assert_equal 5, Version.count
+      @user2 = create_user
+      @user2.name = "Foo"
+      @user2.save
+      @user2.name = "Bar"
+      @user2.save
+      
+      assert_equal 7, Version.count
+      
+      @user.destroy
+      
+      assert_equal 2, Version.count
+      assert_equal 2, @user2.versions.count
+      assert_equal "Foo", @user2.versions.first.doc['name']
+    end
+  end
+  
+  context 'Versioned document with max versions' do
+    setup do
+      User.max_versions = 5
+      (1..21).each do |i| 
+        @user.name = "Alex #{i}"
+        @user.save!
+      end
+      @user.reload
+    end
+    
+    should 'have no more than max' do
+      assert_equal 5, @user.versions.count
+      assert_equal ["Alex 20", "Alex 19", "Alex 18", "Alex 17", "Alex 16"], @user.versions.collect{|v| v.doc['name']}
+    end
+  end
+  
+  context 'Versioned document with time limit' do
+    setup do
+      class << @user
+        def keep_versions_for
+          5.minutes
+        end
+      end
+      (1..20).each do |i| 
+        Timecop.freeze(i.minutes.ago) do
+          @user.name = "Alex #{i}"
+          @user.save!
+        end
+      end
+    end
+    
+    should 'calculate time threshold' do
+      assert_equal (Time.now.utc - 5.minutes).to_i, @user.keep_versions_created_before.to_i
+    end
+    
+    should 'prune documents older than time limit' do
+      @user.prune_versions
+      assert_equal 4, @user.versions.count
+      @user.versions.each do |v|
+        assert v.created_at >= @user.keep_versions_created_before
+      end
+    end
+    
+    should "not prune other documents' versions" do
+      Timecop.freeze(10.minutes.ago) do
+        @user2 = create_user
+        @user2.name = "Foo Bar"
+        @user2.save!
+      end
+      @user.prune_versions
+      assert_equal 1, @user2.versions.count
+    end
+  end
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: mongomapper-versioned
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Alex Wolfe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: &70092868791380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70092868791380
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  requirement: &70092868790820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70092868790820
+- !ruby/object:Gem::Dependency
+  name: mongo_mapper
+  requirement: &70092868790140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.10.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *70092868790140
+- !ruby/object:Gem::Dependency
+  name: mongomapper_id2
+  requirement: &70092868789500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70092868789500
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70092868788360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70092868788360
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: &70092868787940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70092868787940
+- !ruby/object:Gem::Dependency
+  name: ruby-debug19
+  requirement: &70092868787380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70092868787380
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: &70092868786800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70092868786800
+description: 
+email: alexkwolfe@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mongomapper-versioned.rb
+- lib/tasks/versioned.rake
+- lib/versioned/meta.rb
+- lib/versioned/version.rb
+- lib/versioned/versioned.rb
+- lib/versioned.rb
+- Gemfile
+- Rakefile
+- README.md
+- test/config/config.rb
+- test/config/database.yml
+- test/models/post.rb
+- test/models/user.rb
+- test/performance/read_write.rb
+- test/test_helper.rb
+- test/unit/test_versioning.rb
+homepage: http://github.com/alexkwolfe/mongomapper-versioned
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: A MongoMapper extension adding Versioning
+test_files:
+- test/config/config.rb
+- test/config/database.yml
+- test/models/post.rb
+- test/models/user.rb
+- test/performance/read_write.rb
+- test/test_helper.rb
+- test/unit/test_versioning.rb