acts_as_versionable 0.3.5 → 0.5.0

data/README.rdoc

@@ -1,57 +1,69 @@
 = Acts As Versionable
 
  Minimalist versionable engine for rails > 3
+ Maintains versions in same table, just adding two new fields 
+
+ 
 
 === Installation
  
   gem 'acts_as_versionable' 
 
-=== Generator
-
-  rails g versionable MODEL
+  add two fields to your model 
 
-  rails g model Document title:string body:text
-  rake db:migrate
+  version_number:integer
+  version_id:integer
 
- _generate versionable table_
-
-  rails g versionable Document	
-  create  db/migrate/20120119150513_create_document_versions.rb
-	
-  class CreateDocumentVersions < ActiveRecord::Migration
+  class ActsAsVersionableDocuments < ActiveRecord::Migration
     def self.up
-      create_table :document_versions do |t| 
-        t.column :title, :string
-        t.column :body, :text
-        t.column :current_version, :integer
-        t.integer :document_id
-        t.integer :versioned_as
-        t.timestamps
-      end
-      add_index :document_versions, :versioned_as
-      add_column :documents, :current_version, :integer
+	  add_column :documents, :version_number, :default => 0
+	  add_column :documents, :version_id, :default => null
+	
+	  # optional indexes
+	  add_index :documents, :version_number, :name => "index_documents_on_version_number"
+	  add_index :documents, :version_id, :name => "index_documents_on_version_id"
+	  # optional unique :id, :version_number
     end
 
     def self.down
-      drop_table :document_versions
-      remove_column :documents, :current_version
+      remove_column :documents, :version_number
+      remove_column :documents, :version_id
     end
   end
-
+	
 === Example
 
   class Document < ActiveRecord::Base
     acts_as_versionable :limit => 3
   end
 
+  # use scope to get top versions	
+  documents = Document.last_versions	 => scope that return top versions
+
+  # cerate first version	
   document = Document.create(:title => 'title', :body => 'body')
   document.version => 1
+  document.last_version => 1
 
+  # modify
   document.title = 'new title'
   document.save => true
+  
+  # new version was created
   document.version => 2
+  document.last_version => 2
   document.versions => Array(2)
-  document.revert_to(1) => #<Document ...>
-  document.versions.get_version 2 => #<DocumentVersion ... versioned => 2>	
 
-  document.new_from_version(2) => #<Document ...> 
+  # revert to version 1
+  document.revert_to_version(1) => #<Document ...>
+  document.version => 3	# after revert a new version is created with content of version 1
+  document.title => 'title'
+	
+  # get a version		
+  version2 = document.get_version 2 => #<Document ... version_number => 2>	
+  version2.version => 2	
+  version2.title => 'new title"		
+  version2.last_version => 4
+
+    
+

data/Rakefile

@@ -12,4 +12,4 @@ Rake::TestTask.new(:test) do |t|
   t.libs << 'test'
   t.pattern = 'test/**/*_test.rb'
   t.verbose = true
-end
+end

data/acts_as_versionable.gemspec

@@ -5,11 +5,11 @@ require "acts_as_versionable/version"
 Gem::Specification.new do |s|
   s.name        = "acts_as_versionable"
   s.version     = ActsAsVersionable::VERSION
-  s.authors     = ["Carlos Segura"]
+  s.authors     = ["carlos segura"]
   s.email       = ["csegura@ideseg.com"]
   s.homepage    = ""
-  s.summary     = "Minimalist engine for versions"
-  s.description = ""
+  s.summary     = %q{Minimalist engine for versions}
+  s.description = %q{Maintain versions in same table only add two fields version_number:integer and version_id:integer}
 
   s.rubyforge_project = "acts_as_versionable"
 

data/lib/acts_as_versionable/version.rb

@@ -1,3 +1,3 @@
 module ActsAsVersionable
-  VERSION = "0.3.5"
+  VERSION = "0.5.0"
 end

data/lib/acts_as_versionable.rb

