versions 0.0.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Gaspard Bucher (http://teti.ch)
+
+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,24 @@
+== Versions
+
+A list of libraries to work with ActiveRecord model versioning.
+
+website: http://zenadmin.org/650
+
+license: MIT
+
+== Auto
+
+Duplicate on save if should_clone? returns true.
+
+== Multi
+
+Hide many versions behind a single current one.
+
+== Transparent
+
+Hide versions from outside world.
+
+== Property
+
+Define properties on model, store them in versions.
+

data/Rakefile

@@ -0,0 +1,50 @@
+require 'pathname'
+$LOAD_PATH.unshift((Pathname(__FILE__).dirname +  'lib').expand_path)
+
+require 'versions/version'
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |test|
+  test.libs     << 'lib' << 'test'
+  test.pattern  = 'test/**/**_test.rb'
+  test.verbose  = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test' << 'lib'
+    test.pattern = 'test/**/auto_test.rb'
+    test.verbose = true
+    test.rcov_opts = ['-T', '--exclude-only', '"test\/,^\/"']
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install rcov"
+  end
+end
+
+task :default => :test
+
+# GEM management
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.version = Versions::VERSION
+    gemspec.name = "versions"
+    gemspec.summary = %Q{A list of libraries to work with ActiveRecord model versioning}
+    gemspec.description = %Q{A list of libraries to work with ActiveRecord model versioning: Auto (duplicate on save), Multi (hide many versions behind a single one), Transparent (hide versions from outside world), Property (define properties on model, store them in versions)}
+    gemspec.email = "gaspard@teti.ch"
+    gemspec.homepage = "http://zenadmin.org/650"
+    gemspec.authors = ["Gaspard Bucher"]
+    gemspec.add_development_dependency "shoulda", ">= 0"
+
+    gemspec.add_development_dependency('shoulda')
+    gemspec.add_dependency('activerecord')
+    gemspec.add_dependency('property', '>= 0.8.0')
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end

data/lib/versions/auto.rb

@@ -0,0 +1,38 @@
+module Versions
+  # When you include this module into a class, it will automatically clone itself
+  # depending on the call to should_clone?
+  module Auto
+    attr_reader :previous_id
+
+    def self.included(base)
+      base.before_save :prepare_save_or_clone
+    end
+
+    def should_clone?
+      raise NoMethodError.new("You should implement 'should_clone?' in your model (return true for a new version, false to update).")
+    end
+
+    # This method provides a hook to alter values after a clone operation (just before save: no validation).
+    def cloned
+    end
+
+    # Return true if the record was cloned just before the last save
+    def cloned?
+      !@previous_id.nil?
+    end
+
+    def prepare_save_or_clone
+      if !new_record? && should_clone?
+        @previous_id = self[:id]
+        self[:id] = nil
+        self[:created_at] = nil
+        self[:updated_at] = nil
+        @new_record = true
+        cloned
+      else
+        @previous_id = nil
+      end
+      true
+    end
+  end # Auto
+end # Versions

data/lib/versions/multi.rb

@@ -0,0 +1,142 @@
+module Zena
+  module Use
+    # This module hides 'has_many' versions as if there was only a 'belongs_to' version,
+    # automatically registering the latest version's id.
+    module MultiVersion
+      # This module should be included in the model that serves as version.
+      module Version
+        def self.included(base)
+
+          base.class_eval do
+            attr_accessor :__destroy
+            belongs_to :node
+            before_create :setup_version_on_create
+            attr_protected :number, :user_id
+
+            alias_method_chain :node, :secure
+            alias_method_chain :save, :destroy
+          end
+        end
+
+        def node_with_secure
+          @node ||= begin
+            if n = node_without_secure
+              visitor.visit(n)
+              n.version = self
+            end
+            n
+          end
+        end
+
+        def save_with_destroy(*args)
+          if @__destroy
+            node = self.node
+            if destroy
+              # reset @version
+              node.send(:version_destroyed)
+              true
+            end
+          else
+            save_without_destroy(*args)
+          end
+        end
+
+        private
+          def setup_version_on_create
+            raise "You should define 'setup_version_on_create' method in '#{self.class}' class."
+          end
+      end
+
+      def self.included(base)
+        base.has_many      :versions, :order=>"number DESC", :dependent => :destroy  #, :inverse_of => :node
+        base.validate      :validate_version
+        base.before_update :save_version_before_update
+        base.after_create  :save_version_after_create
+        #base.accepts_nested_attributes_for :version
+
+        base.alias_method_chain :save, :destroy
+      end
+
+      def save_with_destroy(*args)
+        version = self.version
+        # TODO: we could use 'version.mark_for_destruction' instead of __destroy...
+        if version.__destroy && versions.count == 1
+          self.destroy # will destroy last version
+        else
+          self.save_without_destroy(*args)
+        end
+      end
+
+      def version_attributes=(attributes)
+        version.attributes = attributes
+      end
+
+      # The logic to get the 'current' version should be
+      # rewritten in class including MultiVersion.
+      def version
+        raise "You should define 'version' method in '#{self.class}' class."
+      end
+
+      def version=(v)
+        @version = v
+      end
+
+      private
+
+        def validate_version
+          # We force the existence of at least one version with this code
+          unless version.valid?
+            merge_version_errors
+          end
+        end
+
+        def save_version_before_update
+          if !@version.save #_with_validation(false)
+            merge_version_errors
+          else
+            current_version_before_update
+          end
+        end
+
+        def save_version_after_create
+          version.node_id = self[:id]
+          if !@version.save #_with_validation(false)
+            merge_version_errors
+            rollback!
+          else
+            current_version_after_create
+          end
+          true
+        end
+
+        # This method is triggered when the version is saved, but before the
+        # master record is updated.
+        # The role of this method is typically to do things like:
+        #   self[:version_id] = version.id
+        def current_version_before_update
+        end
+
+        # This method is triggered when the version is saved, after the
+        # master record has been created.
+        # The role of this method is typically to do things like:
+        #   update_attribute(:version_id, version.id)
+        def current_version_after_create
+        end
+
+        # This is called after a version is destroyed
+        def version_destroyed
+          # remove from versions list
+          if versions.loaded?
+            node.versions -= [@version]
+          end
+        end
+
+        def merge_version_errors
+          @version.errors.each_error do |attribute, message|
+            attribute = "version_#{attribute}"
+            errors.add(attribute, message) unless errors[attribute] # FIXME: rails 3: if errors[attribute].empty?
+          end
+        end
+    end
+  end
+end

data/lib/versions/property.rb

@@ -0,0 +1,98 @@
+module Zena
+  module Use
+    # This module lets the user use a node as if it was not versioned and will
+    # take care of routing the attributes between the node and the version.
+    module TransparentVersion
+
+      def self.included(base)
+        base.class_eval do
+          # When writing attributes, we send everything that we do not know of
+          # to the version.
+          def attributes_with_multi_version=(attributes)
+            columns = self.class.column_names
+            version_attributes = {}
+            attributes.keys.each do |k|
+              if !respond_to?("#{k}=") && !columns.include?(k)
+                version_attributes[k] = attributes.delete(k)
+              end
+            end
+            version.attributes = version_attributes
+            self.attributes_without_multi_version = attributes
+          end
+
+          alias_method_chain :attributes=, :multi_version
+        end
+      end
+
+      private
+        # We need method_missing in forms, normal access in templates should be made
+        # through 'node.version.xxxx', not 'node.xxxx'.
+        def method_missing(meth, *args)
+          method = meth.to_s
+          if !args.empty? || method[-1..-1] == '?' || self.class.column_names.include?(method)
+            super
+          elsif version.respond_to?(meth)
+            version.send(meth)
+          else
+            #version.prop[meth.to_s]
+            super
+          end
+        end
+
+        # Any attribute starting with 'v_' belongs to the 'version' or 'redaction'
+        # Any attribute starting with 'c_' belongs to the 'version' or 'redaction' content
+        # FIXME: performance: create methods on the fly so that next calls will not pass through 'method_missing'. #189.
+        # FIXME: this should not be used anymore. Remove.
+        # def method_missing(meth, *args)
+        #   if meth.to_s =~ /^(v_|c_|d_)(([\w_\?]+)(=?))$/
+        #     target = $1
+        #     method = $2
+        #     value  = $3
+        #     mode   = $4
+        #     if mode == '='
+        #       begin
+        #         # set
+        #         unless recipient = redaction
+        #           # remove trailing '='
+        #           redaction_error(meth.to_s[0..-2], "could not be set (no redaction)")
+        #           return
+        #         end
+        #
+        #         case target
+        #         when 'c_'
+        #           if recipient.content_class && recipient = recipient.redaction_content
+        #             recipient.send(method,*args)
+        #           else
+        #             redaction_error(meth.to_s[0..-2], "cannot be set") # remove trailing '='
+        #           end
+        #         when 'd_'
+        #           recipient.prop[method[0..-2]] = args[0]
+        #         else
+        #           recipient.send(method,*args)
+        #         end
+        #       rescue NoMethodError
+        #         # bad attribute, just ignore
+        #       end
+        #     else
+        #       # read
+        #       recipient = version
+        #       if target == 'd_'
+        #         version.prop[method]
+        #       else
+        #         recipient = recipient.content if target == 'c_'
+        #         return nil unless recipient
+        #         begin
+        #           recipient.send(method,*args)
+        #         rescue NoMethodError
+        #           # bad attribute
+        #           return nil
+        #         end
+        #       end
+        #     end
+        #   else
+        #     super
+        #   end
+        # end
+    end
+  end
+end

data/lib/versions/shared_attachment/attachment.rb

@@ -0,0 +1,66 @@
+module Versions
+  # This module enables file attachments to versions. 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 SharedAttachment
+    class Attachment < ::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 # Attachment
+  end # SharedAttachment
+end # Versions

data/lib/versions/shared_attachment/owner.rb

@@ -0,0 +1,77 @@
+
+module Zena
+  module Use
+
+    # The attachement module provides shared file attachments to a class with a copy-on-write
+    # pattern.
+    # Basically the module provides 'file=' and 'file' methods.
+    module SharedAttachment
+      module ClassMethods
+        def set_attachment_class(class_name)
+          belongs_to :attachment,
+                     :class_name => class_name,
+                     :foreign_key => 'attachment_id'
+        end
+      end
+
+      def self.included(base)
+        base.class_eval do
+          before_create  :save_attachment
+          before_update  :attachment_before_update
+          before_destroy :attachment_before_destroy
+
+          extend Zena::Use::SharedAttachment::ClassMethods
+          set_attachment_class 'Zena::Use::SharedAttachment::Attachment'
+        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
+
+        def unlink_attachment_mark
+          @attachment_to_unlink = self.attachment
+        end
+
+        def unlink_attachment
+        end
+
+
+    end # SharedAttachment
+  end # Use
+end # Zena

data/lib/versions/shared_attachment.rb

@@ -0,0 +1,2 @@
+require 'versions/shared_attachment/attachment'
+require 'versions/shared_attachment/owner'

data/lib/versions/transparent.rb

@@ -0,0 +1,98 @@
+module Zena
+  module Use
+    # This module lets the user use a node as if it was not versioned and will
+    # take care of routing the attributes between the node and the version.
+    module TransparentVersion
+
+      def self.included(base)
+        base.class_eval do
+          # When writing attributes, we send everything that we do not know of
+          # to the version.
+          def attributes_with_multi_version=(attributes)
+            columns = self.class.column_names
+            version_attributes = {}
+            attributes.keys.each do |k|
+              if !respond_to?("#{k}=") && !columns.include?(k)
+                version_attributes[k] = attributes.delete(k)
+              end
+            end
+            version.attributes = version_attributes
+            self.attributes_without_multi_version = attributes
+          end
+
+          alias_method_chain :attributes=, :multi_version
+        end
+      end
+
+      private
+        # We need method_missing in forms, normal access in templates should be made
+        # through 'node.version.xxxx', not 'node.xxxx'.
+        def method_missing(meth, *args)
+          method = meth.to_s
+          if !args.empty? || method[-1..-1] == '?' || self.class.column_names.include?(method)
+            super
+          elsif version.respond_to?(meth)
+            version.send(meth)
+          else
+            #version.prop[meth.to_s]
+            super
+          end
+        end
+
+        # Any attribute starting with 'v_' belongs to the 'version' or 'redaction'
+        # Any attribute starting with 'c_' belongs to the 'version' or 'redaction' content
+        # FIXME: performance: create methods on the fly so that next calls will not pass through 'method_missing'. #189.
+        # FIXME: this should not be used anymore. Remove.
+        # def method_missing(meth, *args)
+        #   if meth.to_s =~ /^(v_|c_|d_)(([\w_\?]+)(=?))$/
+        #     target = $1
+        #     method = $2
+        #     value  = $3
+        #     mode   = $4
+        #     if mode == '='
+        #       begin
+        #         # set
+        #         unless recipient = redaction
+        #           # remove trailing '='
+        #           redaction_error(meth.to_s[0..-2], "could not be set (no redaction)")
+        #           return
+        #         end
+        #
+        #         case target
+        #         when 'c_'
+        #           if recipient.content_class && recipient = recipient.redaction_content
+        #             recipient.send(method,*args)
+        #           else
+        #             redaction_error(meth.to_s[0..-2], "cannot be set") # remove trailing '='
+        #           end
+        #         when 'd_'
+        #           recipient.prop[method[0..-2]] = args[0]
+        #         else
+        #           recipient.send(method,*args)
+        #         end
+        #       rescue NoMethodError
+        #         # bad attribute, just ignore
+        #       end
+        #     else
+        #       # read
+        #       recipient = version
+        #       if target == 'd_'
+        #         version.prop[method]
+        #       else
+        #         recipient = recipient.content if target == 'c_'
+        #         return nil unless recipient
+        #         begin
+        #           recipient.send(method,*args)
+        #         rescue NoMethodError
+        #           # bad attribute
+        #           return nil
+        #         end
+        #       end
+        #     end
+        #   else
+        #     super
+        #   end
+        # end
+    end
+  end
+end

data/lib/versions.rb

@@ -0,0 +1,5 @@
+require 'versions/shared_attachment'
+require 'versions/auto'
+require 'versions/multi'
+require 'versions/property'
+require 'versions/transparent'

data/test/fixtures.rb

@@ -0,0 +1,34 @@
+begin
+  class VersionsMigration < ActiveRecord::Migration
+    def self.down
+      drop_table 'pages'
+      drop_table 'versions'
+    end
+    def self.up
+      create_table 'pages' do |t|
+        t.integer 'version_id'
+        t.string  'name'
+        t.timestamps
+      end
+
+      create_table 'versions' do |t|
+        t.string  'title'
+        t.text    'text'
+        t.string  'properties'
+        t.integer 'attachment_id'
+        t.timestamps
+      end
+
+      create_table 'attachments' do |t|
+        t.string 'owner_table'
+        t.string 'filename'
+        t.timestamps
+      end
+    end
+  end
+
+  ActiveRecord::Base.establish_connection(:adapter=>'sqlite3', :database=>':memory:')
+  ActiveRecord::Migration.verbose = false
+  VersionsMigration.migrate(:up)
+  ActiveRecord::Migration.verbose = true
+end

data/test/helper.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'active_record'
+require 'active_support'
+require 'active_support/testing/assertions'
+require 'versions'
+require 'fixtures'
+
+class Test::Unit::TestCase
+  include ActiveSupport::Testing::Assertions
+end

data/test/unit/attachment_test.rb

@@ -0,0 +1,222 @@
+require 'helper'
+
+#class SharedAttachmentTest < Zena::Unit::TestCase
+#  self.use_transactional_fixtures = false
+#
+#  Attachment = Class.new(Zena::Use::SharedAttachment::Attachment) do
+#    def filepath
+#      File.join(RAILS_ROOT, 'tmp', 'attachments', super)
+#    end
+#  end
+#
+#  # Mock a document class with many versions
+#  class Document < ActiveRecord::Base
+#    include Zena::Use::MultiVersion
+#
+#    set_table_name :nodes
+#    before_save :set_dummy_defaults
+#
+#    def title=(title)
+#      version.title = title
+#    end
+#
+#    def file=(file)
+#      version.file = file
+#    end
+#
+#    def version
+#      @version ||= new_record? ? versions.build : versions.first(:order => 'id DESC')
+#    end
+#    private
+#      def set_dummy_defaults
+#        self[:user_id] ||= 0
+#      end
+#  end
+#
+#  # Mock a version class with shared attachments (between versions of the same document)
+#  class Version < ActiveRecord::Base
+#    include Zena::Use::MultiVersion::Version
+#    include Zena::Use::AutoVersion
+#    include Zena::Use::SharedAttachment
+#    set_attachment_class 'SharedAttachmentTest::Attachment'
+#    set_table_name :versions
+#
+#    def should_clone?
+#      true
+#    end
+#
+#    private
+#      def setup_version_on_create
+#        # Dummy values when testing Version without a Document
+#        self[:node_id] ||= 0
+#        self[:user_id] ||= 0
+#        self[:status]  ||= 0
+#      end
+#  end
+#
+#  def setup
+#    FileUtils.rmtree(File.join(RAILS_ROOT, 'tmp', 'attachments'))
+#  end
+#
+#  context 'When creating a new owner' do
+#    setup do
+#      @owner = Version.create(:file => uploaded_jpg('bird.jpg'))
+#    end
+#
+#    should 'store file in the filesystem' do
+#      assert File.exist?(@owner.filepath)
+#      assert_equal uploaded_jpg('bird.jpg').read, File.read(@owner.filepath)
+#    end
+#
+#    should 'restore the filepath from the database' do
+#      attachment = Attachment.find(@owner.attachment_id)
+#      assert_equal @owner.filepath, attachment.filepath
+#    end
+#  end
+#
+#  context 'When the transaction fails' do
+#    should 'not write file on create' do
+#      owner    = nil
+#      filepath = nil
+#      assert_difference('Attachment.count', 0) do
+#        Version.transaction do
+#          owner = Version.create(:file => uploaded_jpg('bird.jpg'))
+#          filepath = owner.filepath
+#          assert !File.exist?(filepath)
+#          raise ActiveRecord::Rollback
+#        end
+#      end
+#      assert !File.exist?(filepath)
+#    end
+#
+#    should 'not remove file on destroy' do
+#      @owner   = Version.create(:file => uploaded_jpg('bird.jpg'))
+#      filepath = @owner.filepath
+#      assert File.exist?(filepath)
+#      assert_difference('Attachment.count', 0) do
+#        Version.transaction do
+#          @owner.destroy
+#          assert File.exist?(filepath)
+#          raise ActiveRecord::Rollback
+#        end
+#      end
+#      assert File.exist?(filepath)
+#    end
+#  end
+#
+#  context 'On an owner with a file' do
+#    setup do
+#      @owner = Version.create(:file => uploaded_jpg('bird.jpg'))
+#      @owner = Version.find(@owner.id)
+#    end
+#
+#    should 'remove file in the filesystem when updating file' do
+#      old_filepath = @owner.filepath
+#      puts "Start"
+#      assert_difference('Attachment.count', 0) do # destroy + create
+#        assert @owner.update_attributes(:file => uploaded_jpg('lake.jpg'))
+#      end
+#      assert_not_equal old_filepath, @owner.filepath
+#      assert File.exist?(@owner.filepath)
+#      assert_equal uploaded_jpg('lake.jpg').read, File.read(@owner.filepath)
+#      assert !File.exist?(old_filepath)
+#    end
+#  end
+#
+#  context 'Updating document' do
+#    setup do
+#      begin
+#        @doc = Document.create(:title => 'birdy', :file => uploaded_jpg('bird.jpg'))
+#      rescue => err
+#        puts err.message
+#        puts err.backtrace.join("\n")
+#      end
+#    end
+#
+#    # Updating document ...attributes
+#    context 'attributes' do
+#      setup do
+#        assert_difference('Version.count', 1) do
+#          @doc.update_attributes(:title => 'hopla')
+#        end
+#      end
+#
+#      should 'reuse the same filepath in new versions' do
+#        filepath = nil
+#        @doc.versions.each do |version|
+#          if filepath
+#            assert_equal filepath, version.filepath
+#          else
+#            filepath = version.filepath
+#          end
+#        end
+#      end
+#    end
+#
+#    # Updating document ...file
+#    context 'file' do
+#      setup do
+#        assert_difference('Version.count', 1) do
+#          @doc.update_attributes(:file => uploaded_jpg('lake.jpg'))
+#        end
+#      end
+#
+#      should 'create new filepath' do
+#        filepath = nil
+#        @doc.versions.each do |version|
+#          if filepath
+#            assert_not_equal filepath, version.filepath
+#          else
+#            filepath = version.filepath
+#          end
+#        end
+#      end
+#    end # Updating document .. file
+#  end # Updating document
+#
+#  context 'On a document with many versions' do
+#    setup do
+#      assert_difference('Version.count', 2) do
+#        @doc = Document.create(:title => 'birdy', :file => uploaded_jpg('bird.jpg'))
+#        @doc.update_attributes(:title => 'Vögel')
+#        @doc = Document.find(@doc.id)
+#      end
+#    end
+#
+#    context 'removing a version' do
+#
+#      should 'not remove shared attachment' do
+#        filepath = @doc.version.filepath
+#
+#        assert_difference('Version.count', -1) do
+#          assert_difference('Attachment.count', 0) do
+#            assert @doc.version.destroy
+#          end
+#        end
+#        assert File.exist?(filepath)
+#      end
+#    end
+#
+#    context 'removing the last version' do
+#
+#      should 'remove shared attachment' do
+#        filepath = @doc.version.filepath
+#
+#        assert_difference('Version.count', -2) do
+#          assert_difference('Attachment.count', -1) do
+#            @doc.versions.each do |version|
+#              assert version.destroy
+#            end
+#          end
+#        end
+#        assert !File.exist?(filepath)
+#      end
+#    end
+#  end
+#
+#  private
+#    def filepath(attachment_id, filename)
+#      digest = Digest::SHA1.hexdigest(attachment_id.to_s)
+#      "#{digest[0..0]}/#{digest[1..1]}/#{filename}"
+#    end
+#end

data/test/unit/auto_test.rb

@@ -0,0 +1,85 @@
+require 'helper'
+
+class AutoTest < Test::Unit::TestCase
+
+  class BadVersion < ActiveRecord::Base
+    include Versions::Auto
+    set_table_name :versions
+  end
+
+  class Version < ActiveRecord::Base
+    attr_accessor :should_clone, :messages
+    include Versions::Auto
+
+    def should_clone?
+      @should_clone
+    end
+
+    def cloned
+      @messages ||= []
+      @messages << 'cloned'
+    end
+  end
+
+  context 'An instance of a class with Auto included' do
+    subject { @version }
+
+    context 'without should_clone' do
+      setup do
+        @version = BadVersion.create('title' => 'Socrate')
+      end
+
+      should 'raise an exception on update' do
+        assert_raise(NoMethodError) { subject.update_attributes('title' => 'Aristotle') }
+      end
+    end
+
+    context 'with should_clone' do
+      setup do
+        @version = Version.create('title' => 'Socrate')
+      end
+
+      context 'returning false' do
+        should 'update record if should_clone is false' do
+          assert_difference('Version.count', 0) do
+            assert subject.update_attributes('title' => 'Aristotle')
+          end
+        end
+
+        should 'not call cloned before saving' do
+          assert_nil subject.messages
+          subject.update_attributes('title' => 'Aristotle')
+          assert_nil subject.messages
+        end
+
+        should 'return false on cloned?' do
+          subject.update_attributes('title' => 'Aristotle')
+          assert !subject.cloned?
+        end
+      end
+
+      context 'returning true' do
+        setup do
+          subject.should_clone = true
+        end
+
+        should 'duplicate record' do
+          assert_difference('Version.count', 1) do
+            assert subject.update_attributes('title' => 'Aristotle')
+          end
+        end
+
+        should 'call cloned before saving' do
+          assert_nil subject.messages
+          subject.update_attributes('title' => 'Aristotle')
+          assert_equal ['cloned'], subject.messages
+        end
+
+        should 'return true on cloned?' do
+          subject.update_attributes('title' => 'Aristotle')
+          assert subject.cloned?
+        end
+      end
+    end
+  end
+end

data/test/unit/multi_test.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class MultiVersionTest < Test::Unit::TestCase
+  def test_truth
+    assert true
+  end
+end

data/test/unit/transparent_test.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TransparentTest < Test::Unit::TestCase
+  def test_truth
+    assert true
+  end
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification 
+name: versions
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Gaspard Bucher
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-13 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: property
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.8.0
+    version: 
+description: "A list of libraries to work with ActiveRecord model versioning: Auto (duplicate on save), Multi (hide many versions behind a single one), Transparent (hide versions from outside world), Property (define properties on model, store them in versions)"
+email: gaspard@teti.ch
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- lib/versions.rb
+- lib/versions/auto.rb
+- lib/versions/multi.rb
+- lib/versions/property.rb
+- lib/versions/shared_attachment.rb
+- lib/versions/shared_attachment/attachment.rb
+- lib/versions/shared_attachment/owner.rb
+- lib/versions/transparent.rb
+- test/fixtures.rb
+- test/helper.rb
+- test/unit/attachment_test.rb
+- test/unit/auto_test.rb
+- test/unit/multi_test.rb
+- test/unit/transparent_test.rb
+has_rdoc: true
+homepage: http://zenadmin.org/650
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A list of libraries to work with ActiveRecord model versioning
+test_files: 
+- test/fixtures.rb
+- test/helper.rb
+- test/unit/attachment_test.rb
+- test/unit/auto_test.rb
+- test/unit/multi_test.rb
+- test/unit/transparent_test.rb