vestal_versions 1.0.2 → 2.0.0

data/spec/vestal_versions/reversion_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe VestalVersions::Reversion do
+  subject{ User.new }
+  let(:attributes){ {} }
+  let(:first_version){ attributes.keys.min }
+  let(:last_version){ attributes.keys.max }
+  let(:times){ {} }
+  let(:names){
+    ['Steve Richert', 'Stephen Richert', 'Stephen Jobs', 'Steve Jobs']
+  }
+
+  before do
+    time = names.size.hours.ago
+
+    names.each do |name|
+      subject.update_attribute(:name, name)
+      attributes[subject.version] = subject.attributes
+      time += 1.hour
+
+      subject.versions.last.try(:update_attribute, :created_at, time)
+
+      times[subject.version] = time
+    end
+  end
+
+  it 'returns the new version number' do
+    subject.revert_to(first_version).should == first_version
+  end
+
+  it 'changes the version number when saved' do
+    expect{ subject.revert_to! first_version }.to change{ subject.version }
+  end
+
+  it 'does nothing for a invalid argument' do
+    [nil, :bogus, 'bogus', (1..2)].each do |invalid|
+      expect{ subject.revert_to(invalid) }.to_not change{ subject.version }
+    end
+  end
+
+  it 'is able to target a version number' do
+    subject.revert_to(1)
+    subject.version.should == 1
+  end
+
+  it 'is able to target a date and time' do
+    times.each do |version, time|
+      subject.revert_to(time + 1.second)
+      subject.version.should == version
+    end
+  end
+
+  it 'is able to target a version object' do
+    subject.versions.each do |version|
+      subject.revert_to(version)
+      subject.version.should == version.number
+    end
+  end
+
+  it "correctly rolls back the model's attributes" do
+    except = %w(created_at created_on updated_at updated_on)
+
+    attributes.each do |version, attributes|
+      subject.revert_to!(version)
+      subject.attributes.except(*except).should == attributes.except(*except)
+    end
+  end
+
+  it "stores the reverted_from pointing to the previous version" do
+    subject.revert_to!(1)
+    subject.versions.last.reverted_from.should == 1
+  end
+
+  it "does not store the reverted_from for subsequent saves" do
+    subject.revert_to!(1)
+    subject.update_attributes(:name => 'Bill Gates')
+    subject.versions.last.reverted_from.should be_nil
+  end
+
+  it "stores the reverted_from pointing to the version it was reverted from when save is called later" do
+    subject.revert_to(1)
+    subject.name = "Reverted"
+    subject.save
+    subject.versions.last.reverted_from.should == 1
+  end
+
+  it "does not store the reverted_from for subsequent saves when the revert_to-save is called later" do
+    subject.revert_to(1)
+    subject.name = "Reverted"
+    subject.save
+    subject.update_attributes(:name => 'Bill Gates')
+    subject.versions.last.reverted_from.should be_nil
+  end
+
+  it "clears the reverted_from if the model is reloaded after a revert_to without a save" do
+    subject.revert_to(1)
+    subject.reload
+    subject.update_attributes(:name => 'Bill Gates')
+
+    subject.versions.last.reverted_from.should be_nil
+  end
+
+end

data/spec/vestal_versions/users_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe VestalVersions::Users do
+  let(:updated_by){ User.create(:name => 'Steve Jobs') }
+  let(:user){ User.create(:name => 'Steve Richert') }
+
+  it 'defaults to nil' do
+    user.update_attributes(:first_name => 'Stephen')
+    user.versions.last.user.should be_nil
+  end
+
+  it 'accepts and returns an ActiveRecord user' do
+    user.update_attributes(:first_name => 'Stephen', :updated_by => updated_by)
+    user.versions.last.user.should == updated_by
+  end
+
+  it 'accepts and returns a string user name' do
+    user.update_attributes(:first_name => 'Stephen', :updated_by => updated_by.name)
+    user.versions.last.user.should == updated_by.name
+  end
+end

