versions 0.1.0 → 0.2.0

data/.gitignore

@@ -2,4 +2,5 @@
 coverage
 rdoc
 pkg
-*.gem
+*.gem
+test/test.log

data/History.txt

@@ -1,4 +1,9 @@
-== 0.2.0
+== 0.2.0 2010-02-15
+
+* 1 major enhancement
+  * Changed inverse option from 'as' to 'inverse' in Multi
+  * Implemented the Attachment module
+  * Added AfterCommit module
 
 == 0.1.0 2010-02-14
 

data/README.rdoc

@@ -12,13 +12,19 @@ Duplicate on save if should_clone? returns true.
 
 == Multi (status: beta)
 
-Hide many versions behind a single current one.
+Hide many versions behind a single current one. For example if you want
+to version the content of a Page class, you should add a 'version_id' in
+the "pages" table to store the current version and you will need a Version
+model with a "page_id" to link back:
 
-== Transparent (status: alpha)
+  class Version < ActiveRecord::Base
+    include Versions::Auto
+  end
 
-Hide versions from outside world (simulate read/writes on the node but
-the actions are done on the version). Uses method_missing to forward
-method calls.
+  class Page < ActiveRecord::Base
+    include Versions::Multi
+    has_multiple :versions
+  end
 
 === Properties integration (status: beta)
 
@@ -37,9 +43,37 @@ storing properties in the version:
     end
   end
 
+== AfterCommit (status: beta)
 
-== SharedAttachment (status: alpha)
+Requiring 'versions' adds an 'after_commit' method to your models. The code in the after_commit block
+will only be executed if the top-most transaction succeeds (after the database commit).
+Example:
+
+  class Document < ActiveRecord::Base
+    include Versions::AfterCommit
+    after_save :save_file
+
+    def save_file
+      if @file
+        after_commit do
+          # write file to disk
+        end
+      end
+    end
+  end
+
+== Attachment (status: beta)
 
 Enable file attachments linked to versions. The attachments are shared between versions
-and deleted when no more versions are using them.
+and deleted when no more versions are using them. Example:
+
+
+  # Mock a document class with many versions
+  class Document < ActiveRecord::Base
+    include Versions::Multi
+    has_multiple :versions
+
+    include Versions::Attachment
+    store_attachments_in :version, :attachment_class => 'Attachment'
+  end
 

data/Rakefile

@@ -41,6 +41,7 @@ begin
 
     gemspec.add_development_dependency('shoulda')
     gemspec.add_development_dependency('property', '>= 0.8.1')
+    gemspec.add_development_dependency('activesupport')
 
     gemspec.add_dependency('activerecord')
   end

data/lib/versions.rb

@@ -1,5 +1,6 @@
 require 'active_record'
-require 'versions/shared_attachment'
+require 'versions/after_commit'
+require 'versions/attachment'
 require 'versions/auto'
 require 'versions/multi'
-require 'versions/transparent'
+require 'versions/version'

data/lib/versions/after_commit.rb

@@ -0,0 +1,69 @@
+require 'active_record/connection_adapters/abstract_adapter'
+module AfterCommit
+  module Initializer
+    def self.included(base)
+      base.alias_method_chain :new_connection, :after_commit
+    end
+    private
+      def new_connection_with_after_commit(*args)
+        conn = new_connection_without_after_commit(*args)
+        conn.class_eval do
+          include AfterCommit::Connection
+        end
+        conn
+      end
+  end
+
+  module Connection
+    def self.included(base)
+      base.alias_method_chain :commit_db_transaction, :after_commit
+      base.alias_method_chain :transaction, :after_commit
+    end
+
+    def after_commit(&block)
+      if block_given?
+        if open_transactions == 0
+          raise Exception.new("'after_commit' should only be used inside a transaction")
+        else
+          (@after_commit ||= []) << block
+        end
+      end
+    end
+
+    def commit_db_transaction_with_after_commit
+      after_commit_actions = @after_commit
+      @after_commit = nil
+      commit_db_transaction_without_after_commit
+      if after_commit_actions
+        after_commit_actions.each do |block|
+          block.call
+        end
+      end
+    end
+
+    def transaction_with_after_commit(*args, &block)
+      transaction_without_after_commit(*args, &block)
+    ensure
+      @after_commit = nil if open_transactions == 0
+    end
+  end
+
+  module ModelMethods
+    module ClassMethods
+      def after_commit(&block)
+        connection.after_commit(&block)
+      end
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def after_commit(&block)
+      self.class.connection.after_commit(&block)
+    end
+  end
+end
+
+ActiveRecord::ConnectionAdapters::ConnectionPool.send(:include, AfterCommit::Initializer)
+ActiveRecord::Base.send(:include, AfterCommit::ModelMethods)

