rails3: update acts_as_versioned to a rails3 compatible version

Rodrigo Souto
1 parent 8042c0ea
Showing 28 changed files with 513 additions and 1240 deletions Show diff stats
vendor/plugins/acts_as_versioned/.document
vendor/plugins/acts_as_versioned/.rvmrc
vendor/plugins/acts_as_versioned/CHANGELOG
vendor/plugins/acts_as_versioned/Gemfile
vendor/plugins/acts_as_versioned/Gemfile.lock
vendor/plugins/acts_as_versioned/Manifest
vendor/plugins/acts_as_versioned/README
vendor/plugins/acts_as_versioned/README.md
vendor/plugins/acts_as_versioned/Rakefile
vendor/plugins/acts_as_versioned/VERSION.yml
vendor/plugins/acts_as_versioned/acts_as_versioned.gemspec
vendor/plugins/acts_as_versioned/lib/acts_as_versioned.rb
vendor/plugins/acts_as_versioned/test/abstract_unit.rb
vendor/plugins/acts_as_versioned/test/database.yml
vendor/plugins/acts_as_versioned/test/fixtures/authors.yml
vendor/plugins/acts_as_versioned/test/fixtures/landmark.rb
vendor/plugins/acts_as_versioned/test/fixtures/landmark_versions.yml
vendor/plugins/acts_as_versioned/test/fixtures/landmarks.yml
vendor/plugins/acts_as_versioned/test/fixtures/locked_pages.yml
vendor/plugins/acts_as_versioned/test/fixtures/locked_pages_revisions.yml
@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE
@@ -0,0 +1 @@
+rvm --create use 1.9.2@acts_as_versioned
@@ -1,82 +0,0 @@
-*GIT* (version numbers are overrated)
-
-* (16 Jun 2008) Backwards Compatibility is overrated (big updates for rails 2.1)
-
-  * Use ActiveRecord 2.1's dirty attribute checking instead [Asa Calow]
-  * Remove last traces of #non_versioned_fields
-  * Remove AR::Base.find_version and AR::Base.find_versions, rely on AR association proxies and named_scope
-  * Remove #versions_count, rely on AR association counter caching.
-  * Remove #versioned_attributes, basically the same as AR::Base.versioned_columns
-
-* (5 Oct 2006) Allow customization of #versions association options [Dan Peterson]
-
-*0.5.1*
-
-* (8 Aug 2006) Versioned models now belong to the unversioned model.  @article_version.article.class => Article [Aslak Hellesoy]
-
-*0.5* # do versions even matter for plugins?
-
-* (21 Apr 2006) Added without_locking and without_revision methods.
-
-  Foo.without_revision do
-    @foo.update_attributes ...
-  end
-
-*0.4*
-
-* (28 March 2006) Rename non_versioned_fields to non_versioned_columns (old one is kept for compatibility).
-* (28 March 2006) Made explicit documentation note that string column names are required for non_versioned_columns.
-
-*0.3.1*
-
-* (7 Jan 2006) explicitly set :foreign_key option for the versioned model's belongs_to assocation for STI [Caged]
-* (7 Jan 2006) added tests to prove has_many :through joins work
-
-*0.3*
-
-* (2 Jan 2006) added ability to share a mixin with versioned class
-* (2 Jan 2006) changed the dynamic version model to MyModel::Version
-
-*0.2.4*
-
-* (27 Nov 2005) added note about possible destructive behavior of if_changed? [Michael Schuerig]
-
-*0.2.3*
-
-* (12 Nov 2005) fixed bug with old behavior of #blank? [Michael Schuerig]
-* (12 Nov 2005) updated tests to use ActiveRecord Schema
-
-*0.2.2*
-
-* (3 Nov 2005) added documentation note to #acts_as_versioned [Martin Jul]
-
-*0.2.1*
-
-* (6 Oct 2005) renamed dirty? to changed? to keep it uniform.  it was aliased to keep it backwards compatible.
-
-*0.2* 
-
-* (6 Oct 2005)  added find_versions and find_version class methods.
-
-* (6 Oct 2005)  removed transaction from create_versioned_table().  
-  this way you can specify your own transaction around a group of operations.
-
-* (30 Sep 2005) fixed bug where find_versions() would order by 'version' twice. (found by Joe Clark)
-
-* (26 Sep 2005) added :sequence_name option to acts_as_versioned to set the sequence name on the versioned model
-
-*0.1.3* (18 Sep 2005)
-
-* First RubyForge release
-
-*0.1.2*
-
-* check if module is already included when acts_as_versioned is called
-
-*0.1.1*
-
-* Adding tests and rdocs
-
-*0.1* 
-
-* Initial transfer from Rails ticket: http://dev.rubyonrails.com/ticket/1974
 \ No newline at end of file
@@ -0,0 +1,7 @@
+source 'http://rubygems.org'
+
+group :development do
+  gem 'rails',        '~> 3.1.0'
+  gem 'sqlite3'
+  gem 'echoe'
+end
@@ -0,0 +1,101 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionmailer (3.1.4)
+      actionpack (= 3.1.4)
+      mail (~> 2.3.0)
+    actionpack (3.1.4)
+      activemodel (= 3.1.4)
+      activesupport (= 3.1.4)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      i18n (~> 0.6)
+      rack (~> 1.3.6)
+      rack-cache (~> 1.1)
+      rack-mount (~> 0.8.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.0.3)
+    activemodel (3.1.4)
+      activesupport (= 3.1.4)
+      builder (~> 3.0.0)
+      i18n (~> 0.6)
+    activerecord (3.1.4)
+      activemodel (= 3.1.4)
+      activesupport (= 3.1.4)
+      arel (~> 2.2.3)
+      tzinfo (~> 0.3.29)
+    activeresource (3.1.4)
+      activemodel (= 3.1.4)
+      activesupport (= 3.1.4)
+    activesupport (3.1.4)
+      multi_json (~> 1.0)
+    allison (2.0.3)
+    arel (2.2.3)
+    builder (3.0.0)
+    echoe (4.6.3)
+      allison (>= 2.0.3)
+      gemcutter (>= 0.7.0)
+      rake (>= 0.9.2)
+      rdoc (>= 3.6.1)
+      rubyforge (>= 2.0.4)
+    erubis (2.7.0)
+    gemcutter (0.7.1)
+    hike (1.2.1)
+    i18n (0.6.0)
+    json (1.6.6)
+    json_pure (1.7.7)
+    mail (2.3.3)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.18)
+    multi_json (1.2.0)
+    polyglot (0.3.3)
+    rack (1.3.6)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-mount (0.8.3)
+      rack (>= 1.0.0)
+    rack-ssl (1.3.2)
+      rack
+    rack-test (0.6.1)
+      rack (>= 1.0)
+    rails (3.1.4)
+      actionmailer (= 3.1.4)
+      actionpack (= 3.1.4)
+      activerecord (= 3.1.4)
+      activeresource (= 3.1.4)
+      activesupport (= 3.1.4)
+      bundler (~> 1.0)
+      railties (= 3.1.4)
+    railties (3.1.4)
+      actionpack (= 3.1.4)
+      activesupport (= 3.1.4)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (~> 0.14.6)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    rubyforge (2.0.4)
+      json_pure (>= 1.1.7)
+    sprockets (2.0.3)
+      hike (~> 1.2)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    sqlite3 (1.3.5)
+    thor (0.14.6)
+    tilt (1.3.3)
+    treetop (1.4.10)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.33)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  echoe
+  rails (~> 3.1.0)
+  sqlite3
@@ -0,0 +1,11 @@
+Gemfile
+Gemfile.lock
+MIT-LICENSE
+Manifest
+README.md
+RUNNING_UNIT_TESTS
+Rakefile
+acts_as_versioned.gemspec
+acts_as_versioned_plugin.sqlite3.db
+init.rb
+lib/acts_as_versioned.rb
@@ -1,28 +0,0 @@
-= acts_as_versioned
-
-This library adds simple versioning to an ActiveRecord module.  ActiveRecord is required.
-
-== Resources
-
-Install
-
-* gem install acts_as_versioned
-
-Rubyforge project
-
-* http://rubyforge.org/projects/ar-versioned
-
-RDocs
-
-* http://ar-versioned.rubyforge.org
-
-Subversion
-
-* http://techno-weenie.net/svn/projects/acts_as_versioned
-
-Collaboa
-
-* http://collaboa.techno-weenie.net/repository/browse/acts_as_versioned
-
-Special thanks to Dreamer on ##rubyonrails for help in early testing.  His ServerSideWiki (http://serversidewiki.com) 
-was the first project to use acts_as_versioned <em>in the wild</em>.
 \ No newline at end of file
@@ -0,0 +1,120 @@
+## About ##
+=====
+
+acts_as_versioned is a gem for Rails 3.1 & 3.2 to enable easy versioning of models. As a versioned model is updated revisions are kept in a seperate table, providing a record of what changed.
+
+## Getting Started ##
+=====
+
+In your Gemfile simply include:
+
+    gem 'acts_as_versioned', :git => 'https://github.com/jwhitehorn/acts_as_versioned.git'
+    
+The next time you run `bundle install` you'll be all set to start using acts_as_versioned.  
+
+## Usage ##
+=====
+
+#### Versioning a Model ####
+By default acts_as_versioned is unobtrusive. You will need to explicitly state which models to version. To do so, add the line `acts_as_versioned` to your model, like so:
+
+    class MyModel < ActiveRecord::Base
+      acts_as_versioned
+      #...
+    end
+    
+Next we need to create a migration to setup our versioning tables:
+
+    bundle exec rails generate migration AddVersioningToMyModel
+    
+Once that is completed, edit the generated migration. acts_as_versioned patches your model to add a `create_versioned_table` and `drop_versioned_table` method. A migration for `MyModel` (assuming MyModel already existed) might look like:
+
+    class AddVersioningToMyModel < ActiveRecord::Migration
+      def self.up
+        MyModel.create_versioned_table
+      end
+
+      def self.down
+        MyModel.drop_versioned_table
+      end
+    end
+
+Execute your migration:
+    
+    bundle exec rake db:migrate
+    
+And you're finished! Without any addition work, `MyModel` is being versioned.
+
+#### Excluding attributes from versioning  ####
+
+Sometime you want to exclude an attribute of a model from being versioned. That can be accomplished with the `:except` paramter to `acts_as_versioned`:
+
+    class MyMode < ActiveRecord::Base
+      acts_as_versioned :except => :some_attr_i_dont_want_versioned
+      
+    end
+
+
+#### Revisions ####
+
+Recording a history of changes to a model is only useful if you can do something with that data. With acts_as_versioned there are several ways you can interact with a model's revisions.
+
+##### Version Number #####
+To determine what the current version number for a model is:
+
+    model.version
+
+The `version` attribute is available for both the actual model, and also any revisions of a model. Thusly, the following is valid:
+
+    model.versions.last.version
+
+##### Revisions List #####
+As alluded to above, you can get an array of revisions of a model via the `versions` attribute:
+
+    model.versions
+    
+The returned objects are of a type `MyModel::Version` where `MyModel` is the model you are working with. These objects have identical fields to `MyModel`. So, if `MyModel` had a `name` attribute, you could also say:
+
+    model.versions.last.name
+
+##### Reverting to a Revision #####
+To revert a model to an older revision, simply call `revert_to` with the version number you desire to rever to:
+
+    model.revert_to(version_number)
+
+##### Saving Without Revisions #####
+Occasionally you might need to save a model without necessary creating revisions. To do so, use the `save_without_revision` method:
+    
+    model.save_without_revision
+
+
+#### Migrations ####
+Adding a field to your model does not automatically add it to the versioning table. So, when you add new fields, be sure to add them to both:
+
+    class AddNewFieldToMyModel < ActiveRecord::Migration
+      def change
+        add_column :my_models, :new_field_, :string
+        add_column :my_model_versions, :new_field_, :string
+      end
+    end
+
+#### Version Class ####
+As has been stated, the versioned data is stored seperately from the main class. This also implies that `model.versions` returns an area of object of a class _other_ than `MyModel` (where `model` is an instance of `MyModel`, keeping with our working example). The instances returned are actually of type `MyModel::Version`. With this, comes the fact that any methods, associations, etc. defined on `MyModel` are not present on `MyModel::Version`.
+
+While this sounds obvious, it can some times be unexpected. Especially when acts_as_versioned make it so easy to grab historical records from a live record. A common scenario where this can come up is associations.
+
+Say `MyModel` belongs to `TheMan`. Also, assume that you want to find out where (in the past) a particular instance of `MyModel` was updated in regards to it's association to `TheMan`. You could write that as:  
+    
+    model.versions.keep_if { |m| m.the_man != current_man }.last
+    
+However, this will not work. This is because `MyModel::Version` does _not_ belong to `TheMan`. You could compare ids here, or you could patch `MyModel::Version` to belong to `TheMan` like:
+
+    class MyModel
+      acts_as_versioned
+      belongs_to :the_men
+      #some stuff
+      
+      class Version
+        belongs_to :the_men
+      end
+    end
 \ No newline at end of file
