vestal_versions 0.4.4

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+test/*.db

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Steve Richert
+
+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,77 @@
+= vestal_versions
+
+Finally, DRY ActiveRecord versioning!
+
+<tt>acts_as_versioned</tt>[http://github.com/technoweenie/acts_as_versioned] by technoweenie[http://github.com/technoweenie] was a great start, but it failed to keep up with ActiveRecord's introduction of dirty objects in version 2.1. Additionally, each versioned model needs its own versions table that duplicates most of the original table's columns. The versions table is then populated with records that often duplicate most of the original record's attributes. All in all, not very DRY.
+
+<tt>simply_versioned</tt>[http://github.com/mmower/simply_versioned] by mmower[http://github.com/mmower] started to move in the right direction by removing a great deal of the duplication of acts_as_versioned. It requires only one versions table and no changes whatsoever to existing models. Its versions table stores all of the model attributes as a YAML hash in a single text column. But we could be DRYer!
+
+<tt>vestal_versions</tt> keeps in the spirit of consolidating to one versions table, polymorphically associated with its parent models. But it goes one step further by storing a serialized hash of only the models' changes. Think modern version control systems. By traversing the record of changes, the models can be reverted to any point in time.
+
+And that's just what <tt>vestal_versions</tt> does. Not only can a model be reverted to a previous version number but also to a date or time!
+
+== Installation
+
+In <tt>environment.rb</tt>:
+
+  Rails::Initializer.run do |config|
+    config.gem 'laserlemon-vestal_versions', :lib => 'vestal_versions', :source => 'http://gems.github.com'
+  end
+
+At your application root, run:
+
+  $ sudo rake gems:install
+  
+Next, generate and run the first and last versioning migration you'll ever need:
+
+  $ script/generate vestal_versions_migration
+  $ rake db:migrate
+
+== Example
+
+To version an ActiveRecord model, simply add <tt>versioned</tt> to your class like so:
+
+  class User < ActiveRecord::Base
+    versioned
+    
+    validates_presence_of :first_name, :last_name
+    
+    def name
+      "#{first_name} #{last_name}"
+    end
+  end
+
+It's that easy! Now watch it in action...
+
+  >> u = User.create(:first_name => 'Steve', :last_name => 'Richert')
+  => #<User first_name: "Steve", last_name: "Richert">
+  >> u.version
+  => 1
+  >> u.update_attribute(:first_name, 'Stephen')
+  => true
+  >> u.name
+  => "Stephen Richert"
+  >> u.version
+  => 2
+  >> u.revert_to(:first)
+  => 1
+  >> u.name
+  => "Steve Richert"
+  >> u.version
+  => 1
+  >> u.save
+  => true
+  >> u.version
+  => 3
+  >> u.update_attribute(:last_name, 'Jobs')
+  => true
+  >> u.name
+  => "Steve Jobs"
+  >> u.version
+  => 4
+  >> u.revert_to!(2)
+  => true
+  >> u.name
+  => "Stephen Richert"
+  >> u.version
+  => 5

data/Rakefile

@@ -0,0 +1,38 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |g|
+    g.name = 'vestal_versions'
+    g.summary = %(Keep a DRY history of your ActiveRecord models' changes)
+    g.description = %(Keep a DRY history of your ActiveRecord models' changes)
+    g.email = 'steve@laserlemon.com'
+    g.homepage = 'http://github.com/laserlemon/vestal_versions'
+    g.authors = %w(laserlemon)
+    g.add_development_dependency 'thoughtbot-shoulda'
+    g.rubyforge_project = 'laser-lemon'
+  end
+  Jeweler::RubyforgeTasks.new do |r|
+    r.doc_task = 'rdoc'
+  end
+rescue LoadError
+  puts 'Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com'
+end
+
+Rake::TestTask.new do |t|
+  t.libs = %w(test)
+  t.pattern = 'test/**/*_test.rb'
+end
+
+task :default => :test
+
+Rake::RDocTask.new do |r|
+  version = File.exist?('VERSION') ? File.read('VERSION') : nil
+  r.rdoc_dir = 'rdoc'
+  r.title = ['vestal_versions', version].compact.join(' ')
+  r.rdoc_files.include('README*')
+  r.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.4.4

data/generators/vestal_versions_migration/templates/migration.rb