data/lib/versions/attachment.rb

@@ -0,0 +1,104 @@
+require 'versions/shared_attachment'
+
+module Versions
+
+  # The attachement module provides shared file attachments to a class with a copy-on-write
+  # pattern.
+  # Basically the module provides 'file=' and 'file' methods.
+  # The file is shared between versions if it is not changed. The Attachment only stores a
+  # reference to the file which is saved in the filesystem.
+  module Attachment
+
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+      def store_attachments_in(accessor, options = {})
+        attachment_class = options[:attachment_class] || '::Versions::SharedAttachment'
+
+        if accessor.nil? || accessor == self
+          belongs_to :attachment,
+                     :class_name  => attachment_class,
+                     :foreign_key => 'attachment_id'
+          include Owner
+        else
+          klass = (options[:class_name] || accessor.to_s.capitalize).constantize
+          klass.class_eval do
+            belongs_to :attachment,
+                       :class_name  => attachment_class,
+                       :foreign_key => 'attachment_id'
+            include Owner
+          end
+
+          line = __LINE__
+          definitions = <<-EOF
+            def file=(file)
+              #{accessor}.file = file
+            end
+
+            def file
+              #{accessor}.file
+            end
+          EOF
+
+          methods_module = Module.new
+          methods_module.class_eval(definitions, __FILE__, line + 2)
+          include methods_module
+        end
+
+      end
+    end
+
+    module Owner
+      def self.included(base)
+        base.class_eval do
+          before_create  :save_attachment
+          before_update  :attachment_before_update
+          before_destroy :attachment_before_destroy
+        end
+      end
+
+      def file=(file)
+        if attachment
+          @attachment_to_unlink = self.attachment
+          self.attachment = nil
+        end
+        @attachment_need_save = true
+        self.build_attachment(:file => file)
+      end
+
+      def filepath
+        attachment ? attachment.filepath : nil
+      end
+
+      private
+        def save_attachment
+          if @attachment_need_save
+            @attachment_need_save = nil
+            attachment.save
+          else
+            true
+          end
+        end
+
+        def attachment_before_update
+          if @attachment_to_unlink
+            @attachment_to_unlink.unlink(self)
+            @attachment_to_unlink = nil
+          end
+          save_attachment
+        end
+
+        def attachment_before_destroy
+          if attachment = self.attachment
+            attachment.unlink(self)
+          else
+            true
+          end
+        end
+    end # Owner
+  end # Attachment
+end # Versions

data/lib/versions/auto.rb

@@ -12,7 +12,8 @@ module Versions
     end
 
     def should_clone?
-      raise NoMethodError.new("You should implement 'should_clone?' in your model (return true for a new version, false to update).")
+      # Always clone on update
+      true
     end
 
     # This method provides a hook to alter values after a clone operation (just before save: no validation).
@@ -27,7 +28,7 @@ module Versions
     def prepare_save_or_clone
       if new_record?
         self[:number] = 1
-      elsif should_clone?
+      elsif changed? && should_clone?
         @previous_id = self[:id]
         @previous_number ||= self[:number]
         self[:number] = @previous_number + 1

data/lib/versions/multi.rb

@@ -8,32 +8,57 @@ module Versions
 
     module ClassMethods
 
