versions 0.0.1 → 0.1.0

data/.gitignore

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

data/History.txt

@@ -0,0 +1,12 @@
+== 0.2.0
+
+== 0.1.0 2010-02-14
+
+* 2 major enhancements
+  * Multi working
+  * tested with properties (Property gem)
+
+== 0.0.1 2010-02-13
+
+* 1 major enhancement
+  * initial release, Auto working

data/README.rdoc

@@ -6,19 +6,40 @@ website: http://zenadmin.org/650
 
 license: MIT
 
-== Auto
+== Auto (status: beta)
 
 Duplicate on save if should_clone? returns true.
 
-== Multi
+== Multi (status: beta)
 
 Hide many versions behind a single current one.
 
-== Transparent
+== Transparent (status: alpha)
 
-Hide versions from outside world.
+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.
 
-== Property
+=== Properties integration (status: beta)
 
-Define properties on model, store them in versions.
+You can get the same functionality as 'Transparent' by using the Property gem and
+storing properties in the version:
+
+  class Contact < ActiveRecord::Base
+    include Versions::Multi
+    has_multiple :versions
+
+    include Property
+    store_properties_in :version
+
+    property do |p|
+      p.string 'first_name', 'name'
+    end
+  end
+
+
+== SharedAttachment (status: alpha)
+
+Enable file attachments linked to versions. The attachments are shared between versions
+and deleted when no more versions are using them.
 

data/Rakefile

@@ -15,7 +15,7 @@ begin
   require 'rcov/rcovtask'
   Rcov::RcovTask.new do |test|
     test.libs << 'test' << 'lib'
-    test.pattern = 'test/**/auto_test.rb'
+    test.pattern = 'test/**/**_test.rb'
     test.verbose = true
     test.rcov_opts = ['-T', '--exclude-only', '"test\/,^\/"']
   end
@@ -38,11 +38,11 @@ begin
     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_development_dependency('property', '>= 0.8.1')
+
     gemspec.add_dependency('activerecord')
-    gemspec.add_dependency('property', '>= 0.8.0')
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError

data/lib/versions/auto.rb

@@ -5,7 +5,10 @@ module Versions
     attr_reader :previous_id
 
     def self.included(base)
+      raise TypeError.new("Missing 'number' field in table #{base.table_name}.") unless base.column_names.include?('number')
       base.before_save :prepare_save_or_clone
+      base.after_save  :clear_number_counter
+      base.attr_protected :number
     end
 
     def should_clone?
@@ -22,8 +25,13 @@ module Versions
     end
 
     def prepare_save_or_clone
-      if !new_record? && should_clone?
+      if new_record?
+        self[:number] = 1
+      elsif should_clone?
         @previous_id = self[:id]
+        @previous_number ||= self[:number]
+        self[:number] = @previous_number + 1
+
         self[:id] = nil
         self[:created_at] = nil
         self[:updated_at] = nil
@@ -34,5 +42,10 @@ module Versions
       end
       true
     end
+
+    def clear_number_counter
+      @previous_number = nil
+      true
+    end
   end # Auto
 end # Versions

data/lib/versions/destroy.rb

@@ -0,0 +1,63 @@
+module Versions
+  # If you include this module in your model (which should also include Versions::Multi), deleting
+  # the last version will destroy the model.
+  module Destroy
+    
+    # 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 :save, :destroy
+        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.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
+        destroy # will destroy last version
+      else
+        save_without_destroy(*args)
+      end
+    end
+    
+    private
+      # This is called after a version is destroyed
+      def version_destroyed
+        # remove from versions list
+        if versions.loaded?
+          node.versions -= [@version]
+        end
+      end
+
+  end
+end

data/lib/versions/multi.rb

@@ -1,142 +1,124 @@
-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
+module Versions
+  # This module hides 'has_many' versions as if there was only a 'belongs_to' version,
+  # automatically registering the latest version's id.
+  module Multi
+    def self.included(base)
+      base.extend ClassMethods
+    end
 