data/spec/vestal_versions/version_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe VestalVersions::Versions do
+  let(:user){ User.create(:name => 'Stephen Richert') }
+
+  before do
+    user.update_attribute(:name, 'Steve Jobs')
+    user.update_attribute(:last_name, 'Richert')
+    @first_version, @last_version = user.versions.first, user.versions.last
+  end
+
+  it 'is comparable to another version based on version number' do
+    @first_version.should == @first_version
+    @last_version.should == @last_version
+    @first_version.should_not == @last_version
+    @last_version.should_not == @first_version
+    @first_version.should < @last_version
+    @last_version.should > @first_version
+    @first_version.should <= @last_version
+    @last_version.should >= @first_version
+  end
+
+  it "is not equal a separate model's version with the same number" do
+    other = User.create(:name => 'Stephen Richert')
+    other.update_attribute(:name, 'Steve Jobs')
+    other.update_attribute(:last_name, 'Richert')
+    first_version, last_version = other.versions.first, other.versions.last
+
+    @first_version.should_not == first_version
+    @last_version.should_not == last_version
+  end
+
+  it 'defaults to ordering by number when finding through association' do
+    numbers = user.versions.map(&:number)
+    numbers.sort.should == numbers
+  end
+
+  it 'returns true for the "initial?" method when the version number is 1' do
+    version = user.versions.build(:number => 1)
+    version.number.should == 1
+    version.should be_initial
+  end
+  
+  it "sreturn the version number if it is not a revert" do
+    user.version.should == user.versions.last.original_number
+  end
+
+  it "return the reverted_version if it is a revert" do
+    user.revert_to!(1)
+    user.versions.last.original_number.should == 1
+  end
+
+  it "return the original version if it is a double revert" do
+    user.revert_to!(2)
+    version = user.version
+    user.update_attributes(:last_name => 'Gates')
+    user.revert_to!(version)
+    user.versions.last.original_number.should == 2
+  end
+  
+end

data/spec/vestal_versions/version_tagging_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe VestalVersions::VersionTagging do
+  let(:user){ User.create(:name => 'Steve Richert') }
+
+  before do
+    user.update_attribute(:last_name, 'Jobs')
+  end
+
+  context 'an untagged version' do
+    it "updates the version record's tag column" do
+      tag_name = 'TAG'
+      last_version = user.versions.last
+
+      last_version.tag.should_not == tag_name
+      user.tag_version(tag_name)
+      last_version.reload.tag.should == tag_name
+    end
+
+    it 'creates a version record for an initial version' do
+      user.revert_to(1)
+      user.versions.at(1).should be_nil
+
+      user.tag_version('TAG')
+      user.versions.at(1).should_not be_nil
+    end
+  end
+
+  context 'A tagged version' do
+    subject{ user.versions.last }
+
+    before do
+      user.tag_version('TAG')
+    end
+
+    it { should be_tagged }
+  end
+
+end

data/spec/vestal_versions/versioned_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe VestalVersions::Versioned do
+  it 'respond to the "versioned?" method' do
+    ActiveRecord::Base.should respond_to(:versioned?)
+    User.should respond_to(:versioned?)
+  end
+
+  it 'return true for the "versioned?" method if the model is versioned' do
+    User.should be_versioned
+  end
+
+  it 'return false for the "versioned?" method if the model is not versioned' do
+    ActiveRecord::Base.should_not be_versioned
+  end
+end

data/spec/vestal_versions/versions_spec.rb