-require 'rubygems'
-
-require 'rake/rdoctask'
-require 'rake/packagetask'
-require 'rake/gempackagetask'
-require 'rake/testtask'
-require 'rake/contrib/rubyforgepublisher'
-
-PKG_NAME           = 'acts_as_versioned'
-PKG_VERSION        = '0.3.1'
-PKG_FILE_NAME      = "#{PKG_NAME}-#{PKG_VERSION}"
-PROD_HOST          = "technoweenie@bidwell.textdrive.com"
-RUBY_FORGE_PROJECT = 'ar-versioned'
-RUBY_FORGE_USER    = 'technoweenie'
-
-desc 'Default: run unit tests.'
-task :default => :test
-
-desc 'Test the calculations plugin.'
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = true
-end
-
-desc 'Generate documentation for the calculations plugin.'
-Rake::RDocTask.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = "#{PKG_NAME} -- Simple versioning with active record models"
-  rdoc.options << '--line-numbers --inline-source'
-  rdoc.rdoc_files.include('README', 'CHANGELOG', 'RUNNING_UNIT_TESTS')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
-spec = Gem::Specification.new do |s|
-  s.name            = PKG_NAME
-  s.version         = PKG_VERSION
-  s.platform        = Gem::Platform::RUBY
-  s.summary         = "Simple versioning with active record models"
-  s.files           = FileList["{lib,test}/**/*"].to_a + %w(README MIT-LICENSE CHANGELOG RUNNING_UNIT_TESTS)
-  s.files.delete      "acts_as_versioned_plugin.sqlite.db"
-  s.files.delete      "acts_as_versioned_plugin.sqlite3.db"
-  s.files.delete      "test/debug.log"
-  s.require_path    = 'lib'
-  s.autorequire     = 'acts_as_versioned'
-  s.has_rdoc        = true
-  s.test_files      = Dir['test/**/*_test.rb']
-  s.add_dependency    'activerecord', '>= 1.10.1'
-  s.add_dependency    'activesupport', '>= 1.1.1'
-  s.author          = "Rick Olson"
-  s.email           = "technoweenie@gmail.com"
-  s.homepage        = "http://techno-weenie.net"
-end
-
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.need_tar = true
-end
-
-desc "Publish the API documentation"
-task :pdoc => [:rdoc] do
-  Rake::RubyForgePublisher.new(RUBY_FORGE_PROJECT, RUBY_FORGE_USER).upload
-end
-
-desc 'Publish the gem and API docs'
-task :publish => [:pdoc, :rubyforge_upload]
-
-desc "Publish the release files to RubyForge."
-task :rubyforge_upload => :package do
-  files = %w(gem tgz).map { |ext| "pkg/#{PKG_FILE_NAME}.#{ext}" }
-
-  if RUBY_FORGE_PROJECT then
-    require 'net/http'
-    require 'open-uri'
-
-    project_uri = "http://rubyforge.org/projects/#{RUBY_FORGE_PROJECT}/"
-    project_data = open(project_uri) { |data| data.read }
-    group_id = project_data[/[?&]group_id=(\d+)/, 1]
-    raise "Couldn't get group id" unless group_id
-
-    # This echos password to shell which is a bit sucky
-    if ENV["RUBY_FORGE_PASSWORD"]
-      password = ENV["RUBY_FORGE_PASSWORD"]
-    else
-      print "#{RUBY_FORGE_USER}@rubyforge.org's password: "
-      password = STDIN.gets.chomp
-    end
-
-    login_response = Net::HTTP.start("rubyforge.org", 80) do |http|
-      data = [
-        "login=1",
-        "form_loginname=#{RUBY_FORGE_USER}",
-        "form_pw=#{password}"
-      ].join("&")
-      http.post("/account/login.php", data)
-    end
-
-    cookie = login_response["set-cookie"]
-    raise "Login failed" unless cookie
-    headers = { "Cookie" => cookie }
-
-    release_uri = "http://rubyforge.org/frs/admin/?group_id=#{group_id}"
-    release_data = open(release_uri, headers) { |data| data.read }
-    package_id = release_data[/[?&]package_id=(\d+)/, 1]
-    raise "Couldn't get package id" unless package_id
-
-    first_file = true
-    release_id = ""
-
-    files.each do |filename|
-      basename  = File.basename(filename)
-      file_ext  = File.extname(filename)
-      file_data = File.open(filename, "rb") { |file| file.read }
-
-      puts "Releasing #{basename}..."
-
-      release_response = Net::HTTP.start("rubyforge.org", 80) do |http|
-        release_date = Time.now.strftime("%Y-%m-%d %H:%M")
-        type_map = {
-          ".zip"    => "3000",
-          ".tgz"    => "3110",
-          ".gz"     => "3110",
-          ".gem"    => "1400"
-        }; type_map.default = "9999"
-        type = type_map[file_ext]
-        boundary = "rubyqMY6QN9bp6e4kS21H4y0zxcvoor"
-
-        query_hash = if first_file then
-          {
-            "group_id" => group_id,
-            "package_id" => package_id,
-            "release_name" => PKG_FILE_NAME,
-            "release_date" => release_date,
-            "type_id" => type,
-            "processor_id" => "8000", # Any
-            "release_notes" => "",
-            "release_changes" => "",
-            "preformatted" => "1",
-            "submit" => "1"
-          }
-        else
-          {
-            "group_id" => group_id,
-            "release_id" => release_id,
-            "package_id" => package_id,
-            "step2" => "1",
-            "type_id" => type,
-            "processor_id" => "8000", # Any
-            "submit" => "Add This File"
-          }
-        end
-
-        query = "?" + query_hash.map do |(name, value)|
-          [name, URI.encode(value)].join("=")
-        end.join("&")
-
-        data = [
-          "--" + boundary,
-          "Content-Disposition: form-data; name=\"userfile\"; filename=\"#{basename}\"",
-          "Content-Type: application/octet-stream",
-          "Content-Transfer-Encoding: binary",
-          "", file_data, ""
-          ].join("\x0D\x0A")
-
-        release_headers = headers.merge(
-          "Content-Type" => "multipart/form-data; boundary=#{boundary}"
-        )
-
-        target = first_file ? "/frs/admin/qrs.php" : "/frs/admin/editrelease.php"
-        http.post(target + query, data, release_headers)
-      end
-
-      if first_file then
-        release_id = release_response.body[/release_id=(\d+)/, 1]
-        raise("Couldn't get release id") unless release_id
-      end
-
-      first_file = false
-    end
-  end
-end
 \ No newline at end of file
+require 'rubygems'  
+require 'rake'  
+require 'echoe'  
+  
+Echoe.new('acts_as_versioned', '3.2.1') do |p|  
+  p.description     = "Active Record model versioning"  
+  p.url             = "http://github.com/jwhitehorn/acts_as_versioned"  
+  p.author          = "Jason Whitehorn"  
+  p.email           = "jason.whitehorn@gmail.com"  
+  p.dependencies = ['activerecord']  
+end  
+  
+Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each { |ext| load ext }  
 \ No newline at end of file
@@ -1,4 +0,0 @@
---- 
-:patch: 2
-:major: 0
-:minor: 5
 # -*- encoding: utf-8 -*-
  
 Gem::Specification.new do |s|
-  s.name = %q{acts_as_versioned}
-  s.version = "0.5.2"
+  s.name = "acts_as_versioned"
+  s.version = "3.2.1"
  
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["technoweenie"]
-  s.date = %q{2009-01-20}
-  s.description = %q{TODO}
-  s.email = %q{technoweenie@bidwell.textdrive.com}
-  s.files = ["VERSION.yml", "lib/acts_as_versioned.rb", "test/abstract_unit.rb", "test/database.yml", "test/fixtures", "test/fixtures/authors.yml", "test/fixtures/landmark.rb", "test/fixtures/landmark_versions.yml", "test/fixtures/landmarks.yml", "test/fixtures/locked_pages.yml", "test/fixtures/locked_pages_revisions.yml", "test/fixtures/migrations", "test/fixtures/migrations/1_add_versioned_tables.rb", "test/fixtures/page.rb", "test/fixtures/page_versions.yml", "test/fixtures/pages.yml", "test/fixtures/widget.rb", "test/migration_test.rb", "test/schema.rb", "test/versioned_test.rb"]
-  s.has_rdoc = true
-  s.homepage = %q{http://github.com/technoweenie/acts_as_versioned}
-  s.rdoc_options = ["--inline-source", "--charset=UTF-8"]
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jason Whitehorn"]
+  s.date = "2013-05-03"
+  s.description = "Active Record model versioning"
+  s.email = "jason.whitehorn@gmail.com"
+  s.extra_rdoc_files = ["README.md", "lib/acts_as_versioned.rb"]
+  s.files = ["Gemfile", "Gemfile.lock", "MIT-LICENSE", "Manifest", "README.md", "RUNNING_UNIT_TESTS", "Rakefile", "acts_as_versioned.gemspec", "acts_as_versioned_plugin.sqlite3.db", "init.rb", "lib/acts_as_versioned.rb"]
+  s.homepage = "http://github.com/jwhitehorn/acts_as_versioned"
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Acts_as_versioned", "--main", "README.md"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.1}
-  s.summary = %q{TODO}
+  s.rubyforge_project = "acts_as_versioned"
+  s.rubygems_version = "1.8.25"
+  s.summary = "Active Record model versioning"
  
   if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 2
+    s.specification_version = 3
  
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, [">= 0"])
     else
+      s.add_dependency(%q<activerecord>, [">= 0"])
     end
   else
+    s.add_dependency(%q<activerecord>, [">= 0"])
   end
 end
@@ -18,6 +18,7 @@
 # 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.
+require 'active_support/concern'
  
 module ActiveRecord #:nodoc:
   module Acts #:nodoc:
@@ -66,203 +67,206 @@ module ActiveRecord #:nodoc:
     #
     # See ActiveRecord::Acts::Versioned::ClassMethods#acts_as_versioned for configuration options
     module Versioned
+      VERSION   = "0.6.0"
       CALLBACKS = [:set_new_version, :save_version, :save_version?]
-      def self.included(base) # :nodoc:
-        base.extend ClassMethods
-      end
  
