vestal_versions 1.0.2 → 2.0.0

data/lib/vestal_versions/changes.rb

@@ -2,63 +2,59 @@ 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
-    def self.included(base) # :nodoc:
-      Hash.send(:include, HashMethods)
+    extend ActiveSupport::Concern
+    included do
+      Hash.class_eval{ include HashMethods }
 
-      base.class_eval do
-        include InstanceMethods
-
-        after_update :merge_version_changes
-      end
+      after_update :merge_version_changes
     end
 
     # Methods available to versioned ActiveRecord::Base instances in order to manage changes used
     # for version creation.
-    module InstanceMethods
-      # 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
+		# 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?
 
-        chain.inject({}) do |changes, version|
-          changes.append_changes!(backward ? version.changes.reverse_changes : version.changes)
-        end
-      end
+			backward = from_number > to_number
+			backward ? chain.pop : chain.shift unless from_number == 1 || to_number == 1
 
-      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
+			chain.inject({}) do |changes, version|
+				changes.append_changes!(backward ? version.changes.reverse_changes : version.changes)
+			end
+		end
 
-        # Stores the cumulative changes that are eventually used for version creation.
-        def version_changes
-          @version_changes ||= {}
-        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 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
+			# Stores the cumulative changes that are eventually used for version creation.
+			def version_changes
+				@version_changes ||= {}
+			end
 
-        # Simply resets the cumulative changes after version creation.
-        def reset_version_changes
-          @version_changes = nil
-        end
-    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.
@@ -122,4 +118,4 @@ module VestalVersions
       end
     end
   end
-end
+end

data/lib/vestal_versions/conditions.rb

@@ -2,19 +2,7 @@ module VestalVersions
   # Allows version creation to occur conditionally based on given <tt>:if</tt> and/or
   # <tt>:unless</tt> options.
   module Conditions
-    def self.included(base) # :nodoc:
-      base.class_eval do
-        extend ClassMethods
-        include InstanceMethods
-
-        alias_method_chain :create_version?, :conditions
-        alias_method_chain :update_version?, :conditions
-
-        class << self
-          alias_method_chain :prepare_versioned_options, :conditions
-        end
-      end
-    end
+    extend ActiveSupport::Concern
 
     # Class methods on ActiveRecord::Base to prepare the <tt>:if</tt> and <tt>:unless</tt> options.
     module ClassMethods
@@ -25,11 +13,11 @@ module VestalVersions
       #
       # 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_with_conditions(options)
-        result = prepare_versioned_options_without_conditions(options)
+      def prepare_versioned_options(options)
+        result = super(options)
 
-        self.vestal_versions_options[:if] = Array(options.delete(:if)).map(&:to_proc)
-        self.vestal_versions_options[:unless] = Array(options.delete(:unless)).map(&:to_proc)
+        vestal_versions_options[:if] = Array(options.delete(:if)).map(&:to_proc)
+        vestal_versions_options[:unless] = Array(options.delete(:unless)).map(&:to_proc)
 
         result
       end
@@ -37,33 +25,33 @@ module VestalVersions
 
     # Instance methods that determine based on the <tt>:if</tt> and <tt>:unless</tt> conditions,
     # whether a version is to be create or updated.
-    module InstanceMethods
-      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_with_conditions?
-          version_conditions_met? && create_version_without_conditions?
-        end
+    
+    
+    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_with_conditions?
-          version_conditions_met? && update_version_without_conditions?
-        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
+      # 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

data/lib/vestal_versions/control.rb

@@ -2,174 +2,198 @@ module VestalVersions
   # The control feature allows use of several code blocks that provide finer control over whether
   # a new version is created, or a previous version is updated.
   module Control
-    def self.included(base) # :nodoc:
-      base.class_eval do
-        include InstanceMethods
+    extend ActiveSupport::Concern
 
-        alias_method_chain :create_version?, :control
-        alias_method_chain :update_version?, :control
-      end
+    included do
+      class_attribute :_skip_version, :instance_writer => false
     end
 
