archivist 1.0.5.1 → 1.1.0

data/MIT-LICENSE

@@ -1,18 +1,20 @@
-Copyright (c) 2010 Tyler Pickett
+Copyright 2012 YOURNAME
 
-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:
+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 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.
+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.rdoc

@@ -0,0 +1,3 @@
+= Archivist
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,36 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Archivist'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks
+
+require 'appraisal'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task :default => :test

data/lib/archivist.rb

@@ -1,6 +1,5 @@
 #require dependencies even though 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

data/lib/archivist/archive.rb

@@ -8,7 +8,7 @@ module Archivist
     end
 
     def method_missing(method,*args,&block)
-      if get_klass_instance_methods.include?(method.to_s)
+      if get_klass_instance_methods.include?(method)
         build_proxy_method(method.to_s)
         self.method(method).call(*args,&block)
       else
@@ -17,7 +17,7 @@ module Archivist
     end
 
     def respond_to?(method,include_private=false)
-      if get_klass_instance_methods.include?(method.to_s)
+      if get_klass_instance_methods.include?(method)
         return true
       else
         super(method,include_private)
@@ -32,8 +32,14 @@ module Archivist
       @klass_name ||= self.class.to_s.split("::").first
     end
 
-    def get_klass_instance_methods
-      @klass_instance_methods ||= get_klass.instance_methods(false)
+    if RUBY_VERSION >= "1.9"
+      def get_klass_instance_methods
+        @klass_instance_methods ||= get_klass.instance_methods(false)
+      end
+    else
+      def get_klass_instance_methods
+        @klass_instance_methods ||= get_klass.instance_methods(false).map(&:to_sym)
+      end
     end
     
     def build_proxy_method(method_name)

data/lib/archivist/base.rb

@@ -7,7 +7,7 @@ end
 module Archivist
   module Base
 
-    DEFAULT_OPTIONS = {:associate_with_original=>false,:allow_multiple_archives=>false}
+    ARCHIVIST_DEFAULTS = {:associate_with_original=>false,:allow_multiple_archives=>false}
 
     def self.included(base)
       base.extend ClassMethods
@@ -15,47 +15,51 @@ module Archivist
     
     module ClassMethods
       def has_archive(options={})
-        options = DEFAULT_OPTIONS.merge(options)
+        options = ARCHIVIST_DEFAULTS.merge(options)
         options[:allow_multiple_archives] = true if options[:associate_with_original]
-        
-        class_eval <<-EOF
+
+        class_eval(%Q{
           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.archive_options
-            #{options.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?
+            def archive_indexes
+              #{Array(options[:indexes]).collect{|i| i.to_s}.inspect}
+            end
+
+            def archive_options
+              #{options.inspect}
+            end
+
+            def has_archive?
+              true
+            end
+
+            def acts_as_archive?
+              warn("DEPRECATION WARNING: #acts_as_archive is provided for compatibility with AAA and will be removed soon, please use has_archive?",caller )
+              has_archive?
+            end
           end
 
           class Archive < ActiveRecord::Base
             self.record_timestamps = false
             self.table_name = "archived_#{self.table_name}"
-            #{build_serialization_strings(self.serialized_attributes)}
-            #{build_belongs_to_association(options[:associate_with_original])}
-            #{build_inclusion_strings(options[:included_modules])}
             include Archivist::ArchiveMethods
           end
-
-          #{build_has_many_association(options[:associate_with_original])}
           
           #{build_copy_self_to_archive(options[:allow_multiple_archives])}
-        EOF
-        
+        },File.expand_path(__FILE__),21)
+
+        if ActiveRecord::VERSION::STRING >= "3.1.0"
+          enable_archive_mass_assignment!(self)
+        end
+
+        attach_serializations!(self)
+        include_modules!(self,options[:included_modules]) if options[:included_modules]
+
+        build_associations!(self) if options[:associate_with_original]
+
         include InstanceMethods
         extend ClassExtensions
         include DB
@@ -65,31 +69,36 @@ module Archivist
         has_archive(options)
       end
 
-      def build_inclusion_strings(included_modules)
-        modules = ""
-        included_modules = [included_modules] unless included_modules.is_a?(Array)
-        included_modules.each do |mod|
-          modules << "include #{mod.to_s}\n"
-        end
-        return modules
+      def archive_for(klass)
+        "#{klass.to_s}::Archive".constantize
       end