@@ -1,118 +1,112 @@
-require 'acts_as_versionable/version'
+require "acts_as_versionable/version"
 
 module ActsAsVersionable
 
   class NoSuchVersionError < Exception
   end
-  
-  extend ActiveSupport::Concern
 
-    included do 
-    end
+  extend ActiveSupport::Concern
 
-    module ClassMethods      
-    
-      def create_class(name, superclass, &block)
-        klass = Class.new superclass, &block
-        Object.const_set name, klass
-      end
-          
-      def acts_as_versionable options={}
-          options.symbolize_keys!
-
-          has_many :versions, :class_name => "#{self.name}Versions", :dependent => :destroy
-          after_save :apply_versioning
-          after_save :clear_old_versions 
-
-          attr_accessor :local_changes
-          cattr_accessor :max_versions
-          
-          self.max_versions = options[:limit].to_i  
-          
-          class << create_class("#{self.name}Versions", ActiveRecord::Base)
-            REJECT_COLUMNS = %w(id created_at updated_at versioned_as)
-            def actual_columns
-              columns.reject { |c| REJECT_COLUMNS.include?(c.name) }
-            end
-            
-            def get_version(version)
-              revision = self.find_by_versioned_as(version) 
-              raise NoSuchVersionError, "Couldn't find #{version} version" if revision.blank?
-              revision
-            end
-          end
-          
-          include InstanceMethods
-      end
-    
-    end
-    
-    module InstanceMethods
-      
-      def version
-        current_version || 0
-      end
+  included do |base|    
+  end
 
-      def revert_to(version)
-        revision = versions.get_version(version)
+  module ClassMethods
+    def acts_as_versionable(options = {})
+      cattr_accessor :max_versions
+      self.max_versions = (options[:max_versions] || 10)
 
-        move_columns revision, self
-              
-        self.current_version = version
-        self.local_changes = true
-        self.save
-      end
+      after_save :create_new_version
 
-      def new_from_version(version)
-        revision = versions.get_version(version)
-        dummy = self.class.new         
-        
-        move_columns revision, dummy
-        
-        dummy
-      end  
+      has_many :internal_versions,
+               :class_name => self.name,
+               :foreign_key => "version_id",
+               :order => "version_number desc",
+               :dependent => :destroy
+      
+      belongs_to :parent_version, :class_name => self.name, :foreign_key => "version_id" 
+      
+      scope :last_versions, where(:version_id => nil)
+      scope :get_versionable, lambda { |id, version| where(:version_id => id, :version_number => version) }
+            
+      include InstanceMethods
+    end             
+  end
 
-      private
+  module InstanceMethods  
+    def revert_to_version(number)
+      version = get_version number
+      editable = last_version_editable
+      copy_version_values version, editable
+      editable.version_number = nil
+      editable.version_id = nil
+      editable.save
+      editable
+    end
 
-      def _get_version(version)
-        revision = versions.find_by_versioned_as(version) 
-        raise NoSuchVersionError, "Couldn't find #{version} version" if revision.blank?
-        revision
-      end  
+    # return a determined version number
+    def get_version(number)
+      version = versions.where(:version_number => number).first
+      raise NoSuchVersionError if version.nil?
+      version
+    end
 
-      def apply_versioning
-        unless self.local_changes
-          version_content = {}
-          last_version = version + 1
+    # return an array with all versions
+    def versions
+      if versionable?
+        internal_versions
+      else
+        self.class.where(:version_id => self.version_id).order(:version_number).reverse_order
+      end
+    end
 
-          move_columns self, version_content
+    # check if we are in main version
+    def versionable?
+      version_id.nil?
+    end
 
-          version_content.merge!(:versioned_as => last_version)
+    # return the current version
+    def version
+      return last_version if versionable?
+      version_number
+    end  
 
-          if versions.create(version_content)
-            self.local_changes = true
-            self.update_attribute(:current_version, last_version)
-          end
-        end
+    # return the last version number
+    def last_version
+      return 0 if versions.count == 0
+      versions.first.version_number 
+    end
 
