mil_vestal_versions 1.2.6

data/mil_vestal_versions.gemspec

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+Gem::Specification.new do |gem|
+  gem.name    = 'mil_vestal_versions'
+  gem.version = '1.2.6'
+
+  gem.authors     = ['Steve Richert', "James O'Kelly"]
+  gem.email       = ['steve.richert@gmail.com', 'dreamr.okelly@gmail.com']
+  gem.description = "Keep a DRY history of your ActiveRecord models' changes"
+  gem.summary     = gem.description
+  gem.homepage    = 'http://github.com/laserlemon/vestal_versions'
+
+  gem.add_dependency 'activerecord', '~> 3.0'
+  gem.add_dependency 'activesupport', '~> 3.0'
+
+  gem.files         = `git ls-files`.split($\)
+  gem.test_files    = gem.files.grep(/^spec/)
+  gem.require_paths = ['lib']
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'bundler'
+Bundler.require
+require 'rspec/core'
+
+RSpec.configure do |c|
+  c.before(:suite) do
+    CreateSchema.suppress_messages{ CreateSchema.migrate(:up) }
+  end
+
+  c.after(:suite) do
+    FileUtils.rm_rf(File.expand_path('../test.db', __FILE__))
+  end
+
+  c.after(:each) do
+    VestalVersions::Version.config.clear
+    User.prepare_versioned_options({})
+  end
+end
+
+Dir[File.expand_path('../support/*.rb', __FILE__)].each{|f| require f }

data/spec/support/models.rb

@@ -0,0 +1,19 @@
+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
+
+class DeletedUser < ActiveRecord::Base
+  self.table_name = 'users'
+  versioned :dependent => :tracking
+end
+
+class MyCustomVersion < VestalVersions::Version
+end

data/spec/support/schema.rb

@@ -0,0 +1,25 @@
+ActiveRecord::Base.establish_connection(
+  :adapter  => 'sqlite3',
+  :database => File.expand_path('../../test.db', __FILE__)
+)
+
+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.belongs_to :user, :polymorphic => true
+      t.string :user_name
+      t.text :modifications
+      t.integer :number
+      t.integer :reverted_from
+      t.string :tag
+      t.timestamps
+    end
+  end
+end

data/spec/vestal_versions/changes_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+describe VestalVersions::Changes do
+  context "a version's changes" do
+    let(:user){ User.create(:name => 'Steve Richert') }
+    subject{ user.versions.last.changes }
+
+    before do
+      user.update_attribute(:last_name, 'Jobs')
+    end
+
+    it { should be_a(Hash) }
+    it { should_not be_empty }
+
+    it 'has string keys' do
+      subject.keys.each{ |key| key.should be_a(String) }
+    end
+
+    it 'has two-element array values' do
+      subject.values.each do |key|
+        key.should be_a(Array)
+        key.size.should == 2
+      end
+    end
+
+    it 'has unique-element values' do
+      subject.values.each{ |v| v.uniq.should == v }
+    end
+
+    it "equals the model's changes" do
+      user.first_name = 'Stephen'
+      model_changes = user.changes
+      user.save
+      changes = user.versions.last.changes
+
+      model_changes.should == changes
+    end
+  end
+
+  context 'a hash of changes' do
+    let(:changes){ {'first_name' => ['Steve', 'Stephen']} }
+    let(:other){ {'first_name' => ['Catie', 'Catherine']} }
+
+    it 'properly appends other changes' do
+      expected = {'first_name' => ['Steve', 'Catherine']}
+
+      changes.append_changes(other).should == expected
+
+      changes.append_changes!(other)
+      changes.should == expected
+    end
+
+    it 'properly prepends other changes' do
+      expected = {'first_name' => ['Catie', 'Stephen']}
+
+      changes.prepend_changes(other).should == expected
+
+      changes.prepend_changes!(other)
+      changes.should == expected
+    end
+
+    it 'is reversible' do
+      expected = {'first_name' => ['Stephen', 'Steve']}
+
+      changes.reverse_changes.should == expected
+
+      changes.reverse_changes!
+      changes.should == expected
+    end
+  end
+
+  context 'the changes between two versions' do
+    let(:name){ 'Steve Richert' }
+    let(:user){ User.create(:name => name) }          # 1
+    let(:version){ user.version }
+
+    before do
+      user.update_attribute(:last_name, 'Jobs')       # 2
+      user.update_attribute(:first_name, 'Stephen')   # 3
+      user.update_attribute(:last_name, 'Richert')    # 4
+      user.update_attribute(:name, name)              # 5
+    end
+
+    it 'is a hash' do
+      1.upto(version) do |i|
+        1.upto(version) do |j|
+          user.changes_between(i, j).should be_a(Hash)
+        end
+      end
+    end
+
+    it 'has string keys' do
+      1.upto(version) do |i|
+        1.upto(version) do |j|
+          user.changes_between(i, j).keys.each{ |key| key.should be_a(String) }
+        end
+      end
+    end
+
+    it 'has two-element arrays with unique values' do
+      1.upto(version) do |i|
+        1.upto(version) do |j|
+          user.changes_between(i, j).values.each do |value|
+            value.should be_a(Array)
+            value.size.should == 2
+            value.uniq.should == value
+          end
+        end
+      end
+    end
+
+    it 'is empty between identical versions' do
+      user.changes_between(1, version).should be_empty
+      user.changes_between(version, 1).should be_empty
+    end
+
+    it 'is should reverse with direction' do
+      1.upto(version) do |i|
+        i.upto(version) do |j|
+          up    = user.changes_between(i, j)
+          down  = user.changes_between(j, i)
+          up.should == down.reverse_changes
+        end
+      end
+    end
+
+    it 'is empty with invalid arguments' do
+      1.upto(version) do |i|
+        user.changes_between(i, nil).should be_blank
+        user.changes_between(nil, i).should be_blank
+      end
+    end
+  end
+end

