brianjlandau-vestal_versions 1.3.0

data/lib/vestal_versions/versioned.rb

@@ -0,0 +1,30 @@
+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
+
+    # 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)
+
+      class << self
+        def versioned?
+          true
+        end
+      end
+    end
+
+    # For all ActiveRecord::Base models that do not call the +versioned+ method, the +versioned?+
+    # method will return false.
+    def versioned?
+      false
+    end
+  end
+end

data/lib/vestal_versions/versions.rb

@@ -0,0 +1,74 @@
+module VestalVersions
+  # An extension module for the +has_many+ association with versions.
+  module Versions
+    # Returns all versions between (and including) the two given arguments. See documentation for
+    # the +at+ extension method for what arguments are valid. If either of the given arguments is
+    # invalid, an empty array is returned.
+    #
+    # The +between+ method preserves returns an array of version records, preserving the order
+    # given by the arguments. If the +from+ value represents a version before that of the +to+
+    # value, the array will be ordered from earliest to latest. The reverse is also true.
+    def between(from, to)
+      from_number, to_number = number_at(from), number_at(to)
+      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'}"
+      )
+    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}")
+    end
+
+    # Returns all version records created after the version associated with the given value.
+    #
+    # 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}")
+    end
+
+    # Returns a single version associated with the given value. The following formats are valid:
+    # * A Date or Time object: When given, +to_time+ is called on the value and the last version
+    #   record in the history created before (or at) that time is returned.
+    # * A Numeric object: Typically a positive integer, these values correspond to version numbers
+    #   and the associated version record is found by a version number equal to the given value
+    #   rounded down to the nearest integer.
+    # * A String: A string value represents a version tag and the associated version is searched
+    #   for by a matching tag value. *Note:* Be careful with string representations of numbers.
+    # * A Symbol: Symbols represent association class methods on the +has_many+ versions
+    #   association. While all of the built-in association methods require arguments, additional
+    #   extension modules can be defined using the <tt>:extend</tt> option on the +versioned+
+    #   method. See the +versioned+ documentation for more information.
+    # * A Version object: If a version object is passed to the +at+ method, it is simply returned
+    #   untouched.
+    def at(value)
+      case value
+        when Date, Time then last(:conditions => ["#{aliased_table_name}.created_at <= ?", value.to_time])
+        when Numeric then find_by_number(value.floor)
+        when String then find_by_tag(value)
+        when Symbol then respond_to?(value) ? send(value) : nil
+        when Version then value
+      end
+    end
+
+    # Returns the version number associated with the given value. In many cases, this involves
+    # simply passing the value to the +at+ method and then returning the subsequent version number.
+    # Hoever, for Numeric values, the version number can be returned directly and for Date/Time
+    # values, a default value of 1 is given to ensure that times prior to the first version
+    # still return a valid version number (useful for reversion).
+    def number_at(value)
+      case value
+        when Date, Time then (v = at(value)) ? v.number : 1
+        when Numeric then value.floor
+        when String, Symbol then (v = at(value)) ? v.number : nil
+        when Version then value.number
+      end
+    end
+  end
+end

data/test/associations_test.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class AssociationsTest < Test::Unit::TestCase
+  context "A version's associations" do
+    should 'should propogate through belongs_to' do
+      group = Group.create :name => "The Group"
+      user = User.create(:name => 'Steve Richert', :group_id => group.id)
+      assert_equal 1, user.version
+      assert_equal 1, user.group.version
+      group.update_attributes(:name => "New Group")
+      user.update_attributes(:name => "New Name")
+      assert_equal 2, user.version
+      assert_equal 2, user.group.version
+      user.revert_to(1)
+      assert_equal 1, user.group.version
+    end
+    
+    should 'return a versioned object through AssociationProxy#first' do
+      group = Group.create :name => "The Group"
+      user = User.create(:name => 'Steve Richert', :group_id => group.id)
+      group.update_attributes(:name => "New Group")
+      user.update_attributes(:name => "New Name")
+      group.revert_to(1)
+      assert_equal 1, group.users.first.version
+    end
+    
+    should 'return a versioned object through AssociationProxy#last' do
+      group = Group.create :name => "The Group"
+      user = User.create(:name => 'Steve Richert', :group_id => group.id)
+      group.update_attributes(:name => "New Group")
+      user.update_attributes(:name => "New Name")
+      group.revert_to(1)
+      assert_equal 1, group.users.last.version
+    end
+    
+    should 'should propogate through has_many' do
+      group = Group.create :name => "The Group"
+      user = User.create(:name => 'Steve Richert', :group_id => group.id)
+      assert_equal 1, group.version
+      assert_equal 1, group.users.first.version
+      group.update_attributes(:name => "New Group")
+      user.update_attributes(:name => "New Name")
+      assert_equal 2, group.version
+      assert_equal 2, group.users.first.version
+      group.revert_to(1)
+      assert_equal 1, group.users.last.version
+    end
+  end
+end

