acts_as_archive 0.1.4

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,109 @@
+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
+-------
+
+script/plugin:
+
+<pre>
+script/plugin install git://github.com/winton/acts_as_archive.git
+</pre>
+
+rubygems:
+
+<pre>
+# terminal
+sudo gem install winton-acts_as_archive
+
+# environment.rb
+config.gem "winton-acts_as_archive", :lib => "acts_as_archive", :source => "http://gems.github.com"
+</pre>
+
+Update models
+-------------
+
+Add <code>acts\_as\_archive</code> to your models:
+
+<pre>
+class Article < ActiveRecord::Base
+  acts_as_archive
+end
+</pre>
+
+<a name="run_acts_as_archive"></a>
+
+Run acts\_as\_archive
+---------------------
+
+Terminal:
+
+<pre>
+cd your_rails_app
+acts_as_archive
+</pre>
+
+This command creates your archive tables (<code>archived_articles</code> as per the example).
+
+Archive tables mirror your table's structure, but with an additional <code>deleted_at</code> column.
+
+Run this command every time you add <code>acts\_as\_archive</code> to a new model.
+
+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?
+--------------------------
+
+Any new migrations on your table are automatically applied to the archive table.
+
+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>, running the <code>acts\_as\_archive</code>
+command will automatically move your deleted records to the archive table
+(see <a href="#run_acts_as_archive">_Run acts\_as\_archive_</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>
+
+Run the <code>acts\_as\_archive</code> command any time you add new indexes
+(see <a href="#run_acts_as_archive">_Run acts\_as\_archive_</a>).

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'rake'
+require 'rake/gempackagetask'
+require 'spec/rake/spectask'
+
+GEM_NAME = 'acts_as_archive'
+PKG_FILES = FileList['**/*'] - FileList['coverage', 'coverage/**/*', 'pkg', 'pkg/**/*', 'spec/db/log/*.log']
+
+spec = Gem::Specification.new do |s|
+  s.author = "Winton Welsh"
+  s.email = "mail@wintoni.us"
+  s.executables << GEM_NAME
+  s.extra_rdoc_files = [ "README.markdown" ]
+  s.files = PKG_FILES.to_a
+  s.homepage = "http://github.com/winton/#{GEM_NAME}"
+  s.name = GEM_NAME
+  s.platform = Gem::Platform::RUBY
+  s.require_path = "lib"
+  s.summary = "Don't delete your records, move them to a different table"
+  s.version = "0.1.4"
+end
+
+desc "Package gem"
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "Install gem"
+task :install do
+  Rake::Task['gem'].invoke
+  `sudo gem uninstall #{GEM_NAME} -x`
+  `sudo gem install pkg/#{GEM_NAME}*.gem`
+  `rm -Rf pkg`
+end
+
+desc "Generate gemspec"
+task :gemspec do
+  File.open("#{File.dirname(__FILE__)}/#{GEM_NAME}.gemspec", 'w') do |f|
+    f.write(spec.to_ruby)
+  end
+end
+
+desc "Run specs"
+Spec::Rake::SpecTask.new do |t|
+  t.rcov = true
+  t.spec_opts = ["--format", "specdoc", "--colour"]
+  t.spec_files = FileList["spec/**/*_spec.rb"]
+end

data/acts_as_archive.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{acts_as_archive}
+  s.version = "0.1.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Winton Welsh"]
+  s.date = %q{2009-10-14}
+  s.default_executable = %q{acts_as_archive}
+  s.email = %q{mail@wintoni.us}
+  s.executables = ["acts_as_archive"]
+  s.extra_rdoc_files = ["README.markdown"]
+  s.files = ["acts_as_archive.gemspec", "bin", "bin/acts_as_archive", "init.rb", "lib", "lib/acts_as_archive", "lib/acts_as_archive/base", "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", "MIT-LICENSE", "rails", "rails/init.rb", "Rakefile", "README.markdown", "spec", "spec/acts_as_archive", "spec/acts_as_archive/base", "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", "spec/db/config", "spec/db/config/database.yml", "spec/db/log", "spec/db/migrate", "spec/db/migrate/001_add_to_articles.rb", "spec/db/migrate_2", "spec/db/migrate_2/001_add_to_articles.rb", "spec/db/models", "spec/db/models/article.rb", "spec/spec.opts", "spec/spec_helper.rb"]
+  s.homepage = %q{http://github.com/winton/acts_as_archive}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Don't delete your records, move them to a different table}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/bin/acts_as_archive

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+$:.push File.expand_path("#{File.dirname(__FILE__)}/../lib")
+require 'acts_as_archive'
+
+puts `script/runner "ActsAsArchive.update"`

data/init.rb

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

data/lib/acts_as_archive.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + "/acts_as_archive/base"
+require File.dirname(__FILE__) + "/acts_as_archive/migration"

data/lib/acts_as_archive/base.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + "/base/destroy"
+require File.dirname(__FILE__) + "/base/restore"
+require File.dirname(__FILE__) + "/base/table"
+
+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
+          
+          class Archive < ActiveRecord::Base
+            self.record_timestamps = false
+            self.table_name = "archived_#{self.table_name}"
+          end
+        end_eval
+        include Destroy
+        include Restore
+        include Table
+      end
+    end
+  end
+end

data/lib/acts_as_archive/base/destroy.rb

@@ -0,0 +1,66 @@
+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
+          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
+          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,35 @@
+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' ]
+          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,65 @@
+module ActsAsArchive
+  module Base
+    module Table
+
+      def self.included(base)
+        unless base.included_modules.include?(InstanceMethods)
+          base.send :extend, ClassMethods
+          base.send :include, InstanceMethods
+        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
+                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 = "SHOW INDEX FROM archived_#{table_name}"
+            indexes = connection.select_all(indexes).collect do |r|
+              r["Column_name"]
+            end
+            (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
+      end
+
+      module InstanceMethods
+      end
+    end
+  end
+end

data/lib/acts_as_archive/migration.rb

@@ -0,0 +1,47 @@
+module ActsAsArchive
+  module Migration
+    
+    def self.included(base)
+      unless base.included_modules.include?(InstanceMethods)
+        base.send :extend, ClassMethods
+        base.class_eval do
+          class <<self
+            alias_method :method_missing_without_archive, :method_missing
+            alias_method :method_missing, :method_missing_with_archive
+          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]
+          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,16 @@
+require File.expand_path(File.dirname(__FILE__) + "/../lib/acts_as_archive")
+
+ActiveRecord::Base.send(:include, ActsAsArchive::Base)
+ActiveRecord::Migration.send(:include, ActsAsArchive::Migration)
+
+module ActsAsArchive
+  def self.update
+    Object.subclasses_of(ActiveRecord::Base).each do |klass|
+      if klass.respond_to?(:acts_as_archive?) && klass.acts_as_archive?
+        klass.create_archive_table
+        klass.migrate_from_acts_as_paranoid
+        klass.create_archive_indexes
+      end
+    end
+  end
+end

data/spec/acts_as_archive/base/destroy_spec.rb

@@ -0,0 +1,98 @@
+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 '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
+    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.should == [ "id", "deleted_at" ]
+    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,24 @@
+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
+  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.yml

@@ -0,0 +1,7 @@
+test:
+  adapter: mysql
+  database: acts_as_archive
+  username: root
+  password: 
+  host: localhost
+  socket: /tmp/mysql.sock

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/spec.opts

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

data/spec/spec_helper.rb

@@ -0,0 +1,100 @@
+$TESTING=true
+SPEC = File.expand_path(File.dirname(__FILE__))
+
+require 'rubygems'
+require 'active_record'
+require 'logger'
+require 'yaml'
+require 'pp'
+
+require File.expand_path("#{SPEC}/../rails/init")
+
+Spec::Runner.configure do |config|
+end
+
+def article_match?(original, copy)
+  copy.id.should == original.id
+  copy.title.should == original.title
+  copy.body.should == original.body
+  if copy.respond_to?(:deleted_at)
+    copy.deleted_at.strftime('%j%H%M').should == Time.now.utc.strftime('%j%H%M')
+  end
+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'
+        else "'#{c.capitalize} #{x}'"
+        end
+      end
+    end
+    connection.execute(%{
+      INSERT INTO #{table} (#{cols.collect { |c| "`#{c}`" }.join(', ')})
+        VALUES (#{vals.join(', ')})
+    })
+    klass.find(x)
+  end
+end
+
+def debug(object)
+  puts "<pre>"
+  pp object
+  puts "</pre>"
+end
+
+def establish_test_db
+  # Establish connection
+  unless ActiveRecord::Base.connected?
+    config = YAML::load(File.open("#{SPEC}/db/config/database.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
+  end
+  # Load the model
+  load "#{SPEC}/db/models/article.rb"
+end
+
+def indexes
+  query = "SHOW INDEX FROM archived_#{Article.table_name}"
+  connection.select_all(query).collect do |r|
+    r["Column_name"]
+  end
+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,78 @@
+--- !ruby/object:Gem::Specification 
+name: acts_as_archive
+version: !ruby/object:Gem::Version 
+  version: 0.1.4
+platform: ruby
+authors: 
+- Winton Welsh
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-06 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: 
+email: mail@wintoni.us
+executables: 
+- acts_as_archive
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- acts_as_archive.gemspec
+- bin/acts_as_archive
+- init.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
+- MIT-LICENSE
+- rails/init.rb
+- Rakefile
+- README.markdown
+- 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.yml
+- spec/db/migrate/001_add_to_articles.rb
+- spec/db/migrate_2/001_add_to_articles.rb
+- spec/db/models/article.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/winton/acts_as_archive
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Don't delete your records, move them to a different table
+test_files: []
+