ryanlowe-acts_as_indestructible 0.1.1

data/CHANGELOG

@@ -0,0 +1,40 @@
+
+== 0.1.1
+
+May 26
+= test destroy_all with conditions
+
+== 0.1.0
+
+May 26
+= add GitHub gemspec file
+
+May 23
+= divide the unit tests into subdirectories
+= support find by id
+
+May 22
+= support for exists? and with :include_destroy option
+
+May 15
+= destroy and destroy_all: check that user is not nil and has an id method
+= require user parameter for destroy and destroy_all methods
+= prefix test models with Indestructible to avoid name collisions with popular model names
+
+May 14
+= add options_excluding_deleted protected method
+
+May 2
+= don't allow self methods delete or delete_all to be called
+= test destroy_all
+= don't destroy if already destroyed
+= naively implement destroy instance method
+= add Comment model
+
+May 1 2008
+= implement destroyed? instance method
+= acts_as_indestructible declaration working
+= add Post model
+= add partial Rails skeleton to help with testing
+= basic plugin project skeleton
+= started project

data/MIT-LICENSE

@@ -0,0 +1,49 @@
+Copyright (c) 2008 Ryan Lowe
+
+http://ryanlowe.ca
+http://disruptiveagility.com
+
+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.
+
+===
+
+Based on ideas from acts_as_paranoid
+http://rubyforge.org/projects/ar-paranoid/
+
+Copyright (c) 2005 Rick Olson
+
+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

@@ -0,0 +1,59 @@
+IMPORTANT: This plugin is a work in progress and should not be used in production
+yet.  Feel free to fork on GitHub and send patches.
+
+If you would like to see your patch in this Git repository it must be tested.
+If you find a bug, a test exposing the bug would be great.
+
+= acts_as_indestructible
+
+  acts_as_indestructible aims to be an alternate version
+  of the acts_as_paranoid plugin idea, which is to mark ActiveRecord objects
+  as destroyed instead of actually deleting them from the database.
+  
+  After an object is marked as destroyed it should be excluded from
+  all of the ActiveRecord method calls and act as if it
+  was deleted from the database.
+  
+= Differences from acts_as_paranoid
+
+  1. acts_as_indestructible fills the destroyed_at field as well
+     as destroyed_by
+
+  2. destroy() and destroy_all(conditions=nil) have a
+     user parameter, making them destroy(user) and
+     destroy_all(user,conditions=nil).  The user
+     parameter is an ActiveRecord user object and
+     the user.id is stored in the destroyed_by column.
+  
+  3. acts_as_paranoid overrides protected and private
+     ActiveRecord::Base methods which could change at any time.
+     acts_as_indestructible will work to provide the
+     same function while using the public API contract that
+     will not change within major Rails versions.
+    
+  4. delete() and delete_all() throw exceptions and are effectively
+     deprecated, which prevents developers from permanently deleting
+     objects this way.  Raw SQL could still delete objects permanently.
+     
+     
+= API changes from ActiveRecord::Base
+
+  destroy(user)
+  destroy_all(user, conditions = nil)
+  
+  exists?(id_or_conditions, options = {})
+  
+  DEPRECATED:
+  
+    ActiveRecord::Base.delete(id)
+    ActiveRecord::Base.delete_all
+    
+     
+= Major plugin goals
+
+  - test all corner cases of the ActiveRecord methods affected by this plugin
+  - not impact performance, when possible
+  - play well with other major plugins
+  
+  Also see TODO for specific things left to do
+

data/Rakefile

@@ -0,0 +1,10 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require(File.join(File.dirname(__FILE__), 'config', 'boot'))
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+require 'tasks/rails'

data/acts_as_indestructible.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name = "acts_as_indestructible"
+  s.version = "0.1.1"
+  s.date = "2008-05-26"
+  s.summary = "Mark objects as destroyed instead of deleting them from the database for Ruby on Rails ActiveRecord"
+  s.email = "rails@ryanlowe.ca"
+  s.homepage = "http://github.com/ryanlowe/acts_as_indestructible"
+  s.description = "Mark objects as destroyed instead of deleting them from the database for Ruby on Rails ActiveRecord"
+  s.has_rdoc = false
+  s.authors = ["Ryan Lowe"]
+  s.files = ["README", "CHANGELOG", "MIT-LICENSE", "Rakefile", "acts_as_indestructible.gemspec", "init.rb",
+    "lib/acts_as_indestructible.rb","lib/fixture.rb"]
+  s.test_files = []
+  s.rdoc_options = ["--main", "README"]
+  s.extra_rdoc_files = ["README","CHANGELOG"]
+  s.add_dependency("rails", ["> 2.0.0"])
+end

data/init.rb

@@ -0,0 +1,3 @@
+require 'acts_as_indestructible'
+require 'fixture'
+ActiveRecord::Base.send(:include, ActiveRecord::Acts::Indestructible)