@@ -0,0 +1,176 @@
+require 'spec_helper'
+
+describe VestalVersions::Versions do
+  subject{ User.new }
+  let(:times){ {} }
+  let(:names){
+    ['Steve Richert', 'Stephen Richert', 'Stephen Jobs', 'Steve Jobs']
+  }
+
+  before do
+    time = names.size.hours.ago
+
+    names.each do |name|
+      subject.update_attribute(:name, name)
+      subject.tag_version(subject.version.to_s)
+      time += 1.hour
+
+      subject.versions.last.update_attribute(:created_at, time)
+      times[subject.version] = time
+    end
+  end
+
+  it 'is searchable between two valid version values' do
+    times.keys.each do |number|
+      times.values.each do |time|
+        subject.versions.between(number, number).should be_a(Array)
+        subject.versions.between(number, time).should be_a(Array)
+        subject.versions.between(time, number).should be_a(Array)
+        subject.versions.between(time, time).should be_a(Array)
+        subject.versions.between(number, number).should_not be_empty
+        subject.versions.between(number, time).should_not be_empty
+        subject.versions.between(time, number).should_not be_empty
+        subject.versions.between(time, time).should_not be_empty
+      end
+    end
+  end
+
+  it 'returns an empty array when searching between a valid and an invalid version value' do
+    times.each do |number, time|
+      subject.versions.between(number, nil).should == []
+      subject.versions.between(time, nil).should == []
+      subject.versions.between(nil, number).should == []
+      subject.versions.between(nil, time).should == []
+    end
+  end
+
+  it 'returns an empty array when searching between two invalid version values' do
+    subject.versions.between(nil, nil).should == []
+  end
+
+  it 'is searchable before a valid version value' do
+    times.sort.each_with_index do |(number, time), i|
+      subject.versions.before(number).size.should == i
+      subject.versions.before(time).size.should == i
+    end
+  end
+
+  it 'returns an empty array when searching before an invalid version value' do
+    subject.versions.before(nil).should == []
+  end
+
+  it 'is searchable after a valid version value' do
+    times.sort.reverse.each_with_index do |(number, time), i|
+      subject.versions.after(number).size.should == i
+      subject.versions.after(time).size.should == i
+    end
+  end
+
+  it 'returns an empty array when searching after an invalid version value' do
+    subject.versions.after(nil).should == []
+  end
+
+  it 'is fetchable by version number' do
+    times.keys.each do |number|
+      subject.versions.at(number).should be_a(VestalVersions::Version)
+      subject.versions.at(number).number.should == number
+    end
+  end
+
+  it 'is fetchable by tag' do
+    times.keys.map{|n| [n, n.to_s] }.each do |number, tag|
+      subject.versions.at(tag).should be_a(VestalVersions::Version)
+      subject.versions.at(tag).number.should == number
+    end
+  end
+
+  it "is fetchable by the exact time of a version's creation" do
+    times.each do |number, time|
+      subject.versions.at(time).should be_a(VestalVersions::Version)
+      subject.versions.at(time).number.should == number
+    end
+  end
+
+  it "is fetchable by any time after the model's creation" do
+    times.each do |number, time|
+      subject.versions.at(time + 30.minutes).should be_a(VestalVersions::Version)
+      subject.versions.at(time + 30.minutes).number.should == number
+    end
+  end
+
+  it "returns nil when fetching a time before the model's creation" do
+    creation = times.values.min
+    subject.versions.at(creation - 1.second).should be_nil
+  end
+
+  it 'is fetchable by an association extension method' do
+    subject.versions.at(:first).should be_a(VestalVersions::Version)
+    subject.versions.at(:last).should be_a(VestalVersions::Version)
+    subject.versions.at(:first).number.should == times.keys.min
+    subject.versions.at(:last).number.should == times.keys.max
+  end
+
+  it 'is fetchable by a version object' do
+    times.keys.each do |number|
+      version = subject.versions.at(number)
+
+      subject.versions.at(version).should be_a(VestalVersions::Version)
+      subject.versions.at(version).number.should == number
+    end
+  end
+
+  it 'returns nil when fetching an invalid version value' do
+    subject.versions.at(nil).should be_nil
+  end
+
+  it 'provides a version number for any given numeric version value' do
+    times.keys.each do |number|
+      subject.versions.number_at(number).should be_a(Fixnum)
+      subject.versions.number_at(number + 0.5).should be_a(Fixnum)
+      subject.versions.number_at(number).should == subject.versions.number_at(number + 0.5)
+    end
+  end
+
+  it 'provides a version number for a valid tag' do
+    times.keys.map{|n| [n, n.to_s] }.each do |number, tag|
+      subject.versions.number_at(tag).should be_a(Fixnum)
+      subject.versions.number_at(tag).should == number
+    end
+  end
+
+  it 'returns nil when providing a version number for an invalid tag' do
+    subject.versions.number_at('INVALID').should be_nil
+  end
+
+  it 'provides a version number of a version corresponding to an association extension method' do
+    subject.versions.at(:first).should be_a(VestalVersions::Version)
+    subject.versions.at(:last).should be_a(VestalVersions::Version)
+    subject.versions.number_at(:first).should == times.keys.min
+    subject.versions.number_at(:last).should == times.keys.max
+  end
+
+  it 'returns nil when providing a version number for an invalid association extension method' do
+    subject.versions.number_at(:INVALID).should be_nil
+  end
+
+  it "provides a version number for any time after the model's creation" do
+    times.each do |number, time|
+      subject.versions.number_at(time + 30.minutes).should be_a(Fixnum)
+      subject.versions.number_at(time + 30.minutes).should == number
+    end
+  end
+
+  it "provides a version number of 1 for a time before the model's creation" do
+    creation = times.values.min
+    subject.versions.number_at(creation - 1.second).should == 1
+  end
+
+  it 'provides a version number for a given version object' do
+    times.keys.each do |number|
+      version = subject.versions.at(number)
+
+      subject.versions.number_at(version).should == number
+    end
+  end
+
+end