-      module ClassMethods
-        # == Configuration options
-        #
-        # * <tt>class_name</tt> - versioned model class name (default: PageVersion in the above example)
-        # * <tt>table_name</tt> - versioned model table name (default: page_versions in the above example)
-        # * <tt>foreign_key</tt> - foreign key used to relate the versioned model to the original model (default: page_id in the above example)
-        # * <tt>inheritance_column</tt> - name of the column to save the model's inheritance_column value for STI.  (default: versioned_type)
-        # * <tt>version_column</tt> - name of the column in the model that keeps the version number (default: version)
-        # * <tt>sequence_name</tt> - name of the custom sequence to be used by the versioned model.
-        # * <tt>limit</tt> - number of revisions to keep, defaults to unlimited
-        # * <tt>if</tt> - symbol of method to check before saving a new version.  If this method returns false, a new version is not saved.
-        #   For finer control, pass either a Proc or modify Model#version_condition_met?
-        #
-        #     acts_as_versioned :if => Proc.new { |auction| !auction.expired? }
-        #
-        #   or...
-        #
-        #     class Auction
-        #       def version_condition_met? # totally bypasses the <tt>:if</tt> option
-        #         !expired?
-        #       end
-        #     end
-        #
-        # * <tt>if_changed</tt> - Simple way of specifying attributes that are required to be changed before saving a model.  This takes
-        #   either a symbol or array of symbols.
-        #
-        # * <tt>extend</tt> - Lets you specify a module to be mixed in both the original and versioned models.  You can also just pass a block
-        #   to create an anonymous mixin:
-        #
-        #     class Auction
-        #       acts_as_versioned do
-        #         def started?
-        #           !started_at.nil?
-        #         end
-        #       end
-        #     end
-        #
-        #   or...
-        #
-        #     module AuctionExtension
-        #       def started?
-        #         !started_at.nil?
-        #       end
-        #     end
-        #     class Auction
-        #       acts_as_versioned :extend => AuctionExtension
-        #     end
-        #
-        #  Example code:
-        #
-        #    @auction = Auction.find(1)
-        #    @auction.started?
-        #    @auction.versions.first.started?
-        #
-        # == Database Schema
-        #
-        # The model that you're versioning needs to have a 'version' attribute. The model is versioned 
-        # into a table called #{model}_versions where the model name is singlular. The _versions table should 
-        # contain all the fields you want versioned, the same version column, and a #{model}_id foreign key field.
-        #
-        # A lock_version field is also accepted if your model uses Optimistic Locking.  If your table uses Single Table inheritance,
-        # then that field is reflected in the versioned model as 'versioned_type' by default.
-        #
-        # Acts_as_versioned comes prepared with the ActiveRecord::Acts::Versioned::ActMethods::ClassMethods#create_versioned_table 
-        # method, perfect for a migration.  It will also create the version column if the main model does not already have it.
-        #
-        #   class AddVersions < ActiveRecord::Migration
-        #     def self.up
-        #       # create_versioned_table takes the same options hash
-        #       # that create_table does
-        #       Post.create_versioned_table
-        #     end
-        # 
-        #     def self.down
-        #       Post.drop_versioned_table
-        #     end
-        #   end
-        # 
-        # == Changing What Fields Are Versioned
-        #
-        # By default, acts_as_versioned will version all but these fields: 
-        # 
-        #   [self.primary_key, inheritance_column, 'version', 'lock_version', versioned_inheritance_column]
-        #
-        # You can add or change those by modifying #non_versioned_columns.  Note that this takes strings and not symbols.
-        #
-        #   class Post < ActiveRecord::Base
-        #     acts_as_versioned
-        #     self.non_versioned_columns << 'comments_count'
-        #   end
-        # 
-        def acts_as_versioned(options = {}, &extension)
-          # don't allow multiple calls
-          return if self.included_modules.include?(ActiveRecord::Acts::Versioned::ActMethods)
-
-          send :include, ActiveRecord::Acts::Versioned::ActMethods
-
-          cattr_accessor :versioned_class_name, :versioned_foreign_key, :versioned_table_name, :versioned_inheritance_column, 
-            :version_column, :max_version_limit, :track_altered_attributes, :version_condition, :version_sequence_name, :non_versioned_columns,
-            :version_association_options, :version_if_changed
-
-          self.versioned_class_name         = options[:class_name]  || "Version"
-          self.versioned_foreign_key        = options[:foreign_key] || self.to_s.foreign_key
-          self.versioned_table_name         = options[:table_name]  || "#{table_name_prefix}#{base_class.name.demodulize.underscore}_versions#{table_name_suffix}"
-          self.versioned_inheritance_column = options[:inheritance_column] || "versioned_#{inheritance_column}"
-          self.version_column               = options[:version_column]     || 'version'
-          self.version_sequence_name        = options[:sequence_name]
-          self.max_version_limit            = options[:limit].to_i
-          self.version_condition            = options[:if] || true
-          self.non_versioned_columns        = [self.primary_key, inheritance_column, self.version_column, 'lock_version', versioned_inheritance_column] + options[:non_versioned_columns].to_a.map(&:to_s)
-          self.version_association_options  = {
-                                                :class_name  => "#{self.to_s}::#{versioned_class_name}",
-                                                :foreign_key => versioned_foreign_key,
-                                                :dependent   => :delete_all
-                                              }.merge(options[:association_options] || {})
-
-          if block_given?
-            extension_module_name = "#{versioned_class_name}Extension"
-            silence_warnings do
-              self.const_set(extension_module_name, Module.new(&extension))
-            end
-
-            options[:extend] = self.const_get(extension_module_name)
+      # == Configuration options
+      #
+      # * <tt>class_name</tt> - versioned model class name (default: PageVersion in the above example)
+      # * <tt>table_name</tt> - versioned model table name (default: page_versions in the above example)
+      # * <tt>foreign_key</tt> - foreign key used to relate the versioned model to the original model (default: page_id in the above example)
+      # * <tt>inheritance_column</tt> - name of the column to save the model's inheritance_column value for STI.  (default: versioned_type)
+      # * <tt>version_column</tt> - name of the column in the model that keeps the version number (default: version)
+      # * <tt>sequence_name</tt> - name of the custom sequence to be used by the versioned model.
+      # * <tt>limit</tt> - number of revisions to keep, defaults to unlimited
+      # * <tt>if</tt> - symbol of method to check before saving a new version.  If this method returns false, a new version is not saved.
+      #   For finer control, pass either a Proc or modify Model#version_condition_met?
+      #
+      #     acts_as_versioned :if => Proc.new { |auction| !auction.expired? }
+      #
+      #   or...
+      #
+      #     class Auction
+      #       def version_condition_met? # totally bypasses the <tt>:if</tt> option
+      #         !expired?
+      #       end
+      #     end
+      #
+      # * <tt>if_changed</tt> - Simple way of specifying attributes that are required to be changed before saving a model.  This takes
+      #   either a symbol or array of symbols.
+      #
+      # * <tt>extend</tt> - Lets you specify a module to be mixed in both the original and versioned models.  You can also just pass a block
+      #   to create an anonymous mixin:
+      #
+      #     class Auction
+      #       acts_as_versioned do
+      #         def started?
+      #           !started_at.nil?
+      #         end
+      #       end
+      #     end
+      #
+      #   or...
+      #
+      #     module AuctionExtension
+      #       def started?
+      #         !started_at.nil?
+      #       end
+      #     end
+      #     class Auction
+      #       acts_as_versioned :extend => AuctionExtension
+      #     end
+      #
+      #  Example code:
+      #
+      #    @auction = Auction.find(1)
+      #    @auction.started?
+      #    @auction.versions.first.started?
+      #
+      # == Database Schema
+      #
+      # The model that you're versioning needs to have a 'version' attribute. The model is versioned
+      # into a table called #{model}_versions where the model name is singlular. The _versions table should
+      # contain all the fields you want versioned, the same version column, and a #{model}_id foreign key field.
+      #
+      # A lock_version field is also accepted if your model uses Optimistic Locking.  If your table uses Single Table inheritance,
+      # then that field is reflected in the versioned model as 'versioned_type' by default.
+      #
+      # Acts_as_versioned comes prepared with the ActiveRecord::Acts::Versioned::ActMethods::ClassMethods#create_versioned_table
+      # method, perfect for a migration.  It will also create the version column if the main model does not already have it.
+      #
+      #   class AddVersions < ActiveRecord::Migration
+      #     def self.up
+      #       # create_versioned_table takes the same options hash
+      #       # that create_table does
+      #       Post.create_versioned_table
+      #     end
+      #
+      #     def self.down
+      #       Post.drop_versioned_table
+      #     end
+      #   end
+      #
+      # == Changing What Fields Are Versioned
+      #
+      # By default, acts_as_versioned will version all but these fields:
+      #
+      #   [self.primary_key, inheritance_column, 'version', 'lock_version', versioned_inheritance_column]
+      #
+      # You can add or change those by modifying #non_versioned_columns.  Note that this takes strings and not symbols.
+      #
+      #   class Post < ActiveRecord::Base
+      #     acts_as_versioned
+      #     self.non_versioned_columns << 'comments_count'
+      #   end
+      #
+      def acts_as_versioned(options = {}, &extension)
+        # don't allow multiple calls
+        return if self.included_modules.include?(ActiveRecord::Acts::Versioned::Behaviors)
+
+        cattr_accessor :versioned_class_name, :versioned_foreign_key, :versioned_table_name, :versioned_inheritance_column,
+                       :version_column, :max_version_limit, :track_altered_attributes, :version_condition, :version_sequence_name, :non_versioned_columns,
+                       :version_association_options, :version_if_changed, :version_except_columns
+
+        self.versioned_class_name         = options[:class_name] || "Version"
+        self.versioned_foreign_key        = options[:foreign_key] || self.to_s.foreign_key
+        self.versioned_table_name         = options[:table_name] || "#{table_name_prefix}#{base_class.name.demodulize.underscore}_versions#{table_name_suffix}"
+        self.versioned_inheritance_column = options[:inheritance_column] || "versioned_#{inheritance_column}"
+        self.version_column               = options[:version_column] || 'version'
+        self.version_sequence_name        = options[:sequence_name]
+        self.max_version_limit            = options[:limit].to_i
+        self.version_condition            = options[:if] || true
+        self.version_except_columns       = [options[:except]].flatten.map(&:to_s)  #these columns are kept in _versioned, but changing them does not excplitly cause a version change
+        self.non_versioned_columns        = [self.primary_key, inheritance_column, self.version_column, 'lock_version', versioned_inheritance_column] #these columns are excluded from _versions, and changing them does not cause a version change
+        self.version_association_options  = {
+                                                    :class_name  => "#{self.to_s}::#{versioned_class_name}",
+                                                    :foreign_key => versioned_foreign_key,
+                                                    :dependent   => :delete_all
+        }.merge(options[:association_options] || {})
+
+        if block_given?
+          extension_module_name = "#{versioned_class_name}Extension"
+          silence_warnings do
+            self.const_set(extension_module_name, Module.new(&extension))
           end
  
-          class_eval <<-CLASS_METHODS
-            has_many :versions, version_association_options do
-              # finds earliest version of this record
-              def earliest
-                @earliest ||= find(:first, :order => '#{version_column}')
-              end
+          options[:extend] = self.const_get(extension_module_name)
+        end
  
-              # find latest version of this record
-              def latest
-                @latest ||= find(:first, :order => '#{version_column} desc')
-              end
-            end
-            before_save  :set_new_version
-            after_save   :save_version
-            after_save   :clear_old_versions
-
-            unless options[:if_changed].nil?
-              self.track_altered_attributes = true
-              options[:if_changed] = [options[:if_changed]] unless options[:if_changed].is_a?(Array)
-              self.version_if_changed = options[:if_changed].map(&:to_s)
-            end
+        unless options[:if_changed].nil?
+          self.track_altered_attributes = true
+          options[:if_changed] = [options[:if_changed]] unless options[:if_changed].is_a?(Array)
+          self.version_if_changed = options[:if_changed].map(&:to_s)
+        end
  
-            include options[:extend] if options[:extend].is_a?(Module)
-          CLASS_METHODS
+        include options[:extend] if options[:extend].is_a?(Module)
  
-          # create the dynamic versioned model
-          const_set(versioned_class_name, Class.new(ActiveRecord::Base)).class_eval do
-            def self.reloadable? ; false ; end
-            # find first version before the given version
-            def self.before(version)
-              find :first, :order => 'version desc',
-                :conditions => ["#{original_class.versioned_foreign_key} = ? and version < ?", version.send(original_class.versioned_foreign_key), version.version]
-            end
+        include ActiveRecord::Acts::Versioned::Behaviors
  