+
     # Control blocks are called on ActiveRecord::Base instances as to not cause any conflict with
     # other instances of the versioned class whose behavior could be inadvertently altered within
     # a control block.
-    module InstanceMethods
-      # The +skip_version+ block simply allows for updates to be made to an instance of a versioned
-      # ActiveRecord model while ignoring all new version creation. The <tt>:if</tt> and
-      # <tt>:unless</tt> conditions (if given) will not be evaulated inside a +skip_version+ block.
-      #
-      # When the block closes, the instance is automatically saved, so explicitly saving the
-      # object within the block is unnecessary.
-      #
-      # == Example
-      #
-      #   user = User.find_by_first_name("Steve")
-      #   user.version # => 1
-      #   user.skip_version do
-      #     user.first_name = "Stephen"
-      #   end
-      #   user.version # => 1
-      def skip_version
-        with_version_flag(:skip_version) do
-          yield if block_given?
-          save
-        end
+    
+    # The +skip_version+ block simply allows for updates to be made to an instance of a versioned
+    # ActiveRecord model while ignoring all new version creation. The <tt>:if</tt> and
+    # <tt>:unless</tt> conditions (if given) will not be evaulated inside a +skip_version+ block.
+    #
+    # When the block closes, the instance is automatically saved, so explicitly saving the
+    # object within the block is unnecessary.
+    #
+    # == Example
+    #
+    #   user = User.find_by_first_name("Steve")
+    #   user.version # => 1
+    #   user.skip_version do
+    #     user.first_name = "Stephen"
+    #   end
+    #   user.version # => 1
+    def skip_version
+      _with_version_flag(:_skip_version) do
+        yield if block_given?
+        save
       end
+    end
 
-      # Behaving almost identically to the +skip_version+ block, the only difference with the
-      # +skip_version!+ block is that the save automatically performed at the close of the block
-      # is a +save!+, meaning that an exception will be raised if the object cannot be saved.
-      def skip_version!
-        with_version_flag(:skip_version) do
-          yield if block_given?
-          save!
-        end
+    # Behaving almost identically to the +skip_version+ block, the only difference with the
+    # +skip_version!+ block is that the save automatically performed at the close of the block
+    # is a +save!+, meaning that an exception will be raised if the object cannot be saved.
+    def skip_version!
+      _with_version_flag(:_skip_version) do
+        yield if block_given?
+        save!
       end
+    end
 
-      # A convenience method for determining whether a versioned instance is set to skip its next
-      # version creation.
-      def skip_version?
-        !!@skip_version
+    # Merging versions with the +merge_version+ block will take all of the versions that would
+    # be created within the block and merge them into one version and pushing that single version
+    # onto the ActiveRecord::Base instance's version history. A new version will be created and
+    # the instance's version number will be incremented.
+    #
+    # == Example
+    #
+    #   user = User.find_by_first_name("Steve")
+    #   user.version # => 1
+    #   user.merge_version do
+    #     user.update_attributes(:first_name => "Steven", :last_name => "Tyler")
+    #     user.update_attribute(:first_name, "Stephen")
+    #     user.update_attribute(:last_name, "Richert")
+    #   end
+    #   user.version # => 2
+    #   user.versions.last.changes
+    #   # => {"first_name" => ["Steve", "Stephen"], "last_name" => ["Jobs", "Richert"]}
+    #
+    # See VestalVersions::Changes for an explanation on how changes are appended.
+    def merge_version
+      _with_version_flag(:merge_version) do
+        yield if block_given?
       end
+      save
+    end
 