@@ -0,0 +1,20 @@
+class CreateVestalVersions < ActiveRecord::Migration
+  def self.up
+    create_table :versions do |t|
+      t.belongs_to :versioned, :polymorphic => true
+      t.text :changes
+      t.integer :number
+      t.datetime :created_at
+    end
+
+    change_table :versions do |t|
+      t.index [:versioned_type, :versioned_id]
+      t.index :number
+      t.index :created_at
+    end
+  end
+
+  def self.down
+    drop_table :versions
+  end
+end

data/generators/vestal_versions_migration/vestal_versions_migration_generator.rb

@@ -0,0 +1,11 @@
+class VestalVersionsMigrationGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      m.migration_template 'migration.rb', 'db/migrate'
+    end
+  end
+
+  def file_name
+    'create_vestal_versions'
+  end
+end

data/init.rb

@@ -0,0 +1 @@
+require 'vestal_versions'

data/lib/version.rb

@@ -0,0 +1,13 @@
+class Version < ActiveRecord::Base
+  include Comparable
+
+  belongs_to :versioned, :polymorphic => true
+
+  serialize :changes, Hash
+
+  alias_attribute :version, :number
+
+  def <=>(other)
+    number <=> other.number
+  end
+end

data/lib/vestal_versions.rb

@@ -0,0 +1,127 @@
+require 'version'
+
+module LaserLemon
+  module VestalVersions
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def versioned
+        has_many :versions, :as => :versioned, :order => 'versions.number ASC', :dependent => :destroy do
+          def between(from_value, to_value)
+            from, to = number_at(from_value), number_at(to_value)
+            return [] if from.nil? || to.nil?
+            condition = (from == to) ? to : Range.new(*[from, to].sort)
+            all(
+              :conditions => {:number => condition},
+              :order => "versions.number #{(from > to) ? 'DESC' : 'ASC'}"
+            )
+          end
+
+          def at(value)
+            case value
+              when Version then value
+              when Numeric then find_by_number(value.floor)
+              when Symbol then respond_to?(value) ? send(value) : nil
+              when Date, Time then last(:conditions => ['versions.created_at <= ?', value.to_time])
+            end
+          end
+
+          def number_at(value)
+            case value
+              when Version then value.number
+              when Numeric then value.floor
+              when Symbol, Date, Time then at(value).try(:number)
+            end
+          end
+        end
+
+        after_save :create_version, :if => :needs_version?
+
+        include InstanceMethods
+        alias_method_chain :reload, :versions
+      end
+    end
+
+    module InstanceMethods
+      private
+        def needs_version?
+          !changed.empty?
+        end
+
+        def reset_version(new_version = nil)
+          @last_version = nil if new_version.nil?
+          @version = new_version
+        end
+
+        def create_version
+          if versions.empty?
+            versions.create(:changes => attributes, :number => 1)
+          else
+            reset_version
+            versions.create(:changes => changes, :number => (version.to_i + 1))
+          end
+
+          reset_version
+        end
+
+      public
+        def version
+          @version ||= last_version
+        end
+
+        def last_version
+          @last_version ||= versions.maximum(:number)
+        end
+
+        def reverted?
+          version != last_version
+        end
+
+        def reload_with_versions(*args)
+          reset_version
+          reload_without_versions(*args)
+        end
+
+        def revert_to(value)
+          to_value = versions.number_at(value)
+          return version if to_value == version
+          chain = versions.between(version, to_value)
+          return version if chain.empty?
+
+          new_version = chain.last.number
+          backward = chain.first > chain.last
+          backward ? chain.pop : chain.shift
+
+          timestamps = %w(created_at created_on updated_at updated_on)
+
+          chain.each do |version|
+            version.changes.except(*timestamps).each do |attribute, change|
+              new_value = backward ? change.first : change.last
+              write_attribute(attribute, new_value)
+            end
+          end
+
+          reset_version(new_version)
+        end
+
+        def revert_to!(value)
+          revert_to(value)
+          reset_version if saved = save
+          saved
+        end
+
+        def last_changes
+          return {} if version.nil? || version == 1
+          versions.at(version).changes
+        end
+
+        def last_changed
+          last_changes.keys
+        end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, LaserLemon::VestalVersions)

data/test/between_test.rb