-      
-      def build_serialization_strings(serializde_attributes)
-        serializations = ""
-        self.serialized_attributes.each do |key,value|
-          serializations << "serialize(:#{key},#{value.to_s})\n"
+
+      def enable_archive_mass_assignment!(klass)
+        archive_class = archive_for(klass)
+        attrs = archive_class.attribute_names
+        archive_class.send(:attr_accessible,*attrs.map(&:to_sym))
+      end
+
+      def attach_serializations!(klass)
+        archive_class = archive_for(klass)
+        klass.serialized_attributes.each do |column,type|
+          archive_class.send(:serialize,column,type)
         end
-        return serializations
       end
-      
-      def build_has_many_association(associate=false)
-        associate ? "has_many :archived_#{self.table_name},:class_name=>'#{self.new.class.to_s}::Archive'" : ""
+
+      def include_modules!(klass,modules)
+        archive_class = archive_for(klass)
+        [*modules].each do |mod|
+          archive_class.send(:include,mod)
+        end
       end
-      
-      def build_belongs_to_association(associate=false)
-        associate ? "belongs_to :#{self.table_name},:class_name=>'#{self.new.class.to_s}'" : ""
+
+      def build_associations!(klass)
+        archive_class = archive_for(klass)
+        klass.send(:has_many,"archived_#{klass.table_name}".to_sym,:class_name => archive_class.to_s)
+        archive_class.send(:belongs_to, klass.table_name.to_sym, :class_name => klass.to_s)
       end
-      
+
       def build_copy_self_to_archive(allow_multiple=false)
         if allow_multiple #we put the original pk in the fk instead
           "def copy_self_to_archive
@@ -123,9 +132,8 @@ module Archivist
         archived.save"
       end
       
-      private :build_inclusion_strings,:build_serialization_strings,
-              :build_has_many_association,:build_belongs_to_association,
-              :build_copy_self_to_archive,:yield_and_save
+      private :include_modules!,:attach_serializations!, :build_associations!,
+              :archive_for,:build_copy_self_to_archive,:yield_and_save
     end
     
     module InstanceMethods #these defs can't happen untill after we've aliased their respective originals

data/lib/archivist/migration.rb

@@ -14,7 +14,6 @@ module Archivist
 
     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,
@@ -30,6 +29,7 @@ module Archivist
             ActiveRecord::Base.connection.send(method, *args, &block)
           end
         end
+        method_missing_without_archive(method, *arguments, &block)
       end
     end
   end

data/lib/archivist/version.rb

@@ -0,0 +1,3 @@
+module Archivist
+  VERSION = "1.0.1.beta1"
+end

data/lib/tasks/archivist_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :archivist do
+#   # Task goes here
+# end

data/test/archive_test.rb

@@ -0,0 +1,16 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class ArchiveTest < ActiveSupport::TestCase
+  context "The module Archivist::ArchiveMethods" do
+    should "give the Archive subclass the super's methods" do
+      assert_nothing_raised do
+        model = SomeModel::Archive.new(:first_name=>"Steve",:last_name=>"Smith")
+        model.full_name
+      end
+    end
+
+    should "make the Archive subclass respond_to? correctly" do
+      assert SomeModel::Archive.new.respond_to?(:full_name)
+    end
+  end
+end

data/test/archivist_test.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class ArchivistTest < Test::Unit::TestCase
+  context "The Archivist" do
+    should "include Archivist::Base in ActiveRecord::Base" do
+      assert ActiveRecord::Base.include?(Archivist::Base)
+    end
+
+    should "include Archivist::Migration in ActiveRecord::Migration" do
+      assert ActiveRecord::Migration.include?(Archivist::Migration)
+    end
+
+    should "respond to Archivist.update" do
+      assert Archivist.respond_to?(:update)
+    end
+  end
+end

data/test/base_test.rb

