permanent_records 2.3.0 → 3.0.0

data/Gemfile

@@ -1,9 +1,16 @@
-source 'http://rubygems.org'
+source 'https://rubygems.org'
 
-gem 'activerecord'
+gem 'activerecord', '> 3.0.0'
 
 group :development do
-  gem 'jeweler' # Because Bundler doesn't fucking have version:bump tasks
   gem 'rake'
+  gem 'pg'
+  gem 'activesupport'
   gem 'sqlite3'
 end
+
+group :test do
+  gem 'awesome_print'
+  gem 'rspec'
+  gem 'database_cleaner'
+end

data/Rakefile

@@ -1,28 +1,13 @@
-require 'rubygems'
-require 'rake'
+require 'bundler'
+Bundler::GemHelper.install_tasks
 
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "permanent_records"
-    gem.summary = %Q{Soft-delete your ActiveRecord records}
-    gem.description = %Q{Never Lose Data. Rather than deleting rows this sets Record#deleted_at and gives you all the scopes you need to work with your data.}
-    gem.email = "gems@6brand.com"
-    gem.homepage = "http://github.com/JackDanger/permanent_records"
-    gem.authors = ["Jack Danger Canty", "David Sulc"]
+namespace :db do
+  task :create do
+    `createdb permanent_records`
   end
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
 end
 
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.ruby_opts << '-rubygems'
-  test.pattern = 'test/*_test.rb'
-  test.verbose = true
+desc 'Run all tests'
+task :spec => 'db:create' do
+  exec 'rspec'
 end
-task :spec => :test
-
-task :default => :test
-

data/VERSION

@@ -1 +1 @@
-2.3.0
+3.0.0

data/lib/permanent_records.rb

@@ -1,245 +1,168 @@
 module PermanentRecords
+
   def self.included(base)
 
-    base.send :include, InstanceMethods
-
-    # Rails 3
-    if ActiveRecord::VERSION::MAJOR >= 3
-      base.extend Scopes
-      base.instance_eval { define_model_callbacks :revive }
-    # Rails 2.x.x
-    elsif base.respond_to?(:named_scope)
-      base.named_scope :deleted, :conditions => 'deleted_at IS NOT NULL'
-      base.named_scope :not_deleted, :conditions => { :deleted_at => nil }
-      base.instance_eval { define_callbacks :before_revive, :after_revive }
-      base.send :alias_method_chain, :destroy, :permanent_records
-    # Early Rails code
-    else
-      base.extend EarlyRails
-      base.instance_eval { define_callbacks :before_revive, :after_revive }
-    end
+    base.extend Scopes
+    base.extend IsPermanent
+
     base.instance_eval do
+      define_model_callbacks :revive
+
       before_revive :revive_destroyed_dependent_records
-      def is_permanent?
-        columns.detect {|c| 'deleted_at' == c.name}
-      end
     end
+
   end
-  
+
   module Scopes
     def deleted
-      where("#{table_name}.deleted_at IS NOT NULL")
+      where "#{table_name}.deleted_at IS NOT NULL"
     end
+
     def not_deleted
-      where("#{table_name}.deleted_at IS NULL")
+      where "#{table_name}.deleted_at IS NULL"
     end
   end
-  
-  module EarlyRails
-    def with_deleted
-      with_scope :find => {:conditions => "#{quoted_table_name}.deleted_at IS NOT NULL"} do
-        yield
-      end
-    end
-    
-    def with_not_deleted
-      with_scope :find => {:conditions => "#{quoted_table_name}.deleted_at IS NULL"} do
-        yield
-      end
+
+  module IsPermanent
+    def is_permanent?
+      columns.detect {|c| 'deleted_at' == c.name}
     end
-    
-    # this next bit is basically stolen from the scope_out plugin
-    [:deleted, :not_deleted].each do |name|
-      define_method "find_#{name}" do |*args|
-        send("with_#{name}") { find(*args) }
-      end
+  end
 
-      define_method "count_#{name}" do |*args|
-        send("with_#{name}") { count(*args) }
-      end
+  def is_permanent?
+    respond_to?(:deleted_at)
+  end
 
-      define_method "calculate_#{name}" do |*args|
-        send("with_#{name}") { calculate(*args) }
-      end
+  def deleted?
+    deleted_at if is_permanent?
+  end
 
-      define_method "find_all_#{name}" do |*args|
-        send("with_#{name}") { find(:all, *args) }
-      end
-    end
+  def revive
+    _run_revive_callbacks { set_deleted_at nil }
+    self
   end
 
-  module InstanceMethods
-    
-    def is_permanent?
-      respond_to?(:deleted_at)
+  def destroy(force = nil)
+    unless is_permanent? && (:force != force)
+      return permanently_delete_records_after { super() }
     end
-    
-    def deleted?
-      deleted_at if is_permanent?
+    destroy_with_permanent_records force
+  end
+
+  protected
+
+  def set_deleted_at(value)
+    return self unless is_permanent?
+    record = self.class.unscoped.find(id)
+    record.deleted_at = value
+    begin
+      # we call save! instead of update_attribute so an ActiveRecord::RecordInvalid
+      # error will be raised if the record isn't valid. (This prevents reviving records that
+      # disregard validation constraints,)
+      record.save!
+      @attributes, @attributes_cache = record.attributes, record.attributes
+    rescue Exception => e
+      # trigger dependent record destruction (they were revived before this record,
+      # which cannot be revived due to validations)
+      record.destroy
+      raise e
     end
+  end
 
-    def revive
-      if active_record_3?
-        _run_revive_callbacks do
-          set_deleted_at nil
-        end
-      else
-        run_callbacks :before_revive
-        attempt_notifying_observers(:before_revive)
-        set_deleted_at nil
-        run_callbacks :after_revive
-        attempt_notifying_observers(:after_revive)
-      end
-      self
+  def destroy_with_permanent_records(force = nil)
+    _run_destroy_callbacks do
+      deleted? || new_record? ? save : set_deleted_at(Time.now)
     end
+    self
+  end
 
-    def destroy(force = nil)
-      if active_record_3?
-        unless is_permanent? && (:force != force)
-          return permanently_delete_records_after{ super() }
+  def revive_destroyed_dependent_records
+    self.class.reflections.select do |name, reflection|
+      'destroy' == reflection.options[:dependent].to_s && reflection.klass.is_permanent?
+    end.each do |name, reflection|
+      cardinality = reflection.macro.to_s.gsub('has_', '')
+      if cardinality == 'many'
+        records = send(name).unscoped.find(
+          :all,
+          :conditions => [
+            "#{reflection.quoted_table_name}.deleted_at > ?" +
+            " AND " +
+            "#{reflection.quoted_table_name}.deleted_at < ?",
+            deleted_at - 3.seconds,
+            deleted_at + 3.seconds
+          ]
+        )
+      elsif cardinality == 'one' or cardinality == 'belongs_to'
+        self.class.unscoped do
+          records = [] << send(name)
         end
       end
-      destroy_with_permanent_records force
-    end
-    
-    private
-    def set_deleted_at(value)
-      return self unless is_permanent?
-      record = self.class
-      record = record.unscoped if active_record_3?
-      record = record.find(id)
-      record.deleted_at = value
-      begin
-        # we call save! instead of update_attribute so an ActiveRecord::RecordInvalid
-        # error will be raised if the record isn't valid. (This prevents reviving records that
-        # disregard validation constraints,)
-        record.save!
-        @attributes, @attributes_cache = record.attributes, record.attributes
-      rescue Exception => e
-        # trigger dependent record destruction (they were revived before this record,
-        # which cannot be revived due to validations)
-        record.destroy
-        raise e
+      [records].flatten.compact.each do |dependent|
+        dependent.revive
       end
+
+      # and update the reflection cache
+      send(name, :reload)
     end
+  end
 
-    def destroy_with_permanent_records(force = nil)
-      unless active_record_3?
-        unless is_permanent? && (:force != force)
-          return permanently_delete_records_after{ destroy_without_permanent_records }
-        end
-      end
-      if active_record_3?
-        _run_destroy_callbacks do
-          deleted? || new_record? ? save : set_deleted_at(Time.now)
-        end
-      else
-        run_callbacks :before_destroy
-        deleted? || new_record? ? save : set_deleted_at(Time.now)
-        run_callbacks :after_destroy
-      end
-      self
+  def attempt_notifying_observers(callback)
+    begin
+      notify_observers(callback)
+    rescue NoMethodError => e
+      # do nothing: this model isn't being observed
     end
+  end
 
-    def revive_destroyed_dependent_records
-      self.class.reflections.select do |name, reflection|
-        'destroy' == reflection.options[:dependent].to_s && reflection.klass.is_permanent?
-      end.each do |name, reflection|
-        cardinality = reflection.macro.to_s.gsub('has_', '')
-        if cardinality == 'many'
-          records = send(name)
-          records = records.unscoped if active_record_3?
-          records = records.find(:all,
-            :conditions => [
-              "#{reflection.quoted_table_name}.deleted_at > ?" +
-              " AND " +
-              "#{reflection.quoted_table_name}.deleted_at < ?",
-              deleted_at - 3.seconds,
-              deleted_at + 3.seconds
-            ]
-          )
-        elsif cardinality == 'one' or cardinality == 'belongs_to'
-          if active_record_3?
-            self.class.unscoped do
-              records = [] << send(name)
-            end
-          else
-            records = [] << send(name)
-          end
-        end
-        [records].flatten.compact.each do |dependent|
-          dependent.revive
-        end
+  # return the records corresponding to an association with the `:dependent => :destroy` option
+  def get_dependent_records
+    dependent_records = {}
 
-        # and update the reflection cache
-        send(name, :reload)
-      end
-    end
-    
-    def attempt_notifying_observers(callback)
-      begin
-        notify_observers(callback)
-      rescue NoMethodError => e
-        # do nothing: this model isn't being observed
-      end
-    end
-    
-    # return the records corresponding to an association with the `:dependent => :destroy` option
-    def get_dependent_records
-      dependent_records = {}
-      
-      # check which dependent records are to be destroyed
-      klass = self.class
-      klass.reflections.each do |key, reflection|
-        if reflection.options[:dependent] == :destroy
-          next unless records = self.send(key) # skip if there are no dependent record instances
-          if records.respond_to? :size
-            next unless records.size > 0 # skip if there are no dependent record instances
-          else
-            records = [] << records
-          end
-          dependent_record = records.first
-          next if dependent_record.nil?
-          dependent_records[dependent_record.class] = records.map(&:id)
+    # check which dependent records are to be destroyed
+    klass = self.class
+    klass.reflections.each do |key, reflection|
+      if reflection.options[:dependent] == :destroy
+        next unless records = self.send(key) # skip if there are no dependent record instances
+        if records.respond_to? :size
+          next unless records.size > 0 # skip if there are no dependent record instances
+        else
+          records = [] << records
         end
+        dependent_record = records.first
+        next if dependent_record.nil?
+        dependent_records[dependent_record.class] = records.map(&:id)
       end
-      dependent_records
-    end
-    
-    # If we force the destruction of the record, we will need to force the destruction of dependent records if the
-    # user specified `:dependent => :destroy` in the model.
-    # By default, the call to super/destroy_with_permanent_records (i.e. the &block param) will only soft delete 
-    # the dependent records; we keep track of the dependent records
-    # that have `:dependent => :destroy` and call destroy(force) on them after the call to super
-    def permanently_delete_records_after(&block)
-      dependent_records = get_dependent_records
-      result = block.call
-      if result
-        permanently_delete_records(dependent_records)
-      end
-      result
     end
-    
-    # permanently delete the records (i.e. remove from database)
-    def permanently_delete_records(dependent_records)
-      dependent_records.each do |klass, ids|
-        ids.each do |id|
-          begin
-            record = klass
-            record = record.unscoped if active_record_3?
-            record = record.find(id)
-          rescue ActiveRecord::RecordNotFound
-            next # the record has already been deleted, possibly due to another association with `:dependent => :destroy`
-          end
-          record.deleted_at = nil
-          record.destroy(:force)
+    dependent_records
+  end
+
+  # If we force the destruction of the record, we will need to force the destruction of dependent records if the
+  # user specified `:dependent => :destroy` in the model.
+  # By default, the call to super/destroy_with_permanent_records (i.e. the &block param) will only soft delete
+  # the dependent records; we keep track of the dependent records
+  # that have `:dependent => :destroy` and call destroy(force) on them after the call to super
+  def permanently_delete_records_after(&block)
+    dependent_records = get_dependent_records
+    result = block.call
+    if result
+      permanently_delete_records(dependent_records)
+    end
+    result
+  end
+
+  # permanently delete the records (i.e. remove from database)
+  def permanently_delete_records(dependent_records)
+    dependent_records.each do |klass, ids|
+      ids.each do |id|
+        record = begin
+          klass.unscoped.find id
+        rescue ActiveRecord::RecordNotFound
+          next # the record has already been deleted, possibly due to another association with `:dependent => :destroy`
         end
+        record.deleted_at = nil
+        record.destroy(:force)
       end
     end
-    
-    def active_record_3?
-      ActiveRecord::VERSION::MAJOR >= 3
-    end
   end
 end
 

data/permanent_records.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = "permanent_records"
-  s.version = "2.3.0"
+  s.version = File.read('VERSION')
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jack Danger Canty", "David Sulc"]
@@ -26,20 +26,20 @@ Gem::Specification.new do |s|
     "VERSION",
     "lib/permanent_records.rb",
     "permanent_records.gemspec",
-    "test/comment.rb",
-    "test/database.yml",
-    "test/difficulty.rb",
-    "test/dirt.rb",
-    "test/earthworm.rb",
-    "test/hole.rb",
-    "test/kitty.rb",
-    "test/location.rb",
-    "test/mole.rb",
-    "test/muskrat.rb",
-    "test/permanent_records_test.rb",
-    "test/schema.rb",
-    "test/test_helper.rb",
-    "test/unused_model.rb"
+    "spec/spec_helper.rb",
+    "spec/permanent_records_spec.rb",
+    "spec/support/comment.rb",
+    "spec/support/database.yml",
+    "spec/support/difficulty.rb",
+    "spec/support/dirt.rb",
+    "spec/support/earthworm.rb",
+    "spec/support/hole.rb",
+    "spec/support/kitty.rb",
+    "spec/support/location.rb",
+    "spec/support/mole.rb",
+    "spec/support/muskrat.rb",
+    "spec/support/schema.rb",
+    "spec/support/unused_model.rb"
   ]
   s.homepage = "http://github.com/JackDanger/permanent_records"
   s.require_paths = ["lib"]

