archivist 1.0.2

data/MIT-LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2010 Tyler Pickett
+
+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.md

@@ -0,0 +1,33 @@
+README.md
+=================
+
+This gem is intended as a direct replacement for acts\_as\_archive (AAA)
+in Rails 3 apps with most of the same functionality and wrapping AAA's 
+methods in aliases to maintain compatibilty for some time. Thanks to 
+[Winton Welsh](https://github.com/winton "Winton on github") for his 
+original work on AAA, it is good solution to a problem that makes 
+maintaining audit records a breeze.
+
+More Later
+
+TODO
+-----------------
+
+v1.0
+
+ *  <del>License</del>
+ *  <del>Base Module</del>
+     *  <del> Inserting Subclass (SomeModel::Archive) </del>
+     *  <del> Archive method </del>
+     *  <del> Intercept destroy/deletes </del>
+     *  <del>Restore archive</del>
+     *  <del> Build archive table for existing models </del>
+ *  <del>Migrations Module</del>
+     *  <del>rewrite method_missing to act on the archived table</del>
+
+Future
+
+ *  give subclass Archive its parent's methods
+ *  give Archive relations
+ *  give Archive scopes
+ *  make archive\_all method chain-able with scopes 

data/lib/archivist.rb

@@ -0,0 +1,24 @@
+#require dependancies eventhough starting a rails app will already have them in place
+require 'rubygems'
+gem 'activerecord','~>3.0.1' #enforce rails 3+
+require 'active_record'
+
+#require the rest of Archivist's files
+files = File.join(File.dirname(__FILE__),'**','*.rb')
+Dir.glob(files).each do |file|
+  require file
+end
+
+ActiveRecord::Base.send(:include, Archivist::Base)
+ActiveRecord::Migration.send(:include,Archivist::Migration)
+module Archivist
+  def self.update(*models)
+    models.each do |klass|
+      if klass.respond_to?(:has_archive) && klass.has_archive?
+        klass.create_archive_table
+        klass.create_archive_indexes
+      end
+    end
+  end
+end
+

data/lib/archivist/base.rb

@@ -0,0 +1,129 @@
+# Require sub-module's files
+mods = File.join(File.dirname(__FILE__),"base","**","*.rb")
+Dir.glob(mods).each do |mod|
+  require mod
+end
+
+module Archivist
+  module Base
+    def self.included(base)
+      base.extend ClassMethods
+    end
+    
+    module ClassMethods
+      def has_archive(options={})
+        class_eval <<-EOF
+          alias_method :delete!, :delete
+          
+          class << self
+            alias_method :delete_all!, :delete_all
+          end
+          
+          def self.archive_indexes
+            #{Array(options[:indexes]).collect{|i| i.to_s}.inspect}
+          end
+          
+          def self.has_archive?
+            true
+          end
+          
+          def self.acts_as_archive?
+            warn "DEPRECATION WARNING: #acts_as_archive is provided for compatibility with AAA and will be removed soon, please use has_archive?"
+            has_archive?
+          end
+          class Archive < ActiveRecord::Base
+            self.record_timestamps = false
+            self.table_name = "archived_#{self.table_name}"
+          end
+        EOF
+        include InstanceMethods
+        extend ClassExtensions
+        include DB
+      end
+
+      def acts_as_archive(options={})
+        has_archive(options)
+      end
+    end
+    
+    module InstanceMethods #these defs can't happen untill after we've aliased their respective originals
+      def delete
+        self.class.copy_to_archive({:id=>self.id}) unless new_record?
+        @destroyed = true
+        freeze
+      end
+      
+      def destroy
+        _run_destroy_callbacks do
+          self.delete
+        end
+      end
+      
+      def destroy!
+        transaction do
+          _run_destroy_callbacks do
+            self.delete!
+          end
+        end
+      end
+    end
+
+    module ClassExtensions #these can't get included in the class def untill after all aliases are done
+      def copy_to_archive(conditions,delete=true)
+        where = sanitize_sql(conditions)
+        found = self.where(where)
+        
+        found.each do |m|
+          self.transaction do # I would hate for something to happen in the middle of all of this
+            attrs = m.attributes.merge(:deleted_at=>DateTime.now)
+            
+            if self::Archive.where(:id=>m.id).empty? #create a new one if necessary, else update
+              archived = self::Archive.new
+              archived.id = m.id
+              archived.attributes = attrs.reject{|k,v| k==:id}
+              archived.save
+            else
+              self::Archive.where(:id=>m.id).first.update_attributes(attrs)
+            end
+            m.destroy! if delete
+          end
+        end
+      end
+      
+      def copy_from_archive(conditions,delete=true)
+        where = sanitize_sql(conditions)
+        where = where.gsub("#{table_name}","archived_#{table_name}") unless where.nil? || where =~ /archived/
+        unless where == ""
+          found = self::Archive.where(where)
+        else
+          found = self::Archive.all
+        end
+
+        found.each do |m|
+          self.transaction do
+            attrs = m.attributes.reject{|k,v| k=="deleted_at"}
+
+            if self.where(:id=>m.id).empty?
+              new_m = self.create(attrs)
+              connection.execute(%Q{UPDATE #{table_name} 
+                                    SET #{self.primary_key} = #{m.id} 
+                                    WHERE #{self.primary_key} = #{new_m.id}
+                                   })
+            else
+              self.where(:id=>m.id).first.update_attributes(attrs)
+            end
+            m.destroy if delete  
+          end
+        end
+      end
+
+      def delete_all(conditions=nil)
+        copy_to_archive(conditions)
+      end
+
+      def restore_all(conditions=nil)
+        copy_from_archive(conditions)
+      end
+    end
+  end
+end

data/lib/archivist/base/db.rb

@@ -0,0 +1,53 @@
+module Archivist
+  module Base
+    module DB
+      
+      def self.included(base)
+        base.send(:extend, ClassMethods)
+        base.send(:include, InstanceMethods)
+
+        if base.connection.class.to_s.include?("Mysql")
+          base.send(:extend, MySQL)
+        elsif base.connection.class.to_s.include?("Postgresql")
+          base.send(:extend, PostgreSQL)
+        else
+          raise "DB type not supported by Archivist!"
+        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?
+            cols = self.content_columns
+            connection.create_table("archived_#{table_name}")
+            cols.each do |c|
+              connection.add_column("archived_#{table_name}",c.name,c.type)
+            end
+            connection.add_column("archived_#{table_name}",:deleted_at,:datetime)
+          end
+        end
+      end
+
+      module InstanceMethods
+      end
+
+      module MySQL
+        private
+        def archive_table_indexed_columns
+          @indexes ||= connection.select_all("SHOW INDEX FROM archived_#{table_name}").collect{|r| r["Column_name"]}
+        end
+      end
+
+      module PostgreSQL
+        private
+        def archived_table_indexed_columns
+          @indexes ||= connection.indexes("archived_#{table_name}").map{|i| i.column_names}
+        end
+      end
+    end
+  end
+end

data/lib/archivist/migration.rb

@@ -0,0 +1,36 @@
+module Archivist
+  module Migration
+    def self.included(base)
+      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
+
+    module ClassMethods
+      def method_missing_with_archive(method, *arguments, &block)
+        method_missing_without_archive(method, *arguments, &block)
+        allowed = [:add_column,:add_timestamps,:change_column,
+                   :change_column_default,:change_table,:drop_table,
+                   :remove_column, :remove_columns, :remove_timestamps,
+                   :rename_column,:rename_table]
+        return if arguments.include?(:deleted_at) || arguments.include?('deleted_at')
+        
+        if !arguments.empty? && allowed.include?(method)
+          args = Marshal.load(Marshal.dump(arguments))
+          args[0] = "archived_#{ActiveRecord::Migrator.proper_table_name(args[0])}"
+          args[1] = "archived_#{args[1].to_s}" if method == :rename_table
+          
+          if ActiveRecord::Base.connection.table_exists?(args[0])
+            ActiveRecord::Base.connection.send(method, *args, &block)
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification 
+name: archivist
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 2
+  version: 1.0.2
+platform: ruby
+authors: 
+- Tyler Pickett
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-11 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 3
+        - 0
+        - 1
+        version: 3.0.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: |-
+  This is a functional replacement for acts_as_archive in
+                        rails 3 applications, the only functionality that is not
+                        duplicated is the migration from acts_as_paranoid
+email: 
+- t.pickett66@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/archivist/base/db.rb
+- lib/archivist/base.rb
+- lib/archivist/migration.rb
+- lib/archivist.rb
+- MIT-LICENSE
+- README.md
+has_rdoc: true
+homepage: http://github.com/tpickett66/archivist
+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: A rails 3 model archiving system based on acts_as_archive
+test_files: []
+