+      # Hide many instances behind a single current one.
+      # === Example
+      # A page with many versions and a current one representing the latest content:
+      # <tt>has_multiple :versions</tt>
+      #
+      # === Supported options
+      # [:class_name]
+      #   Specify the class name of the association. Use it only if that name can't be inferred
+      #   from the association name. So <tt>has_multiple :versions</tt> will by default be linked to the Version class
+      # [:inverse]
+      #   Specify the name of the relation from the associated record back to this record. By default the name
+      #   will be infered from the name of the current class. Note that this setting also defines the default
+      #   the foreign key name.
+      # [:foreign_key]
+      #   Specify the foreign key used for the association. By default this is guessed to be the name of this class
+      #   (or the inverse) in lower-case and "_id" suffixed. So a Person class that makes a +has_multiple+ association will
+      #   use "person_id" as the default <tt>:foreign_key</tt>.
+      # [:local_key]
+      #   Specify the local key to retrieve the current associated record. By default this is guessed from the name of the
+      #   association in lower-case and "_id" suffixed. So a model that <tt>has_multiple :pages</tt> would use "page_id" as
+      #   local key to get the current page. Note that the local key does not need to live in the database if the model
+      #   defines <tt>set_current_[assoc]_before_update</tt> and <tt>set_current_[assoc]_after_create</tt> where '[assoc]'
+      #   represents the association name.
       def has_multiple(versions, options = {})
-        name       = versions.to_s.singularize
-        klass      = (options[:class_name] || name.capitalize).constantize
-        owner_name = options[:as] || 'owner'
+        name        = versions.to_s.singularize
+        klass       = (options[:class_name] || name.capitalize).constantize
+        owner_name  = options[:inverse]     || self.to_s.split('::').last.underscore
+        foreign_key = (options[:foreign_key] || "#{owner_name}_id").to_s
+        local_key   = (options[:local_key]   || "#{name}_id").to_s
 
         raise TypeError.new("Missing 'number' field in table #{klass.table_name}.") unless klass.column_names.include?('number')
-        raise TypeError.new("Missing '#{owner_name}_id' in table #{klass.table_name}.") unless klass.column_names.include?("#{owner_name}_id")
+        raise TypeError.new("Missing '#{foreign_key}' in table #{klass.table_name}.") unless klass.column_names.include?(foreign_key)
 
-        has_many versions, :order => 'number DESC', :dependent => :destroy
+        has_many versions, :order => 'number DESC', :class_name => klass.to_s, :foreign_key => foreign_key, :dependent => :destroy
         validate      :"validate_#{name}"
         after_create  :"save_#{name}_after_create"
         before_update :"save_#{name}_before_update"
 
-        include module_for_multiple(name, klass, owner_name)
+        include module_for_multiple(name, klass, owner_name, foreign_key, local_key)
         klass.belongs_to owner_name, :class_name => self.to_s
       end
 
       protected
-        def module_for_multiple(name, klass, owner_name)
+        def module_for_multiple(name, klass, owner_name, foreign_key, local_key)
 
           # Eval is ugly, but it's the fastest solution I know of
           line = __LINE__
           definitions = <<-EOF
             def #{name}                                     # def version
               @#{name} ||= begin                            #   @version ||= begin
-                if v_id = #{name}_id                        #     if v_id = version_id
+                if v_id = #{local_key}                      #     if v_id = version_id
                   version = ::#{klass}.find(v_id)           #       version = ::Version.find(v_id)
                 else                                        #     else
                   version = ::#{klass}.new                  #       version = ::Version.new
@@ -60,6 +85,7 @@ module Versions
 
               def save_#{name}_before_update                # def save_version_before_update
                 return true if !@#{name}.changed?           #   return true if !@version.changed?