-            # find first version after the given version.
-            def self.after(version)
-              find :first, :order => 'version',
-                :conditions => ["#{original_class.versioned_foreign_key} = ? and version > ?", version.send(original_class.versioned_foreign_key), version.version]
-            end
+        #
+        # Create the dynamic versioned model
+        #
+        const_set(versioned_class_name, Class.new(ActiveRecord::Base)).class_eval do
+          def self.reloadable?;
+            false;
+          end
  
-            def previous
-              self.class.before(self)
-            end
+          # find first version before the given version
+          def self.before(version)
+            where(["#{original_class.versioned_foreign_key} = ? and version < ?", version.send(original_class.versioned_foreign_key), version.version]).
+                    order('version DESC').
+                    first
+          end
  
-            def next
-              self.class.after(self)
-            end
+          # find first version after the given version.
+          def self.after(version)
+            where(["#{original_class.versioned_foreign_key} = ? and version > ?", version.send(original_class.versioned_foreign_key), version.version]).
+                    order('version ASC').
+                    first
+          end
  
-            def versions_count
-              page.version
-            end
+          # finds earliest version of this record
+          def self.earliest
+            order("#{original_class.version_column}").first
+          end
+
+          # find latest version of this record
+          def self.latest
+            order("#{original_class.version_column} desc").first
+          end
+
+          def previous
+            self.class.before(self)
+          end
+
+          def next
+            self.class.after(self)
           end
  
-          versioned_class.cattr_accessor :original_class
-          versioned_class.original_class = self
-          versioned_class.set_table_name versioned_table_name
-          versioned_class.belongs_to self.to_s.demodulize.underscore.to_sym, 
-            :class_name  => "::#{self.to_s}", 
-            :foreign_key => versioned_foreign_key
-          versioned_class.send :include, options[:extend]         if options[:extend].is_a?(Module)
-          versioned_class.set_sequence_name version_sequence_name if version_sequence_name
+          def versions_count
+            page.version
+          end
         end
+
+        versioned_class.cattr_accessor :original_class
+        versioned_class.original_class = self
+        versioned_class.table_name = versioned_table_name
+        versioned_class.belongs_to self.to_s.demodulize.underscore.to_sym,
+                                   :class_name  => "::#{self.to_s}",
+                                   :foreign_key => versioned_foreign_key
+        versioned_class.send :include, options[:extend] if options[:extend].is_a?(Module)
+        versioned_class.set_sequence_name version_sequence_name if version_sequence_name
       end
  
-      module ActMethods
-        def self.included(base) # :nodoc:
-          base.extend ClassMethods
+      module Behaviors
+        extend ActiveSupport::Concern
+
+        included do
+          has_many :versions, self.version_association_options
+
+          before_save :set_new_version
+          after_save :save_version
+          after_save :clear_old_versions
         end
  
         # Saves a version of the model in the versioned table.  This is called in the after_save callback by default
@@ -292,7 +296,7 @@ module ActiveRecord #:nodoc:
           if version.is_a?(self.class.versioned_class)
             return false unless version.send(self.class.versioned_foreign_key) == id and !version.new_record?
           else
-            return false unless version = versions.send("find_by_#{self.class.version_column}", version)
+            return false unless version = versions.where(self.class.version_column => version).first
           end
           self.clone_versioned_model(version, self)
           send("#{self.class.version_column}=", version.send(self.class.version_column))
@@ -320,23 +324,33 @@ module ActiveRecord #:nodoc:
             end
           end
         end
-        
+
         def altered?
-          track_altered_attributes ? (version_if_changed - changed).length < version_if_changed.length : changed?
+          changed.map { |c| self.class.versioned_columns.map(&:name).include?(c) & !self.class.version_except_columns.include?(c) }.any?
         end
  
         # Clones a model.  Used when saving a new version or reverting a model's version.
         def clone_versioned_model(orig_model, new_model)
           self.class.versioned_columns.each do |col|
-            new_model.send("#{col.name}=", orig_model.send(col.name)) if orig_model.has_attribute?(col.name)
+            next unless orig_model.has_attribute?(col.name)
+            define_method(new_model, col.name.to_sym)
+            new_model.send("#{col.name.to_sym}=", orig_model.send(col.name))
           end
  
           if orig_model.is_a?(self.class.versioned_class)
             new_model[new_model.class.inheritance_column] = orig_model[self.class.versioned_inheritance_column]
           elsif new_model.is_a?(self.class.versioned_class)
-            new_model[self.class.versioned_inheritance_column] = orig_model[orig_model.class.inheritance_column]
+            sym = self.class.versioned_inheritance_column.to_sym
+            define_method new_model, sym
+            new_model.send("#{sym}=", orig_model[orig_model.class.inheritance_column]) if orig_model[orig_model.class.inheritance_column]
           end
         end
+          
+        def define_method(object, method)
+          return if object.methods.include? method
+          metaclass = class << object; self; end
+          metaclass.send :attr_accessor, method
+        end
  
         # Checks whether a new version shall be saved or not.  Calls <tt>version_condition_met?</tt> and <tt>changed?</tt>.
         def save_version?
@@ -347,12 +361,12 @@ module ActiveRecord #:nodoc:
         # custom version condition checking.
         def version_condition_met?
           case
-          when version_condition.is_a?(Symbol)
-            send(version_condition)
-          when version_condition.respond_to?(:call) && (version_condition.arity == 1 || version_condition.arity == -1)
-            version_condition.call(self)
-          else
-            version_condition
+            when version_condition.is_a?(Symbol)
+              send(version_condition)
+            when version_condition.respond_to?(:call) && (version_condition.arity == 1 || version_condition.arity == -1)
+              version_condition.call(self)
+            else
+              version_condition
           end
         end
  
@@ -376,19 +390,23 @@ module ActiveRecord #:nodoc:
           self.class.without_locking(&block)
         end
  
-        def empty_callback() end #:nodoc:
+        def empty_callback()
+        end
+
+        #:nodoc:
  
         protected
-          # sets the new version before saving, unless you're using optimistic locking.  In that case, let it take care of the version.
-          def set_new_version
-            @saving_version = new_record? || save_version?
-            self.send("#{self.class.version_column}=", next_version) if new_record? || (!locking_enabled? && save_version?)
-          end
+        # sets the new version before saving, unless you're using optimistic locking.  In that case, let it take care of the version.
+        def set_new_version
+          @saving_version = new_record? || save_version?
+          self.send("#{self.class.version_column}=", next_version) if new_record? || (!locking_enabled? && save_version?)
+        end
+
+        # Gets the next available version for the current record, or 1 for a new record
+        def next_version
+          (new_record? ? 0 : versions.calculate(:maximum, version_column).to_i) + 1
+        end
  
-          # Gets the next available version for the current record, or 1 for a new record
-          def next_version
-            (new_record? ? 0 : versions.calculate(:max, version_column).to_i) + 1
-          end
  
         module ClassMethods
           # Returns an array of columns that are versioned.  See non_versioned_columns
@@ -410,28 +428,28 @@ module ActiveRecord #:nodoc:
             end
  
             return if connection.table_exists?(versioned_table_name)
-            
+
             self.connection.create_table(versioned_table_name, create_table_options) do |t|
               t.column versioned_foreign_key, :integer
               t.column version_column, :integer
             end
  
-            self.versioned_columns.each do |col| 
-              self.connection.add_column versioned_table_name, col.name, col.type, 
-                :limit     => col.limit, 
-                :default   => col.default,
-                :scale     => col.scale,
-                :precision => col.precision
+            self.versioned_columns.each do |col|
+              self.connection.add_column versioned_table_name, col.name, col.type,
+                                         :limit     => col.limit,
+                                         :default   => col.default,
+                                         :scale     => col.scale,
+                                         :precision => col.precision
             end
  
             if type_col = self.columns_hash[inheritance_column]
-              self.connection.add_column versioned_table_name, versioned_inheritance_column, type_col.type, 
-                :limit     => type_col.limit, 
-                :default   => type_col.default,
-                :scale     => type_col.scale,
-                :precision => type_col.precision
+              self.connection.add_column versioned_table_name, versioned_inheritance_column, type_col.type,
+                                         :limit     => type_col.limit,
+                                         :default   => type_col.default,
+                                         :scale     => type_col.scale,
+                                         :precision => type_col.precision
             end
-            
+
             self.connection.add_index versioned_table_name, versioned_foreign_key
           end
  
@@ -447,7 +465,7 @@ module ActiveRecord #:nodoc:
           #   end
           #
           def without_revision(&block)
-            class_eval do 
+            class_eval do
               CALLBACKS.each do |attr_name|
                 alias_method "orig_#{attr_name}".to_sym, attr_name
                 alias_method attr_name, :empty_callback
@@ -455,7 +473,7 @@ module ActiveRecord #:nodoc:
             end
             block.call
           ensure
-            class_eval do 
+            class_eval do
               CALLBACKS.each do |attr_name|
                 alias_method attr_name, "orig_#{attr_name}".to_sym
               end
@@ -483,4 +501,4 @@ module ActiveRecord #:nodoc:
   end
 end
  
-ActiveRecord::Base.send :include, ActiveRecord::Acts::Versioned
+ActiveRecord::Base.extend ActiveRecord::Acts::Versioned
@@ -1,48 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + '/../../../rails/activesupport/lib')
-$:.unshift(File.dirname(__FILE__) + '/../../../rails/activerecord/lib')
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-require 'test/unit'
-begin
-  require 'active_support'
-  require 'active_record'
-  require 'active_record/fixtures'
-rescue LoadError
-  require 'rubygems'
-  retry
-end
-
-begin
-  require 'ruby-debug'
-  Debugger.start
-rescue LoadError
-end
-
-require 'acts_as_versioned'
-
-config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
-ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
-ActiveRecord::Base.configurations = {'test' => config[ENV['DB'] || 'sqlite3']}
-ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
-
-load(File.dirname(__FILE__) + "/schema.rb")
-
-# set up custom sequence on widget_versions for DBs that support sequences
-if ENV['DB'] == 'postgresql'
-  ActiveRecord::Base.connection.execute "DROP SEQUENCE widgets_seq;" rescue nil
-  ActiveRecord::Base.connection.remove_column :widget_versions, :id
-  ActiveRecord::Base.connection.execute "CREATE SEQUENCE widgets_seq START 101;"
-  ActiveRecord::Base.connection.execute "ALTER TABLE widget_versions ADD COLUMN id INTEGER PRIMARY KEY DEFAULT nextval('widgets_seq');"
-end
-
-Test::Unit::TestCase.fixture_path = File.dirname(__FILE__) + "/fixtures/"
-$:.unshift(Test::Unit::TestCase.fixture_path)
-
-class Test::Unit::TestCase #:nodoc:
-  # Turn off transactional fixtures if you're working with MyISAM tables in MySQL
-  self.use_transactional_fixtures = true
-  
-  # Instantiated fixtures are slow, but give you @david where you otherwise would need people(:david)
-  self.use_instantiated_fixtures  = false
-
-  # Add more helper methods to be used by all tests here...
-end
 \ No newline at end of file
@@ -1,18 +0,0 @@
-sqlite:
-  :adapter: sqlite
-  :dbfile: acts_as_versioned_plugin.sqlite.db
-sqlite3:
-  :adapter: sqlite3
-  :dbfile: acts_as_versioned_plugin.sqlite3.db
-postgresql:
-  :adapter: postgresql
-  :username: postgres
-  :password: postgres
-  :database: acts_as_versioned_plugin_test
-  :min_messages: ERROR
-mysql:
-  :adapter: mysql
-  :host: localhost
-  :username: rails
-  :password:
-  :database: acts_as_versioned_plugin_test
 \ No newline at end of file
@@ -1,6 +0,0 @@
-caged:
-  id: 1
-  name: caged
-mly:
-  id: 2
-  name: mly
 \ No newline at end of file