-      # Merging versions with the +merge_version+ block will take all of the versions that would
-      # be created within the block and merge them into one version and pushing that single version
-      # onto the ActiveRecord::Base instance's version history. A new version will be created and
-      # the instance's version number will be incremented.
-      #
-      # == Example
-      #
-      #   user = User.find_by_first_name("Steve")
-      #   user.version # => 1
-      #   user.merge_version do
-      #     user.update_attributes(:first_name => "Steven", :last_name => "Tyler")
-      #     user.update_attribute(:first_name, "Stephen")
-      #     user.update_attribute(:last_name, "Richert")
-      #   end
-      #   user.version # => 2
-      #   user.versions.last.changes
-      #   # => {"first_name" => ["Steve", "Stephen"], "last_name" => ["Jobs", "Richert"]}
-      #
-      # See VestalVersions::Changes for an explanation on how changes are appended.
-      def merge_version
-        with_version_flag(:merge_version) do
-          yield if block_given?
-        end
+    # Behaving almost identically to the +merge_version+ block, the only difference with the
+    # +merge_version!+ block is that the save automatically performed at the close of the block
+    # is a +save!+, meaning that an exception will be raised if the object cannot be saved.
+    def merge_version!
+      _with_version_flag(:merge_version) do
+        yield if block_given?
+      end
+      save!
+    end
+
+    # A convenience method for determining whether a versioned instance is set to merge its next
+    # versions into one before version creation.
+    def merge_version?
+      !!@merge_version
+    end
+
+    # Appending versions with the +append_version+ block acts similarly to the +merge_version+
+    # block in that all would-be version creations within the block are defered until the block
+    # closes. The major difference is that with +append_version+, a new version is not created.
+    # Rather, the cumulative changes are appended to the serialized changes of the instance's
+    # last version. A new version is not created, so the version number is not incremented.
+    #
+    # == Example
+    #
+    #   user = User.find_by_first_name("Steve")
+    #   user.version # => 2
+    #   user.versions.last.changes
+    #   # => {"first_name" => ["Stephen", "Steve"]}
+    #   user.append_version do
+    #     user.last_name = "Jobs"
+    #   end
+    #   user.versions.last.changes
+    #   # => {"first_name" => ["Stephen", "Steve"], "last_name" => ["Richert", "Jobs"]}
+    #   user.version # => 2
+    #
+    # See VestalVersions::Changes for an explanation on how changes are appended.
+    def append_version
+      _with_version_flag(:merge_version) do
+        yield if block_given?
+      end
+
+      _with_version_flag(:append_version) do
         save
       end
+    end
 
-      # Behaving almost identically to the +merge_version+ block, the only difference with the
-      # +merge_version!+ block is that the save automatically performed at the close of the block
-      # is a +save!+, meaning that an exception will be raised if the object cannot be saved.
-      def merge_version!
-        with_version_flag(:merge_version) do
-          yield if block_given?
-        end
-        save!
+    # Behaving almost identically to the +append_version+ block, the only difference with the
+    # +append_version!+ block is that the save automatically performed at the close of the block
+    # is a +save!+, meaning that an exception will be raised if the object cannot be saved.
+    def append_version!
+      _with_version_flag(:merge_version) do
+        yield if block_given?
       end
 
-      # A convenience method for determining whether a versioned instance is set to merge its next
-      # versions into one before version creation.
-      def merge_version?
-        !!@merge_version
+      _with_version_flag(:append_version) do
+        save!
       end
+    end
+
+    # A convenience method for determining whether a versioned instance is set to append its next
+    # version's changes into the last version changes.
+    def append_version?
+      !!@append_version
+    end
 