@@ -0,0 +1,342 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class BaseTest < ActiveSupport::TestCase
+
+  context "The module Archivist::Base" do
+    should "make ActiveRecord::Base respond to has_archive" do
+      assert ActiveRecord::Base.respond_to?(:has_archive)
+    end
+
+    should "make ActiveRecord::Base respond to acts_as_archive" do
+      assert ActiveRecord::Base.respond_to?(:acts_as_archive)
+    end
+  end
+
+  context "Models that call has_archive" do
+    should "have subclass Archive" do
+      assert_nothing_raised do
+        archive = SomeModel::Archive
+      end
+    end
+
+    should "respond to archive_indexes as a class method" do
+      assert SomeModel.respond_to?(:archive_indexes)
+    end
+
+    should "respond to acts_as_archive?" do
+      assert SomeModel.respond_to?(:acts_as_archive?)
+    end
+
+    should "respond to has_archive?" do
+      assert SomeModel.respond_to?(:has_archive?)
+    end
+
+    should "respond to has_archive? with true" do
+      assert SomeModel.has_archive?
+    end
+
+    should "respond_to? archive_options" do
+      assert SomeModel.respond_to?(:archive_options)
+    end
+
+    should "return the options hash when archive_options is called" do
+      options_hash = Archivist::Base::ARCHIVIST_DEFAULTS.merge({:associate_with_original=>true,:allow_multiple_archives=>true})
+      assert_equal options_hash,AnotherModel.archive_options
+    end
+
+    context "with the associate_with_original option set to true" do
+      should "cause the main class to have a has_many reflection to the achive class" do
+        reflections = AnotherModel.reflect_on_all_associations(:has_many).map{|r| r.name}
+        assert_match /archived_another_models/,reflections.join(',')
+      end
+
+      should "cause the Archive class to have a belongs_to reflection to the main class" do
+        reflections = AnotherModel::Archive.reflect_on_all_associations(:belongs_to).map{|r| r.name}
+        assert_match /another_models/,reflections.join(',')
+      end
+    end
+  end
+
+  context "The Archive subclass" do
+    should "not write updated timestamps" do
+      assert !SomeModel::Archive.record_timestamps
+    end
+
+    should "have the same serialized attributes as the parent" do
+      assert_equal SomeModel.serialized_attributes,SomeModel::Archive.serialized_attributes
+    end
+
+    should "have the Archivist::Base::Archive included in it" do
+      assert SomeModel::Archive.include?(Archivist::ArchiveMethods)
+    end
+
+    should "have the correct modules included when the included_modules option is set" do
+      assert SomeModel::Archive.include?(ThisModule)
+    end
+  end
+  
+  context "The archiving functionality" do
+    context "when using copy_self_to_archive and the associate_with_original option is set to true" do
+      setup do
+        @zapp = AnotherModel.create!(:first_name=>"Zapp",:last_name=>"Brannigan")
+        @zapp.copy_self_to_archive
+      end
+
+      should "create a new archive record" do
+        assert_equal 1,AnotherModel::Archive.count
+      end
+
+      should "create a child record" do
+        assert_equal 1,@zapp.archived_another_models.size
+      end
+    end
+
+    context "when calling #copy_to_archive directly" do
+      setup do
+        @my_model = FactoryGirl.create(:some_model)
+      end
+
+      should "not delete the original if told not to" do
+        SomeModel.copy_to_archive({:id=>@my_model.id},false)
+        assert SomeModel.exists?(@my_model.id)
+      end
+
+      should "allow the user to pass in a block" do
+        block_called = false
+        SomeModel.copy_to_archive({:id=>@my_model.id},false) do |archive|
+          block_called = true
+        end
+        assert block_called
+      end   
+
+      should "create a new entry in the archive when told not to delete" do
+        SomeModel.copy_to_archive({:id=>@my_model.id},false)
+        assert !SomeModel::Archive.where({:id=>@my_model.id}).empty?
+      end
+
+      should "delete the original if not specified" do
+        SomeModel.copy_to_archive({:id=>@my_model.id})
+        assert SomeModel.where({:id=>@my_model.id}).empty?
+      end
+
+      should "create a new entry in the archive if delete is not specified" do
+        SomeModel.copy_to_archive({:id=>@my_model.id})
+        assert !SomeModel::Archive.where({:id=>@my_model.id}).empty?
+      end
+
+      should "update the archived info when previously archived" do
+        SomeModel.copy_to_archive({:id=>@my_model.id},false)
+        SomeModel.where({:id=>@my_model.id}).first.update_attributes!(:first_name=>"Cindy",:last_name=>"Crawford")
+        SomeModel.copy_to_archive({:id=>@my_model.id})
+        m = SomeModel::Archive.where({:id=>@my_model.id}).first
+        assert_equal "Crawford",m.last_name
+      end
+
+      should "not create duplicate entries when previously copied" do
+        SomeModel.copy_to_archive({:id=>@my_model.id},false)
+        SomeModel.where({:id=>@my_model.id}).first.update_attributes!(:first_name=>"Cindy",:last_name=>"Crawford")
+        SomeModel.copy_to_archive({:id=>@my_model.id})
+        assert_equal 1,SomeModel::Archive.all.size
+      end
+    end
+
+    context "when calling #delete on an existing record" do
+      setup do
+        @my_model = FactoryGirl.create(:some_model)
+        @my_model.delete
+      end
+
+      should "archive the record in question" do
+        assert SomeModel::Archive.exists?(@my_model.id)
+      end
+
+      should "remove the original record" do
+        assert !SomeModel.exists?(@my_model.id)
+      end
+
+      should "not change a model's id" do
+        @original = SomeModel.new
+        @original.id = 15
+        @original.first_name = "Clark"
+        @original.last_name = "Wayne"
+        @original.save
+        SomeModel.where(:id=>15).first.destroy
+        @archived = SomeModel::Archive.where(:id=>15)
+        assert_equal "Wayne",@archived.first.last_name
+      end
+    end
+    
+    context "when calling #delete! on an existing record" do
+      setup do
+        @my_model = FactoryGirl.create(:some_model)
+        @my_model.delete!
+      end
+
+      should "NOT archive the record in question" do
+        assert !SomeModel::Archive.exists?(@my_model.id)
+      end
+
+      should "remove the original record" do
+        assert !SomeModel.exists?(@my_model.id)
+      end
+    end
+
+    context "when calling delete on a new record" do
+      setup do
+        m = SomeModel.new(:first_name=>"Fabio",:last_name=>"Lanzoni")
+        m.delete
+      end
+
+      should "not archive the record" do
+        assert SomeModel::Archive.where(:first_name=>"Fabio").empty?
+      end
+    end
+
+    context "when calling destroy on an existing record" do
+      setup do
+        @my_model = FactoryGirl.create(:some_model)
+        @my_model.destroy
+      end
+
+      should "archive the record in question" do
+        assert SomeModel::Archive.exists?(@my_model.id)
+      end
+
+      should "remove the original record" do
+        assert !SomeModel.exists?(@my_model.id)
+      end
+    end
+    
+    context "when calling destroy! on an existing record" do
+      setup do
+        @my_model = FactoryGirl.create(:some_model)
+        @my_model.destroy!
+      end
+
+      should "NOT archive the record in question" do
+        assert !SomeModel::Archive.exists?(@my_model.id)
+      end
+
+      should "remove the original record" do
+        assert !SomeModel.exists?(@my_model.id)
+      end
+    end
+    
+    context "when calling delete_all without conditions" do
+      setup do
+        3.times do
+          FactoryGirl.create(:some_model)
+        end
+        @count = SomeModel.count
+        SomeModel.delete_all
+      end
+
+      should "empty the original table" do
+        assert SomeModel.all.empty?
+      end
+
+      should "fill the archive table" do
+        assert_equal @count,SomeModel::Archive.count
+      end
+    end
+    
+    context "when calling delete_all with conditions" do
+      setup do
+        @models = []
+        2.times do
+          @models << FactoryGirl.create(:some_model)
+        end
+        @mid = @models[1].id
+        SomeModel.delete_all(:id=>@mid)
+      end
+
+      should "leave non_matching items in table" do
+        assert_equal 1,SomeModel.all.size
+      end
+
+      should "remove matching items" do
+        assert SomeModel.where(:id=>@mid).empty?
+      end
+
+      should "fill the archive table" do
+        assert_equal 1,SomeModel::Archive.count
+      end
+    end
+    
+    context "when calling delete_all! without conditions" do
+      setup do
+        2.times do
+          FactoryGirl.create(:some_model)
+        end
+        SomeModel.delete_all!
+      end
+      
+      should "empty the original table" do
+        assert SomeModel.all.empty?
+      end
+      
+      should "NOT fill the archive table" do
+        assert SomeModel::Archive.all.empty?
+      end
+    end
+    
+    context "when calling delete_all! with conditions" do
+      setup do
+        @models = []
+        2.times do
+          @models << FactoryGirl.create(:some_model)
+        end
+        @mid = @models[1].id
+        SomeModel.delete_all!(:id=>@mid)
+      end
+
+      should "NOT fill the archive table" do
+        assert_equal 0,SomeModel::Archive.count
+      end
+    end
+
+    context "when restoring from the archive" do
+      setup do
+        @models = []
+        2.times do
+          @models << FactoryGirl.create(:some_model)
+        end
+        @mid = @models[1].id
+        SomeModel.delete_all
+      end
+
+      context "with conditions" do
+        setup do
+          @mod = SomeModel::Archive.where(:id=>@mid).first
+          SomeModel.copy_from_archive(:id=>@mid)
+        end
+
+        should "re-populate the original table" do
+          assert_equal 1,SomeModel.count
+        end
+
+        should "remove the archived record" do
+          assert SomeModel::Archive.where(:id=>@mid).empty?
+        end
+
+        should "restore with original id" do
+          assert_equal @mod.first_name,SomeModel.where(:id=>@mid).first.first_name
+        end
+      end
+
+      context "using restore_all" do
+        setup do
+          SomeModel.restore_all
+        end
+
+        should "repopulate the original table" do
+          assert_equal 2,SomeModel.count
+        end
+
+        should "empty the archive table" do
+          assert SomeModel::Archive.all.empty?
+        end
+      end
+    end
+  end
+end