@@ -1,3 +0,0 @@
-class Landmark < ActiveRecord::Base
-  acts_as_versioned :if_changed => [ :name, :longitude, :latitude ]
-end
@@ -1,7 +0,0 @@
-washington:
-    id: 1
-    landmark_id: 1
-    version: 1
-    name: Washington, D.C.
-    latitude: 38.895
-    longitude: -77.036667
@@ -1,7 +0,0 @@
-washington:
-    id: 1
-    name: Washington, D.C.
-    latitude: 38.895
-    longitude: -77.036667
-    doesnt_trigger_version: This is not important
-    version: 1
@@ -1,10 +0,0 @@
-welcome:
-  id: 1
-  title: Welcome to the weblog
-  lock_version: 24
-  type: LockedPage
-thinking:
-  id: 2
-  title: So I was thinking
-  lock_version: 24
-  type: SpecialLockedPage
@@ -1,27 +0,0 @@
-welcome_1:
-  id: 1
-  page_id: 1
-  title: Welcome to the weblg
-  lock_version: 23
-  version_type: LockedPage
-
-welcome_2:
-  id: 2
-  page_id: 1
-  title: Welcome to the weblog
-  lock_version: 24
-  version_type: LockedPage
-
-thinking_1:
-  id: 3
-  page_id: 2
-  title: So I was thinking!!!
-  lock_version: 23
-  version_type: SpecialLockedPage
-
-thinking_2:
-  id: 4
-  page_id: 2
-  title: So I was thinking
-  lock_version: 24
-  version_type: SpecialLockedPage
@@ -1,15 +0,0 @@
-class AddVersionedTables < ActiveRecord::Migration
-  def self.up
-    create_table("things") do |t|
-      t.column :title, :text
-      t.column :price, :decimal, :precision => 7, :scale => 2
-      t.column :type, :string
-    end
-    Thing.create_versioned_table
-  end
-  
-  def self.down
-    Thing.drop_versioned_table
-    drop_table "things" rescue nil
-  end
-end
 \ No newline at end of file
@@ -1,43 +0,0 @@
-class Page < ActiveRecord::Base
-  belongs_to :author
-  has_many   :authors,  :through => :versions, :order => 'name'
-  belongs_to :revisor,  :class_name => 'Author'
-  has_many   :revisors, :class_name => 'Author', :through => :versions, :order => 'name'
-  acts_as_versioned :if => :feeling_good? do
-    def self.included(base)
-      base.cattr_accessor :feeling_good
-      base.feeling_good = true
-      base.belongs_to :author
-      base.belongs_to :revisor, :class_name => 'Author'
-    end
-    
-    def feeling_good?
-      @@feeling_good == true
-    end
-  end
-end
-
-module LockedPageExtension
-  def hello_world
-    'hello_world'
-  end
-end
-
-class LockedPage < ActiveRecord::Base
-  acts_as_versioned \
-    :inheritance_column => :version_type, 
-    :foreign_key        => :page_id, 
-    :table_name         => :locked_pages_revisions, 
-    :class_name         => 'LockedPageRevision',
-    :version_column     => :lock_version,
-    :limit              => 2,
-    :if_changed         => :title,
-    :extend             => LockedPageExtension
-end
-
-class SpecialLockedPage < LockedPage
-end
-
-class Author < ActiveRecord::Base
-  has_many :pages
-end
 \ No newline at end of file
@@ -1,16 +0,0 @@
-welcome_2:
-  id: 1
-  page_id: 1
-  title: Welcome to the weblog
-  body: Such a lovely day
-  version: 24
-  author_id: 1
-  revisor_id: 1
-welcome_1:
-  id: 2
-  page_id: 1
-  title: Welcome to the weblg
-  body: Such a lovely day
-  version: 23
-  author_id: 2
-  revisor_id: 2
@@ -1,8 +0,0 @@
-welcome:
-  id: 1
-  title: Welcome to the weblog
-  body: Such a lovely day
-  version: 24
-  author_id: 1
-  revisor_id: 1
-  created_on: "2008-01-01 00:00:00"
 \ No newline at end of file
@@ -1,6 +0,0 @@
-class Widget < ActiveRecord::Base
-  acts_as_versioned :sequence_name => 'widgets_seq', :association_options => {
-    :dependent => :nullify, :order => 'version desc'
-  }
-  non_versioned_columns << 'foo'
-end
 \ No newline at end of file