+                @#{name}.#{foreign_key} = self[:id]         #   @version.owner_id = self[:id]
                 if !@#{name}.save(false)                    #   if !@version.save_with_validation(false)
                   merge_multi_errors('#{name}', @#{name})   #     merge_multi_errors('version', @version)
                   false                                     #     false
@@ -70,10 +96,12 @@ module Versions
               end                                           # end
                                                             #
               def save_#{name}_after_create                 # def save_version_after_create
-                @#{name}.#{owner_name}_id = self[:id]       #   version.owner_id = self[:id]
-                if !@#{name}.save(false)                    #   if !@version.save_with_validation(false)
+                @#{name}.#{foreign_key} = self[:id]         #   version.owner_id = self[:id]
+                if !@#{name}.save(false)                    #   if !@version.save(false)
                   merge_multi_errors('#{name}', @#{name})   #     merge_multi_errors('version', @version)
-                  raise ActiveRecord::RecordInvalid.new(self) #   raise ActiveRecord::RecordInvalid.new(self)
+                  self[:id]   = nil
+                  @new_record = true
+                  raise ActiveRecord::Rollback              #   raise ActiveRecord::Rollback
                 else                                        #   else
                   set_current_#{name}_after_create          #     set_current_version_after_create
                 end                                         #   end
@@ -85,7 +113,7 @@ module Versions
               # master record is updated. This method is usually overwritten
               # in the class.
               def set_current_#{name}_before_update         # def set_current_version_before_update
-                self[:#{name}_id] = @#{name}.id             #   self[:version_id] = @version.id
+                self[:#{local_key}] = @#{name}.id           #   self[:version_id] = @version.id
               end                                           # end
 
               # This method is triggered when the version is saved, after the
@@ -97,17 +125,17 @@ module Versions
 
                 # conn.execute("UPDATE pages SET \#{conn.quote_column_name("version_id")} = \#{conn.quote(@version.id)} WHERE id = \#{conn.quote(self.id)}")
                 conn.execute(
-                  "UPDATE #{table_name} " +
-                  "SET \#{conn.quote_column_name("#{name}_id")} = \#{conn.quote(@#{name}.id)} " +
+                  "UPDATE \#{self.class.table_name} " +
+                  "SET \#{conn.quote_column_name("#{local_key}")} = \#{conn.quote(@#{name}.id)} " +
                   "WHERE id = \#{conn.quote(self.id)}"
                 )
-                self[:#{name}_id] = @#{name}.id             #   self[:version_id] = @version.id
+                self[:#{local_key}] = @#{name}.id           #   self[:version_id] = @version.id
                 changed_attributes.clear                    #   changed_attributes.clear
               end                                           # end
           EOF
 
           methods_module = Module.new
-          methods_module.class_eval(definitions, __FILE__, line + 1)
+          methods_module.class_eval(definitions, __FILE__, line + 2)
           methods_module
         end # module_for_multiple
     end # ClassMethods

data/lib/versions/shared_attachment.rb

@@ -1,2 +1,62 @@
-require 'versions/shared_attachment/attachment'
-require 'versions/shared_attachment/owner'
+require 'digest'
+
+module Versions
+  class SharedAttachment < ::ActiveRecord::Base
+    set_table_name 'attachments'
+    after_destroy :destroy_file
+    after_save    :write_file
+
+    def unlink(model)
+      link_count = model.class.count(:conditions => ["attachment_id = ? AND id != ?", self.id, model.id])
+      if link_count == 0
+        destroy
+      end
+    end
+
+    def file=(file)
+      @file = file
+      self[:filename] = get_filename(file)
+    end
+
+    def filepath
+      @filepath ||= begin digest = ::Digest::SHA1.hexdigest(self[:id].to_s)
+        "#{digest[0..0]}/#{digest[1..1]}/#{filename}"
+      end
+    end
+
+    private
+      def write_file
+        after_commit do
+          make_file(filepath, @file)
+        end
+      end
+
+      def destroy_file
+        after_commit do
+          remove_file
+        end
+      end
+
+      def make_file(path, data)
+        FileUtils::mkpath(File.dirname(path)) unless File.exist?(File.dirname(path))
+        if data.respond_to?(:rewind)
+          data.rewind
+        end
+        File.open(path, "wb") { |f| f.syswrite(data.read) }
+      end
+
+      def remove_file
+        FileUtils.rm(filepath)
+      end
+
+      def get_filename(file)
+        # make sure name is not corrupted
+        fname = file.original_filename.gsub(/[^a-zA-Z\-_0-9\.]/,'')
+        if fname[0..0] == '.'
+          # Forbid names starting with a dot
+          fname = Digest::SHA1.hexdigest(Time.now.to_i.to_s)[0..6]
+        end
+        fname
+      end
+  end # SharedAttachment
+end # Versions