data/spec/vestal_versions/conditions_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe VestalVersions::Conditions do
+  shared_examples_for 'a conditional option' do |option|
+    before do
+      User.class_eval do
+        def true; true; end
+      end
+    end
+
+    it 'is an array' do
+      User.vestal_versions_options[option].should be_a(Array)
+      User.prepare_versioned_options(option => :true)
+      User.vestal_versions_options[option].should be_a(Array)
+    end
+
+    it 'has proc values' do
+      User.prepare_versioned_options(option => :true)
+      User.vestal_versions_options[option].each{|i| i.should be_a(Proc) }
+    end
+  end
+
+  it_should_behave_like 'a conditional option', :if
+  it_should_behave_like 'a conditional option', :unless
+
+  context 'a new version' do
+    subject{ User.create(:name => 'Steve Richert') }
+    let(:count){ subject.versions.count }
+
+    before do
+      User.class_eval do
+        def true; true; end
+        def false; false; end
+      end
+      count # memoize this value
+    end
+
+    after do
+      User.prepare_versioned_options(:if => [], :unless => [])
+    end
+
+    context 'with :if conditions' do
+      context 'that pass' do
+        before do
+          User.prepare_versioned_options(:if => [:true])
+          subject.update_attribute(:last_name, 'Jobs')
+        end
+
+        its('versions.count'){ should == count + 1 }
+      end
+
+      context 'that fail' do
+        before do
+          User.prepare_versioned_options(:if => [:false])
+          subject.update_attribute(:last_name, 'Jobs')
+        end
+
+        its('versions.count'){ should == count }
+      end
+    end
+
+    context 'with :unless conditions' do
+      context 'that pass' do
+        before do
+          User.prepare_versioned_options(:unless => [:true])
+          subject.update_attribute(:last_name, 'Jobs')
+        end
+
+        its('versions.count'){ should == count }
+      end
+
+      context 'that fail' do
+        before do
+          User.prepare_versioned_options(:unless => [:false])
+          subject.update_attribute(:last_name, 'Jobs')
+        end
+
+        its('versions.count'){ should == count + 1 }
+      end
+    end
+
+    context 'with :if and :unless conditions' do
+      context 'that pass' do
+        before do
+          User.prepare_versioned_options(:if => [:true], :unless => [:true])
+          subject.update_attribute(:last_name, 'Jobs')
+        end
+
+        its('versions.count'){ should == count }
+      end
+
+      context 'that fail' do
+        before do
+          User.prepare_versioned_options(:if => [:false], :unless => [:false])
+          subject.update_attribute(:last_name, 'Jobs')
+        end
+
+        its('versions.count'){ should == count }
+      end
+    end
+
+  end
+end

