vestal_versions 1.0.2 → 2.0.0

data/lib/vestal_versions/version.rb

@@ -1,17 +1,28 @@
+require 'active_record'
+require 'active_support/configurable'
+
 module VestalVersions
   # The ActiveRecord model representing versions.
   class Version < ActiveRecord::Base
     include Comparable
+    include ActiveSupport::Configurable
 
     # Associate polymorphically with the parent record.
     belongs_to :versioned, :polymorphic => true
 
+    if ActiveRecord::VERSION::MAJOR == 3
+      attr_accessible :modifications, :number, :user, :tag, :reverted_from
+    end
+
     # ActiveRecord::Base#changes is an existing method, so before serializing the +changes+ column,
-    # the existing +changes+ method is undefined. The overridden +changes+ method pertained to 
+    # the existing +changes+ method is undefined. The overridden +changes+ method pertained to
     # dirty attributes, but will not affect the partial updates functionality as that's based on
     # an underlying +changed_attributes+ method, not +changes+ itself.
     undef_method :changes
-    serialize :changes, Hash
+    def changes
+      self[:modifications]
+    end
+    serialize :modifications, Hash
 
     # In conjunction with the included Comparable module, allows comparison of version records
     # based on their corresponding version numbers, creation timestamps and IDs.
@@ -25,5 +36,49 @@ module VestalVersions
     def initial?
       number == 1
     end
+    
+    # Returns the original version number that this version was.
+    def original_number
+      if reverted_from.nil?
+        number
+      else
+        version = versioned.versions.at(reverted_from)
+        version.nil? ? 1 : version.original_number
+      end
+    end
+
+    def restore!
+      model = restore
+      
+      if model
+        model.save!
+        destroy
+      end
+      
+      model
+    end
+    
+    def restore
+      if tag == 'deleted'
+        attrs = modifications
+
+        class_name = attrs['type'].blank? ? versioned_type : attrs['type']
+        klass = class_name.constantize
+        model = klass.new
+
+        attrs.each do |k, v|
+          begin
+            model.send "#{k}=", v
+          rescue NoMethodError
+            logger.warn "Attribute #{k} does not exist on #{class_name} (Version id: #{id})." rescue nil
+          end
+        end
+
+        model
+      else
+        latest_version = self.class.where(:versioned_id => versioned_id, :versioned_type => versioned_type, :tag => 'deleted').first
+        latest_version.nil? ? nil : latest_version.restore
+      end
+    end
   end
 end

data/lib/vestal_versions/version_tagging.rb

@@ -0,0 +1,51 @@
+module VestalVersions
+  # Allows specific versions to be tagged with a custom string. Useful for assigning a more
+  # meaningful value to a version for the purpose of reversion.
+  module VersionTagging
+    extend ActiveSupport::Concern
+
+    # Adds an instance method which allows version tagging through the parent object.
+
+    # Accepts a single string argument which is attached to the version record associated with
+    # the current version number of the parent object.
+    #
+    # Returns the given tag if successful, nil if not. Tags must be unique within the scope of
+    # the parent object. Tag creation will fail if non-unique.
+    #
+    # Version records corresponding to version number 1 are not typically created, but one will
+    # be built to house the given tag if the parent object's current version number is 1.
+    def tag_version(tag)
+      v = versions.at(version) || versions.build(:number => 1)
+      t = v.tag!(tag)
+      versions.reload
+      t
+    end
+  end
+
+  # Instance methods included into VestalVersions::Version to enable version tagging.
+  module VersionMethods
+    extend ActiveSupport::Concern
+
+    included do
+      validates_uniqueness_of :tag, :scope => [:versioned_id, :versioned_type], :if => :validate_tags?
+    end
+
+    # Attaches the given string to the version tag column. If the uniqueness validation fails,
+    # nil is returned. Otherwise, the given string is returned.
+    def tag!(tag)
+      write_attribute(:tag, tag)
+      save ? tag : nil
+    end
+
+    # Simply returns a boolean signifying whether the version instance has a tag value attached.
+    def tagged?
+      !tag.nil?
+    end
+
+    def validate_tags?
+      tagged? && tag != 'deleted'
+    end
+
+    Version.class_eval{ include VersionMethods }
+  end
+end