-        self.local_changes = false 
-      end
+    private
 
-      def clear_old_versions
-        return if self.max_versions == 0
-        excess_baggage = self.current_version - self.max_versions
+    # return the last version editable
+    def last_version_editable
+      parent_version.nil? ? self : parent_version        
+    end
+    
+    # callback after save
+    def create_new_version
+      if versionable?
+       
+        cloned = copy_version_values self, self.class.new
+        cloned.version_id = self.id
+        cloned.version_number = last_version + 1
+        cloned.save
+        
+        # purge max limit
+        excess_baggage = cloned.version_number - max_versions
         if excess_baggage > 0
-          versions.where("versioned_as <= ?",excess_baggage).destroy_all
-        end    
-      end  
-      
-      def move_columns from, to
-        versions.actual_columns.each do |column|
-          to[column.name] = from[column.name]  
+          versions.where("version_number <= ?", excess_baggage).delete_all
         end
-      end  
+      end
+    end
 
+    def copy_version_values(from, to)
+      columns = self.class.columns.reject { |c| c.name == "id" }
+      columns.each {|c| to[c.name] = from[c.name] }
+      to
     end
+  end
+
 end
 
-ActiveRecord::Base.class_eval { include ActsAsVersionable }
+ActiveRecord::Base.send :extend, ActsAsVersionable::ClassMethods

metadata

@@ -1,17 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_versionable
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
-- Carlos Segura
+- carlos segura
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-20 00:00:00.000000000Z
+date: 2012-01-22 00:00:00.000000000Z
 dependencies: []
-description: ''
+description: Maintain versions in same table only add two fields version_number:integer
+  and version_id:integer
 email:
 - csegura@ideseg.com
 executables: []
@@ -19,16 +20,12 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
-- CHANGELOG.rdoc
 - Gemfile
 - README.rdoc
 - Rakefile
 - acts_as_versionable.gemspec
 - lib/acts_as_versionable.rb
 - lib/acts_as_versionable/version.rb
-- lib/generators/versionable/templates/migration.rb.erb
-- lib/generators/versionable/versionable_generator.rb
-- test/acts_as_versionable_test.rb
 homepage: ''
 licenses: []
 post_install_message: 
@@ -53,5 +50,4 @@ rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Minimalist engine for versions
-test_files:
-- test/acts_as_versionable_test.rb
+test_files: []

data/CHANGELOG.rdoc

@@ -1,10 +0,0 @@
-== 0.3.5
-
-* fixed generator
-* get_version 
-
-== 0.3.4
-
-* generator only rejects id & timestamp columns
-* new_from_version returns a new record from a determined version
-

data/lib/generators/versionable/templates/migration.rb.erb

@@ -1,25 +0,0 @@
-<% 
-  versions_table = "#{@model_name}_versions".downcase
-  rejects_columns = %w(id created_at updated_at current_version)
-  columns = @model.classify.constantize.columns.reject { |c| rejects_columns.include?(c.name) }
-%>
-class <%= migration_name %> < ActiveRecord::Migration
-  def self.up
-    create_table :<%= versions_table %> do |t| 
-      <% columns.each do |column| %>
-      t.column :<%= column.name %>, :<%= column.type %>
-      <% end %>
-      t.integer :<%= model_name + '_id' %>
-      t.integer :versioned_as
-      t.timestamps
-    end
-
-    add_index :<%= versions_table %>, :versioned_as
-    add_column :<%= model_name.pluralize %>, :current_version, :integer
-  end
-
-  def self.down
-    drop_table :<%= versions_table %>
-    remove_column :<%= model_name.pluralize %>, :current_version
-  end
-end

data/lib/generators/versionable/versionable_generator.rb