data/spec/vestal_versions/control_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe VestalVersions::Control do
+  let(:user){ User.create(:name => 'Steve Richert') }
+  let(:other_user){ User.create(:name => 'Michael Rossin') }
+  before do
+    @count = user.versions.count
+  end
+
+  shared_examples_for 'a version preserver' do |method|
+    it 'creates one version with a model update' do
+      user.send(method){ user.update_attribute(:last_name, 'Jobs') }
+
+      user.versions.count.should == @count
+    end
+
+    it 'creates one version with multiple model updates' do
+      user.send(method) do
+        user.update_attribute(:first_name, 'Stephen')
+        user.update_attribute(:last_name, 'Jobs')
+        user.update_attribute(:first_name, 'Steve')
+      end
+
+      user.versions.count.should == @count
+    end
+
+  end
+
+  shared_examples_for 'a version incrementer' do |method|
+    it 'creates one version with a model update' do
+      user.send(method){ user.update_attribute(:last_name, 'Jobs') }
+
+      user.versions.count.should == @count + 1
+    end
+
+    it 'creates one version with multiple model updates' do
+      user.send(method) do
+        user.update_attribute(:first_name, 'Stephen')
+        user.update_attribute(:last_name, 'Jobs')
+        user.update_attribute(:first_name, 'Steve')
+      end
+
+      user.versions.count.should == @count + 1
+    end
+
+  end
+
+  it_should_behave_like 'a version preserver', :skip_version
+  it_should_behave_like 'a version incrementer', :merge_version
+
+  context "when operating on the class level" do
+    before do
+      @count = user.versions.count
+      @other_user_count = other_user.versions.count
+    end
+    it 'skip_version doesn\' create versions on multiple models' do
+      other_user_count = other_user.versions.count
+
+      User.skip_version do
+        user.update_attribute(:first_name, 'Stephen')
+        user.update_attribute(:last_name, 'Jobs')
+        user.update_attribute(:first_name, 'Steve')
+
+        other_user.update_attribute(:first_name, 'Stephen')
+        other_user.update_attribute(:last_name, 'Jobs')
+        other_user.update_attribute(:first_name, 'Steve')
+      end
+      user.versions.count.should == @count
+      other_user.versions.count.should == @other_user_count
+    end
+
+  end
+
+  context 'within a append_version block' do
+
+    context 'when no versions exist' do
+      it_should_behave_like 'a version incrementer', :append_version
+    end
+
+    context 'when versions exist' do
+      let(:last_version){ user.versions.last }
+
+      before do
+        user.update_attribute(:last_name, 'Jobs')
+        user.update_attribute(:last_name, 'Richert')
+
+        @count = user.versions.count
+      end
+
+      it_should_behave_like 'a version preserver', :append_version
+
+      it "updates the last version with one update" do
+        original_id = last_version.id
+        original_attrs = last_version.attributes
+
+        user.append_version{ user.update_attribute(:last_name, 'Jobs') }
+
+        other_last_version = user.versions(true).last
+        other_last_version.id.should == original_id
+        other_last_version.attributes.should_not == original_attrs
+      end
+
+      it "updates the last version with multiple updates" do
+        original_id = last_version.id
+        original_attrs = last_version.attributes
+
+        user.append_version do
+          user.update_attribute(:first_name, 'Stephen')
+          user.update_attribute(:last_name, 'Jobs')
+          user.update_attribute(:first_name, 'Steve')
+        end
+
+        other_last_version = user.versions(true).last
+        other_last_version.id.should == original_id
+        other_last_version.attributes.should_not == original_attrs
+      end
+
+    end
+  end
+end