brianjlandau-acts_as_archive 0.2.6

data/MIT-LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2009 Winton Welsh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the "Software"), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 
+the Software, and to permit persons to whom the Software is furnished to do so, 
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,119 @@
+ActsAsArchive
+=============
+
+Don't delete your records, move them to a different table.
+
+Like <code>acts\_as\_paranoid</code>, but doesn't mess with your SQL queries.
+
+Install
+-------
+
+<pre>
+sudo gem install acts_as_archive
+</pre>
+
+**environment.rb**:
+
+<pre>
+config.gem 'acts_as_archive'
+</pre>
+
+Update models
+-------------
+
+Add <code>acts\_as\_archive</code> to your models:
+
+<pre>
+class Article < ActiveRecord::Base
+  acts_as_archive
+end
+</pre>
+
+<a name="create_archive_tables"></a>
+
+Create archive tables
+---------------------
+
+Add this line to a migration:
+
+<pre>
+ActsAsArchive.update Article, Comment
+</pre>
+
+Replace <code>Article, Comment</code> with your own models that use <code>acts_as_archive</code>.
+
+Archive tables mirror your table's structure, but with an additional <code>deleted_at</code> column.
+
+There is an [alternate way to create archive tables](http://wiki.github.com/winton/acts_as_archive/alternatives-to-migrations) if you don't like migrations.
+
+That's it!
+----------
+
+Use <code>destroy</code>, <code>delete</code>, and <code>delete_all</code> like you normally would.
+
+Records move into the archive table instead of being destroyed.
+
+What if my schema changes?
+--------------------------
+
+New migrations are automatically applied to the archive table.
+
+No action is necessary on your part.
+
+Query the archive
+-----------------
+
+Add <code>::Archive</code> to your ActiveRecord class:
+
+<pre>
+Article::Archive.find(:first)
+</pre>
+
+Restore from the archive
+------------------------
+
+Use <code>restore\_all</code> to copy archived records back to your table:
+
+<pre>
+Article.restore_all([ 'id = ?', 1 ])
+</pre>
+
+Auto-migrate from acts\_as\_paranoid
+------------------------------------
+
+If you previously used <code>acts\_as\_paranoid</code>, the <code>ActsAsArchive.update</code>
+call will automatically move your deleted records to the archive table
+(see <a href="#create_archive_tables">_Create archive tables_</a>).
+
+Original <code>deleted_at</code> values are preserved.
+
+Add indexes to the archive table
+--------------------------------
+
+To keep insertions fast, there are no indexes on your archive table by default.
+
+If you are querying your archive a lot, you will want to add indexes:
+
+<pre>
+class Article < ActiveRecord::Base
+  acts_as_archive :indexes => [ :id, :created_at, :deleted_at ]
+end
+</pre>
+
+Call <code>ActsAsArchive.update</code> upon adding new indexes
+(see <a href="#create_archive_tables">_Create archive tables_</a>).
+
+Delete records without archiving
+--------------------------------
+
+To destroy a record without archiving:
+
+<pre>
+article.destroy!
+</pre>
+
+To delete multiple records without archiving:
+
+<pre>
+Article.delete_all!(["id in (?)", [1,2,3]])
+</pre>

data/Rakefile

@@ -0,0 +1,9 @@
+require "#{File.dirname(__FILE__)}/require"
+Require.rakefile!
+
+desc "Generate gemspec"
+task :gemspec do
+  File.open("#{Rake.original_dir}/acts_as_archive.gemspec", 'w') do |f|
+    f.write(Require.gemspec.to_ruby)
+  end
+end

data/bin/acts_as_archive

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+puts `script/runner "ActsAsArchive.update #{ARGV.join ', '}"`

data/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + "/rails/init"

data/lib/acts_as_archive.rb

@@ -0,0 +1,19 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../require")
+Require.lib!
+
+module ActsAsArchive
+  
+  def self.update(*models)
+    models.each do |klass|
+      if klass.respond_to?(:acts_as_archive?) && klass.acts_as_archive?
+        time = Benchmark.measure do
+          klass.create_archive_table
+          klass.migrate_from_acts_as_paranoid
+          klass.create_archive_indexes
+        end
+        $stdout.puts "-- ActsAsArchive.update(#{models.join(', ')})"
+        $stdout.puts "   -> #{"%.4fs" % time.real}"
+      end
+    end
+  end
+end

data/lib/acts_as_archive/base.rb

@@ -0,0 +1,42 @@
+module ActsAsArchive
+  
+  module Base
+    def self.included(base)
+      base.extend ActMethods
+    end
+  
+    module ActMethods
+      def acts_as_archive(options={})
+        class_eval <<-end_eval
+          
+          def self.acts_as_archive?
+            self.to_s == #{self.to_s.inspect}
+          end
+          
+          def self.archive_indexes
+            #{Array(options[:indexes]).collect(&:to_s).inspect}
+          end
+          
+          if self.descends_from_active_record?
+            class Archive < ActiveRecord::Base
+              self.record_timestamps = false
+              self.table_name = "archived_#{self.table_name}"
+            end
+          else
+            class Archive < self.superclass::Archive
+              self.record_timestamps = false
+              self.table_name = "archived_#{self.table_name}"
+              
+              def self.sti_name
+                "#{self.sti_name}"
+              end
+            end
+          end
+        end_eval
+        include Destroy
+        include Restore
+        include Table
+      end
+    end
+  end
+end

data/lib/acts_as_archive/base/adapters/mysql.rb

@@ -0,0 +1,17 @@
+module ActsAsArchive
+  module Base
+    module Adapters
+      module MySQL
+        
+        private
+
+        def archive_table_indexed_columns
+          index_query = "SHOW INDEX FROM archived_#{table_name}"
+          indexes = connection.select_all(index_query).collect do |r|
+            r["Column_name"]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_archive/base/adapters/postgresql.rb

@@ -0,0 +1,40 @@
+module ActsAsArchive
+  module Base
+    module Adapters
+      module PostgreSQL
+
+        private
+
+        def archive_table_indexed_columns
+          # This query comes courtesy of cope360:
+          # http://stackoverflow.com/questions/2204058/show-which-columns-an-index-is-on-in-postgresql/2213199#2213199
+          index_query = <<-SQL
+select
+    t.relname as table_name,
+    i.relname as index_name,
+    a.attname as column_name
+from
+    pg_class t,
+    pg_class i,
+    pg_index ix,
+    pg_attribute a
+where
+    t.oid = ix.indrelid
+    and i.oid = ix.indexrelid
+    and a.attrelid = t.oid
+    and a.attnum = ANY(ix.indkey)
+    and t.relkind = 'r'
+    and t.relname = 'archived_#{table_name}'
+order by
+    t.relname,
+    i.relname
+SQL
+
+          indexes = connection.select_all(index_query).collect do |r|
+            r["column_name"]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_archive/base/destroy.rb

@@ -0,0 +1,71 @@
+module ActsAsArchive
+  module Base
+    module Destroy
+
+      def self.included(base)
+        unless base.included_modules.include?(InstanceMethods)
+          base.class_eval do
+            alias_method :destroy_without_callbacks!, :destroy_without_callbacks
+            class <<self
+              alias_method :delete_all!, :delete_all
+            end
+          end
+          base.send :extend, ClassMethods
+          base.send :include, InstanceMethods
+        end
+      end
+
+      module ClassMethods
+        def copy_to_archive(conditions, import=false)
+          add_conditions!(where = '', conditions)
+          insert_cols = column_names.clone
+          select_cols = column_names.clone
+          if insert_cols.include?('deleted_at')
+            unless import
+              select_cols[select_cols.index('deleted_at')] = "'#{Time.now.utc.to_s(:db)}'"
+            end
+          else
+            insert_cols << 'deleted_at'
+            select_cols << "'#{Time.now.utc.to_s(:db)}'"
+          end
+
+          insert_cols.map! { |col| connection.quote_column_name(col) }
+          select_cols.map! { |col| col =~ /^\'/ ? col : connection.quote_column_name(col) }
+
+          connection.execute(%{
+            INSERT INTO archived_#{table_name} (#{insert_cols.join(', ')})
+              SELECT #{select_cols.join(', ')}
+              FROM #{table_name}
+              #{where}
+          })
+          connection.execute("DELETE FROM #{table_name} #{where}")
+        end
+      
+        def delete_all(conditions=nil)
+          copy_to_archive(conditions)
+        end
+      end
+
+      module InstanceMethods
+        def destroy_without_callbacks
+          unless new_record?
+            self.class.copy_to_archive("#{self.class.primary_key} = #{id}")
+          end
+          @destroyed = true
+          freeze
+        end
+
+        def destroy!
+          transaction { destroy_with_callbacks! }
+        end
+
+        def destroy_with_callbacks!
+          return false if callback(:before_destroy) == false
+          result = destroy_without_callbacks!
+          callback(:after_destroy)
+          result
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_archive/base/restore.rb

@@ -0,0 +1,36 @@
+module ActsAsArchive
+  module Base
+    module Restore
+
+      def self.included(base)
+        unless base.included_modules.include?(InstanceMethods)
+          base.send :extend, ClassMethods
+          base.send :include, InstanceMethods
+        end
+      end
+
+      module ClassMethods
+        
+        def copy_from_archive(conditions)
+          add_conditions!(where = '', conditions)
+          col_names = column_names - [ 'deleted_at' ]
+          col_names.map! { |col| connection.quote_column_name(col) }
+          connection.execute(%{
+            INSERT INTO #{table_name} (#{col_names.join(', ')})
+              SELECT #{col_names.join(', ')}
+              FROM archived_#{table_name}
+              #{where}
+          })
+          connection.execute("DELETE FROM archived_#{table_name} #{where}")
+        end
+        
+        def restore_all(conditions=nil)
+          copy_from_archive(conditions)
+        end
+      end
+
+      module InstanceMethods
+      end
+    end
+  end
+end

data/lib/acts_as_archive/base/table.rb

@@ -0,0 +1,109 @@
+module ActsAsArchive
+  module Base
+    module Table
+
+      def self.included(base)
+        unless base.included_modules.include?(InstanceMethods)
+          base.send :extend, ClassMethods
+          base.send :include, InstanceMethods
+
+          if base.connection.class.to_s.include?('Mysql')
+            base.send :extend, ActsAsArchive::Base::Adapters::MySQL
+          elsif base.connection.class.to_s.include?('PostgreSQL')
+            base.send :extend, ActsAsArchive::Base::Adapters::PostgreSQL
+          else
+            raise 'acts_as_archive does not support this database adapter'
+          end
+        end
+      end
+
+      module ClassMethods
+
+        def archive_table_exists?
+          connection.table_exists?("archived_#{table_name}")
+        end
+
+        def create_archive_table
+          if table_exists? && !archive_table_exists?
+            connection.execute(%{
+              CREATE TABLE archived_#{table_name}
+                #{"ENGINE=InnoDB" if connection.class.to_s.include?('Mysql')}
+                AS SELECT * from #{table_name}
+                WHERE false;
+            })
+            columns = connection.columns("archived_#{table_name}").collect(&:name)
+            unless columns.include?('deleted_at')
+              connection.add_column("archived_#{table_name}", :deleted_at, :datetime)
+            end
+          end
+        end
+
+        def create_archive_indexes
+          if archive_table_exists?
+            indexes = archive_table_indexed_columns
+
+            (archive_indexes - indexes).each do |index|
+              connection.add_index("archived_#{table_name}", index)
+            end
+            (indexes - archive_indexes).each do |index|
+              connection.remove_index("archived_#{table_name}", index)
+            end
+          end
+        end
+
+
+        def migrate_from_acts_as_paranoid
+          if column_names.include?('deleted_at')
+            if table_exists? && archive_table_exists?
+              condition = "deleted_at IS NOT NULL"
+              if self.count_by_sql("SELECT COUNT(*) FROM #{table_name} WHERE #{condition}") > 0
+                # Base::Destroy.copy_to_archive
+                copy_to_archive(condition, true)
+              end
+            end
+          end
+        end
+
+        private
+
+        def archive_table_indexed_columns
+          case connection.class.to_s
+          when "ActiveRecord::ConnectionAdapters::MysqlAdapter"
+            index_query = "SHOW INDEX FROM archived_#{table_name}"
+            indexes = connection.select_all(index_query).collect do |r|
+              r["Column_name"]
+            end
+          when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
+            #postgresql is...slightly...more complicated
+            index_query = <<EOS
+SELECT c2.relname as index_name
+FROM pg_catalog.pg_class c,
+     pg_catalog.pg_class c2,
+     pg_catalog.pg_index i
+WHERE c.oid = (SELECT c.oid
+               FROM pg_catalog.pg_class c
+               WHERE c.relname ~ '^(archived_#{table_name})$')
+AND c.oid = i.indrelid
+AND i.indexrelid = c2.oid
+EOS
+            indexes = connection.select_all(index_query).collect do |r|
+              r["index_name"]
+            end
+
+            # HACK: reverse engineer the column name
+            # This sucks, but acts_as_archive only adds indexes on single columns anyway so it should work OK
+            # and getting the columns indexed is INCREDIBLY complicated in PostgreSQL.
+            indexes.map do |index|
+              index.split("_on_").last
+            end
+          else
+            raise "Unsupported Database"
+          end
+        end
+      end
+
+      module InstanceMethods
+      end
+    end
+  end
+end

data/lib/acts_as_archive/migration.rb

@@ -0,0 +1,49 @@
+module ActsAsArchive
+  module Migration
+    
+    def self.included(base)
+      unless base.included_modules.include?(InstanceMethods)
+        base.send :extend, ClassMethods
+        base.class_eval do
+          class <<self
+            unless method_defined?(:method_missing_without_archive)
+              alias_method :method_missing_without_archive, :method_missing
+              alias_method :method_missing, :method_missing_with_archive
+            end
+          end
+        end
+      end
+    end
+    
+    module ClassMethods
+      
+      def method_missing_with_archive(method, *arguments, &block)
+        args = Marshal.load(Marshal.dump(arguments))
+        method_missing_without_archive(method, *arguments, &block)
+        supported = [
+          :add_column, :add_timestamps, :change_column,
+          :change_column_default, :change_table,
+          :drop_table, :remove_column, :remove_columns,
+          :remove_timestamps, :rename_column, :rename_table
+        ]
+        if args.include?(:deleted_at) || args.include?('deleted_at')
+          # Don't change the archive's deleted_at column
+          return
+        end
+        if !args.empty? && supported.include?(method)
+          connection = ActiveRecord::Base.connection
+          args[0] = "archived_" + ActiveRecord::Migrator.proper_table_name(args[0])
+          if method == :rename_table
+            args[1] = "archived_" + args[1].to_s
+          end
+          if connection.table_exists?(args[0])
+            connection.send(method, *args, &block)
+          end
+        end
+      end
+    end
+    
+    module InstanceMethods
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1,5 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../require")
+Require.rails_init!
+
+ActiveRecord::Base.send(:include, ActsAsArchive::Base)
+ActiveRecord::Migration.send(:include, ActsAsArchive::Migration)

data/require.rb

@@ -0,0 +1,49 @@
+require 'rubygems'
+gem 'require'
+require 'require'
+
+Require do
+  gem(:activerecord) { require 'active_record' }
+  gem :require, '=0.2.7'
+  gem(:rake, '=0.8.7') { require 'rake' }
+  gem :rspec, '=1.3.0'
+  
+  gemspec do
+    author 'Winton Welsh'
+    dependencies do
+      gem :require
+    end
+    email 'mail@wintoni.us'
+    name 'brianjlandau-acts_as_archive'
+    homepage "http://github.com/winton/#{name}"
+    summary "Don't delete your records, move them to a different table"
+    version '0.2.6'
+  end
+  
+  lib do
+    require "lib/acts_as_archive/base"
+    require "lib/acts_as_archive/base/adapters/mysql"
+    require "lib/acts_as_archive/base/adapters/postgresql"
+    require "lib/acts_as_archive/base/destroy"
+    require "lib/acts_as_archive/base/restore"
+    require "lib/acts_as_archive/base/table"
+    require "lib/acts_as_archive/migration"
+  end
+  
+  rails_init { require 'lib/acts_as_archive' }
+  
+  rakefile do
+    gem(:rake) { require 'rake/gempackagetask' }
+    gem(:rspec) { require 'spec/rake/spectask' }
+    require 'require/tasks'
+  end
+  
+  spec_helper do
+    require 'require/spec_helper'
+    gem :activerecord
+    require 'logger'
+    require 'yaml'
+    require 'pp'
+    require 'rails/init'
+  end
+end

data/spec/acts_as_archive/base/destroy_spec.rb

@@ -0,0 +1,117 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe ActsAsArchive::Base::Destroy do
+  
+  before(:all) do
+    establish_test_db
+    Article.create_archive_table
+  end
+  
+  describe 'delete_all!' do
+    
+    before(:all) do
+      create_records
+    end
+    
+    it "should really delete all records" do
+      Article.delete_all!
+      Article.count.should == 0
+      Article::Archive.count.should == 0
+    end
+    
+  end
+
+  describe 'destroy!' do
+
+    before(:all) do
+      create_records
+      @article = Article.first
+    end
+
+    it "should really destroy a records" do
+      @article.destroy!
+      Article::Archive.count.should == 0
+    end
+
+  end
+  
+  describe 'delete_all' do
+    
+    before(:all) do
+      @articles = create_records
+    end
+    
+    describe 'with conditions' do
+      
+      before(:all) do
+        # Mini delete_all parameter test
+        Article.delete_all [ 'id = ?', @articles[0].id ]
+        Article.delete_all "id = #{@articles[1].id}"
+      end
+      
+      it "should move some records to the archive table" do
+        Article.count.should == 3
+        Article::Archive.count.should == 2
+      end
+      
+      it "should preserve record attributes" do
+        2.times do |x|
+          original = @articles[x]
+          copy = Article::Archive.find(original.id)
+          article_match?(original, copy)
+        end
+      end
+    end
+    
+    describe 'without conditions' do
+      
+      before(:all) do
+        Article.delete_all
+      end
+      
+      it "should move all records to the archive table" do
+        Article.count.should == 0
+        Article::Archive.count.should == 5
+      end
+      
+      it "should preserve record attributes" do
+        5.times do |x|
+          original = @articles[x]
+          copy = Article::Archive.find(original.id)
+          article_match?(original, copy)
+        end
+      end
+    end
+  end
+  
+  [ :destroy, :delete ].each do |d|
+    
+    describe d do
+    
+      before(:all) do
+        @articles = create_records
+        Article.find(@articles[0..1].collect(&:id)).each do |a|
+          a.send(d)
+        end
+      end
+    
+      it "should move some records to the archive table" do
+        Article.count.should == 3
+        Article::Archive.count.should == 2
+      end
+    
+      it "should preserve record attributes" do
+        2.times do |x|
+          original = @articles[x]
+          copy = Article::Archive.find(original.id)
+          article_match?(original, copy)
+        end
+      end
+      
+      it "should mark the object as destroyed" do
+        @articles[3].send(d)
+        @articles[3].destroyed?.should == true
+      end
+    end
+  end
+end

data/spec/acts_as_archive/base/restore_spec.rb

@@ -0,0 +1,58 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe ActsAsArchive::Base::Restore do
+  
+  before(:all) do
+    establish_test_db
+    Article.create_archive_table
+  end
+  
+  describe 'restore_all' do
+    
+    before(:all) do
+      @articles = create_records(Article::Archive)
+    end
+    
+    describe 'with conditions' do
+      
+      before(:all) do
+        # Mini restore parameter test
+        Article.restore_all [ 'id = ?', @articles[0].id ]
+        Article.restore_all "id = #{@articles[1].id}"
+      end
+      
+      it "should move some records to the article table" do
+        Article::Archive.count.should == 3
+        Article.count.should == 2
+      end
+      
+      it "should preserve record attributes" do
+        2.times do |x|
+          original = @articles[x]
+          copy = Article.find(original.id)
+          article_match?(original, copy)
+        end
+      end
+    end
+    
+    describe 'without conditions' do
+      
+      before(:all) do
+        Article.restore_all
+      end
+      
+      it "should move all records to the archive table" do
+        Article::Archive.count.should == 0
+        Article.count.should == 5
+      end
+      
+      it "should preserve record attributes" do
+        5.times do |x|
+          original = @articles[x]
+          copy = Article.find(original.id)
+          article_match?(original, copy)
+        end
+      end
+    end
+  end
+end

data/spec/acts_as_archive/base/table_spec.rb

@@ -0,0 +1,74 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe ActsAsArchive::Base::Table do
+
+  before(:all) do
+    establish_test_db
+    Article.create_archive_table
+  end
+
+  describe 'create_archive_table' do
+
+    before(:all) do
+      @article_columns = connection.columns("articles").collect(&:name)
+      @archive_columns = connection.columns("archived_articles").collect(&:name)
+    end
+
+    it "should create an archive table" do
+      connection.table_exists?("archived_articles").should == true
+    end
+
+    it "should create an archive table with the same structure as the original table" do
+      @article_columns.each do |col|
+        @archive_columns.include?(col).should == true
+      end
+    end
+
+    it "should add a deleted_at column to the archive table" do
+      (@archive_columns - @article_columns).should == [ 'deleted_at' ]
+    end
+  end
+
+  describe 'create_archive_indexes' do
+
+    before(:all) do
+      Article.create_archive_indexes
+    end
+
+    it "should create archive indexes" do
+      indexes.to_set.should == [ "id", "deleted_at" ].to_set
+    end
+
+    it "should destroy archive indexes" do
+      Article.class_eval { acts_as_archive }
+      Article.create_archive_indexes
+      indexes.should == []
+    end
+  end
+
+  describe 'migrate_from_acts_as_paranoid' do
+
+    before(:all) do
+      connection.add_column(:articles, :deleted_at, :datetime)
+      Article.reset_column_information
+    end
+
+    before(:each) do
+      connection.execute("DELETE FROM #{Article::Archive.table_name}")
+    end
+
+    it "should move deleted records to the archive" do
+      create_records(Article, :deleted_at => Time.now.utc)
+      Article.migrate_from_acts_as_paranoid
+      Article.count.should == 0
+      Article::Archive.count.should == 5
+    end
+
+    it "should not move non-deleted records to the archive" do
+      create_records
+      Article.migrate_from_acts_as_paranoid
+      Article.count.should == 5
+      Article::Archive.count.should == 0
+    end
+  end
+end

data/spec/acts_as_archive/base_spec.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe ActsAsArchive::Base do
+  
+  before(:all) do
+    establish_test_db
+  end
+  
+  describe 'acts_as_archive' do    
+    it "should add self.acts_as_archive? to the model" do
+      Article.respond_to?(:acts_as_archive?).should == true
+    end
+    
+    it "should add self.archive_indexes to the model" do
+      Article.respond_to?(:archive_indexes).should == true
+      Article.archive_indexes.should == [ 'id', 'deleted_at' ]
+    end
+    
+    it "should add Archive class to the model" do
+      defined?(Article::Archive).should == "constant"
+    end
+    
+    describe 'for STI models' do
+      before do
+        Article.create_archive_table
+        @headline = Headline.create(:title => "This is a headline")
+        @oped = Opinion.create(:title => "This is an op-ed")
+        @headline.destroy
+        @oped.destroy
+      end
+      
+      it 'should only return a deleted entry for the STI type used' do
+        Headline::Archive.all.map(&:id).should include(@headline.id)
+        Headline::Archive.all.map(&:id).should_not include(@oped.id)
+        Opinion::Archive.all.map(&:id).should_not include(@headline.id)
+        Opinion::Archive.all.map(&:id).should include(@oped.id)
+      end
+    end
+  end
+end

data/spec/acts_as_archive/migration_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe ActsAsArchive::Migration do
+  
+  before(:each) do
+    establish_test_db
+    Article.create_archive_table
+  end
+  
+  describe 'method_missing_with_archive' do
+    
+    it 'should migrate both tables up' do
+      migrate_up
+      (@new_article_columns - @old_article_columns).should == [ 'permalink' ]
+      (@new_archive_columns - @old_archive_columns).should == [ 'permalink' ]
+    end
+    
+    it 'should migrate both tables down' do
+      migrate_up
+      @old_article_columns = @new_article_columns
+      @old_archive_columns = @new_archive_columns
+      ActiveRecord::Migrator.migrate("#{SPEC}/db/migrate", 0)
+      @new_article_columns = columns("articles")
+      @new_archive_columns = columns("archived_articles")
+      (@old_article_columns - @new_article_columns).should == [ 'permalink' ]
+      (@old_archive_columns - @new_archive_columns).should == [ 'permalink' ]
+    end
+    
+    it "should not touch the archive's deleted_at column" do
+      connection.add_column(:articles, :deleted_at, :datetime)
+      Article.reset_column_information
+      migrate_up("migrate_2")
+      (@old_article_columns - @new_article_columns).should == [ 'deleted_at' ]
+      (@old_archive_columns - @new_archive_columns).should == []
+    end
+  end
+end

data/spec/db/config/database.mysql.yml

@@ -0,0 +1,6 @@
+test:
+  adapter: mysql
+  database: acts_as_archive
+  username: root
+  password: 
+  host: localhost

data/spec/db/config/database.postgresql.yml

@@ -0,0 +1,6 @@
+test:
+  adapter: postgresql
+  database: acts_as_archive
+  username: postgres
+  password: 
+  host: localhost

data/spec/db/migrate/001_add_to_articles.rb

@@ -0,0 +1,9 @@
+class AddToArticles < ActiveRecord::Migration
+  def self.up
+    add_column :articles, :permalink, :string
+  end
+
+  def self.down
+    remove_column :articles, :permalink
+  end
+end

data/spec/db/migrate_2/001_add_to_articles.rb

@@ -0,0 +1,9 @@
+class AddToArticles < ActiveRecord::Migration
+  def self.up
+    remove_column :articles, :deleted_at
+  end
+
+  def self.down
+    add_column :articles, :deleted_at, :string
+  end
+end

data/spec/db/models/article.rb

@@ -0,0 +1,3 @@
+class Article < ActiveRecord::Base
+  acts_as_archive :indexes => [ :id, :deleted_at ]
+end

data/spec/db/models/headline.rb

@@ -0,0 +1,3 @@
+class Headline < Article
+  acts_as_archive :indexes => [ :id, :deleted_at ]
+end

data/spec/db/models/opinion.rb

@@ -0,0 +1,3 @@
+class Opinion < Article
+  acts_as_archive :indexes => [ :id, :deleted_at ]
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,89 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../require")
+Require.spec_helper!
+
+Spec::Runner.configure do |config|
+end
+
+def db_type
+  ENV['DB_TYPE'] ? ENV['DB_TYPE'] : 'mysql'
+end
+
+def article_match?(original, copy)
+  copy.id.should == original.id
+  copy.title.should == original.title
+  copy.body.should == original.body
+end
+
+def columns(table)
+  connection.columns(table).collect(&:name)
+end
+
+def connection
+  ActiveRecord::Base.connection
+end
+
+def create_records(klass=Article, values={})
+  articles = []
+  table = klass.table_name
+  cols = columns(table)
+  connection.execute("DELETE FROM #{table}")
+  (1..5).collect do |x|
+    vals = cols.collect do |c|
+      if values.keys.include?(c.intern)
+        values[c.intern] ? "'#{values[c.intern]}'" : "NULL"
+      else
+        case c.intern
+        when :id; x
+        when :deleted_at; 'NULL'
+        when :type; klass.sti_name.to_s.inspect
+        else "'#{c.capitalize} #{x}'"
+        end
+      end
+    end
+    connection.execute(%{
+      INSERT INTO #{table} (#{cols.collect { |c| "#{connection.quote_column_name(c)}" }.join(', ')})
+        VALUES (#{vals.join(', ')})
+    })
+    klass.find(x)
+  end
+end
+
+def establish_test_db
+  # Establish connection
+  unless ActiveRecord::Base.connected?
+    config = YAML::load(File.open("#{SPEC}/db/config/database.#{db_type}.yml"))
+    ActiveRecord::Base.configurations = config
+    ActiveRecord::Base.establish_connection(config['test'])
+  end
+  # Establish logger
+  logger_file = File.open("#{SPEC}/db/log/test.log", 'a')
+  logger_file.sync = true
+  @logger = Logger.new(logger_file)
+  ActiveRecord::Base.logger = @logger
+  # The database should have only a simple articles table
+  connection.execute("DROP TABLE IF EXISTS articles")
+  connection.execute("DROP TABLE IF EXISTS archived_articles")
+  connection.execute("DROP TABLE IF EXISTS schema_migrations")
+  connection.create_table(:articles) do |t|
+    t.string :title
+    t.string :body
+    t.string :type
+    t.boolean :read # break mysql w/o quotation
+  end
+  # Load the model
+  load "#{SPEC}/db/models/article.rb"
+  load "#{SPEC}/db/models/headline.rb"
+  load "#{SPEC}/db/models/opinion.rb"
+end
+
+def indexes
+  Article.send(:archive_table_indexed_columns)
+end
+
+def migrate_up(directory='migrate')
+  @old_article_columns = columns("articles")
+  @old_archive_columns = columns("archived_articles")
+  ActiveRecord::Migrator.migrate("#{SPEC}/db/#{directory}")
+  @new_article_columns = columns("articles")
+  @new_archive_columns = columns("archived_articles")
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification 
+name: brianjlandau-acts_as_archive
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 6
+  version: 0.2.6
+platform: ruby
+authors: 
+- Winton Welsh
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-29 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: require
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 0
+        - 2
+        - 7
+        version: 0.2.7
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: mail@wintoni.us
+executables: 
+- acts_as_archive
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- MIT-LICENSE
+- README.markdown
+- Rakefile
+- bin/acts_as_archive
+- init.rb
+- lib/acts_as_archive/base/adapters/mysql.rb
+- lib/acts_as_archive/base/adapters/postgresql.rb
+- lib/acts_as_archive/base/destroy.rb
+- lib/acts_as_archive/base/restore.rb
+- lib/acts_as_archive/base/table.rb
+- lib/acts_as_archive/base.rb
+- lib/acts_as_archive/migration.rb
+- lib/acts_as_archive.rb
+- rails/init.rb
+- require.rb
+- spec/acts_as_archive/base/destroy_spec.rb
+- spec/acts_as_archive/base/restore_spec.rb
+- spec/acts_as_archive/base/table_spec.rb
+- spec/acts_as_archive/base_spec.rb
+- spec/acts_as_archive/migration_spec.rb
+- spec/db/config/database.mysql.yml
+- spec/db/config/database.postgresql.yml
+- spec/db/migrate/001_add_to_articles.rb
+- spec/db/migrate_2/001_add_to_articles.rb
+- spec/db/models/article.rb
+- spec/db/models/headline.rb
+- spec/db/models/opinion.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/winton/brianjlandau-acts_as_archive
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Don't delete your records, move them to a different table
+test_files: []
+