houston-vestal_versions 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bb8143287729c95ca8970beb1f6b36228a30cd01
+  data.tar.gz: cf8e8d7cbb7398c6852f148856022c4cc03cf8c9
+SHA512:
+  metadata.gz: bb2a468aaec1cd1c3177c42efd7fc316aa49e1af3584068e74997835c464ad94a5768b38b454edee16cb4025c3656cde8636c0fadae8ff45dfccdf222209555d
+  data.tar.gz: 2e6786d698cc096065fc646476d4da7d6c56e7a78515d28ea50a09252b1d4596f2b1f8dabf5b395bf545e48cce986d73fbf46b5398d52dd0eb8f087ed6f1e048

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.rvmrc
+.yardoc
+coverage
+doc/
+Gemfile.lock
+gemfiles/*.lock
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+_yardoc
+.rspec
+.ruby-gemset
+.ruby-version

data/.travis.yml

@@ -0,0 +1,22 @@
+branches:
+  only:
+    - master
+gemfile:
+  - gemfiles/activerecord_3_0.gemfile
+  - gemfiles/activerecord_3_1.gemfile
+  - gemfiles/activerecord_3_2.gemfile
+  - gemfiles/activerecord_4_0.gemfile
+language: ruby
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+  include:
+    - env: COVERAGE=1
+      gemfile: Gemfile
+      rvm: 2.1.0
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - ruby-head
+script: bundle exec rspec

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# 2.0.0 / 2014-01-20
+
+ * [ENHANCEMENT] Ruby 2.1.0 compatibility
+ * [ENHANCEMENT] Ruby 2.0.0 compatibility
+ * [ENHANCEMENT] Ruby 1.9.3 compatibility
+ * [ENHANCEMENT] Initial Rails 4 compatibility
+ * [ENHANCEMENT] Initial Rails 3 compatibility

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'coveralls', '~> 0.7', :require => false
+  gem 'rspec', '~> 2.0'
+  gem 'sqlite3', '~> 1.0'
+end
+

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,206 @@
+= Vestal Versions
+
+{<img src="https://badge.fury.io/rb/vestal_versions.png" alt="Gem Version" />}[http://badge.fury.io/rb/vestal_versions]
+{<img src="https://travis-ci.org/laserlemon/vestal_versions.png?branch=master" alt="Build Status" />}[https://travis-ci.org/laserlemon/vestal_versions]
+{<img src="https://codeclimate.com/github/laserlemon/vestal_versions.png" alt="Code Climate" />}[https://codeclimate.com/github/laserlemon/vestal_versions]
+{<img src="https://coveralls.io/repos/laserlemon/vestal_versions/badge.png" alt="Coverage Status" />}[https://coveralls.io/r/laserlemon/vestal_versions]
+{<img src="https://gemnasium.com/laserlemon/vestal_versions.png" alt="Dependency Status" />}[https://gemnasium.com/laserlemon/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>vestal_versions</tt>[http://github.com/laserlemon/vestal_versions] requires only one versions table (polymorphically associated with its parent models) and no changes whatsoever to existing tables. But it goes one step DRYer 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!
+
+== Compatibility
+
+Tested with Active Record 3.2.16 with Ruby 1.9.3 and 1.9.2.
+
+== Installation
+
+In the Gemfile:
+
+** Note: I am giving this project some much needed love to keep her relevant in a post Rails 3 world. I will be finalizing a version to support 1.9.2+ and Rails 3.2+ soon and pushing the gem, till then, use the git repo:
+~dreamr
+  
+  gem 'vestal_versions', :git => 'git://github.com/laserlemon/vestal_versions'
+  
+
+Next, generate and run the first and last versioning migration you'll ever need:
+
+  $ rails 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(10.seconds.ago)
+  => 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
+
+== Upgrading to 1.0
+
+For the most part, version 1.0 of <tt>vestal_versions</tt> is backwards compatible, with just a few notable changes:
+
+* The versions table has been beefed up. You'll need to add the following columns (and indexes, if you feel so inclined):
+
+    change_table :versions do |t|
+      t.belongs_to :user, :polymorphic => true
+      t.string :user_name
+      t.string :tag
+    end
+
+    change_table :versions do |t|
+      t.index [:user_id, :user_type]
+      t.index :user_name
+      t.index :tag
+    end
+
+* When a model is created (or updated the first time after being versioned), an initial version record with a number of 1 is no longer created. These aren't used during reversion and so they end up just being dead weight. Feel free to scrap all your versions where <tt>number == 1</tt> after the upgrade if you'd like to free up some room in your database (but you don't have to).
+
+* Models that have no version records in the database will return a <tt>@user.version</tt> of 1. In the past, this would have returned <tt>nil</tt> instead.
+
+* <tt>Version</tt> has moved to <tt>VestalVersions::Version</tt> to make way for custom version classes.
+
+* <tt>Version#version</tt> did not survive the move to <tt>VestalVersions::Version#version</tt>. That alias was dropped (too confusing). Use <tt>VestalVersions::Version#number</tt>.
+
+== New to 1.0
+
+There are a handful of exciting new additions in version 1.0 of <tt>vestal_versions</tt>. A lot has changed in the code: much better documentation, more modular organization of features, and a more exhaustive test suite. But there are also a number of new features that are available in this release of <tt>vestal_versions</tt>:
+
+* The ability to completely skip versioning within a new <tt>skip_version</tt> block:
+
+    @user.version # => 1
+    @user.skip_version do
+      @user.update_attribute(:first_name, "Stephen")
+      @user.first_name = "Steve"
+      @user.save
+      @user.update_attributes(:last_name => "Jobs")
+    end
+    @user.version # => 1
+
+  Also available, are <tt>merge_version</tt> and <tt>append_version</tt> blocks. The <tt>merge_version</tt> block will compile the possibly multiple versions that would result from the updates inside the block into one summary version. The single resulting version is then tacked onto the version history as usual. The <tt>append_version</tt> block works similarly except that the resulting single version is combined with the most recent version in the history and saved.
+
+* Version tagging. Any version can have a tag attached to it (must be unique within the scope of the versioned parent) and that tag can be used for reversion.
+
+    @user.name # => "Steve Richert"
+    @user.update_attribute(:last_name, "Jobs")
+    @user.name # => "Steve Jobs"
+    @user.tag_version("apple")
+    @user.update_attribute(:last_name, "Richert")
+    @user.name # => "Steve Richert"
+    @user.revert_to("apple")
+    @user.name # => "Steve Jobs"
+
+  So if you're not big on version numbers, you could just tag your versions and avoid the numbers altogether.
+
+* Resetting. This is basically a hard revert. The new <tt>reset_to!</tt> instance method behaves just like the <tt>revert_to!</tt> method except that after the reversion, it will also scrap all the versions that came after that target version.
+
+    @user.name # => "Steve Richert"
+    @user.version # => 1
+    @user.versions.count # => 0
+    @user.update_attribute(:last_name, "Jobs")
+    @user.name # => "Steve Jobs"
+    @user.version # => 2
+    @user.versions.count # => 1
+    @user.reset_to!(1)
+    @user.name # => "Steve Richert"
+    @user.version # => 1
+    @user.versions.count # => 0
+
+* Storing which user is responsible for a revision. Rather than introduce a lot of controller magic to guess what to store, you can simply update an additional attribute on your versioned model: <tt>updated_by</tt>.
+
+    @user.update_attributes(:last_name => "Jobs", :updated_by => "Tyler")
+    @user.versions.last.user # => "Tyler"
+
+  Instead of passing a simple string to the <tt>updated_by</tt> setter, you can pass a model instance, such as an ActiveRecord user or administrator. The association will be saved polymorphically alongside the version.
+
+    @user.update_attributes(:last_name => "Jobs", :updated_by => current_user)
+    @user.versions.last.user # => #<User first_name: "Steven", last_name: "Tyler">
+
+* Global configuration. The new <tt>vestal_versions</tt> Rails generator also writes an initializer with instructions on how to set application-wide options for the <tt>versioned</tt> method.
+
+* Conditional version creation. The <tt>versioned</tt> method now accepts <tt>:if</tt> and <tt>:unless</tt> options. Each expects a symbol representing an instance method or a proc that will be evaluated to determine whether or not to create a new version after an update. An array containing any combination of symbols and procs can also be given.
+
+    class User < ActiveRecord::Base
+      versioned :if => :really_create_a_version?
+    end
+
+* Custom version classes. By passing a <tt>:class_name</tt> option to the <tt>versioned</tt> method, you can specify your own ActiveRecord version model. <tt>VestalVersions::Version</tt> is the default, but feel free to stray from that. I recommend that your custom model inherit from <tt>VestalVersions::Version</tt>, but that's up to you!
+
+* A <tt>versioned?</tt> convenience class method. If your user model is versioned, <tt>User.versioned?</tt> will let you know.
+
+* Soft Deletes & Restoration.  By setting <tt>:dependent</tt> to <tt>:tracking</tt> destroys will be tracked.  On destroy a new version will be created storing the complete details of the object with a tag of 'deleted'.  The object can later be restored using the <tt>restore!</tt> method on the VestalVersions::Version record.  The attributes of the restored object will be set using the attribute writer methods.  After a restore! is performed the version record with the 'deleted' tag is removed from the history.
+
+    class User < ActiveRecord::Base
+      versioned :dependent => :tracking
+    end
+
+    >> @user.version
+    => 2
+    >> @user.destroy
+    => <User id: 2, first_name: "Steve", last_name: "Jobs", ... >
+    >> User.find(2)
+    => ActiveRecord::RecordNotFound: Couldn't find User with ID=2
+    >> VestalVersions::Version.last
+    => <VestalVersions::Version id: 4, versioned_id: 2, versioned_type: "User", user_id: nil, user_type: nil, user_name: nil, modifications: {"created_at"=>Sun Aug 01 18:39:57 UTC 2010, "updated_at"=>Sun Aug 01 18:42:28 UTC 2010, "id"=>2, "last_name"=>"Jobs", "first_name"=>"Stephen"}, number: 3, tag: "deleted", created_at: "2010-08-01 18:42:43", updated_at: "2010-08-01 18:42:43">
+    >> VestalVersions::Version.last.restore!
+    => <User id: 2, first_name => "Steven", last_name: "Jobs", ... >
+    >> @user = User.find(2)
+    => <User id: 2, first_name => "Steven", last_name: "Jobs", ... >
+    >> @user.version
+    => 2
+
+== Thanks!
+
+Thank you to all those who post {issues and suggestions}[http://github.com/laserlemon/vestal_versions/issues]. And special thanks to:
+
+* splattael[http://github.com/splattael], who first bugged (and helped) me to write some tests for this thing
+* snaury[http://github.com/snaury], who helped out early on with the <tt>between</tt> association method, the <tt>:dependent</tt> option and a conflict from using a method called <tt>changes</tt>
+* sthapit[http://github.com/sthapit], who was responsible for the <tt>:only</tt> and <tt>:except</tt> options as well as showing me that I'm a dummy for storing a useless first version
+
+To contribute to <tt>vestal_versions</tt>, please fork, hack away in the integration[http://github.com/laserlemon/vestal_versions/tree/integration] branch and send me a pull request. Remember your tests!

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/gemfiles/activerecord_3_0.gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gem 'activerecord', '~> 3.0.0'
+
+gemspec :path => '..'
+
+group :test do
+  gem 'rspec', '~> 2.0'
+  gem 'sqlite3', '~> 1.0'
+end

data/gemfiles/activerecord_3_1.gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gem 'activerecord', '~> 3.1.0'
+
+gemspec :path => '..'
+
+group :test do
+  gem 'rspec', '~> 2.0'
+  gem 'sqlite3', '~> 1.0'
+end

data/gemfiles/activerecord_3_2.gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gem 'activerecord', '~> 3.2.0'
+
+gemspec :path => '..'
+
+group :test do
+  gem 'rspec', '~> 2.0'
+  gem 'sqlite3', '~> 1.0'
+end

data/gemfiles/activerecord_4_0.gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gem 'activerecord', '~> 4.0.0'
+
+gemspec :path => '..'
+
+group :test do
+  gem 'rspec', '~> 2.0'
+  gem 'sqlite3', '~> 1.0'
+end

data/lib/generators/vestal_versions/migration/migration_generator.rb

@@ -0,0 +1,17 @@
+require 'generators/vestal_versions'
+require 'rails/generators/active_record'
+
+module VestalVersions
+  module Generators
+    class MigrationGenerator < ActiveRecord::Generators::Base
+      extend Base
+
+      argument :name, :type => :string, :default => 'create_vestal_versions'
+
+      def generate_files
+        migration_template 'migration.rb', "db/migrate/#{name}"
+        template 'initializer.rb', 'config/initializers/vestal_versions.rb'
+      end
+    end
+  end
+end

data/lib/generators/vestal_versions/migration/templates/initializer.rb

@@ -0,0 +1,9 @@
+VestalVersions.configure do |config|
+  # Place any global options here. For example, in order to specify your own version model to use
+  # throughout the application, simply specify:
+  #
+  # config.class_name = "MyCustomVersion"
+  #
+  # Any options passed to the "versioned" method in the model itself will override this global
+  # configuration.
+end

data/lib/generators/vestal_versions/migration/templates/migration.rb

@@ -0,0 +1,28 @@
+class CreateVestalVersions < ActiveRecord::Migration
+  def self.up
+    create_table :versions 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
+
+    change_table :versions do |t|
+      t.index [:versioned_id, :versioned_type]
+      t.index [:user_id, :user_type]
+      t.index :user_name
+      t.index :number
+      t.index :tag
+      t.index :created_at
+    end
+  end
+
+  def self.down
+    drop_table :versions
+  end
+end

data/lib/generators/vestal_versions.rb

@@ -0,0 +1,11 @@
+require 'rails/generators/named_base'
+
+module VestalVersions
+  module Generators
+    module Base
+      def source_root
+        @_vestal_versions_source_root ||= File.expand_path(File.join('../vestal_versions', generator_name, 'templates'), __FILE__)
+      end
+    end
+  end
+end

data/lib/vestal_versions/changes.rb

@@ -0,0 +1,121 @@
+module VestalVersions
+  # Provides the ability to manipulate hashes in the specific format that ActiveRecord gives to
+  # dirty attribute changes: string keys and unique, two-element array values.
+  module Changes
+    extend ActiveSupport::Concern
+    included do
+      Hash.class_eval{ include HashMethods }
+
+      after_update :merge_version_changes
+    end
+
+    # Methods available to versioned ActiveRecord::Base instances in order to manage changes used
+    # for version creation.
+
+		# Collects an array of changes from a record's versions between the given range and compiles
+		# them into one summary hash of changes. The +from+ and +to+ arguments can each be either a
+		# version number, a symbol representing an association proxy method, a string representing a
+		# version tag or a version object itself.
+		def changes_between(from, to)
+			from_number, to_number = versions.number_at(from), versions.number_at(to)
+			return {} if from_number == to_number
+			chain = versions.between(from_number, to_number).reject(&:initial?)
+			return {} if chain.empty?
+
+			backward = from_number > to_number
+			backward ? chain.pop : chain.shift unless from_number == 1 || to_number == 1
+
+			chain.inject({}) do |changes, version|
+				changes.append_changes!(backward ? version.changes.reverse_changes : version.changes)
+			end
+		end
+
+		private
+			# Before a new version is created, the newly-changed attributes are appended onto a hash
+			# of previously-changed attributes. Typically the previous changes will be empty, except in
+			# the case that a control block is used where versions are to be merged. See
+			# VestalVersions::Control for more information.
+			def merge_version_changes
+				version_changes.append_changes!(incremental_version_changes)
+			end
+
+			# Stores the cumulative changes that are eventually used for version creation.
+			def version_changes
+				@version_changes ||= {}
+			end
+
+			# Stores the incremental changes that are appended to the cumulative changes before version
+			# creation. Incremental changes are reset when the record is saved because they represent
+			# a subset of the dirty attribute changes, which are reset upon save.
+			def incremental_version_changes
+				changes.slice(*versioned_columns)
+			end
+
+			# Simply resets the cumulative changes after version creation.
+			def reset_version_changes
+				@version_changes = nil
+			end
+
+    # Instance methods included into Hash for dealing with manipulation of hashes in the specific
+    # format of ActiveRecord::Base#changes.
+    module HashMethods
+      # When called on a hash of changes and given a second hash of changes as an argument,
+      # +append_changes+ will run the second hash on top of the first, updating the last element
+      # of each array value with its own, or creating its own key/value pair for missing keys.
+      # Resulting non-unique array values are removed.
+      #
+      # == Example
+      #
+      # first = {
+      #   "first_name" => ["Steve", "Stephen"],
+      #   "age" => [25, 26]
+      # }
+      # second = {
+      #   "first_name" => ["Stephen", "Steve"],
+      #   "last_name" => ["Richert", "Jobs"],
+      #   "age" => [26, 54]
+      # }
+      # first.append_changes(second)
+      # # => {
+      #   "last_name" => ["Richert", "Jobs"],
+      #   "age" => [25, 54]
+      # }
+      def append_changes(changes)
+        changes.inject(self) do |new_changes, (attribute, change)|
+          new_change = [new_changes.fetch(attribute, change).first, change.last]
+          new_changes.merge(attribute => new_change)
+        end.reject do |attribute, change|
+          change.first == change.last
+        end
+      end
+
+      # Destructively appends a given hash of changes onto an existing hash of changes.
+      def append_changes!(changes)
+        replace(append_changes(changes))
+      end
+
+      # Appends the existing hash of changes onto a given hash of changes. Relates to the
+      # +append_changes+ method in the same way that Hash#reverse_merge relates to
+      # Hash#merge.
+      def prepend_changes(changes)
+        changes.append_changes(self)
+      end
+
+      # Destructively prepends a given hash of changes onto an existing hash of changes.
+      def prepend_changes!(changes)
+        replace(prepend_changes(changes))
+      end
+
+      # Reverses the array values of a hash of changes. Useful for reversion both backward and
+      # forward through a record's history of changes.
+      def reverse_changes
+        inject({}){|nc,(a,c)| nc.merge!(a => c.reverse) }
+      end
+
+      # Destructively reverses the array values of a hash of changes.
+      def reverse_changes!
+        replace(reverse_changes)
+      end
+    end
+  end
+end

data/lib/vestal_versions/conditions.rb

@@ -0,0 +1,57 @@
+module VestalVersions
+  # Allows version creation to occur conditionally based on given <tt>:if</tt> and/or
+  # <tt>:unless</tt> options.
+  module Conditions
+    extend ActiveSupport::Concern
+
+    # Class methods on ActiveRecord::Base to prepare the <tt>:if</tt> and <tt>:unless</tt> options.
+    module ClassMethods
+      # After the original +prepare_versioned_options+ method cleans the given options, this alias
+      # also extracts the <tt>:if</tt> and <tt>:unless</tt> options, chaning them into arrays
+      # and converting any symbols to procs. Procs are called with the ActiveRecord model instance
+      # as the sole argument.
+      #
+      # If all of the <tt>:if</tt> conditions are met and none of the <tt>:unless</tt> conditions
+      # are unmet, than version creation will proceed, assuming all other conditions are also met.
+      def prepare_versioned_options(options)
+        result = super(options)
+
+        vestal_versions_options[:if] = Array(options.delete(:if)).map(&:to_proc)
+        vestal_versions_options[:unless] = Array(options.delete(:unless)).map(&:to_proc)
+
+        result
+      end
+    end
+
+    # Instance methods that determine based on the <tt>:if</tt> and <tt>:unless</tt> conditions,
+    # whether a version is to be create or updated.
+    
+    
+    private
+      # After first determining whether the <tt>:if</tt> and <tt>:unless</tt> conditions are
+      # satisfied, the original, unaliased +create_version?+ method is called to determine
+      # whether a new version should be created upon update of the ActiveRecord::Base instance.
+      def create_version?
+        version_conditions_met? && super
+      end
+
+      # After first determining whether the <tt>:if</tt> and <tt>:unless</tt> conditions are
+      # satisfied, the original, unaliased +update_version?+ method is called to determine
+      # whther the last version should be updated to include changes merged from the current
+      # ActiveRecord::Base instance update.
+      #
+      # The overridden +update_version?+ method simply returns false, effectively delegating
+      # the decision to whether the <tt>:if</tt> and <tt>:unless</tt> conditions are met.
+      def update_version?
+        version_conditions_met? && super
+      end
+
+      # Simply checks whether the <tt>:if</tt> and <tt>:unless</tt> conditions given in the
+      # +versioned+ options are met: meaning that all procs in the <tt>:if</tt> array must
+      # evaluate to a non-false, non-nil value and that all procs in the <tt>:unless</tt> array
+      # must all evaluate to either false or nil.
+      def version_conditions_met?
+        vestal_versions_options[:if].all?{|p| p.call(self) } && !vestal_versions_options[:unless].any?{|p| p.call(self) }
+      end
+  end
+end