data/spec/permanent_records_spec.rb

@@ -0,0 +1,212 @@
+require 'spec_helper'
+
+describe PermanentRecords do
+
+  let!(:frozen_moment) { Time.now                            }
+  let!(:dirt)          { Dirt.create!                        }
+  let!(:earthworm)     { dirt.create_earthworm               }
+  let!(:hole)          { dirt.create_hole                    }
+  let!(:muskrat)       { hole.muskrats.create!               }
+  let!(:mole)          { hole.moles.create!                  }
+  let!(:location)      { hole.create_location                }
+  let!(:difficulty)    { hole.create_difficulty              }
+  let!(:comments)      { 2.times.map {hole.comments.create!} }
+  let!(:kitty)         { Kitty.create!                       }
+
+
+  describe '#destroy' do
+
+    let(:record)       { hole    }
+    let(:should_force) { false   }
+
+    subject { record.destroy should_force }
+
+    it 'returns the record' do
+      subject.should == record
+    end
+
+    it 'makes deleted? return true' do
+      subject.should be_deleted
+    end
+
+    it 'sets the deleted_at attribute' do
+      subject.deleted_at.should be_within(0.1).of(Time.now)
+    end
+
+    it 'does not really remove the record' do
+      expect { subject }.to_not change { record.class.count }
+    end
+
+    context 'with force argument set to truthy' do
+      let(:should_force) { :force }
+
+      it 'does really remove the record' do
+        expect { subject }.to change { record.class.count }.by(-1)
+      end
+    end
+
+    context 'when model has no deleted_at column' do
+      let(:record) { kitty }
+
+      it 'really removes the record' do
+        expect { subject }.to change { record.class.count }.by(-1)
+      end
+    end
+
+    context 'with dependent records' do
+      context 'that are permanent' do
+        it '' do
+          expect { subject }.to_not change { Muskrat.count }
+        end
+
+        context 'with has_many cardinality' do
+          it 'marks records as deleted' do
+            subject.muskrats.each {|m| m.should be_deleted }
+          end
+          context 'with force delete' do
+            let(:should_force) { :force }
+            it('') { expect { subject }.to change { Muskrat.count }.by(-1) }
+            it('') { expect { subject }.to change { Comment.count }.by(-2) }
+          end
+        end
+
+        context 'with has_one cardinality' do
+          it 'marks records as deleted' do
+            subject.location.should be_deleted
+          end
+          context 'with force delete' do
+            let(:should_force) { :force }
+            it('') { expect { subject }.to change { Muskrat.count  }.by(-1) }
+            it('') { expect { subject }.to change { Location.count }.by(-1) }
+          end
+        end
+      end
+      context 'that are non-permanent' do
+        it 'removes them' do
+          expect { subject }.to change { Mole.count }.by(-1)
+        end
+      end
+      context 'as default scope' do
+        context 'with :has_many cardinality' do
+          its('comments.size') { should == 2 }
+          it 'deletes them' do
+            subject.comments.each {|c| c.should be_deleted }
+            subject.comments.each {|c| Comment.find_by_id(c.id).should be_nil }
+          end
+        end
+        context 'with :has_one cardinality' do
+          it 'deletes them' do
+            subject.difficulty.should be_deleted
+            Difficulty.find_by_id(subject.difficulty.id).should be_nil
+          end
+        end
+      end
+    end
+  end
+
+  describe '#revive' do
+
+    let!(:record) { hole.destroy }
+
+    subject { record.revive }
+
+    it 'returns the record' do
+      subject.should == record
+    end
+
+    it 'unsets deleted_at' do
+      expect { subject }.to change {
+        record.deleted_at
+      }.to(nil)
+    end
+
+    it 'makes deleted? return false' do
+      subject.should_not be_deleted
+    end
+
+    context 'when validations fail' do
+      before {
+        Hole.any_instance.stub(:valid?).and_return(false)
+      }
+      it 'raises' do
+        expect { subject }.to raise_error(ActiveRecord::RecordInvalid)
+      end
+    end
+
+    context 'with dependent records' do
+      context 'that are permanent' do
+        it '' do
+          expect { subject }.to_not change { Muskrat.count }
+        end
+
+        context 'that were deleted previously' do
+          before { muskrat.update_attributes! :deleted_at => 2.minutes.ago }
+          it 'does not restore' do
+            expect { subject }.to_not change { muskrat.deleted? }
+          end
+        end
+
+        context 'with has_many cardinality' do
+          it 'revives them' do
+            subject.muskrats.each {|m| m.should_not be_deleted }
+          end
+        end
+
+        context 'with has_one cardinality' do
+          it 'revives them' do
+            subject.location.should_not be_deleted
+          end
+        end
+      end
+      context 'that are non-permanent' do
+        it 'cannot revive them' do
+          expect { subject }.to_not change { Mole.count }
+        end
+      end
+      context 'as default scope' do
+        context 'with :has_many cardinality' do
+          its('comments.size') { should == 2 }
+          it 'revives them' do
+            subject.comments.each {|c| c.should_not be_deleted }
+            subject.comments.each {|c| Comment.find_by_id(c.id).should == c }
+          end
+        end
+        context 'with :has_one cardinality' do
+          it 'revives them' do
+            subject.difficulty.should_not be_deleted
+            Difficulty.find_by_id(subject.difficulty.id).should == difficulty
+          end
+        end
+      end
+    end
+  end
+
+  describe 'scopes' do
+
+    before {
+      3.times { Muskrat.create! }
+      6.times { Muskrat.create!.destroy }
+    }
+
+    context '.not_deleted' do
+
+      it 'counts' do
+        Muskrat.not_deleted.count.should == Muskrat.all.reject(&:deleted?).size
+      end
+
+      it 'has no deleted records' do
+        Muskrat.not_deleted.each {|m| m.should_not be_deleted }
+      end
+    end
+
+    context '.deleted' do
+      it 'counts' do
+        Muskrat.deleted.count.should == Muskrat.all.select(&:deleted?).size
+      end
+
+      it 'has no non-deleted records' do
+        Muskrat.deleted.each {|m| m.should be_deleted }
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,48 @@
+
+# Include this file in your test by copying the following line to your test:
+#   require File.expand_path(File.dirname(__FILE__) + "/test_helper")
+
+lib     = Pathname.new File.expand_path('../../lib',       File.dirname(__FILE__))
+support = Pathname.new File.expand_path('../spec/support', File.dirname(__FILE__))
+$:.unshift lib
+$:.unshift support
+RAILS_ROOT = File.dirname(__FILE__)
+
+require 'active_record'
+require 'active_support'
+require 'permanent_records'
+require 'awesome_print'
+
+module Rails
+  def self.env; 'test'end
+end
+
+require 'logger'
+ActiveRecord::Base.logger = Logger.new support.join("debug.log")
+ActiveRecord::Base.configurations = YAML::load_file support.join('database.yml')
+ActiveRecord::Base.establish_connection
+
+load 'schema.rb' if File.exist?(support.join('schema.rb'))
+
+Dir.glob(support.join('*.rb')).each do |file|
+  autoload File.basename(file).chomp('.rb').camelcase.intern, file
+end.each do |file|
+  require file
+end
+
+require 'database_cleaner'
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+end

