Merge branch 'question-editing'

Luke Baker
2 parents a511fe4b 602762b9
Showing 29 changed files with 1638 additions and 2 deletions Show diff stats
app/models/question.rb
db/migrate/20110524171217_add_version_to_question.rb
db/schema.rb
spec/models/question_spec.rb
vendor/plugins/acts_as_versioned/CHANGELOG
vendor/plugins/acts_as_versioned/MIT-LICENSE
vendor/plugins/acts_as_versioned/README
vendor/plugins/acts_as_versioned/RUNNING_UNIT_TESTS
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/init.rb
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
 class Question < ActiveRecord::Base
+  acts_as_versioned
+  
   require 'set'
   include Utility
   extend ActiveSupport::Memoizable
-  
+
   belongs_to :creator, :class_name => "Visitor", :foreign_key => "creator_id"
   belongs_to :site, :class_name => "User", :foreign_key => "site_id"
@@ -0,0 +1,20 @@
+class AddVersionToQuestion < ActiveRecord::Migration
+  def self.up
+    # set default to one because we're going to create
+    # versions for all the existing data.
+    add_column :questions, :version, :integer, :default => 1
+    Question.create_versioned_table
+    Question.find(:all).each do |q|
+      attributes = q.attributes
+      attributes[q.versioned_foreign_key] = attributes.delete("id")
+      Question::Version.create(attributes)
+    end
+    # make version nil by default after we've created initial versions
+    change_column :questions, :version, :integer, :default => nil
+  end
+
+  def self.down
+    remove_column :questions, :version
+    Question.drop_versioned_table
+  end
+end
@@ -9,7 +9,7 @@
 #
 # It's strongly recommended to check this file into your version control system.
-ActiveRecord::Schema.define(:version => 20110131154228) do
+ActiveRecord::Schema.define(:version => 20110524171217) do
   create_table "appearances", :force => true do |t|
     t.integer  "voter_id"
@@ -142,6 +142,29 @@ ActiveRecord::Schema.define(:version =&gt; 20110131154228) do
   add_index "prompts", ["question_id"], :name => "index_prompts_on_question_id"
   add_index "prompts", ["right_choice_id"], :name => "index_prompts_on_right_choice_id"
+  create_table "question_versions", :force => true do |t|
+    t.integer  "question_id"
+    t.integer  "version"
+    t.integer  "creator_id"
+    t.string   "name",                         :default => ""
+    t.datetime "created_at"
+    t.datetime "updated_at"
+    t.integer  "choices_count",                :default => 0
+    t.integer  "prompts_count",                :default => 0
+    t.boolean  "active",                       :default => false
+    t.text     "tracking"
+    t.text     "information"
+    t.integer  "site_id"
+    t.string   "local_identifier"
+    t.integer  "votes_count",                  :default => 0
+    t.boolean  "it_should_autoactivate_ideas", :default => false
+    t.integer  "inactive_choices_count",       :default => 0
+    t.boolean  "uses_catchup",                 :default => true
+    t.boolean  "show_results",                 :default => true
+  end
+
+  add_index "question_versions", ["question_id"], :name => "index_question_versions_on_question_id"
+
   create_table "questions", :force => true do |t|
     t.integer  "creator_id"
     t.string   "name",                         :default => ""
@@ -159,6 +182,7 @@ ActiveRecord::Schema.define(:version =&gt; 20110131154228) do
     t.integer  "inactive_choices_count",       :default => 0
     t.boolean  "uses_catchup",                 :default => true
     t.boolean  "show_results",                 :default => true
+    t.integer  "version"
   end
   create_table "skips", :force => true do |t|
@@ -31,6 +31,13 @@ describe Question do
     aoiquestion.median_votes_per_session.should == 2
   end
+  it "should create a new revision if modified" do
+    oldVer = @question.version
+    @question.name = "some new name"
+    @question.save
+    @question.version.should == oldVer + 1
+  end
+
   it "should create a new instance given valid attributes" do
     # Factory.attributes_for does not return associations, this is a good enough substitute
     Question.create!(Factory.build(:question).attributes.symbolize_keys)