data/lib/vestal_versions/versioned.rb

@@ -1,30 +1,27 @@
 module VestalVersions
   # Simply adds a flag to determine whether a model class if versioned.
   module Versioned
-    def self.extended(base) # :nodoc:
-      base.class_eval do
-        class << self
-          alias_method_chain :versioned, :flag
-        end
-      end
-    end
+    extend ActiveSupport::Concern
 
     # Overrides the +versioned+ method to first define the +versioned?+ class method before
     # deferring to the original +versioned+.
-    def versioned_with_flag(*args)
-      versioned_without_flag(*args)
+    module ClassMethods
+      def versioned(*args)
+        super(*args)
 
-      class << self
-        def versioned?
-          true
+        class << self
+          def versioned?
+            true
+          end
         end
       end
-    end
 
-    # For all ActiveRecord::Base models that do not call the +versioned+ method, the +versioned?+
-    # method will return false.
-    def versioned?
-      false
+      # For all ActiveRecord::Base models that do not call the +versioned+ method, the +versioned?+
+      # method will return false.
+      def versioned?
+        false
+      end
     end
+
   end
 end

data/lib/vestal_versions/versions.rb

@@ -1,3 +1,21 @@
+# See: https://github.com/rails/rails/issues/11026
+if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 0 && RUBY_VERSION >= "2.0.0"
+  module ActiveRecord
+    module Associations
+      class AssociationProxy
+        def send(method, *args)
+          if proxy_respond_to?(method, true)
+            super
+          else
+            load_target
+            @target.send(method, *args)
+          end
+        end
+      end
+    end
+  end
+end
+
 module VestalVersions
   # An extension module for the +has_many+ association with versions.
   module Versions
@@ -13,16 +31,13 @@ module VestalVersions
       return [] if from_number.nil? || to_number.nil?
 
       condition = (from_number == to_number) ? to_number : Range.new(*[from_number, to_number].sort)
-      all(
-        :conditions => {:number => condition},
-        :order => "#{aliased_table_name}.number #{(from_number > to_number) ? 'DESC' : 'ASC'}"
-      )
+      where(:number => condition).order("#{table_name}.#{connection.quote_column_name('number')} #{(from_number > to_number) ? 'DESC' : 'ASC'}").to_a
     end
 
     # Returns all version records created before the version associated with the given value.
     def before(value)
       return [] if (number = number_at(value)).nil?
-      all(:conditions => "#{aliased_table_name}.number < #{number}")
+      where("#{table_name}.#{connection.quote_column_name('number')} < #{number}").to_a
     end
 
     # Returns all version records created after the version associated with the given value.
@@ -30,7 +45,7 @@ module VestalVersions
     # This is useful for dissociating records during use of the +reset_to!+ method.
     def after(value)
       return [] if (number = number_at(value)).nil?
-      all(:conditions => "#{aliased_table_name}.number > #{number}")
+      where("#{table_name}.#{connection.quote_column_name('number')} > #{number}").to_a
     end
 
     # Returns a single version associated with the given value. The following formats are valid:
@@ -49,7 +64,7 @@ module VestalVersions
     #   untouched.
     def at(value)
       case value
-        when Date, Time then last(:conditions => ["#{aliased_table_name}.created_at <= ?", value.to_time])
+        when Date, Time then where("#{table_name}.created_at <= ?", value.to_time).last
         when Numeric then find_by_number(value.floor)
         when String then find_by_tag(value)
         when Symbol then respond_to?(value) ? send(value) : nil

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+if ENV['COVERAGE']
+  require 'coveralls'
+  Coveralls.wear!
+end
+
+require 'vestal_versions'
+
+require 'bundler'
+Bundler.require(:test)
+
+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
+
+  c.order = 'random'
+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