data/{test → spec/support}/comment.rb

@@ -1,6 +1,6 @@
 class Comment < ActiveRecord::Base
   belongs_to :hole
-  
+
   if ActiveRecord::VERSION::MAJOR >= 3
     default_scope where(:deleted_at => nil)
   else

data/spec/support/database.yml

@@ -0,0 +1,16 @@
+test:
+  :adapter: postgresql
+  :database: permanent_records
+  :min_messages: ERROR
+# sqlite:
+#   :adapter: sqlite
+#   :database: plugin.sqlite.db
+# sqlite3:
+#   :adapter: sqlite3
+#   :database: ":memory:"
+# mysql:
+#   :adapter: mysql
+#   :host: localhost
+#   :username: rails
+#   :password:
+#   :database: plugin_test

data/spec/support/difficulty.rb

@@ -0,0 +1,5 @@
+class Difficulty < ActiveRecord::Base
+  belongs_to :hole
+
+  default_scope where(:deleted_at => nil)
+end

data/{test → spec/support}/earthworm.rb

@@ -1,11 +1,11 @@
 class Earthworm < ActiveRecord::Base
   belongs_to :dirt
-  
+
   # Earthworms have been known to complain if they're left on their deathbeds without any dirt
   before_destroy :complain!
-  
+
   def complain!
     raise "Where's my dirt?!" if Dirt.not_deleted.find(self.dirt_id).nil?
   end