@@ -1,46 +0,0 @@
-require File.join(File.dirname(__FILE__), 'abstract_unit')
-
-if ActiveRecord::Base.connection.supports_migrations? 
-  class Thing < ActiveRecord::Base
-    attr_accessor :version
-    acts_as_versioned
-  end
-
-  class MigrationTest < Test::Unit::TestCase
-    self.use_transactional_fixtures = false
-    def teardown
-      if ActiveRecord::Base.connection.respond_to?(:initialize_schema_information)
-        ActiveRecord::Base.connection.initialize_schema_information
-        ActiveRecord::Base.connection.update "UPDATE schema_info SET version = 0"
-      else
-        ActiveRecord::Base.connection.initialize_schema_migrations_table
-        ActiveRecord::Base.connection.assume_migrated_upto_version(0)
-      end
-      
-      Thing.connection.drop_table "things" rescue nil
-      Thing.connection.drop_table "thing_versions" rescue nil
-      Thing.reset_column_information
-    end
-        
-    def test_versioned_migration
-      assert_raises(ActiveRecord::StatementInvalid) { Thing.create :title => 'blah blah' }
-      # take 'er up
-      ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/')
-      t = Thing.create :title => 'blah blah', :price => 123.45, :type => 'Thing'
-      assert_equal 1, t.versions.size
-      
-      # check that the price column has remembered its value correctly
-      assert_equal t.price,  t.versions.first.price
-      assert_equal t.title,  t.versions.first.title
-      assert_equal t[:type], t.versions.first[:type]
-      
-      # make sure that the precision of the price column has been preserved
-      assert_equal 7, Thing::Version.columns.find{|c| c.name == "price"}.precision
-      assert_equal 2, Thing::Version.columns.find{|c| c.name == "price"}.scale
-
-      # now lets take 'er back down
-      ActiveRecord::Migrator.down(File.dirname(__FILE__) + '/fixtures/migrations/')
-      assert_raises(ActiveRecord::StatementInvalid) { Thing.create :title => 'blah blah' }
-    end
-  end
-end
@@ -1,82 +0,0 @@
-ActiveRecord::Schema.define(:version => 0) do
-  create_table :pages, :force => true do |t|
-    t.column :version, :integer
-    t.column :title, :string, :limit => 255
-    t.column :body, :text
-    t.column :created_on, :datetime
-    t.column :updated_on, :datetime
-    t.column :author_id, :integer
-    t.column :revisor_id, :integer
-  end
-
-  create_table :page_versions, :force => true do |t|
-    t.column :page_id, :integer
-    t.column :version, :integer
-    t.column :title, :string, :limit => 255
-    t.column :body, :text
-    t.column :created_on, :datetime
-    t.column :updated_on, :datetime
-    t.column :author_id, :integer
-    t.column :revisor_id, :integer
-  end
-  
-  add_index :page_versions, [:page_id, :version], :unique => true
-  
-  create_table :authors, :force => true do |t|
-    t.column :page_id, :integer
-    t.column :name, :string
-  end
-  
-  create_table :locked_pages, :force => true do |t|
-    t.column :lock_version, :integer
-    t.column :title, :string, :limit => 255
-    t.column :body, :text
-    t.column :type, :string, :limit => 255
-  end
-
-  create_table :locked_pages_revisions, :force => true do |t|
-    t.column :page_id, :integer
-    t.column :lock_version, :integer
-    t.column :title, :string, :limit => 255
-    t.column :body, :text
-    t.column :version_type, :string, :limit => 255
-    t.column :updated_at, :datetime
-  end
-  
-  add_index :locked_pages_revisions, [:page_id, :lock_version], :unique => true
-
-  create_table :widgets, :force => true do |t|
-    t.column :name, :string, :limit => 50
-    t.column :foo, :string
-    t.column :version, :integer
-    t.column :updated_at, :datetime
-  end
-
-  create_table :widget_versions, :force => true do |t|
-    t.column :widget_id, :integer
-    t.column :name, :string, :limit => 50
-    t.column :version, :integer
-    t.column :updated_at, :datetime
-  end
-  
-  add_index :widget_versions, [:widget_id, :version], :unique => true
-  
-  create_table :landmarks, :force => true do |t|
-    t.column :name, :string
-    t.column :latitude, :float
-    t.column :longitude, :float
-    t.column :doesnt_trigger_version,:string
-    t.column :version, :integer
-  end
-
-  create_table :landmark_versions, :force => true do |t|
-    t.column :landmark_id, :integer
-    t.column :name, :string
-    t.column :latitude, :float
-    t.column :longitude, :float
-    t.column :doesnt_trigger_version,:string
-    t.column :version, :integer
-  end
-  
-  add_index :landmark_versions, [:landmark_id, :version], :unique => true
-end
@@ -1,370 +0,0 @@
-require File.join(File.dirname(__FILE__), 'abstract_unit')
-require File.join(File.dirname(__FILE__), 'fixtures/page')
-require File.join(File.dirname(__FILE__), 'fixtures/widget')
-
-class VersionedTest < Test::Unit::TestCase
-  fixtures :pages, :page_versions, :locked_pages, :locked_pages_revisions, :authors, :landmarks, :landmark_versions
-  set_fixture_class :page_versions => Page::Version
-
-  def test_saves_versioned_copy
-    p = Page.create! :title => 'first title', :body => 'first body'
-    assert !p.new_record?
-    assert_equal 1, p.versions.size
-    assert_equal 1, p.version
-    assert_instance_of Page.versioned_class, p.versions.first
-  end
-
-  def test_saves_without_revision
-    p = pages(:welcome)
-    old_versions = p.versions.count
-
-    p.save_without_revision
-
-    p.without_revision do
-      p.update_attributes :title => 'changed'
-    end
-
-    assert_equal old_versions, p.versions.count
-  end
-
-  def test_rollback_with_version_number
-    p = pages(:welcome)
-    assert_equal 24, p.version
-    assert_equal 'Welcome to the weblog', p.title
-
-    assert p.revert_to!(23), "Couldn't revert to 23"
-    assert_equal 23, p.version
-    assert_equal 'Welcome to the weblg', p.title
-  end
-
-  def test_versioned_class_name
-    assert_equal 'Version', Page.versioned_class_name
-    assert_equal 'LockedPageRevision', LockedPage.versioned_class_name
-  end
-
-  def test_versioned_class
-    assert_equal Page::Version,                  Page.versioned_class
-    assert_equal LockedPage::LockedPageRevision, LockedPage.versioned_class
-  end
-
-  def test_special_methods
-    assert_nothing_raised { pages(:welcome).feeling_good? }
-    assert_nothing_raised { pages(:welcome).versions.first.feeling_good? }
-    assert_nothing_raised { locked_pages(:welcome).hello_world }
-    assert_nothing_raised { locked_pages(:welcome).versions.first.hello_world }
-  end
-
-  def test_rollback_with_version_class
-    p = pages(:welcome)
-    assert_equal 24, p.version
-    assert_equal 'Welcome to the weblog', p.title
-
-    assert p.revert_to!(p.versions.find_by_version(23)), "Couldn't revert to 23"
-    assert_equal 23, p.version
-    assert_equal 'Welcome to the weblg', p.title
-  end
-
-  def test_rollback_fails_with_invalid_revision
-    p = locked_pages(:welcome)
-    assert !p.revert_to!(locked_pages(:thinking))
-  end
-
-  def test_saves_versioned_copy_with_options
-    p = LockedPage.create! :title => 'first title'
-    assert !p.new_record?
-    assert_equal 1, p.versions.size
-    assert_instance_of LockedPage.versioned_class, p.versions.first
-  end
-
-  def test_rollback_with_version_number_with_options
-    p = locked_pages(:welcome)
-    assert_equal 'Welcome to the weblog', p.title
-    assert_equal 'LockedPage', p.versions.first.version_type
-
-    assert p.revert_to!(p.versions.first.lock_version), "Couldn't revert to 23"
-    assert_equal 'Welcome to the weblg', p.title
-    assert_equal 'LockedPage', p.versions.first.version_type
-  end
-
-  def test_rollback_with_version_class_with_options
-    p = locked_pages(:welcome)
-    assert_equal 'Welcome to the weblog', p.title
-    assert_equal 'LockedPage', p.versions.first.version_type
-
-    assert p.revert_to!(p.versions.first), "Couldn't revert to 1"
-    assert_equal 'Welcome to the weblg', p.title
-    assert_equal 'LockedPage', p.versions.first.version_type
-  end
-
-  def test_saves_versioned_copy_with_sti
-    p = SpecialLockedPage.create! :title => 'first title'
-    assert !p.new_record?
-    assert_equal 1, p.versions.size
-    assert_instance_of LockedPage.versioned_class, p.versions.first
-    assert_equal 'SpecialLockedPage', p.versions.first.version_type
-  end
-
-  def test_rollback_with_version_number_with_sti
-    p = locked_pages(:thinking)
-    assert_equal 'So I was thinking', p.title
-
-    assert p.revert_to!(p.versions.first.lock_version), "Couldn't revert to 1"
-    assert_equal 'So I was thinking!!!', p.title
-    assert_equal 'SpecialLockedPage', p.versions.first.version_type
-  end
-
-  def test_lock_version_works_with_versioning
-    p = locked_pages(:thinking)
-    p2 = LockedPage.find(p.id)
-
-    p.title = 'fresh title'
-    p.save
-    assert_equal 2, p.versions.size # limit!
-
-    assert_raises(ActiveRecord::StaleObjectError) do
-      p2.title = 'stale title'
-      p2.save
-    end
-  end
-
-  def test_version_if_condition
-    p = Page.create! :title => "title"
-    assert_equal 1, p.version
-
-    Page.feeling_good = false
-    p.save
-    assert_equal 1, p.version
-    Page.feeling_good = true
-  end
-
-  def test_version_if_condition2
-    # set new if condition
-    Page.class_eval do
-      def new_feeling_good() title[0..0] == 'a'; end
-      alias_method :old_feeling_good, :feeling_good?
-      alias_method :feeling_good?, :new_feeling_good
-    end
-
-    p = Page.create! :title => "title"
-    assert_equal 1, p.version # version does not increment
-    assert_equal 1, p.versions.count
-
-    p.update_attributes(:title => 'new title')
-    assert_equal 1, p.version # version does not increment
-    assert_equal 1, p.versions.count
-
-    p.update_attributes(:title => 'a title')
-    assert_equal 2, p.version
-    assert_equal 2, p.versions.count
-
-    # reset original if condition
-    Page.class_eval { alias_method :feeling_good?, :old_feeling_good }
-  end
-
-  def test_version_if_condition_with_block
-    # set new if condition
-    old_condition = Page.version_condition
-    Page.version_condition = Proc.new { |page| page.title[0..0] == 'b' }
-
-    p = Page.create! :title => "title"
-    assert_equal 1, p.version # version does not increment
-    assert_equal 1, p.versions.count
-
-    p.update_attributes(:title => 'a title')
-    assert_equal 1, p.version # version does not increment
-    assert_equal 1, p.versions.count
-
-    p.update_attributes(:title => 'b title')
-    assert_equal 2, p.version
-    assert_equal 2, p.versions.count
-
-    # reset original if condition
-    Page.version_condition = old_condition
-  end
-
-  def test_version_no_limit
-    p = Page.create! :title => "title", :body => 'first body'
-    p.save
-    p.save
-    5.times do |i|
-      p.title = "title#{i}"
-      p.save
-      assert_equal "title#{i}", p.title
-      assert_equal (i+2), p.version
-    end
-  end
-
-  def test_version_max_limit
-    p = LockedPage.create! :title => "title"
-    p.update_attributes(:title => "title1")
-    p.update_attributes(:title => "title2")
-    5.times do |i|
-      p.title = "title#{i}"
-      p.save
-      assert_equal "title#{i}", p.title
-      assert_equal (i+4), p.lock_version
-      assert p.versions(true).size <= 2, "locked version can only store 2 versions"
-    end
-  end
-
-  def test_track_altered_attributes_default_value
-    assert !Page.track_altered_attributes
-    assert LockedPage.track_altered_attributes
-    assert SpecialLockedPage.track_altered_attributes
-  end
-
-  def test_track_altered_attributes
-    p = LockedPage.create! :title => "title"
-    assert_equal 1, p.lock_version
-    assert_equal 1, p.versions(true).size
-
-    p.body = 'whoa'
-    assert !p.save_version?
-    p.save
-    assert_equal 2, p.lock_version # still increments version because of optimistic locking
-    assert_equal 1, p.versions(true).size
-
-    p.title = 'updated title'
-    assert p.save_version?
-    p.save
-    assert_equal 3, p.lock_version
-    assert_equal 1, p.versions(true).size # version 1 deleted
-
-    p.title = 'updated title!'
-    assert p.save_version?
-    p.save
-    assert_equal 4, p.lock_version
-    assert_equal 2, p.versions(true).size # version 1 deleted
-  end
-
-  def test_find_versions
-    assert_equal 1, locked_pages(:welcome).versions.find(:all, :conditions => ['title LIKE ?', '%weblog%']).size
-  end
-
-  def test_find_version
-    assert_equal page_versions(:welcome_1), pages(:welcome).versions.find_by_version(23)
-  end
-
-  def test_with_sequence
-    assert_equal 'widgets_seq', Widget.versioned_class.sequence_name
-    3.times { Widget.create! :name => 'new widget' }
-    assert_equal 3, Widget.count
-    assert_equal 3, Widget.versioned_class.count
-  end
-
-  def test_has_many_through
-    assert_equal [authors(:caged), authors(:mly)], pages(:welcome).authors
-  end
-
-  def test_has_many_through_with_custom_association
-    assert_equal [authors(:caged), authors(:mly)], pages(:welcome).revisors
-  end
-
-  def test_referential_integrity
-    pages(:welcome).destroy
-    assert_equal 0, Page.count
-    assert_equal 0, Page::Version.count
-  end
-
-  def test_association_options
-    association = Page.reflect_on_association(:versions)
-    options = association.options
-    assert_equal :delete_all, options[:dependent]
-
-    association = Widget.reflect_on_association(:versions)
-    options = association.options
-    assert_equal :nullify, options[:dependent]
-    assert_equal 'version desc', options[:order]
-    assert_equal 'widget_id', options[:foreign_key]
-
-    widget = Widget.create! :name => 'new widget'
-    assert_equal 1, Widget.count
-    assert_equal 1, Widget.versioned_class.count
-    widget.destroy
-    assert_equal 0, Widget.count
-    assert_equal 1, Widget.versioned_class.count
-  end
-
-  def test_versioned_records_should_belong_to_parent
-    page = pages(:welcome)
-    page_version = page.versions.last
-    assert_equal page, page_version.page
-  end
-
-  def test_unaltered_attributes
-    landmarks(:washington).attributes = landmarks(:washington).attributes.except("id")
-    assert !landmarks(:washington).changed?
-  end
-
-  def test_unchanged_string_attributes
-    landmarks(:washington).attributes = landmarks(:washington).attributes.except("id").inject({}) { |params, (key, value)| params.update(key => value.to_s) }
-    assert !landmarks(:washington).changed?
-  end
-
-  def test_should_find_earliest_version
-    assert_equal page_versions(:welcome_1), pages(:welcome).versions.earliest
-  end
-
-  def test_should_find_latest_version
-    assert_equal page_versions(:welcome_2), pages(:welcome).versions.latest
-  end
-
-  def test_should_find_previous_version
-    assert_equal page_versions(:welcome_1), page_versions(:welcome_2).previous
-    assert_equal page_versions(:welcome_1), pages(:welcome).versions.before(page_versions(:welcome_2))
-  end
-
-  def test_should_find_next_version
-    assert_equal page_versions(:welcome_2), page_versions(:welcome_1).next
-    assert_equal page_versions(:welcome_2), pages(:welcome).versions.after(page_versions(:welcome_1))
-  end
-
-  def test_should_find_version_count
-    assert_equal 2, pages(:welcome).versions.size
-  end
-
-  def test_if_changed_creates_version_if_a_listed_column_is_changed
-    landmarks(:washington).name = "Washington"
-    assert landmarks(:washington).changed?
-    assert landmarks(:washington).altered?
-  end
-
-  def test_if_changed_creates_version_if_all_listed_columns_are_changed
-    landmarks(:washington).name = "Washington"
-    landmarks(:washington).latitude = 1.0
-    landmarks(:washington).longitude = 1.0
-    assert landmarks(:washington).changed?
-    assert landmarks(:washington).altered?
-  end
-
-  def test_if_changed_does_not_create_new_version_if_unlisted_column_is_changed
-    landmarks(:washington).doesnt_trigger_version = "This should not trigger version"
-    assert landmarks(:washington).changed?
-    assert !landmarks(:washington).altered?
-  end
-
-  def test_without_locking_temporarily_disables_optimistic_locking
-    enabled1 = false
-    block_called = false
-    
-    ActiveRecord::Base.lock_optimistically = true
-    LockedPage.without_locking do
-      enabled1 = ActiveRecord::Base.lock_optimistically
-      block_called = true
-    end
-    enabled2 = ActiveRecord::Base.lock_optimistically
-    
-    assert block_called
-    assert !enabled1
-    assert enabled2
-  end
-  
-  def test_without_locking_reverts_optimistic_locking_settings_if_block_raises_exception
-    assert_raises(RuntimeError) do
-      LockedPage.without_locking do
-        raise RuntimeError, "oh noes"
-      end
-    end
-    assert ActiveRecord::Base.lock_optimistically
-  end
-end
 \ No newline at end of file
...	...	@@ -0,0 +1,5 @@
	1	+README.rdoc
	2	+lib/*/.rb
	3	+bin/*
	4	+features/*/.feature
	5	+LICENSE
...	...
...	...	@@ -0,0 +1 @@
	1	+rvm --create use 1.9.2@acts_as_versioned