-      # Appending versions with the +append_version+ block acts similarly to the +merge_version+
-      # block in that all would-be version creations within the block are defered until the block
-      # closes. The major difference is that with +append_version+, a new version is not created.
-      # Rather, the cumulative changes are appended to the serialized changes of the instance's
-      # last version. A new version is not created, so the version number is not incremented.
+    # Used for each control block, the +_with_version_flag+ method sets a given variable to
+    # true and then executes the given block, ensuring that the variable is returned to a nil
+    # value before returning. This is useful to be certain that one of the control flag
+    # instance variables isn't inadvertently left in the "on" position by execution within the
+    # block raising an exception.
+    def _with_version_flag(flag)
+      instance_variable_set("@#{flag}", true)
+      yield
+    ensure
+      remove_instance_variable("@#{flag}")
+    end
+
+    # Overrides the basal +create_version?+ method to make sure that new versions are not
+    # created when inside any of the control blocks (until the block terminates).
+    def create_version?
+      !_skip_version? && !merge_version? && !append_version? && super
+    end
+
+    # Overrides the basal +update_version?+ method to allow the last version of an versioned
+    # ActiveRecord::Base instance to be updated at the end of an +append_version+ block.
+    def update_version?
+      append_version?
+    end
+    
+    module ClassMethods
+      # The +skip_version+ block simply allows for updates to be made to an instance of a versioned
+      # ActiveRecord model while ignoring all new version creation. The <tt>:if</tt> and
+      # <tt>:unless</tt> conditions (if given) will not be evaulated inside a +skip_version+ block.
+      #
+      # When the block closes, the instance is automatically saved, so explicitly saving the
+      # object within the block is unnecessary.
       #
       # == Example
       #
       #   user = User.find_by_first_name("Steve")
-      #   user.version # => 2
-      #   user.versions.last.changes
-      #   # => {"first_name" => ["Stephen", "Steve"]}
-      #   user.append_version do
-      #     user.last_name = "Jobs"
+      #   user.version # => 1
+      #   user.skip_version do
+      #     user.first_name = "Stephen"
       #   end
-      #   user.versions.last.changes
-      #   # => {"first_name" => ["Stephen", "Steve"], "last_name" => ["Richert", "Jobs"]}
-      #   user.version # => 2
-      #
-      # See VestalVersions::Changes for an explanation on how changes are appended.
-      def append_version
-        with_version_flag(:merge_version) do
-          yield if block_given?
-        end
-
-        with_version_flag(:append_version) do
-          save
-        end
-      end
-
-      # Behaving almost identically to the +append_version+ block, the only difference with the
-      # +append_version!+ block is that the save automatically performed at the close of the block
-      # is a +save!+, meaning that an exception will be raised if the object cannot be saved.
-      def append_version!
-        with_version_flag(:merge_version) do
+      #   user.version # => 1
+      def skip_version
+        _with_version_flag(:_skip_version) do
           yield if block_given?
         end
-
-        with_version_flag(:append_version) do
-          save!
-        end
       end
 
-      # A convenience method for determining whether a versioned instance is set to append its next
-      # version's changes into the last version changes.
-      def append_version?
-        !!@append_version
+      # Used for each control block, the +with_version_flag+ method sets a given variable to
+      # true and then executes the given block, ensuring that the variable is returned to a nil
+      # value before returning. This is useful to be certain that one of the control flag
+      # instance variables isn't inadvertently left in the "on" position by execution within the
+      # block raising an exception.
+      def _with_version_flag(flag)
+        self.send("#{flag}=", true)
+        yield
+      ensure
+        self.send("#{flag}=", nil)
       end
 
-      private
-        # Used for each control block, the +with_version_flag+ method sets a given variable to
-        # true and then executes the given block, ensuring that the variable is returned to a nil
-        # value before returning. This is useful to be certain that one of the control flag
-        # instance variables isn't inadvertently left in the "on" position by execution within the
-        # block raising an exception.
-        def with_version_flag(flag)
-          begin
-            instance_variable_set("@#{flag}", true)
-            yield
-          ensure
-            instance_variable_set("@#{flag}", nil)
-          end
-        end
-
-        # Overrides the basal +create_version?+ method to make sure that new versions are not
-        # created when inside any of the control blocks (until the block terminates).
-        def create_version_with_control?
-          !skip_version? && !merge_version? && !append_version? && create_version_without_control?
-        end
-
-        # Overrides the basal +update_version?+ method to allow the last version of an versioned
-        # ActiveRecord::Base instance to be updated at the end of an +append_version+ block.
-        def update_version_with_control?
-          append_version?
-        end
     end
   end
 end