-  
+
 end

data/{test → spec/support}/hole.rb

@@ -1,14 +1,14 @@
 class Hole < ActiveRecord::Base
   # Because when we're destroying a mole hole we're obviously using high explosives.
   belongs_to :dirt, :dependent => :destroy
-  
+
   # muskrats are permanent
   has_many :muskrats, :dependent => :destroy
   # moles are not permanent
   has_many :moles, :dependent => :destroy
-  
+
   has_one :location, :dependent => :destroy
   has_one :unused_model, :dependent => :destroy
   has_one :difficulty, :dependent => :destroy
   has_many :comments, :dependent => :destroy
-end
+end

data/{test → spec/support}/location.rb

@@ -1,5 +1,5 @@
 class Location < ActiveRecord::Base
   belongs_to :hole
-  
+
   validates_uniqueness_of :name, :scope => :deleted_at
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: permanent_records
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 3.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-07 00:00:00.000000000 Z
+date: 2012-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -94,20 +94,20 @@ files:
 - VERSION
 - lib/permanent_records.rb
 - permanent_records.gemspec
-- test/comment.rb
-- test/database.yml
-- test/difficulty.rb
-- test/dirt.rb
-- test/earthworm.rb
-- test/hole.rb
-- test/kitty.rb
-- test/location.rb
-- test/mole.rb
-- test/muskrat.rb
-- test/permanent_records_test.rb
-- test/schema.rb
-- test/test_helper.rb
-- test/unused_model.rb
+- spec/spec_helper.rb
+- spec/permanent_records_spec.rb
+- spec/support/comment.rb
+- spec/support/database.yml
+- spec/support/difficulty.rb
+- spec/support/dirt.rb
+- spec/support/earthworm.rb
+- spec/support/hole.rb
+- spec/support/kitty.rb
+- spec/support/location.rb
+- spec/support/mole.rb
+- spec/support/muskrat.rb
+- spec/support/schema.rb
+- spec/support/unused_model.rb
 homepage: http://github.com/JackDanger/permanent_records
 licenses: []
 post_install_message: 