data/test/changes_test.rb

@@ -0,0 +1,169 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class ChangesTest < Test::Unit::TestCase
+  context "A version's changes" do
+    setup do
+      @user = User.create(:name => 'Steve Richert')
+      @user.update_attributes(:last_name =>'Jobs')
+      @changes = @user.versions.last.changes
+    end
+
+    should 'be a hash' do
+      assert_kind_of Hash, @changes
+    end
+
+    should 'not be empty' do
+      assert !@changes.empty?
+    end
+
+    should 'have string keys' do
+      @changes.keys.each do |key|
+        assert_kind_of String, key
+      end
+    end
+
+    should 'have array values' do
+      @changes.values.each do |value|
+        assert_kind_of Array, value
+      end
+    end
+
+    should 'have two-element values' do
+      @changes.values.each do |value|
+        assert_equal 2, value.size
+      end
+    end
+
+    should 'have unique-element values' do
+      @changes.values.each do |value|
+        assert_equal value.uniq, value
+      end
+    end
+
+    should "equal the model's changes" do
+      @user.first_name = 'Stephen'
+      model_changes = @user.changes
+      @user.save
+      changes = @user.versions.last.changes
+      assert_equal model_changes, changes
+    end
+  end
+
+  context 'A hash of changes' do
+    setup do
+      @changes = {'first_name' => ['Steve', 'Stephen']}
+      @other = {'first_name' => ['Catie', 'Catherine']}
+    end
+
+    should 'properly append other changes' do
+      expected = {'first_name' => ['Steve', 'Catherine']}
+      changes = @changes.append_changes(@other)
+      assert_equal expected, changes
+      @changes.append_changes!(@other)
+      assert_equal expected, @changes
+    end
+
+    should 'properly prepend other changes' do
+      expected = {'first_name' => ['Catie', 'Stephen']}
+      changes = @changes.prepend_changes(@other)
+      assert_equal expected, changes
+      @changes.prepend_changes!(@other)
+      assert_equal expected, @changes
+    end
+
+    should 'be reversible' do
+      expected = {'first_name' => ['Stephen', 'Steve']}
+      changes = @changes.reverse_changes
+      assert_equal expected, changes
+      @changes.reverse_changes!
+      assert_equal expected, @changes
+    end
+  end
+
+  context 'The changes between two versions' do
+    setup do
+      name = 'Steve Richert'
+      @user = User.create(:name => name)              # 1
+      @user.update_attributes(:last_name => 'Jobs')      # 2
+      @user.update_attributes(:first_name => 'Stephen')  # 3
+      @user.update_attributes(:last_name => 'Richert')   # 4
+      @user.update_attributes(:name => name)             # 5
+      @version = @user.version
+    end
+
+    should 'be a hash' do
+      1.upto(@version) do |i|
+        1.upto(@version) do |j|
+          changes = @user.changes_between(i, j)
+          assert_kind_of Hash, changes
+        end
+      end
+    end
+
+    should 'have string keys' do
+      1.upto(@version) do |i|
+        1.upto(@version) do |j|
+          changes = @user.changes_between(i, j)
+          changes.keys.each do |key|
+            assert_kind_of String, key
+          end
+        end
+      end
+    end
+
+    should 'have array values' do
+      1.upto(@version) do |i|
+        1.upto(@version) do |j|
+          changes = @user.changes_between(i, j)
+          changes.values.each do |value|
+            assert_kind_of Array, value
+          end
+        end
+      end
+    end
+
+    should 'have two-element values' do
+      1.upto(@version) do |i|
+        1.upto(@version) do |j|
+          changes = @user.changes_between(i, j)
+          changes.values.each do |value|
+            assert_equal 2, value.size
+          end
+        end
+      end
+    end
+
+    should 'have unique-element values' do
+      1.upto(@version) do |i|
+        1.upto(@version) do |j|
+          changes = @user.changes_between(i, j)
+          changes.values.each do |value|
+            assert_equal value.uniq, value
+          end
+        end
+      end
+    end
+
+    should 'be empty between identical versions' do
+      assert @user.changes_between(1, @version).empty?
+      assert @user.changes_between(@version, 1).empty?
+    end
+
+    should 'be 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)
+          assert_equal up, down.reverse_changes
+        end
+      end
+    end
+
+    should 'be empty with invalid arguments' do
+      1.upto(@version) do |i|
+        assert @user.changes_between(i, nil)
+        assert @user.changes_between(nil, i)
+      end
+    end
+  end
+end