...	...
...	...	@@ -1,82 +0,0 @@
1		-GIT (version numbers are overrated)
2		-
3		-* (16 Jun 2008) Backwards Compatibility is overrated (big updates for rails 2.1)
4		-
5		- * Use ActiveRecord 2.1's dirty attribute checking instead [Asa Calow]
6		- * Remove last traces of #non_versioned_fields
7		- * Remove AR::Base.find_version and AR::Base.find_versions, rely on AR association proxies and named_scope
8		- * Remove #versions_count, rely on AR association counter caching.
9		- * Remove #versioned_attributes, basically the same as AR::Base.versioned_columns
10		-
11		-* (5 Oct 2006) Allow customization of #versions association options [Dan Peterson]
12		-
13		-0.5.1
14		-
15		-* (8 Aug 2006) Versioned models now belong to the unversioned model. @article_version.article.class => Article [Aslak Hellesoy]
16		-
17		-0.5 # do versions even matter for plugins?
18		-
19		-* (21 Apr 2006) Added without_locking and without_revision methods.
20		-
21		- Foo.without_revision do
22		- @foo.update_attributes ...
23		- end
24		-
25		-0.4
26		-
27		-* (28 March 2006) Rename non_versioned_fields to non_versioned_columns (old one is kept for compatibility).
28		-* (28 March 2006) Made explicit documentation note that string column names are required for non_versioned_columns.
29		-
30		-0.3.1
31		-
32		-* (7 Jan 2006) explicitly set :foreign_key option for the versioned model's belongs_to assocation for STI [Caged]
33		-* (7 Jan 2006) added tests to prove has_many :through joins work
34		-
35		-0.3
36		-
37		-* (2 Jan 2006) added ability to share a mixin with versioned class
38		-* (2 Jan 2006) changed the dynamic version model to MyModel::Version
39		-
40		-0.2.4
41		-
42		-* (27 Nov 2005) added note about possible destructive behavior of if_changed? [Michael Schuerig]
43		-
44		-0.2.3
45		-
46		-* (12 Nov 2005) fixed bug with old behavior of #blank? [Michael Schuerig]
47		-* (12 Nov 2005) updated tests to use ActiveRecord Schema
48		-
49		-0.2.2
50		-
51		-* (3 Nov 2005) added documentation note to #acts_as_versioned [Martin Jul]
52		-
53		-0.2.1
54		-
55		-* (6 Oct 2005) renamed dirty? to changed? to keep it uniform. it was aliased to keep it backwards compatible.
56		-
57		-0.2
58		-
59		-* (6 Oct 2005) added find_versions and find_version class methods.
60		-
61		-* (6 Oct 2005) removed transaction from create_versioned_table().
62		- this way you can specify your own transaction around a group of operations.
63		-
64		-* (30 Sep 2005) fixed bug where find_versions() would order by 'version' twice. (found by Joe Clark)
65		-
66		-* (26 Sep 2005) added :sequence_name option to acts_as_versioned to set the sequence name on the versioned model
67		-
68		-0.1.3 (18 Sep 2005)
69		-
70		-* First RubyForge release
71		-
72		-0.1.2
73		-
74		-* check if module is already included when acts_as_versioned is called
75		-
76		-0.1.1
77		-
78		-* Adding tests and rdocs
79		-
80		-0.1
81		-
82		-* Initial transfer from Rails ticket: http://dev.rubyonrails.com/ticket/1974
83	0	\ No newline at end of file
...	...	@@ -0,0 +1,7 @@
	1	+source 'http://rubygems.org'
	2	+
	3	+group :development do
	4	+ gem 'rails', '~> 3.1.0'
	5	+ gem 'sqlite3'
	6	+ gem 'echoe'
	7	+end
...	...
...	...	@@ -0,0 +1,101 @@
	1	+GEM
	2	+ remote: http://rubygems.org/
	3	+ specs:
	4	+ actionmailer (3.1.4)
	5	+ actionpack (= 3.1.4)
	6	+ mail (~> 2.3.0)
	7	+ actionpack (3.1.4)
	8	+ activemodel (= 3.1.4)
	9	+ activesupport (= 3.1.4)
	10	+ builder (~> 3.0.0)
	11	+ erubis (~> 2.7.0)
	12	+ i18n (~> 0.6)
	13	+ rack (~> 1.3.6)
	14	+ rack-cache (~> 1.1)
	15	+ rack-mount (~> 0.8.2)
	16	+ rack-test (~> 0.6.1)
	17	+ sprockets (~> 2.0.3)
	18	+ activemodel (3.1.4)
	19	+ activesupport (= 3.1.4)
	20	+ builder (~> 3.0.0)
	21	+ i18n (~> 0.6)
	22	+ activerecord (3.1.4)
	23	+ activemodel (= 3.1.4)
	24	+ activesupport (= 3.1.4)
	25	+ arel (~> 2.2.3)
	26	+ tzinfo (~> 0.3.29)
	27	+ activeresource (3.1.4)
	28	+ activemodel (= 3.1.4)
	29	+ activesupport (= 3.1.4)
	30	+ activesupport (3.1.4)
	31	+ multi_json (~> 1.0)
	32	+ allison (2.0.3)
	33	+ arel (2.2.3)
	34	+ builder (3.0.0)
	35	+ echoe (4.6.3)
	36	+ allison (>= 2.0.3)
	37	+ gemcutter (>= 0.7.0)
	38	+ rake (>= 0.9.2)
	39	+ rdoc (>= 3.6.1)
	40	+ rubyforge (>= 2.0.4)
	41	+ erubis (2.7.0)
	42	+ gemcutter (0.7.1)
	43	+ hike (1.2.1)
	44	+ i18n (0.6.0)
	45	+ json (1.6.6)
	46	+ json_pure (1.7.7)
	47	+ mail (2.3.3)
	48	+ i18n (>= 0.4.0)
	49	+ mime-types (~> 1.16)
	50	+ treetop (~> 1.4.8)
	51	+ mime-types (1.18)
	52	+ multi_json (1.2.0)
	53	+ polyglot (0.3.3)
	54	+ rack (1.3.6)
	55	+ rack-cache (1.2)
	56	+ rack (>= 0.4)
	57	+ rack-mount (0.8.3)
	58	+ rack (>= 1.0.0)
	59	+ rack-ssl (1.3.2)
	60	+ rack
	61	+ rack-test (0.6.1)
	62	+ rack (>= 1.0)
	63	+ rails (3.1.4)
	64	+ actionmailer (= 3.1.4)
	65	+ actionpack (= 3.1.4)
	66	+ activerecord (= 3.1.4)
	67	+ activeresource (= 3.1.4)
	68	+ activesupport (= 3.1.4)
	69	+ bundler (~> 1.0)
	70	+ railties (= 3.1.4)
	71	+ railties (3.1.4)
	72	+ actionpack (= 3.1.4)
	73	+ activesupport (= 3.1.4)
	74	+ rack-ssl (~> 1.3.2)
	75	+ rake (>= 0.8.7)
	76	+ rdoc (~> 3.4)
	77	+ thor (~> 0.14.6)
	78	+ rake (0.9.2.2)
	79	+ rdoc (3.12)
	80	+ json (~> 1.4)
	81	+ rubyforge (2.0.4)
	82	+ json_pure (>= 1.1.7)
	83	+ sprockets (2.0.3)
	84	+ hike (~> 1.2)
	85	+ rack (~> 1.0)
	86	+ tilt (~> 1.1, != 1.3.0)
	87	+ sqlite3 (1.3.5)
	88	+ thor (0.14.6)
	89	+ tilt (1.3.3)
	90	+ treetop (1.4.10)
	91	+ polyglot
	92	+ polyglot (>= 0.3.1)
	93	+ tzinfo (0.3.33)
	94	+
	95	+PLATFORMS
	96	+ ruby
	97	+
	98	+DEPENDENCIES
	99	+ echoe
	100	+ rails (~> 3.1.0)
	101	+ sqlite3
...	...
...	...	@@ -0,0 +1,11 @@
	1	+Gemfile
	2	+Gemfile.lock
	3	+MIT-LICENSE
	4	+Manifest
	5	+README.md
	6	+RUNNING_UNIT_TESTS
	7	+Rakefile
	8	+acts_as_versioned.gemspec
	9	+acts_as_versioned_plugin.sqlite3.db
	10	+init.rb
	11	+lib/acts_as_versioned.rb
...	...
...	...	@@ -1,28 +0,0 @@
1		-= acts_as_versioned
2		-
3		-This library adds simple versioning to an ActiveRecord module. ActiveRecord is required.
4		-
5		-== Resources
6		-
7		-Install
8		-
9		-* gem install acts_as_versioned
10		-
11		-Rubyforge project
12		-
13		-* http://rubyforge.org/projects/ar-versioned
14		-
15		-RDocs
16		-
17		-* http://ar-versioned.rubyforge.org
18		-
19		-Subversion
20		-
21		-* http://techno-weenie.net/svn/projects/acts_as_versioned
22		-
23		-Collaboa
24		-
25		-* http://collaboa.techno-weenie.net/repository/browse/acts_as_versioned
26		-
27		-Special thanks to Dreamer on ##rubyonrails for help in early testing. His ServerSideWiki (http://serversidewiki.com)
28		-was the first project to use acts_as_versioned <em>in the wild</em>.
29	0	\ No newline at end of file
...	...	@@ -0,0 +1,120 @@
	1	+## About ##
	2	+=====
	3	+
	4	+acts_as_versioned is a gem for Rails 3.1 & 3.2 to enable easy versioning of models. As a versioned model is updated revisions are kept in a seperate table, providing a record of what changed.
	5	+
	6	+## Getting Started ##
	7	+=====
	8	+
	9	+In your Gemfile simply include:
	10	+
	11	+ gem 'acts_as_versioned', :git => 'https://github.com/jwhitehorn/acts_as_versioned.git'
	12	+
	13	+The next time you run `bundle install` you'll be all set to start using acts_as_versioned.
	14	+
	15	+## Usage ##
	16	+=====
	17	+
	18	+#### Versioning a Model ####
	19	+By default acts_as_versioned is unobtrusive. You will need to explicitly state which models to version. To do so, add the line `acts_as_versioned` to your model, like so:
	20	+
	21	+ class MyModel < ActiveRecord::Base
	22	+ acts_as_versioned
	23	+ #...
	24	+ end
	25	+
	26	+Next we need to create a migration to setup our versioning tables:
	27	+
	28	+ bundle exec rails generate migration AddVersioningToMyModel
	29	+
	30	+Once that is completed, edit the generated migration. acts_as_versioned patches your model to add a `create_versioned_table` and `drop_versioned_table` method. A migration for `MyModel` (assuming MyModel already existed) might look like:
	31	+
	32	+ class AddVersioningToMyModel < ActiveRecord::Migration
	33	+ def self.up
	34	+ MyModel.create_versioned_table
	35	+ end
	36	+
	37	+ def self.down
	38	+ MyModel.drop_versioned_table
	39	+ end
	40	+ end
	41	+
	42	+Execute your migration:
	43	+
	44	+ bundle exec rake db:migrate
	45	+
	46	+And you're finished! Without any addition work, `MyModel` is being versioned.
	47	+
	48	+#### Excluding attributes from versioning ####
	49	+
	50	+Sometime you want to exclude an attribute of a model from being versioned. That can be accomplished with the `:except` paramter to `acts_as_versioned`:
	51	+
	52	+ class MyMode < ActiveRecord::Base
	53	+ acts_as_versioned :except => :some_attr_i_dont_want_versioned
	54	+
	55	+ end
	56	+
	57	+
	58	+#### Revisions ####
	59	+
	60	+Recording a history of changes to a model is only useful if you can do something with that data. With acts_as_versioned there are several ways you can interact with a model's revisions.
	61	+
	62	+##### Version Number #####
	63	+To determine what the current version number for a model is:
	64	+
	65	+ model.version
	66	+
	67	+The `version` attribute is available for both the actual model, and also any revisions of a model. Thusly, the following is valid:
	68	+
	69	+ model.versions.last.version
	70	+
	71	+##### Revisions List #####
	72	+As alluded to above, you can get an array of revisions of a model via the `versions` attribute:
	73	+
	74	+ model.versions
	75	+
	76	+The returned objects are of a type `MyModel::Version` where `MyModel` is the model you are working with. These objects have identical fields to `MyModel`. So, if `MyModel` had a `name` attribute, you could also say:
	77	+
	78	+ model.versions.last.name
	79	+
	80	+##### Reverting to a Revision #####
	81	+To revert a model to an older revision, simply call `revert_to` with the version number you desire to rever to:
	82	+
	83	+ model.revert_to(version_number)
	84	+
	85	+##### Saving Without Revisions #####
	86	+Occasionally you might need to save a model without necessary creating revisions. To do so, use the `save_without_revision` method:
	87	+
	88	+ model.save_without_revision
	89	+
	90	+
	91	+#### Migrations ####
	92	+Adding a field to your model does not automatically add it to the versioning table. So, when you add new fields, be sure to add them to both:
	93	+
	94	+ class AddNewFieldToMyModel < ActiveRecord::Migration
	95	+ def change
	96	+ add_column :my_models, :new_field_, :string
	97	+ add_column :my_model_versions, :new_field_, :string
	98	+ end
	99	+ end
	100	+
	101	+#### Version Class ####
	102	+As has been stated, the versioned data is stored seperately from the main class. This also implies that `model.versions` returns an area of object of a class _other_ than `MyModel` (where `model` is an instance of `MyModel`, keeping with our working example). The instances returned are actually of type `MyModel::Version`. With this, comes the fact that any methods, associations, etc. defined on `MyModel` are not present on `MyModel::Version`.
	103	+
	104	+While this sounds obvious, it can some times be unexpected. Especially when acts_as_versioned make it so easy to grab historical records from a live record. A common scenario where this can come up is associations.
	105	+
	106	+Say `MyModel` belongs to `TheMan`. Also, assume that you want to find out where (in the past) a particular instance of `MyModel` was updated in regards to it's association to `TheMan`. You could write that as:
	107	+
	108	+ model.versions.keep_if { \|m\| m.the_man != current_man }.last
	109	+
	110	+However, this will not work. This is because `MyModel::Version` does _not_ belong to `TheMan`. You could compare ids here, or you could patch `MyModel::Version` to belong to `TheMan` like:
	111	+
	112	+ class MyModel
	113	+ acts_as_versioned
	114	+ belongs_to :the_men
	115	+ #some stuff
	116	+
	117	+ class Version
	118	+ belongs_to :the_men
	119	+ end
	120	+ end