data/vestal_versions.gemspec

@@ -1,105 +1,23 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
-# -*- encoding: utf-8 -*-
+# encoding: utf-8
 
-Gem::Specification.new do |s|
-  s.name = %q{vestal_versions}
-  s.version = "1.0.2"
+Gem::Specification.new do |gem|
+  gem.name    = 'vestal_versions'
+  gem.version = '2.0.0'
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["laserlemon"]
-  s.date = %q{2010-01-13}
-  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/templates/initializer.rb",
-     "generators/vestal_versions/templates/migration.rb",
-     "generators/vestal_versions/vestal_versions_generator.rb",
-     "init.rb",
-     "lib/vestal_versions.rb",
-     "lib/vestal_versions/changes.rb",
-     "lib/vestal_versions/conditions.rb",
-     "lib/vestal_versions/configuration.rb",
-     "lib/vestal_versions/control.rb",
-     "lib/vestal_versions/creation.rb",
-     "lib/vestal_versions/options.rb",
-     "lib/vestal_versions/reload.rb",
-     "lib/vestal_versions/reset.rb",
-     "lib/vestal_versions/reversion.rb",
-     "lib/vestal_versions/tagging.rb",
-     "lib/vestal_versions/users.rb",
-     "lib/vestal_versions/version.rb",
-     "lib/vestal_versions/versioned.rb",
-     "lib/vestal_versions/versions.rb",
-     "test/changes_test.rb",
-     "test/conditions_test.rb",
-     "test/configuration_test.rb",
-     "test/control_test.rb",
-     "test/creation_test.rb",
-     "test/options_test.rb",
-     "test/reload_test.rb",
-     "test/reset_test.rb",
-     "test/reversion_test.rb",
-     "test/schema.rb",
-     "test/tagging_test.rb",
-     "test/test_helper.rb",
-     "test/users_test.rb",
-     "test/version_test.rb",
-     "test/versioned_test.rb",
-     "test/versions_test.rb",
-     "vestal_versions.gemspec"
-  ]
-  s.homepage = %q{http://github.com/laserlemon/vestal_versions}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.5}
-  s.summary = %q{Keep a DRY history of your ActiveRecord models' changes}
-  s.test_files = [
-    "test/changes_test.rb",
-     "test/conditions_test.rb",
-     "test/configuration_test.rb",
-     "test/control_test.rb",
-     "test/creation_test.rb",
-     "test/options_test.rb",
-     "test/reload_test.rb",
-     "test/reset_test.rb",
-     "test/reversion_test.rb",
-     "test/schema.rb",
-     "test/tagging_test.rb",
-     "test/test_helper.rb",
-     "test/users_test.rb",
-     "test/version_test.rb",
-     "test/versioned_test.rb",
-     "test/versions_test.rb"
-  ]
+  gem.authors     = ['Steve Richert', "James O'Kelly", 'C. Jason Harrelson']
+  gem.email       = ['steve.richert@gmail.com', 'dreamr.okelly@gmail.com', 'jason@lookforwardenterprises.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.license     = 'MIT'
 
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
+  gem.add_dependency 'activerecord', '>= 3', '< 5'
+  gem.add_dependency 'activesupport', '>= 3', '< 5'
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activerecord>, [">= 2.1.0"])
-      s.add_development_dependency(%q<shoulda>, [">= 0"])
-      s.add_development_dependency(%q<mocha>, [">= 0"])
-    else
-      s.add_dependency(%q<activerecord>, [">= 2.1.0"])
-      s.add_dependency(%q<shoulda>, [">= 0"])
-      s.add_dependency(%q<mocha>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<activerecord>, [">= 2.1.0"])
-    s.add_dependency(%q<shoulda>, [">= 0"])
-    s.add_dependency(%q<mocha>, [">= 0"])
-  end
-end
+  gem.add_development_dependency 'bundler', '~> 1.0'
+  gem.add_development_dependency 'rake', '~> 10.0'
 
+  gem.files         = `git ls-files`.split($\)
+  gem.test_files    = gem.files.grep(/^spec/)
+  gem.require_paths = ['lib']
+end