data/test/conditions_test.rb

@@ -0,0 +1,137 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class ConditionsTest < Test::Unit::TestCase
+  context 'Converted :if conditions' do
+    setup do
+      User.class_eval do
+        def true; true; end
+      end
+    end
+
+    should 'be an array' do
+      assert_kind_of Array, User.vestal_versions_options[:if]
+      User.prepare_versioned_options(:if => :true)
+      assert_kind_of Array, User.vestal_versions_options[:if]
+    end
+
+    should 'have proc values' do
+      User.prepare_versioned_options(:if => :true)
+      assert User.vestal_versions_options[:if].all?{|i| i.is_a?(Proc) }
+    end
+
+    teardown do
+      User.prepare_versioned_options(:if => [])
+    end
+  end
+
+  context 'Converted :unless conditions' do
+    setup do
+      User.class_eval do
+        def true; true; end
+      end
+    end
+
+    should 'be an array' do
+      assert_kind_of Array, User.vestal_versions_options[:unless]
+      User.prepare_versioned_options(:unless => :true)
+      assert_kind_of Array, User.vestal_versions_options[:unless]
+    end
+
+    should 'have proc values' do
+      User.prepare_versioned_options(:unless => :true)
+      assert User.vestal_versions_options[:unless].all?{|i| i.is_a?(Proc) }
+    end
+
+    teardown do
+      User.prepare_versioned_options(:unless => [])
+    end
+  end
+
+  context 'A new version' do
+    setup do
+      User.class_eval do
+        def true; true; end
+        def false; false; end
+      end
+
+      @user = User.create(:name => 'Steve Richert')
+      @count = @user.versions.count
+    end
+
+    context 'with :if conditions' do
+      context 'that pass' do
+        setup do
+          User.prepare_versioned_options(:if => [:true])
+          @user.update_attributes(:last_name => 'Jobs')
+        end
+
+        should 'be created' do
+          assert_equal @count + 1, @user.versions.count
+        end
+      end
+
+      context 'that fail' do
+        setup do
+          User.prepare_versioned_options(:if => [:false])
+          @user.update_attributes(:last_name => 'Jobs')
+        end
+
+        should 'not be created' do
+          assert_equal @count, @user.versions.count
+        end
+      end
+    end
+
+    context 'with :unless conditions' do
+      context 'that pass' do
+        setup do
+          User.prepare_versioned_options(:unless => [:true])
+          @user.update_attributes(:last_name => 'Jobs')
+        end
+
+        should 'not be created' do
+          assert_equal @count, @user.versions.count
+        end
+      end
+
+      context 'that fail' do
+        setup do
+          User.prepare_versioned_options(:unless => [:false])
+          @user.update_attributes(:last_name => 'Jobs')
+        end
+
+        should 'not be created' do
+          assert_equal @count + 1, @user.versions.count
+        end
+      end
+    end
+
+    context 'with :if and :unless conditions' do
+      context 'that pass' do
+        setup do
+          User.prepare_versioned_options(:if => [:true], :unless => [:true])
+          @user.update_attributes(:last_name => 'Jobs')
+        end
+
+        should 'not be created' do
+          assert_equal @count, @user.versions.count
+        end
+      end
+
+      context 'that fail' do
+        setup do
+          User.prepare_versioned_options(:if => [:false], :unless => [:false])
+          @user.update_attributes(:last_name => 'Jobs')
+        end
+
+        should 'not be created' do
+          assert_equal @count, @user.versions.count
+        end
+      end
+    end
+
+    teardown do
+      User.prepare_versioned_options(:if => [], :unless => [])
+    end
+  end
+end