@@ -1,22 +0,0 @@
-require 'rails/generators'
-require 'rails/generators/migration'
-
-class VersionableGenerator < Rails::Generators::Base  
-  include Rails::Generators::Migration
-  source_root File.expand_path('../templates', __FILE__)
-  argument :klass, :type => :string, :description => "Model to versionate"
-  
-  attr_accessor :migration_name, :model_name, :model
-  
-  def self.next_migration_number(path)
-    Time.now.utc.strftime("%Y%m%d%H%M%S")
-  end
-
-  def create_model_file  
-    @model_name = klass.downcase
-    @model = klass
-    @migration_name = "create_#{@model_name}_versions".camelize        
-    migration_template "migration.rb.erb", "db/migrate/create_#{@model_name}_versions.rb"
-  end
-
-end

data/test/acts_as_versionable_test.rb

@@ -1,135 +0,0 @@
-require 'rubygems'
-gem 'activerecord'
-require 'active_record'
-require 'test/unit'
-#require "#{File.dirname(__FILE__)}/../init"
-require File.join(File.dirname(__FILE__), '../lib', 'acts_as_versionable')
-
-ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
-
-def setup_db
-  ActiveRecord::Schema.define(:version => 1) do
-    create_table :articles do |t|
-      t.string :title
-      t.text   :body
-
-      t.integer :user_id
-      t.integer :current_version
-      t.timestamps
-    end
-
-    create_table :article_versions do |t|
-      t.string  :title
-      t.text    :body
-      t.integer :article_id
-      t.integer :versioned_as
-      t.timestamps
-    end
-  end
-end
-
-def teardown_db
-  ActiveRecord::Base.connection.tables.each do |table|
-    ActiveRecord::Base.connection.drop_table(table)
-  end
-end
-
-class Article < ActiveRecord::Base
-  acts_as_versionable
-end
-
-class VersionableTest < Test::Unit::TestCase
-  def setup
-    setup_db
-
-    (1..3).each { |c| 
-      Article.create!(:title => c.to_s, :body => c.to_s)
-    }
-  end
-
-  def teardown
-    teardown_db
-  end
-
-  def test_if_mixed_methods_present
-    article = Article.first
-    [:versions, :version, :revert_to].each do |method|
-      assert_equal true, article.respond_to?(method) 
-    end
-  end
-
-  def test_initial_versions_of_the_articles
-    Article.all.each do |a|
-      assert_equal 1, a.versions.size
-      assert_equal 1, a.version
-    end
-  end
-
-  def test_version_change_to_2
-    article = Article.first
-
-    assert_not_nil article
-    assert_equal '1', article.title
-    assert_equal 1, article.version
-
-    article.update_attributes(:title => '4', :body => '4')
-    
-    assert_equal 2, article.version
-    assert_equal 2, article.versions.size
-    assert_equal '4', article.title
-    assert_equal '4', article.body
-  end
-
-  def test_revert_to
-    article = Article.first
-    assert_not_nil article
-
-    article.update_attributes(:title => '4', :body => '4')
-    assert_equal 2, article.versions.size
-    
-    article.revert_to(1)
-    assert_equal 1, article.version
-    assert_equal '1', article.title
-    assert_equal '1', article.body
-
-    article.revert_to(2)
-    assert_equal 2, article.version
-    assert_equal '4', article.title 
-    assert_equal '4', article.body
-  
-    assert_raise ActsAsVersionable::NoSuchVersionError do
-      article.revert_to(3)
-    end
-  end
-
-  def test_new_from_version
-     article = Article.first
-     assert_not_nil article
-     
-     dummy = article.new_from_version 1
-    
-     article.revert_to(1)
-     assert_equal dummy.title, article.title 
-     assert_equal dummy.body, article.body      
-  end  
-
-  def test_get_version
-     article = Article.first
-     assert_not_nil article
-     
-     article.update_attributes(:title => '5', :body => '5')
-     assert_equal 2, article.versions.count
-     
-     first = article.versions[1]
-     one = article.versions.get_version(2)
-     
-     assert_equal first.title, one.title 
-     assert_equal first.body, one.body
-  end  
-
-  def test_dependent_destroy
-    Article.destroy_all
-    assert_equal [], ArticleVersions.all
-  end
-end
-