@@ -122,7 +122,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2829435595636432217
+      hash: 1142090409982771536
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:

data/test/database.yml

@@ -1,18 +0,0 @@
-sqlite:
-  :adapter: sqlite
-  :database: plugin.sqlite.db
-sqlite3:
-  :adapter: sqlite3
-  :database: ":memory:"
-postgresql:
-  :adapter: postgresql
-  :username: postgres
-  :password: postgres
-  :database: plugin_test
-  :min_messages: ERROR
-mysql:
-  :adapter: mysql
-  :host: localhost
-  :username: rails
-  :password:
-  :database: plugin_test

data/test/difficulty.rb

@@ -1,11 +0,0 @@
-class Difficulty < ActiveRecord::Base
-  belongs_to :hole
-  
-  if ActiveRecord::VERSION::MAJOR >= 3
-    default_scope where(:deleted_at => nil)
-  else
-    def self.unscoped
-      self
-    end
-  end
-end

data/test/permanent_records_test.rb

@@ -1,270 +0,0 @@
-# note: functionality to deal with default scopes (and the `unscoped` scope) has been added (and will be tested) for Rails 3
-# this default scope functionality is skipped for Rails 2, because Rails 2 provides no functional means of altering the default scope
-# in particular, setting the default scope in Rails 3 to ignore soft deleted records will work properly, whereas in Rails 2, it will
-# lead to a world of pain
-
-require File.expand_path(File.dirname(__FILE__) + "/test_helper")
-
-%w(earthworm dirt hole mole muskrat kitty location comment difficulty unused_model).each do |a|
-  require File.expand_path(File.dirname(__FILE__) + "/" + a)
-end
-
-class PermanentRecordsTest < ActiveSupport::TestCase
-
-  def setup
-    super
-    Muskrat.delete_all
-    @active = Muskrat.create!(:name => 'Wakko')
-    @deleted = Muskrat.create!(:name => 'Yakko', :deleted_at => 4.days.ago)
-    @the_girl   = Muskrat.create!(:name => 'Dot')
-    Kitty.delete_all
-    @kitty = Kitty.create!(:name => 'Meow Meow')
-    @dirt = Dirt.create!(:color => 'Brown')
-    @hole = Hole.create(:number => 14, :dirt => @dirt)
-    @hole.muskrats.create(:name => "Active Muskrat")
-    @hole.muskrats.create(:name => "Deleted Muskrat", :deleted_at => 5.days.ago)
-    Location.delete_all
-    @location = Location.create(:name => "South wall")
-    @hole.location = @location
-    @hole.save!
-    @mole = @hole.moles.create(:name => "Grabowski")
-
-    if ActiveRecord::VERSION::MAJOR >= 3
-      Difficulty.unscoped.delete_all
-      Comment.unscoped.delete_all
-    else
-      Difficulty.delete_all
-      Comment.delete_all
-    end
-    # test has_one cardinality with model having a default scope
-    @hole_with_difficulty = Hole.create(:number => 16)
-    @hole_with_difficulty.difficulty = Difficulty.create!(:name => 'Hard')
-    @hole_with_difficulty.save!
-
-    # test has_many cardinality with model having a default scope
-    @hole_with_comments = Hole.create(:number => 16)
-    @hole_with_comments.comments << Comment.create!(:text => "Beware of the pond.")
-    @hole_with_comments.comments << Comment.create!(:text => "Muskrats live here.")
-  end
-
-  def teardown
-    setup
-  end
-
-  def test_destroy_should_return_the_record
-    muskrat = @active
-    assert_equal muskrat, muskrat.destroy
-  end
-
-  def test_revive_should_return_the_record
-    muskrat = @deleted
-    assert_equal muskrat, muskrat.revive
-  end
-
-  def test_destroy_should_set_deleted_at_attribute
-    assert @active.destroy.deleted_at
-  end
-
-  def test_destroy_should_save_deleted_at_attribute
-    assert Muskrat.find(@active.destroy.id).deleted_at
-  end
-
-  def test_destroy_should_not_really_remove_the_record
-    assert Muskrat.find(@active.destroy.id)
-  end
-
-  def test_destroy_should_recognize_a_force_parameter
-    assert_raises(ActiveRecord::RecordNotFound) { @active.destroy(:force).reload }
-  end
-
-  def test_destroy_should_ignore_other_parameters
-    assert Muskrat.find(@active.destroy(:hula_dancer).id)
-  end
-
-  def test_revive_should_unfreeze_record
-    assert !@deleted.revive.frozen?
-  end
-
-  def test_revive_should_unset_deleted_at
-    assert !@deleted.revive.deleted_at
-  end
-
-  def test_revive_should_make_deleted_return_false
-    assert !@deleted.revive.deleted?
-  end
-
-  def test_deleted_returns_true_for_deleted_records
-    assert @deleted.deleted?
-  end
-
-  def test_destroy_returns_record_with_modified_attributes
-    assert @active.destroy.deleted?
-  end
-
-  def test_revive_and_destroy_should_be_chainable
-    assert @active.destroy.revive.destroy.destroy.revive.revive.destroy.deleted?
-    assert !@deleted.destroy.revive.revive.destroy.destroy.revive.deleted?
-  end
-
-  def test_with_counting_on_deleted_limits_scope_to_count_deleted_records
-    assert_equal Muskrat.deleted.length,
-                 Muskrat.deleted.count
-  end
-
-  def test_with_counting_on_not_deleted_limits_scope_to_count_not_deleted_records
-    assert_equal Muskrat.not_deleted.length,
-                 Muskrat.not_deleted.count
-  end
-
-  def test_with_deleted_limits_scope_to_deleted_records
-    assert Muskrat.deleted.all?(&:deleted?)
-  end
-
-  def test_with_not_deleted_limits_scope_to_not_deleted_records
-    assert !Muskrat.not_deleted.any?(&:deleted?)
-  end
-
-  def test_models_without_a_deleted_at_column_should_destroy_as_normal
-    assert_raises(ActiveRecord::RecordNotFound) {@kitty.destroy.reload}
-  end
-
-  def test_dependent_non_permanent_records_should_be_destroyed
-    assert @hole.is_permanent?
-    assert !@hole.moles.first.is_permanent?
-    assert_difference "Mole.count", -1 do
-      @hole.destroy
-    end
-  end
-
-  def test_dependent_permanent_records_with_has_many_cardinality_should_be_marked_as_deleted
-    assert @hole.is_permanent?
-    assert @hole.muskrats.first.is_permanent?
-    assert_no_difference "Muskrat.count" do
-      @hole.destroy
-    end
-
-    @hole.reload
-    assert @hole.muskrats.first.deleted?
-  end
-
-  def test_dependent_permanent_records_with_has_one_cardinality_should_be_marked_as_deleted
-    assert @hole.is_permanent?
-    assert @hole.location.is_permanent?
-    assert_no_difference "Location.count" do
-      @hole.destroy
-    end
-    assert @hole.location.deleted?
-    assert Location.find_by_name("South wall").deleted?
-  end
-
-  def test_dependent_permanent_records_with_has_many_cardinality_should_be_revived_when_parent_is_revived
-    assert @hole.is_permanent?
-    @hole.destroy
-    assert @dirt.deleted?
-    assert @hole.muskrats.find_by_name("Active Muskrat").deleted?
-    @hole.revive
-    assert !@hole.muskrats.find_by_name("Active Muskrat").deleted?
-    assert !@dirt.deleted?
-  end
-
-  def test_dependent_permanent_records_with_has_one_cardinality_should_be_revived_when_parent_is_revived
-    assert @hole.is_permanent?
-    @hole.destroy
-    assert Location.find_by_name("South wall").deleted?
-    @hole.revive
-    assert !Location.find_by_name("South wall").deleted?
-  end
-
-  def test_before_callbacks_for_dependent_records_fire_before_destroy_occurs
-    @earthworm = Earthworm.create(:dirt => @dirt)
-
-    assert_nothing_raised do
-      @hole.destroy
-    end
-  end
-
-  # see comment at top of file for reasoning behind conditional testing of default scope
-  if ActiveRecord::VERSION::MAJOR >= 3
-    def test_dependent_permanent_records_with_has_one_cardinality_and_default_scope_should_be_revived_when_parent_is_revived
-      assert @hole_with_difficulty.is_permanent?
-      assert_difference("Difficulty.count", -1) do
-        @hole_with_difficulty.destroy
-      end
-      assert_nil Difficulty.find_by_name("Hard")
-      assert Difficulty.unscoped.find_by_name("Hard").deleted?
-      @hole_with_difficulty.revive
-      assert_not_nil Difficulty.find_by_name("Hard")
-      assert !Difficulty.unscoped.find_by_name("Hard").deleted?
-    end
-
-    def test_dependent_permanent_records_with_has_many_cardinality_and_default_scope_should_be_revived_when_parent_is_revived
-      assert @hole_with_comments.is_permanent?
-      assert_difference("Comment.count", -2) do
-        @hole_with_comments.destroy
-      end
-      assert_nil Comment.find_by_text("Beware of the pond.")
-      assert Comment.unscoped.find_by_text("Beware of the pond.").deleted?
-      @hole_with_comments.revive
-      assert_not_nil Comment.find_by_text("Beware of the pond.")
-      assert !Comment.unscoped.find_by_text("Beware of the pond.").deleted?
-    end
-  end
-
-  def test_inexistent_dependent_models_should_not_cause_errors
-    hole_with_unused_model = Hole.create!(:number => 1)
-    hole_with_unused_model.destroy
-    assert_nothing_raised do
-      hole_with_unused_model.revive
-    end
-  end
-
-  def test_old_dependent_permanent_records_should_not_be_revived
-    assert @hole.is_permanent?
-    @hole.destroy
-    assert @hole.muskrats.find_by_name("Deleted Muskrat").deleted?
-    @hole.revive
-    assert @hole.muskrats.find_by_name("Deleted Muskrat").deleted?
-  end
-
-  def test_validate_records_before_revival
-    duplicate_location = Location.new(@location.attributes)
-    @location.destroy
-    @location.reload
-    duplicate_location.save!
-    assert_equal duplicate_location.name, @location.name
-    assert_no_difference('Location.not_deleted.count') do
-      assert_raise (ActiveRecord::RecordInvalid) do
-        @location.revive
-      end
-    end
-  end
-
-  def test_force_deleting_a_record_with_has_one_force_deletes_dependent_records
-    hole = Hole.create(:number => 1)
-    location = Location.create(:name => "Near the clubhouse")
-    hole.location = location
-    hole.save!
-
-    assert_difference(monitor_for('Hole'), -1) do
-      assert_difference(monitor_for('Location'), -1) do
-        hole.destroy(:force)
-      end
-    end
-  end
-
-  def test_force_deleting_a_record_with_has_many_force_deletes_dependent_records
-    assert_difference(monitor_for('Hole'), -1) do
-      assert_difference(monitor_for('Comment'), -2) do
-        @hole_with_comments.destroy(:force)
-      end
-    end
-  end
-
-  def test_force_deletign_with_multiple_associations
-    assert_difference(monitor_for('Muskrat'), -2) do
-      assert_difference(monitor_for('Mole'), -1) do
-        @hole.destroy(:force)
-      end
-    end
-  end
-end