data/lib/acts_as_indestructible.rb

@@ -0,0 +1,120 @@
+module ActiveRecord #:nodoc:
+  
+  class Base
+    #TODO: there must be a better place to put this
+    alias_method :super_reload, :reload
+  end
+  
+  module Acts #:nodoc:
+    module Indestructible #:nodoc:
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+        class << base
+          alias_method :super_calculate, :calculate
+          alias_method :super_exists?,   :exists?
+          alias_method :super_find,      :find
+        end
+      end
+      
+      module ClassMethods
+        
+        def acts_as_indestructible(options = {})
+          extend ActiveRecord::Acts::Indestructible::SingletonMethods
+          include ActiveRecord::Acts::Indestructible::InstanceMethods
+        end
+        
+      end
+      
+      module SingletonMethods
+        
+        def destroy_all(user, conditions = nil)
+          find(:all, :conditions => conditions).each { |object| object.destroy(user) }
+        end
+        
+        def delete(id)
+          raise "Is not allowed"
+        end
+        
+        def delete_all(conditions = nil)
+          raise "Is not allowed"
+        end
+        
+        def calculate(operation, column_name, options = {})
+          super_calculate(operation, column_name, options_excluding_destroyed(options))
+        end
+        
+        def exists?(id_or_conditions, options = {})
+          include_destroyed = options[:include_destroyed]
+          if id_or_conditions.is_a?(Hash)
+            include_destroyed = id_or_conditions[:include_destroyed]
+            id_or_conditions.delete :include_destroyed
+          end
+          options = {}
+          options[:select]            = "#{quoted_table_name}.#{primary_key}"
+          options[:conditions]        = expand_id_conditions(id_or_conditions) # private method; possibly fragile
+          options[:include_destroyed] = include_destroyed          
+          !find(:first, options).nil?
+        end
+        
+        def find(*args)
+          options = args.extract_options!
+          include_destroyed = options[:include_destroyed]
+          return super_find(*args) if include_destroyed # revert to normal behaviour
+          options.delete :include_destroyed
+          args << options_excluding_destroyed(options)
+          super_find(*args)
+        end
+        
+        #protected
+        
+          # if they are protected class methods they cannot be unit tested? :(
+        
+          def destroyed_condition
+            "#{quoted_table_name}.destroyed_at IS NULL"
+          end
+        
+          def options_excluding_destroyed(options)
+            options = Hash.new if options.nil?
+            if options.has_key?(:conditions) and !options[:conditions].nil?
+              case options[:conditions]
+                when Array
+                  options[:conditions][0] = destroyed_condition+" AND "+options[:conditions][0]
+                when Hash
+                  options[:conditions][:destroyed_at] = nil
+              else
+                options[:conditions] = destroyed_condition+" AND "+options[:conditions]
+              end
+            else
+              options[:conditions] = destroyed_condition
+            end
+            options
+          end
+          
+      end
+      
+      module InstanceMethods
+        
+        def destroyed?
+          !self[:destroyed_at].nil?
+        end
+        
+        def destroy(user)
+          return if user.nil? or !user.is_a? ActiveRecord::Base # ...more conditions?
+          return if destroyed?
+          self[:destroyed_at] = Time.now
+          self[:destroyed_by] = user.id
+          save
+        end
+        
+        def reload(options = nil)
+          options = {} if options.nil?
+          options[:include_destroyed] = true
+          super_reload(options)
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/fixture.rb

@@ -0,0 +1,17 @@
+class Fixture
+  
+  #TODO: this is fragile
+  def find
+    klass = @class_name.is_a?(Class) ? @class_name : Object.const_get(@class_name) rescue nil
+    if klass
+      if klass.respond_to? :destroyed_condition
+        klass.find(self[klass.primary_key], :include_destroyed => true)
+      else # bad workaround! before the framework is loaded
+        klass.find(self[klass.primary_key])
+      end
+    else
+      raise FixtureClassNotFound, "The class #{@class_name.inspect} was not found."
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: ryanlowe-acts_as_indestructible
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Ryan Lowe
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-05-26 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+    version: 
+description: Mark objects as destroyed instead of deleting them from the database for Ruby on Rails ActiveRecord
+email: rails@ryanlowe.ca
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- CHANGELOG
+files: 
+- README
+- CHANGELOG
+- MIT-LICENSE
+- Rakefile
+- acts_as_indestructible.gemspec
+- init.rb
+- lib/acts_as_indestructible.rb
+- lib/fixture.rb
+has_rdoc: false
+homepage: http://github.com/ryanlowe/acts_as_indestructible
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+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.0.1
+signing_key: 
+specification_version: 2
+summary: Mark objects as destroyed instead of deleting them from the database for Ruby on Rails ActiveRecord
+test_files: []
+