@@ -0,0 +1,58 @@
+require 'test_helper'
+
+class BetweenTest < Test::Unit::TestCase
+  context 'The number of versions between' do
+    setup do
+      @user = User.create(:name => 'Steve Richert')
+      @version = @user.version
+      @valid = [@version, 0, 1_000_000, :first, :last, 1.day.since(@user.created_at), @user.versions.first]
+      @invalid = [nil, :bogus, 'bogus', Date.parse('0001-12-25')]
+    end
+
+    context 'the current version and the current version' do
+      should 'equal one' do
+        assert_equal 1, @user.versions.between(@version, @version).size
+      end
+    end
+
+    context 'the current version and a valid value' do
+      should 'not equal zero' do
+        @valid.each do |valid|
+          assert_not_equal 0, @user.versions.between(@version, valid).size
+          assert_not_equal 0, @user.versions.between(valid, @version).size
+        end
+      end
+    end
+
+    context 'the current version and an invalid value' do
+      should 'equal zero' do
+        @invalid.each do |invalid|
+          assert_equal 0, @user.versions.between(@version, invalid).size
+          assert_equal 0, @user.versions.between(invalid, @version).size
+        end
+      end
+    end
+
+    context 'two invalid values' do
+      should 'equal zero' do
+        @invalid.each do |first|
+          @invalid.each do |second|
+            assert_equal 0, @user.versions.between(first, second).size
+            assert_equal 0, @user.versions.between(second, first).size
+          end
+        end
+      end
+    end
+
+    context 'a valid value and an invalid value' do
+      should 'equal zero' do
+        @valid.each do |valid|
+          @invalid.each do |invalid|
+            assert_equal 0, @user.versions.between(valid, invalid).size
+            assert_equal 0, @user.versions.between(invalid, valid).size
+          end
+        end
+      end
+    end
+  end
+end

data/test/changes_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+class ChangesTest < Test::Unit::TestCase
+  context "A version's changes" do
+    setup do
+      @user = User.create(:name => 'Steve Richert')
+    end
+
+    should "initially equal its parent's attributes" do
+      assert_equal @user.attributes, @user.versions.first.changes
+    end
+
+    should 'contain all changed attributes' do
+      @user.name = 'Steve Jobs'
+      changes = @user.changes
+      @user.save
+      assert_equal changes, @user.versions.last.changes.slice(*changes.keys)
+    end
+
+    should 'contain timestamp changes when applicable' do
+      timestamp = 'updated_at'
+      @user.update_attribute(:name, 'Steve Jobs')
+      assert @user.class.content_columns.map(&:name).include?(timestamp)
+      assert_contains @user.versions.last.changes.keys, timestamp
+    end
+
+    should 'contain no more than the changed attributes and timestamps' do
+      timestamps = %w(created_at created_on updated_at updated_on)
+      @user.name = 'Steve Jobs'
+      changes = @user.changes
+      @user.save
+      assert_equal changes, @user.versions.last.changes.except(*timestamps)
+    end
+  end
+end

data/test/comparable_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+class ComparableTest < Test::Unit::TestCase
+  context 'A comparable version' do
+    setup do
+      @version_1 = Version.new(:number => 1)
+      @version_2 = Version.new(:number => 2)
+    end
+
+    should 'equal itself' do
+      assert @version_1 == @version_1
+      assert @version_2 == @version_2
+    end
+
+    context 'with version number 1' do
+      should 'not equal a version with version number 2' do
+        assert @version_1 != @version_2
+      end
+
+      should 'be less than a version with version number 2' do
+        assert @version_1 < @version_2
+      end
+    end
+
+    context 'with version number 2' do
+      should 'not equal a version with version number 1' do
+        assert @version_2 != @version_1
+      end
+
+      should 'be greater than a version with version number 1' do
+        assert @version_2 > @version_1
+      end
+    end
+  end
+end

data/test/creation_test.rb