@@ -0,0 +1,82 @@
+*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,20 @@
+Copyright (c) 2005 Rick Olson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 \ No newline at end of file
@@ -0,0 +1,28 @@
+= 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,41 @@
+== Creating the test database
+
+The default name for the test databases is "activerecord_versioned". If you 
+want to use another database name then be sure to update the connection 
+adapter setups you want to test with in test/connections/<your database>/connection.rb. 
+When you have the database online, you can import the fixture tables with 
+the test/fixtures/db_definitions/*.sql files.
+
+Make sure that you create database objects with the same user that you specified in i
+connection.rb otherwise (on Postgres, at least) tests for default values will fail.
+
+== Running with Rake
+
+The easiest way to run the unit tests is through Rake. The default task runs
+the entire test suite for all the adapters. You can also run the suite on just
+one adapter by using the tasks test_mysql_ruby, test_ruby_mysql, test_sqlite, 
+or test_postresql. For more information, checkout the full array of rake tasks with "rake -T"
+
+Rake can be found at http://rake.rubyforge.org
+
+== Running by hand
+
+Unit tests are located in test directory. If you only want to run a single test suite, 
+or don't want to bother with Rake, you can do so with something like:
+
+   cd test; ruby -I "connections/native_mysql" base_test.rb
+   
+That'll run the base suite using the MySQL-Ruby adapter. Change the adapter
+and test suite name as needed.
+
+== Faster tests
+
+If you are using a database that supports transactions, you can set the
+"AR_TX_FIXTURES" environment variable to "yes" to use transactional fixtures.
+This gives a very large speed boost. With rake:
+
+  rake AR_TX_FIXTURES=yes
+
+Or, by hand:
+
+  AR_TX_FIXTURES=yes ruby -I connections/native_sqlite3 base_test.rb
@@ -0,0 +1,180 @@
+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
@@ -0,0 +1,4 @@
+--- 
+:patch: 2
+:major: 0
+:minor: 5
@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{acts_as_versioned}
+  s.version = "0.5.2"
+
+  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.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{TODO}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
@@ -0,0 +1 @@
+require 'acts_as_versioned'
 \ No newline at end of file
@@ -0,0 +1,486 @@
+# Copyright (c) 2005 Rick Olson
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module ActiveRecord #:nodoc:
+  module Acts #:nodoc:
+    # Specify this act if you want to save a copy of the row in a versioned table.  This assumes there is a 
+    # versioned table ready and that your model has a version field.  This works with optimistic locking if the lock_version
+    # column is present as well.
+    #
+    # The class for the versioned model is derived the first time it is seen. Therefore, if you change your database schema you have to restart
+    # your container for the changes to be reflected. In development mode this usually means restarting WEBrick.
+    #
+    #   class Page < ActiveRecord::Base
+    #     # assumes pages_versions table
+    #     acts_as_versioned
+    #   end
+    #
+    # Example:
+    #
+    #   page = Page.create(:title => 'hello world!')
+    #   page.version       # => 1
+    #
+    #   page.title = 'hello world'
+    #   page.save
+    #   page.version       # => 2
+    #   page.versions.size # => 2
+    #
+    #   page.revert_to(1)  # using version number
+    #   page.title         # => 'hello world!'
+    #
+    #   page.revert_to(page.versions.last) # using versioned instance
+    #   page.title         # => 'hello world'
+    #
+    #   page.versions.earliest # efficient query to find the first version
+    #   page.versions.latest   # efficient query to find the most recently created version
+    #
+    #
+    # Simple Queries to page between versions
+    #
+    #   page.versions.before(version) 
+    #   page.versions.after(version)
+    #
+    # Access the previous/next versions from the versioned model itself
+    #
+    #   version = page.versions.latest
+    #   version.previous # go back one version
+    #   version.next     # go forward one version
+    #
+    # See ActiveRecord::Acts::Versioned::ClassMethods#acts_as_versioned for configuration options
+    module Versioned
+      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)
+          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
+
+              # 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
+
+            include options[:extend] if options[:extend].is_a?(Module)
+          CLASS_METHODS
+
+          # 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
+
+            # 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
+
+            def previous
+              self.class.before(self)
+            end
+
+            def next
+              self.class.after(self)
+            end
+
+            def versions_count
+              page.version
+            end
+          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
+        end
+      end
+
+      module ActMethods
+        def self.included(base) # :nodoc:
+          base.extend ClassMethods
+        end
+
+        # Saves a version of the model in the versioned table.  This is called in the after_save callback by default
+        def save_version
+          if @saving_version
+            @saving_version = nil
+            rev = self.class.versioned_class.new
+            clone_versioned_model(self, rev)
+            rev.send("#{self.class.version_column}=", send(self.class.version_column))
+            rev.send("#{self.class.versioned_foreign_key}=", id)
+            rev.save
+          end
+        end
+
+        # Clears old revisions if a limit is set with the :limit option in <tt>acts_as_versioned</tt>.
+        # Override this method to set your own criteria for clearing old versions.
+        def clear_old_versions
+          return if self.class.max_version_limit == 0
+          excess_baggage = send(self.class.version_column).to_i - self.class.max_version_limit
+          if excess_baggage > 0
+            self.class.versioned_class.delete_all ["#{self.class.version_column} <= ? and #{self.class.versioned_foreign_key} = ?", excess_baggage, id]
+          end
+        end
+
+        # Reverts a model to a given version.  Takes either a version number or an instance of the versioned model
+        def revert_to(version)
+          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)
+          end
+          self.clone_versioned_model(version, self)
+          send("#{self.class.version_column}=", version.send(self.class.version_column))
+          true
+        end
+
+        # Reverts a model to a given version and saves the model.
+        # Takes either a version number or an instance of the versioned model
+        def revert_to!(version)
+          revert_to(version) ? save_without_revision : false
+        end
+
+        # Temporarily turns off Optimistic Locking while saving.  Used when reverting so that a new version is not created.
+        def save_without_revision
+          save_without_revision!
+          true
+        rescue
+          false
+        end
+
+        def save_without_revision!
+          without_locking do
+            without_revision do
+              save!
+            end
+          end
+        end
+        
+        def altered?
+          track_altered_attributes ? (version_if_changed - changed).length < version_if_changed.length : changed?
+        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)
+          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]
+          end
+        end
+
+        # Checks whether a new version shall be saved or not.  Calls <tt>version_condition_met?</tt> and <tt>changed?</tt>.
+        def save_version?
+          version_condition_met? && altered?
+        end
+
+        # Checks condition set in the :if option to check whether a revision should be created or not.  Override this for
+        # 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
+          end
+        end
+
+        # Executes the block with the versioning callbacks disabled.
+        #
+        #   @foo.without_revision do
+        #     @foo.save
+        #   end
+        #
+        def without_revision(&block)
+          self.class.without_revision(&block)
+        end
+
+        # Turns off optimistic locking for the duration of the block
+        #
+        #   @foo.without_locking do
+        #     @foo.save
+        #   end
+        #
+        def without_locking(&block)
+          self.class.without_locking(&block)
+        end
+
+        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
+
+          # 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
+          def versioned_columns
+            @versioned_columns ||= columns.select { |c| !non_versioned_columns.include?(c.name) }
+          end
+
+          # Returns an instance of the dynamic versioned model
+          def versioned_class
+            const_get versioned_class_name
+          end
+
+          # Rake migration task to create the versioned table using options passed to acts_as_versioned
+          def create_versioned_table(create_table_options = {})
+            # create version column in main table if it does not exist
+            if !self.content_columns.find { |c| [version_column.to_s, 'lock_version'].include? c.name }
+              self.connection.add_column table_name, version_column, :integer
+              self.reset_column_information
+            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
+            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
+            end
+            
+            self.connection.add_index versioned_table_name, versioned_foreign_key
+          end
+
+          # Rake migration task to drop the versioned table
+          def drop_versioned_table
+            self.connection.drop_table versioned_table_name
+          end
+
+          # Executes the block with the versioning callbacks disabled.
+          #
+          #   Foo.without_revision do
+          #     @foo.save
+          #   end
+          #
+          def without_revision(&block)
+            class_eval do 
+              CALLBACKS.each do |attr_name|
+                alias_method "orig_#{attr_name}".to_sym, attr_name
+                alias_method attr_name, :empty_callback
+              end
+            end
+            block.call
+          ensure
+            class_eval do 
+              CALLBACKS.each do |attr_name|
+                alias_method attr_name, "orig_#{attr_name}".to_sym
+              end
+            end
+          end
+
+          # Turns off optimistic locking for the duration of the block
+          #
+          #   Foo.without_locking do
+          #     @foo.save
+          #   end
+          #
+          def without_locking(&block)
+            current = ActiveRecord::Base.lock_optimistically
+            ActiveRecord::Base.lock_optimistically = false if current
+            begin
+              block.call
+            ensure
+              ActiveRecord::Base.lock_optimistically = true if current
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, ActiveRecord::Acts::Versioned
@@ -0,0 +1,48 @@
+$:.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
@@ -0,0 +1,18 @@
+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
@@ -0,0 +1,6 @@
+caged:
+  id: 1
+  name: caged
+mly:
+  id: 2
+  name: mly
 \ No newline at end of file
@@ -0,0 +1,3 @@
+class Landmark < ActiveRecord::Base
+  acts_as_versioned :if_changed => [ :name, :longitude, :latitude ]
+end
@@ -0,0 +1,7 @@
+washington:
+    id: 1
+    landmark_id: 1
+    version: 1
+    name: Washington, D.C.
+    latitude: 38.895
+    longitude: -77.036667
@@ -0,0 +1,7 @@
+washington:
+    id: 1
+    name: Washington, D.C.
+    latitude: 38.895
+    longitude: -77.036667
+    doesnt_trigger_version: This is not important
+    version: 1
@@ -0,0 +1,10 @@
+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
@@ -0,0 +1,27 @@
+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
@@ -0,0 +1,15 @@
+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
@@ -0,0 +1,43 @@
+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
@@ -0,0 +1,16 @@
+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
@@ -0,0 +1,8 @@
+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
@@ -0,0 +1,6 @@
+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
@@ -0,0 +1,46 @@
+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
@@ -0,0 +1,82 @@
+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
@@ -0,0 +1,370 @@
+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,20 @@		@@ -0,0 +1,20 @@
	1	+class AddVersionToQuestion < ActiveRecord::Migration
	2	+ def self.up
	3	+ # set default to one because we're going to create
	4	+ # versions for all the existing data.
	5	+ add_column :questions, :version, :integer, :default => 1
	6	+ Question.create_versioned_table
	7	+ Question.find(:all).each do \|q\|
	8	+ attributes = q.attributes
	9	+ attributes[q.versioned_foreign_key] = attributes.delete("id")
	10	+ Question::Version.create(attributes)
	11	+ end
	12	+ # make version nil by default after we've created initial versions
	13	+ change_column :questions, :version, :integer, :default => nil
	14	+ end
	15	+
	16	+ def self.down
	17	+ remove_column :questions, :version
	18	+ Question.drop_versioned_table
	19	+ end
	20	+end
	@@ -9,7 +9,7 @@		@@ -9,7 +9,7 @@
9	#	9	#
10	# It's strongly recommended to check this file into your version control system.	10	# It's strongly recommended to check this file into your version control system.
11		11
12	-ActiveRecord::Schema.define(:version => 20110131154228) do	12	+ActiveRecord::Schema.define(:version => 20110524171217) do
13		13
14	create_table "appearances", :force => true do \|t\|	14	create_table "appearances", :force => true do \|t\|
15	t.integer "voter_id"	15	t.integer "voter_id"
	@@ -142,6 +142,29 @@ ActiveRecord::Schema.define(:version => 20110131154228) do		@@ -142,6 +142,29 @@ ActiveRecord::Schema.define(:version => 20110131154228) do
142	add_index "prompts", ["question_id"], :name => "index_prompts_on_question_id"	142	add_index "prompts", ["question_id"], :name => "index_prompts_on_question_id"
143	add_index "prompts", ["right_choice_id"], :name => "index_prompts_on_right_choice_id"	143	add_index "prompts", ["right_choice_id"], :name => "index_prompts_on_right_choice_id"
144		144
		145	+ create_table "question_versions", :force => true do \|t\|
		146	+ t.integer "question_id"
		147	+ t.integer "version"
		148	+ t.integer "creator_id"
		149	+ t.string "name", :default => ""
		150	+ t.datetime "created_at"
		151	+ t.datetime "updated_at"
		152	+ t.integer "choices_count", :default => 0
		153	+ t.integer "prompts_count", :default => 0
		154	+ t.boolean "active", :default => false
		155	+ t.text "tracking"
		156	+ t.text "information"
		157	+ t.integer "site_id"
		158	+ t.string "local_identifier"
		159	+ t.integer "votes_count", :default => 0
		160	+ t.boolean "it_should_autoactivate_ideas", :default => false
		161	+ t.integer "inactive_choices_count", :default => 0
		162	+ t.boolean "uses_catchup", :default => true
		163	+ t.boolean "show_results", :default => true
		164	+ end
		165	+
		166	+ add_index "question_versions", ["question_id"], :name => "index_question_versions_on_question_id"
		167	+
145	create_table "questions", :force => true do \|t\|	168	create_table "questions", :force => true do \|t\|
146	t.integer "creator_id"	169	t.integer "creator_id"
147	t.string "name", :default => ""	170	t.string "name", :default => ""
	@@ -159,6 +182,7 @@ ActiveRecord::Schema.define(:version => 20110131154228) do		@@ -159,6 +182,7 @@ ActiveRecord::Schema.define(:version => 20110131154228) do
159	t.integer "inactive_choices_count", :default => 0	182	t.integer "inactive_choices_count", :default => 0
160	t.boolean "uses_catchup", :default => true	183	t.boolean "uses_catchup", :default => true
161	t.boolean "show_results", :default => true	184	t.boolean "show_results", :default => true
		185	+ t.integer "version"
162	end	186	end
163		187
164	create_table "skips", :force => true do \|t\|	188	create_table "skips", :force => true do \|t\|
	@@ -31,6 +31,13 @@ describe Question do		@@ -31,6 +31,13 @@ describe Question do
31	aoiquestion.median_votes_per_session.should == 2	31	aoiquestion.median_votes_per_session.should == 2
32	end	32	end
33		33
		34	+ it "should create a new revision if modified" do
		35	+ oldVer = @question.version
		36	+ @question.name = "some new name"
		37	+ @question.save
		38	+ @question.version.should == oldVer + 1
		39	+ end
		40	+
34	it "should create a new instance given valid attributes" do	41	it "should create a new instance given valid attributes" do
35	# Factory.attributes_for does not return associations, this is a good enough substitute	42	# Factory.attributes_for does not return associations, this is a good enough substitute
36	Question.create!(Factory.build(:question).attributes.symbolize_keys)	43	Question.create!(Factory.build(:question).attributes.symbolize_keys)
	@@ -0,0 +1,82 @@		@@ -0,0 +1,82 @@
		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
0	\ No newline at end of file	83	\ No newline at end of file
	@@ -0,0 +1,20 @@		@@ -0,0 +1,20 @@
		1	+Copyright (c) 2005 Rick Olson
		2	+
		3	+Permission is hereby granted, free of charge, to any person obtaining
		4	+a copy of this software and associated documentation files (the
		5	+"Software"), to deal in the Software without restriction, including
		6	+without limitation the rights to use, copy, modify, merge, publish,
		7	+distribute, sublicense, and/or sell copies of the Software, and to
		8	+permit persons to whom the Software is furnished to do so, subject to
		9	+the following conditions:
		10	+
		11	+The above copyright notice and this permission notice shall be
		12	+included in all copies or substantial portions of the Software.
		13	+
		14	+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
		15	+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
		16	+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
		17	+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
		18	+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
		19	+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
		20	+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
0	\ No newline at end of file	21	\ No newline at end of file
	@@ -0,0 +1,28 @@		@@ -0,0 +1,28 @@
		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>.
0	\ No newline at end of file	29	\ No newline at end of file
@@ -0,0 +1,41 @@		@@ -0,0 +1,41 @@
	1	+== Creating the test database
	2	+
	3	+The default name for the test databases is "activerecord_versioned". If you
	4	+want to use another database name then be sure to update the connection
	5	+adapter setups you want to test with in test/connections/<your database>/connection.rb.
	6	+When you have the database online, you can import the fixture tables with
	7	+the test/fixtures/db_definitions/*.sql files.
	8	+
	9	+Make sure that you create database objects with the same user that you specified in i
	10	+connection.rb otherwise (on Postgres, at least) tests for default values will fail.
	11	+
	12	+== Running with Rake
	13	+
	14	+The easiest way to run the unit tests is through Rake. The default task runs
	15	+the entire test suite for all the adapters. You can also run the suite on just
	16	+one adapter by using the tasks test_mysql_ruby, test_ruby_mysql, test_sqlite,
	17	+or test_postresql. For more information, checkout the full array of rake tasks with "rake -T"
	18	+
	19	+Rake can be found at http://rake.rubyforge.org
	20	+
	21	+== Running by hand
	22	+
	23	+Unit tests are located in test directory. If you only want to run a single test suite,
	24	+or don't want to bother with Rake, you can do so with something like:
	25	+
	26	+ cd test; ruby -I "connections/native_mysql" base_test.rb
	27	+
	28	+That'll run the base suite using the MySQL-Ruby adapter. Change the adapter
	29	+and test suite name as needed.
	30	+
	31	+== Faster tests
	32	+
	33	+If you are using a database that supports transactions, you can set the
	34	+"AR_TX_FIXTURES" environment variable to "yes" to use transactional fixtures.
	35	+This gives a very large speed boost. With rake:
	36	+
	37	+ rake AR_TX_FIXTURES=yes
	38	+
	39	+Or, by hand:
	40	+
	41	+ AR_TX_FIXTURES=yes ruby -I connections/native_sqlite3 base_test.rb
	@@ -0,0 +1,180 @@		@@ -0,0 +1,180 @@
		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
0	\ No newline at end of file	181	\ No newline at end of file
@@ -0,0 +1,4 @@		@@ -0,0 +1,4 @@
	1	+---
	2	+:patch: 2
	3	+:major: 0
	4	+:minor: 5
@@ -0,0 +1,29 @@		@@ -0,0 +1,29 @@
	1	+# -- encoding: utf-8 --
	2	+
	3	+Gem::Specification.new do \|s\|
	4	+ s.name = %q{acts_as_versioned}
	5	+ s.version = "0.5.2"
	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"]
	16	+ s.require_paths = ["lib"]
	17	+ s.rubygems_version = %q{1.3.1}
	18	+ s.summary = %q{TODO}
	19	+
	20	+ if s.respond_to? :specification_version then
	21	+ current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
	22	+ s.specification_version = 2
	23	+
	24	+ if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
	25	+ else
	26	+ end
	27	+ else
	28	+ end
	29	+end