0	121	\ No newline at end of file
...	...
1		-require 'rubygems'
2		-
3		-require 'rake/rdoctask'
4		-require 'rake/packagetask'
5		-require 'rake/gempackagetask'
6		-require 'rake/testtask'
7		-require 'rake/contrib/rubyforgepublisher'
8		-
9		-PKG_NAME = 'acts_as_versioned'
10		-PKG_VERSION = '0.3.1'
11		-PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
12		-PROD_HOST = "technoweenie@bidwell.textdrive.com"
13		-RUBY_FORGE_PROJECT = 'ar-versioned'
14		-RUBY_FORGE_USER = 'technoweenie'
15		-
16		-desc 'Default: run unit tests.'
17		-task :default => :test
18		-
19		-desc 'Test the calculations plugin.'
20		-Rake::TestTask.new(:test) do \|t\|
21		- t.libs << 'lib'
22		- t.pattern = 'test/*/_test.rb'
23		- t.verbose = true
24		-end
25		-
26		-desc 'Generate documentation for the calculations plugin.'
27		-Rake::RDocTask.new(:rdoc) do \|rdoc\|
28		- rdoc.rdoc_dir = 'rdoc'
29		- rdoc.title = "#{PKG_NAME} -- Simple versioning with active record models"
30		- rdoc.options << '--line-numbers --inline-source'
31		- rdoc.rdoc_files.include('README', 'CHANGELOG', 'RUNNING_UNIT_TESTS')
32		- rdoc.rdoc_files.include('lib/*/.rb')
33		-end
34		-
35		-spec = Gem::Specification.new do \|s\|
36		- s.name = PKG_NAME
37		- s.version = PKG_VERSION
38		- s.platform = Gem::Platform::RUBY
39		- s.summary = "Simple versioning with active record models"
40		- s.files = FileList["{lib,test}/*/"].to_a + %w(README MIT-LICENSE CHANGELOG RUNNING_UNIT_TESTS)
41		- s.files.delete "acts_as_versioned_plugin.sqlite.db"
42		- s.files.delete "acts_as_versioned_plugin.sqlite3.db"
43		- s.files.delete "test/debug.log"
44		- s.require_path = 'lib'
45		- s.autorequire = 'acts_as_versioned'
46		- s.has_rdoc = true
47		- s.test_files = Dir['test/*/_test.rb']
48		- s.add_dependency 'activerecord', '>= 1.10.1'
49		- s.add_dependency 'activesupport', '>= 1.1.1'
50		- s.author = "Rick Olson"
51		- s.email = "technoweenie@gmail.com"
52		- s.homepage = "http://techno-weenie.net"
53		-end
54		-
55		-Rake::GemPackageTask.new(spec) do \|pkg\|
56		- pkg.need_tar = true
57		-end
58		-
59		-desc "Publish the API documentation"
60		-task :pdoc => [:rdoc] do
61		- Rake::RubyForgePublisher.new(RUBY_FORGE_PROJECT, RUBY_FORGE_USER).upload
62		-end
63		-
64		-desc 'Publish the gem and API docs'
65		-task :publish => [:pdoc, :rubyforge_upload]
66		-
67		-desc "Publish the release files to RubyForge."
68		-task :rubyforge_upload => :package do
69		- files = %w(gem tgz).map { \|ext\| "pkg/#{PKG_FILE_NAME}.#{ext}" }
70		-
71		- if RUBY_FORGE_PROJECT then
72		- require 'net/http'
73		- require 'open-uri'
74		-
75		- project_uri = "http://rubyforge.org/projects/#{RUBY_FORGE_PROJECT}/"
76		- project_data = open(project_uri) { \|data\| data.read }
77		- group_id = project_data[/[?&]group_id=(\d+)/, 1]
78		- raise "Couldn't get group id" unless group_id
79		-
80		- # This echos password to shell which is a bit sucky
81		- if ENV["RUBY_FORGE_PASSWORD"]
82		- password = ENV["RUBY_FORGE_PASSWORD"]
83		- else
84		- print "#{RUBY_FORGE_USER}@rubyforge.org's password: "
85		- password = STDIN.gets.chomp
86		- end
87		-
88		- login_response = Net::HTTP.start("rubyforge.org", 80) do \|http\|
89		- data = [
90		- "login=1",
91		- "form_loginname=#{RUBY_FORGE_USER}",
92		- "form_pw=#{password}"
93		- ].join("&")
94		- http.post("/account/login.php", data)
95		- end
96		-
97		- cookie = login_response["set-cookie"]
98		- raise "Login failed" unless cookie
99		- headers = { "Cookie" => cookie }
100		-
101		- release_uri = "http://rubyforge.org/frs/admin/?group_id=#{group_id}"
102		- release_data = open(release_uri, headers) { \|data\| data.read }
103		- package_id = release_data[/[?&]package_id=(\d+)/, 1]
104		- raise "Couldn't get package id" unless package_id
105		-
106		- first_file = true
107		- release_id = ""
108		-
109		- files.each do \|filename\|
110		- basename = File.basename(filename)
111		- file_ext = File.extname(filename)
112		- file_data = File.open(filename, "rb") { \|file\| file.read }
113		-
114		- puts "Releasing #{basename}..."
115		-
116		- release_response = Net::HTTP.start("rubyforge.org", 80) do \|http\|
117		- release_date = Time.now.strftime("%Y-%m-%d %H:%M")
118		- type_map = {
119		- ".zip" => "3000",
120		- ".tgz" => "3110",
121		- ".gz" => "3110",
122		- ".gem" => "1400"
123		- }; type_map.default = "9999"
124		- type = type_map[file_ext]
125		- boundary = "rubyqMY6QN9bp6e4kS21H4y0zxcvoor"
126		-
127		- query_hash = if first_file then
128		- {
129		- "group_id" => group_id,
130		- "package_id" => package_id,
131		- "release_name" => PKG_FILE_NAME,
132		- "release_date" => release_date,
133		- "type_id" => type,
134		- "processor_id" => "8000", # Any
135		- "release_notes" => "",
136		- "release_changes" => "",
137		- "preformatted" => "1",
138		- "submit" => "1"
139		- }
140		- else
141		- {
142		- "group_id" => group_id,
143		- "release_id" => release_id,
144		- "package_id" => package_id,
145		- "step2" => "1",
146		- "type_id" => type,
147		- "processor_id" => "8000", # Any
148		- "submit" => "Add This File"
149		- }
150		- end
151		-
152		- query = "?" + query_hash.map do \|(name, value)\|
153		- [name, URI.encode(value)].join("=")
154		- end.join("&")
155		-
156		- data = [
157		- "--" + boundary,
158		- "Content-Disposition: form-data; name=\"userfile\"; filename=\"#{basename}\"",
159		- "Content-Type: application/octet-stream",
160		- "Content-Transfer-Encoding: binary",
161		- "", file_data, ""
162		- ].join("\x0D\x0A")
163		-
164		- release_headers = headers.merge(
165		- "Content-Type" => "multipart/form-data; boundary=#{boundary}"
166		- )
167		-
168		- target = first_file ? "/frs/admin/qrs.php" : "/frs/admin/editrelease.php"
169		- http.post(target + query, data, release_headers)
170		- end
171		-
172		- if first_file then
173		- release_id = release_response.body[/release_id=(\d+)/, 1]
174		- raise("Couldn't get release id") unless release_id
175		- end
176		-
177		- first_file = false
178		- end
179		- end
180		-end
181	1	\ No newline at end of file
	2	+require 'rubygems'
	3	+require 'rake'
	4	+require 'echoe'
	5	+
	6	+Echoe.new('acts_as_versioned', '3.2.1') do \|p\|
	7	+ p.description = "Active Record model versioning"
	8	+ p.url = "http://github.com/jwhitehorn/acts_as_versioned"
	9	+ p.author = "Jason Whitehorn"
	10	+ p.email = "jason.whitehorn@gmail.com"
	11	+ p.dependencies = ['activerecord']
	12	+end
	13	+
	14	+Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each { \|ext\| load ext }
182	15	\ No newline at end of file
...	...
1	1	# -- encoding: utf-8 --
2	2
3	3	Gem::Specification.new do \|s\|
4		- s.name = %q{acts_as_versioned}
5		- s.version = "0.5.2"
	4	+ s.name = "acts_as_versioned"
	5	+ s.version = "3.2.1"
6	6
7		- s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
8		- s.authors = ["technoweenie"]
9		- s.date = %q{2009-01-20}
10		- s.description = %q{TODO}
11		- s.email = %q{technoweenie@bidwell.textdrive.com}
12		- s.files = ["VERSION.yml", "lib/acts_as_versioned.rb", "test/abstract_unit.rb", "test/database.yml", "test/fixtures", "test/fixtures/authors.yml", "test/fixtures/landmark.rb", "test/fixtures/landmark_versions.yml", "test/fixtures/landmarks.yml", "test/fixtures/locked_pages.yml", "test/fixtures/locked_pages_revisions.yml", "test/fixtures/migrations", "test/fixtures/migrations/1_add_versioned_tables.rb", "test/fixtures/page.rb", "test/fixtures/page_versions.yml", "test/fixtures/pages.yml", "test/fixtures/widget.rb", "test/migration_test.rb", "test/schema.rb", "test/versioned_test.rb"]
13		- s.has_rdoc = true
14		- s.homepage = %q{http://github.com/technoweenie/acts_as_versioned}
15		- s.rdoc_options = ["--inline-source", "--charset=UTF-8"]
	7	+ s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
	8	+ s.authors = ["Jason Whitehorn"]
	9	+ s.date = "2013-05-03"
	10	+ s.description = "Active Record model versioning"
	11	+ s.email = "jason.whitehorn@gmail.com"
	12	+ s.extra_rdoc_files = ["README.md", "lib/acts_as_versioned.rb"]
	13	+ s.files = ["Gemfile", "Gemfile.lock", "MIT-LICENSE", "Manifest", "README.md", "RUNNING_UNIT_TESTS", "Rakefile", "acts_as_versioned.gemspec", "acts_as_versioned_plugin.sqlite3.db", "init.rb", "lib/acts_as_versioned.rb"]
	14	+ s.homepage = "http://github.com/jwhitehorn/acts_as_versioned"
	15	+ s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Acts_as_versioned", "--main", "README.md"]
16	16	s.require_paths = ["lib"]
17		- s.rubygems_version = %q{1.3.1}
18		- s.summary = %q{TODO}
	17	+ s.rubyforge_project = "acts_as_versioned"
	18	+ s.rubygems_version = "1.8.25"
	19	+ s.summary = "Active Record model versioning"
19	20
20	21	if s.respond_to? :specification_version then
21		- current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
22		- s.specification_version = 2
	22	+ s.specification_version = 3
23	23
24		- if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
	24	+ if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
	25	+ s.add_runtime_dependency(%q<activerecord>, [">= 0"])
25	26	else
	27	+ s.add_dependency(%q<activerecord>, [">= 0"])
26	28	end
27	29	else
	30	+ s.add_dependency(%q<activerecord>, [">= 0"])
28	31	end
29	32	end
...	...