@@ -0,0 +1,70 @@
+require 'test_helper'
+
+class CreationTest < Test::Unit::TestCase
+  context 'The number of versions' do
+    setup do
+      @name = 'Steve Richert'
+      @user = User.create(:name => @name)
+      @count = @user.versions.count
+    end
+
+    should 'initially equal one' do
+      assert_equal 1, @count
+    end
+
+    should 'not increase when no changes are made in an update' do
+      @user.update_attribute(:name, @name)
+      assert_equal @count, @user.versions.count
+    end
+
+    should 'not increase when no changes are made before a save' do
+      @user.save
+      assert_equal @count, @user.versions.count
+    end
+
+    should 'not increase when reverting to the current version' do
+      @user.revert_to!(@user.version)
+      assert_equal @count, @user.versions.count
+    end
+
+    context 'after an update' do
+      setup do
+        @initial_count = @count
+        @name = 'Steve Jobs'
+        @user.update_attribute(:name, @name)
+        @count = @user.versions.count
+      end
+
+      should 'increase by one' do
+        assert_equal @initial_count + 1, @count
+      end
+
+      should 'increase by one when reverted' do
+        @user.revert_to!(:first)
+        assert_equal @count + 1, @user.versions.count
+      end
+
+      should 'not increase until a revert is saved' do
+        @user.revert_to(:first)
+        assert_equal @count, @user.versions.count
+        @user.save
+        assert_not_equal @count, @user.versions.count
+      end
+    end
+
+    context 'after multiple updates' do
+      setup do
+        @initial_count = @count
+        @new_name = 'Steve Jobs'
+        @user.update_attribute(:name, @new_name)
+        @user.update_attribute(:name, @name)
+        @count = @user.versions.count
+      end
+
+      should 'not increase when reverting to an identical version' do
+        @user.revert_to!(:first)
+        assert_equal @count, @user.versions.count
+      end
+    end
+  end
+end

data/test/last_changes_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+class LastChangesTest < Test::Unit::TestCase
+  context "A created model's last changes" do
+    setup do
+      @user = User.create(:name => 'Steve Richert')
+    end
+
+    should 'be blank' do
+      assert @user.last_changes.blank?
+      assert @user.last_changed.blank?
+    end
+  end
+
+  context "An updated model's last changes" do
+    setup do
+      @user = User.create(:name => 'Steve Richert')
+      @previous_attributes = @user.attributes
+      @user.update_attribute(:name, 'Steve Jobs')
+      @current_attributes = @user.attributes
+    end
+
+    should 'have keys matching its last changed attributes' do
+      assert_equal @user.last_changes.keys, @user.last_changed
+    end
+
+    should 'values of two-element arrays with unique values' do
+      @user.last_changes.values.each do |value|
+        assert_kind_of Array, value
+        assert_equal 2, value.size
+        assert_equal value, value.uniq
+      end
+    end
+
+    should 'begin with the previous attribute values' do
+      changes = @user.last_changes.inject({}){|h,(k,v)| h.update(k => v.first) }
+      previous = @previous_attributes.slice(*@user.last_changed)
+      assert_equal previous, changes
+    end
+
+    should 'end with the current attribute values' do
+      changes = @user.last_changes.inject({}){|h,(k,v)| h.update(k => v.last) }
+      current = @current_attributes.slice(*@user.last_changed)
+      assert_equal current, changes
+    end
+  end
+end

data/test/revert_test.rb

@@ -0,0 +1,80 @@
+require 'test_helper'
+
+class RevertTest < Test::Unit::TestCase
+  context 'A model reversion' do
+    setup do
+      @user, @attributes, @times = User.new, {}, {}
+      names = ['Steve Richert', 'Stephen Richert', 'Stephen Jobs', 'Steve Jobs']
+      time = names.size.hours.ago
+      names.each do |name|
+        @user.update_attribute(:name, name)
+        @attributes[@user.version] = @user.attributes
+        time += 1.hour
+        @user.versions.last.update_attribute(:created_at, time)
+        @times[@user.version] = time
+      end
+      @user.reload.versions.reload
+      @first_version, @last_version = @attributes.keys.min, @attributes.keys.max
+    end
+
+    should 'do nothing for a non-existent version' do
+      attributes = @user.attributes
+      @user.revert_to!(nil)
+      assert_equal attributes, @user.attributes
+    end
+
+    should 'return the new version number' do
+      new_version = @user.revert_to(@first_version)
+      assert_equal @first_version, new_version
+    end
+
+    should 'change the version number when saved' do
+      current_version = @user.version
+      @user.revert_to!(@first_version)
+      assert_not_equal current_version, @user.version
+    end
+
+    should 'be able to target the first version' do
+      @user.revert_to(:first)
+      assert_equal @first_version, @user.version
+    end
+
+    should 'be able to target the last version' do
+      @user.revert_to(:last)
+      assert_equal @last_version, @user.version
+    end
+
+    should 'do nothing for a non-existent method name' do
+      current_version = @user.version
+      @user.revert_to(:bogus)
+      assert_equal current_version, @user.version
+    end
+
+    should 'be able to target a version number' do
+      @user.revert_to(1)
+      assert 1, @user.version
+    end
+
+    should 'be able to target a date and time' do
+      @times.each do |version, time|
+        @user.revert_to(time + 1.second)
+        assert_equal version, @user.version
+      end
+    end
+
+    should 'be able to target a version object' do
+      @user.versions.each do |version|
+        @user.revert_to(version)
+        assert_equal version.number, @user.version
+      end
+    end
+
+    should "correctly roll back the model's attributes" do
+      timestamps = %w(created_at created_on updated_at updated_on)
+      @attributes.each do |version, attributes|
+        @user.revert_to!(version)
+        assert_equal attributes.except(*timestamps), @user.attributes.except(*timestamps)
+      end
+    end
+  end
+end