data/test/test_helper.rb

@@ -1,46 +0,0 @@
-# Include this file in your test by copying the following line to your test:
-#   require File.expand_path(File.dirname(__FILE__) + "/test_helper")
-
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-RAILS_ROOT = File.dirname(__FILE__)
-
-require 'rubygems'
-require 'test/unit'
-require 'active_record'
-require 'active_record/fixtures'
-require File.expand_path(File.dirname(__FILE__) + '/../lib/permanent_records')
-
-require File.expand_path(File.dirname(__FILE__) + "/muskrat")
-
-config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
-ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
-ActiveRecord::Base.establish_connection(config[ENV['DB'] || 'sqlite3'])
-
-load(File.dirname(__FILE__) + "/schema.rb") if File.exist?(File.dirname(__FILE__) + "/schema.rb")
-
-class ActiveSupport::TestCase #:nodoc:
-  include ActiveRecord::TestFixtures
-  # def create_fixtures(*table_names)
-  #   if block_given?
-  #     Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names) { yield }
-  #   else
-  #     Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names)
-  #   end
-  # end
-
-  self.fixture_path = File.dirname(__FILE__) + "/fixtures/"
-  $LOAD_PATH.unshift(fixture_path)
-
-  # Turn off transactional fixtures if you're working with MyISAM tables in MySQL
-  self.use_transactional_fixtures = true
-
-  # Instantiated fixtures are slow, but give you @david where you otherwise would need people(:david)
-  self.use_instantiated_fixtures  = false
-
-  # Add more helper methods to be used by all tests here...
-  def monitor_for(class_name)
-    result = class_name
-    result += '.unscoped' if ActiveRecord::VERSION::MAJOR >= 3
-    result += '.count'
-  end
-end