-        def node_with_secure
-          @node ||= begin
-            if n = node_without_secure
-              visitor.visit(n)
-              n.version = self
-            end
-            n
-          end
-        end
+    module ClassMethods
 
-        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
+      def has_multiple(versions, options = {})
+        name       = versions.to_s.singularize
+        klass      = (options[:class_name] || name.capitalize).constantize
+        owner_name = options[:as] || 'owner'
 
-        private
-          def setup_version_on_create
-            raise "You should define 'setup_version_on_create' method in '#{self.class}' class."
-          end
-      end
+        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")
 
-      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
+        has_many versions, :order => 'number DESC', :dependent => :destroy
+        validate      :"validate_#{name}"
+        after_create  :"save_#{name}_after_create"
+        before_update :"save_#{name}_before_update"
 
-        base.alias_method_chain :save, :destroy
+        include module_for_multiple(name, klass, owner_name)
+        klass.belongs_to owner_name, :class_name => self.to_s
       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)
+      protected
+        def module_for_multiple(name, klass, owner_name)
+
+          # 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
+                  version = ::#{klass}.find(v_id)           #       version = ::Version.find(v_id)
+                else                                        #     else
+                  version = ::#{klass}.new                  #       version = ::Version.new
+                end                                         #     end
+                version.#{owner_name} = self                #     version.owner = self
+                version                                     #     version
+              end                                           #   end
+            end                                             # end
+
+            def #{name}=(v)                                 # def version=(v)
+              @#{name} = v                                  #   @version = v
+            end                                             # end
+
+            def #{name}_attributes=(attributes)             # def version_attributes=(attributes)
+              #{name}.attributes = attributes               #   version.attributes = attributes
+            end                                             # end
+
+            private
+              def validate_#{name}                          # def validate_version
+                unless #{name}.valid?                       #   unless version.valid?
+                  merge_multi_errors('#{name}', @#{name})   #     merge_multi_errors('version', version)
+                end                                         #   end
+              end                                           # end
+
+              def save_#{name}_before_update                # def save_version_before_update
+                return true if !@#{name}.changed?           #   return true if !@version.changed?
+                if !@#{name}.save(false)                    #   if !@version.save_with_validation(false)
+                  merge_multi_errors('#{name}', @#{name})   #     merge_multi_errors('version', @version)
+                  false                                     #     false
+                else                                        #   else
+                  set_current_#{name}_before_update         #     set_current_version_before_update
+                  true                                      #     true
+                end                                         #   end
+              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)
+                  merge_multi_errors('#{name}', @#{name})   #     merge_multi_errors('version', @version)
+                  raise ActiveRecord::RecordInvalid.new(self) #   raise ActiveRecord::RecordInvalid.new(self)
+                else                                        #   else
+                  set_current_#{name}_after_create          #     set_current_version_after_create
+                end                                         #   end
+                true                                        #   true
+              end                                           # end
+
+
+              # This method is triggered when the version is saved, but before the
+              # 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
+              end                                           # end
+
+              # This method is triggered when the version is saved, after the
+              # master record has been created. This method is usually overwriten
+              # in the class.
+              def set_current_#{name}_after_create          # def set_current_version_after_create
+                # raw SQL to skip callbacks and validtions  #
+                conn = self.class.connection                #   conn = self.class.connection
+
+                # 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)} " +
+                  "WHERE id = \#{conn.quote(self.id)}"
+                )
+                self[:#{name}_id] = @#{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
+        end # module_for_multiple
+    end # ClassMethods
+
+    private
+
+      def merge_multi_errors(name, model)
+        model.errors.each_error do |attribute, message|
+          attribute = "#{name}_#{attribute}"
+          errors.add(attribute, message) unless errors[attribute] # FIXME: rails 3: if errors[attribute].empty?
         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
+  end # Multi
+end # Versions

data/lib/versions/version.rb

@@ -0,0 +1,3 @@
+module Versions
+  VERSION = '0.1.0'
+end

data/lib/versions.rb

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

data/test/fixtures.rb

@@ -1,3 +1,16 @@
+{:default=>[:"models.multi_test/simple_version.should not contain letter x", :"messages.should not contain letter x", "should not contain letter x"], :value=>"Fox", :scope=>[:activerecord, :errors], :model=>"Multitest::simpleversion", :attribute=>"Title"}
+
+module I18n
+  # I hate I18n in rails (soooo many bad surprises)
+  def self.translate(key, options)
+    if options[:default].first.to_s =~ /\A.*\.(.*)\Z/
+      $1
+    else
+      options[:default].last
+    end
+  end
+end
+
 begin
   class VersionsMigration < ActiveRecord::Migration
     def self.down
@@ -7,6 +20,7 @@ begin
     def self.up
       create_table 'pages' do |t|
         t.integer 'version_id'
+        t.integer 'foo_id'
         t.string  'name'
         t.timestamps
       end
@@ -16,6 +30,8 @@ begin
         t.text    'text'
         t.string  'properties'
         t.integer 'attachment_id'
+        t.integer 'number'
+        t.integer 'owner_id'
         t.timestamps
       end
 

data/test/unit/auto_test.rb

@@ -3,8 +3,8 @@ require 'helper'
 class AutoTest < Test::Unit::TestCase
 
   class BadVersion < ActiveRecord::Base
-    include Versions::Auto
     set_table_name :versions
+    include Versions::Auto
   end
 
   class Version < ActiveRecord::Base
@@ -39,6 +39,10 @@ class AutoTest < Test::Unit::TestCase
         @version = Version.create('title' => 'Socrate')
       end
 
+      should 'start number at 1' do
+        assert_equal 1, subject.number
+      end
+
       context 'returning false' do
         should 'update record if should_clone is false' do
           assert_difference('Version.count', 0) do
@@ -56,6 +60,10 @@ class AutoTest < Test::Unit::TestCase
           subject.update_attributes('title' => 'Aristotle')
           assert !subject.cloned?
         end
+
+        should 'not increase version number' do
+          assert_equal 1, subject.number
+        end
       end
 
       context 'returning true' do
@@ -79,6 +87,14 @@ class AutoTest < Test::Unit::TestCase
           subject.update_attributes('title' => 'Aristotle')
           assert subject.cloned?
         end
+
+        should 'increase number on each clone' do
+          subject.update_attributes('title' => 'Aristotle')
+          assert_equal 2, subject.number
+
+          subject.update_attributes('title' => 'Aristotle')
+          assert_equal 3, subject.number
+        end
       end
     end
   end

data/test/unit/multi_test.rb

@@ -1,7 +1,140 @@
 require 'helper'
 
-class MultiVersionTest < Test::Unit::TestCase
-  def test_truth
-    assert true
+class MultiTest < Test::Unit::TestCase
+  class SimpleVersion < ActiveRecord::Base
+    set_table_name :versions
+    validate :title_does_not_contain_letter_x
+    before_save :fail_if_title_contains_y
+
+    def title_does_not_contain_letter_x
+      errors.add('title', 'should not contain letter x') if self[:title].to_s =~ /x/
+    end
+
+    def fail_if_title_contains_y
+      if self[:title].to_s =~ /y/
+        errors.add('title', 'should not contain letter y')
+        false
+      else
+        true
+      end
+    end
+  end
+  class SimplePage < ActiveRecord::Base
+    include Versions::Multi
+
+    set_table_name :pages
+    has_multiple :foos, :class_name => 'MultiTest::SimpleVersion'
+  end
+
+  class Version < ActiveRecord::Base
+    set_table_name :versions
+    include Versions::Auto
+    def should_clone?
+      changed?
+    end
+  end
+  class Page < ActiveRecord::Base
+    set_table_name :pages
+    include Versions::Multi
+    has_multiple :versions, :class_name => 'MultiTest::Version'
+  end
+
+  context 'A class with multiple foos' do
+
+    should 'accept foo nested attributes' do
+      assert_nothing_raised { SimplePage.create('name' => 'one', 'foo_attributes' => {'title' => 'First'}) }
+    end
+
+    should 'create a foo instance of the given type' do
+      page = SimplePage.create
+      assert page.valid?
+      assert_kind_of MultiTest::SimpleVersion, page.foo
+    end
+
+    should 'set foo_id after_create' do
+      page = SimplePage.create
+      foo_id = page.foo_id
+      assert foo_id
+      page = SimplePage.find(page)
+      assert_equal foo_id, page.foo_id
+    end
+
+    should 'replace current instance on new foos' do
+      page = SimplePage.create
+      first_foo = page.foo.id
+      page.foo = SimpleVersion.new('title' => 'hello')
+      assert page.save
+      page = SimplePage.find(page.id)
+      assert_not_equal first_foo, page.foo.id
+    end
+
+    should 'merge foo errors in model on create' do
+      page = SimplePage.create('foo_attributes' => {'title' => 'Fox'})
+      assert !page.valid?
+      assert_equal 'should not contain letter x', page.errors['foo_title']
+    end
+
+    should 'merge foo errors in model on update' do
+      page = SimplePage.create('foo_attributes' => {'title' => 'phone'})
+      assert page.valid?
+      assert !page.update_attributes('foo_attributes' => {'title' => 'fax'})
+      assert_equal 'should not contain letter x', page.errors['foo_title']
+    end
+
+    should 'rollback if foo save fails on create' do
+      assert_difference('MultiTest::SimpleVersion.count', 0) do
+        assert_difference('MultiTest::SimplePage.count', 0) do
+          assert_raise(ActiveRecord::RecordInvalid) do
+            begin
+              page = SimplePage.create('foo_attributes' => {'title' => 'Fly'})
+            rescue ActiveRecord::RecordInvalid => err
+              assert_equal 'Validation failed: Foo title should not contain letter y', err.message
+              raise
+            end
+          end
+        end
+      end
+    end
+
+    should 'abort if foo save fails on update' do
+      page = SimplePage.create('foo_attributes' => {'title' => 'mosquito'})
+      assert page.valid?
+      assert !page.update_attributes('foo_attributes' => {'title' => 'fly'})
+      assert_equal 'should not contain letter y', page.errors['foo_title']
+    end
+  end
+
+  context 'A class with multiple auto versions' do
+    should 'create new versions on update' do
+      page = Page.create
+      assert_difference('Version.count', 1) do
+        assert page.update_attributes('version_attributes' => {'title' => 'newTitle'})
+      end
+    end
+    
+    should 'mark new version as not dirty after create' do
+      page = Page.create
+      assert !page.version.changed?
+    end
+    
+    should 'mark new version as not dirty after update' do
+      page = Page.create
+      assert page.update_attributes('version_attributes' => {'title' => 'Yodle'})
+      assert !page.version.changed?
+    end
+
+    should 'find latest version' do
+      page = Page.create
+      v_id = page.version.id
+      assert page.update_attributes('version_attributes' => {'title' => 'newTitle'})
+      assert_not_equal v_id, page.version.id
+    end
+
+    should 'not create new versions on update if content did not change' do
+      page = Page.create('version_attributes' => {'title' => 'One'})
+      assert_difference('Version.count', 0) do
+        assert page.update_attributes('version_attributes' => {'title' => 'One'})
+      end
+    end
   end
-end
+end

data/test/unit/property_test.rb

@@ -0,0 +1,66 @@
+require 'helper'
+require 'property'
+
+class PropertyTest < Test::Unit::TestCase
+  class Version < ActiveRecord::Base
+    set_table_name :versions
+    include Versions::Auto
+
+    def should_clone?
+      if changed?
+        true
+      else
+        false
+      end
+    end
+  end
+
+  class Page < ActiveRecord::Base
+    set_table_name :pages
+    include Versions::Multi
+    has_multiple :versions, :class_name => 'PropertyTest::Version'
+
+    include Property
+    store_properties_in :version
+
+    property do |p|
+      p.text 'history'
+      p.string 'author', :default => 'John Malkovitch'
+    end
+  end
+
+  context 'Working with properties stored in version' do
+
+    should 'create an initial version' do
+      page = nil
+      assert_difference('PropertyTest::Version.count', 1) do
+        page = Page.create('history' => 'His Story')
+      end
+      assert_equal 'His Story', page.history
+      assert_equal 1, page.version.number
+    end
+
+    should 'create new versions on property update' do
+      page = Page.create('history' => 'His Story')
+      assert_difference('PropertyTest::Version.count', 1) do
+        assert page.update_attributes('history' => 'Her Story')
+      end
+      assert_equal 'Her Story', page.history
+      assert_equal 2, page.version.number
+    end
+
+    should 'mark as dirty on property update' do
+      page = Page.create('history' => 'His Story')
+      page.prop['history'] = 'Her Story'
+      assert page.changed?
+    end
+
+    should 'not create new versions on property update with same values' do
+      page = Page.create('history' => 'His Story')
+      assert_difference('PropertyTest::Version.count', 0) do
+        assert page.update_attributes('history' => 'His Story')
+      end
+      assert_equal 1, page.version.number
+    end
+  end
+end

data/versions.gemspec

@@ -0,0 +1,78 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{versions}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Gaspard Bucher"]
+  s.date = %q{2010-02-14}
+  s.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)}
+  s.email = %q{gaspard@teti.ch}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "History.txt",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "lib/versions.rb",
+     "lib/versions/auto.rb",
+     "lib/versions/destroy.rb",
+     "lib/versions/multi.rb",
+     "lib/versions/shared_attachment.rb",
+     "lib/versions/shared_attachment/attachment.rb",
+     "lib/versions/shared_attachment/owner.rb",
+     "lib/versions/transparent.rb",
+     "lib/versions/version.rb",
+     "test/fixtures.rb",
+     "test/helper.rb",
+     "test/unit/attachment_test.rb",
+     "test/unit/auto_test.rb",
+     "test/unit/multi_test.rb",
+     "test/unit/property_test.rb",
+     "test/unit/transparent_test.rb",
+     "versions.gemspec"
+  ]
+  s.homepage = %q{http://zenadmin.org/650}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{A list of libraries to work with ActiveRecord model versioning}
+  s.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/property_test.rb",
+     "test/unit/transparent_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<property>, [">= 0.8.1"])
+      s.add_runtime_dependency(%q<activerecord>, [">= 0"])
+    else
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<property>, [">= 0.8.1"])
+      s.add_dependency(%q<activerecord>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<property>, [">= 0.8.1"])
+    s.add_dependency(%q<activerecord>, [">= 0"])
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: versions
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors: 
 - Gaspard Bucher
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-13 00:00:00 +01:00
+date: 2010-02-14 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -23,14 +23,14 @@ dependencies:
         version: "0"
     version: 
 - !ruby/object:Gem::Dependency 
-  name: shoulda
+  name: property
   type: :development
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: "0"
+        version: 0.8.1
     version: 
 - !ruby/object:Gem::Dependency 
   name: activerecord
@@ -42,16 +42,6 @@ dependencies:
       - !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: []
@@ -64,23 +54,27 @@ extra_rdoc_files:
 files: 
 - .document
 - .gitignore
+- History.txt
 - LICENSE
 - README.rdoc
 - Rakefile
 - lib/versions.rb
 - lib/versions/auto.rb
+- lib/versions/destroy.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
+- lib/versions/version.rb
 - test/fixtures.rb
 - test/helper.rb
 - test/unit/attachment_test.rb
 - test/unit/auto_test.rb
 - test/unit/multi_test.rb
+- test/unit/property_test.rb
 - test/unit/transparent_test.rb
+- versions.gemspec
 has_rdoc: true
 homepage: http://zenadmin.org/650
 licenses: []
@@ -115,4 +109,5 @@ test_files:
 - test/unit/attachment_test.rb
 - test/unit/auto_test.rb
 - test/unit/multi_test.rb
+- test/unit/property_test.rb
 - test/unit/transparent_test.rb

data/lib/versions/property.rb

@@ -1,98 +0,0 @@
-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