data/test/schema.rb

@@ -0,0 +1,37 @@
+ActiveRecord::Base.establish_connection(
+  :adapter => defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby' ? 'jdbcsqlite3' : 'sqlite3',
+  :database => File.join(File.dirname(__FILE__), 'test.db')
+)
+
+class CreateSchema < ActiveRecord::Migration
+  def self.up
+    create_table :users, :force => true do |t|
+      t.string :first_name
+      t.string :last_name
+      t.timestamps
+    end
+
+    create_table :versions, :force => true do |t|
+      t.belongs_to :versioned, :polymorphic => true
+      t.text :changes
+      t.integer :number
+      t.datetime :created_at
+    end
+  end
+end
+
+CreateSchema.suppress_messages do
+  CreateSchema.migrate(:up)
+end
+
+class User < ActiveRecord::Base
+  versioned
+
+  def name
+    [first_name, last_name].compact.join(' ')
+  end
+
+  def name=(names)
+    self[:first_name], self[:last_name] = names.split(' ', 2)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+$: << File.dirname(__FILE__)
+
+require 'rubygems'
+require 'test/unit'
+require 'activerecord'
+require 'shoulda'
+require 'vestal_versions'
+require 'schema'
+begin; require 'redgreen'; rescue LoadError; end

data/vestal_versions.gemspec

@@ -0,0 +1,69 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{vestal_versions}
+  s.version = "0.4.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["laserlemon"]
+  s.date = %q{2009-09-03}
+  s.description = %q{Keep a DRY history of your ActiveRecord models' changes}
+  s.email = %q{steve@laserlemon.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "generators/vestal_versions_migration/templates/migration.rb",
+     "generators/vestal_versions_migration/vestal_versions_migration_generator.rb",
+     "init.rb",
+     "lib/version.rb",
+     "lib/vestal_versions.rb",
+     "test/between_test.rb",
+     "test/changes_test.rb",
+     "test/comparable_test.rb",
+     "test/creation_test.rb",
+     "test/last_changes_test.rb",
+     "test/revert_test.rb",
+     "test/schema.rb",
+     "test/test_helper.rb",
+     "vestal_versions.gemspec"
+  ]
+  s.homepage = %q{http://github.com/laserlemon/vestal_versions}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{laser-lemon}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Keep a DRY history of your ActiveRecord models' changes}
+  s.test_files = [
+    "test/between_test.rb",
+     "test/changes_test.rb",
+     "test/comparable_test.rb",
+     "test/creation_test.rb",
+     "test/last_changes_test.rb",
+     "test/revert_test.rb",
+     "test/schema.rb",
+     "test/test_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::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    else
+      s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: vestal_versions
+version: !ruby/object:Gem::Version 
+  version: 0.4.4
+platform: ruby
+authors: 
+- laserlemon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-03 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Keep a DRY history of your ActiveRecord models' changes
+email: steve@laserlemon.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- generators/vestal_versions_migration/templates/migration.rb
+- generators/vestal_versions_migration/vestal_versions_migration_generator.rb
+- init.rb
+- lib/version.rb
+- lib/vestal_versions.rb
+- test/between_test.rb
+- test/changes_test.rb
+- test/comparable_test.rb
+- test/creation_test.rb
+- test/last_changes_test.rb
+- test/revert_test.rb
+- test/schema.rb
+- test/test_helper.rb
+- vestal_versions.gemspec
+has_rdoc: true
+homepage: http://github.com/laserlemon/vestal_versions
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: laser-lemon
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Keep a DRY history of your ActiveRecord models' changes
+test_files: 
+- test/between_test.rb
+- test/changes_test.rb
+- test/comparable_test.rb
+- test/creation_test.rb
+- test/last_changes_test.rb
+- test/revert_test.rb
+- test/schema.rb
+- test/test_helper.rb