deactivatable 0.0.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Greg Fitzgerald
+
+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.rdoc

@@ -0,0 +1,21 @@
+= deactivatable
+
+Deactivatable provides methods and a default_scope to allow ActiveRecord objects to be deactivated instead of deleted.
+This is useful if an object needs to be removed from general use, but it's data needs to be retained.
+Additionally, Deactivatable provides the ability to specify dependencies which also need to be deactivated.
+Deactivation is determined by populating a deactivated_at field with the date time at which deactivation happened.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 Greg Fitzgerald. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,62 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "deactivatable"
+    gem.summary = %Q{Adds methods and scopes to ActiveRecord objects to allow deactivation instead of deletion.}
+    gem.description = %Q{Deactivatable provides methods and a default_scope to allow ActiveRecord objects to be deactivated instead of deleted.
+      This is useful if an object needs to be removed from general use, but it's data needs to be retained.
+      Additionally, Deactivatable provides the ability to specify dependencies which also need to be deactivated.
+      Deactivation is determined by populating a deactivated_at field with the date time at which deactivation happened.
+    }
+    gem.email = "greg_fitz@yahoo.com"
+    gem.homepage = "http://github.com/gregfitz23/deactivatable"
+    gem.authors = ["Greg Fitzgerald"]
+    gem.add_dependency "activerecord", ">= 2.3"
+    gem.add_development_dependency "thoughtbot-shoulda"
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  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.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "deactivatable #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/deactivatable.rb

@@ -0,0 +1,118 @@
+module ActiveRecord
+  module Acts
+    module Deactivatable
+    
+      def self.append_features(base) #:nodoc:
+        super
+        base.extend(Definition)  
+      end
+      
+      module Definition
+        # Define the calling class as being deactivatable.  
+        # A call to this will set the default scope of the object to look for deactivated_at = nil.
+        # Options
+        #   *:dependencies* => A list of symbols specifying any associations that are also deactivatable.  (This associations must separately be defined with acts_as_deactivatable).
+        #
+        def acts_as_deactivatable(options={})
+          extend ActiveRecord::Acts::Deactivatable::ClassMethods          
+          include ActiveRecord::Acts::Deactivatable::InstanceMethods
+                    
+          default_scope :conditions => {:deactivated_at => nil}
+          
+          @deactivatable_options = options
+        end
+        
+      end
+      
+      module ClassMethods
+        
+        def deactivatable_options
+          @deactivatable_options || {}
+        end
+        
+        def deactivated_dependencies
+          @deactivated_dependencies ||= []
+        end
+        
+        # Yields to a block, executing that block after removing the deactivated_at scope.
+        #
+        def with_deactivated_objects_scope
+          with_exclusive_scope do
+            with_scope(:find => {:conditions => "`#{self.table_name}`.`deactivated_at` IS NOT NULL"}) do
+              yield
+            end
+          end
+        end
+      end
+   
+      module InstanceMethods
+        
+        # Deactivate this object, and any associated objects as specified at definition time.
+        #
+        def deactivate!
+          with_transaction do
+            self.deactivated_at = Time.now            
+            deactivate_dependencies
+            self.save!
+          end
+        end
+        
+        # Activate this object, and any associated objects as specified at definition time.
+        #
+        def activate!
+          with_transaction do
+            self.deactivated_at = nil
+            activate_dependencies
+            self.save!            
+          end
+        end
+        
+        def deactivated?
+          deactivated_at?
+        end
+                
+        private
+        # Iterate the list of associated objects that need to be deactivated, and deactivate each of them.
+        #
+        def deactivate_dependencies
+          traverse_dependencies(:deactivate!)
+        end
+
+        # Iterate the list of associated objects that need to be activated, and activate each of them.
+        #
+        def activate_dependencies
+          traverse_dependencies(:activate!)
+        end
+        
+        # Traverse the list of dependencies, executing *method* on each of them.
+        #
+        def traverse_dependencies(method)
+          if dependencies = self.class.deactivatable_options[:dependencies]
+            dependencies.each { |dependency_name| execute_on_dependency(dependency_name, method) }
+          end          
+        end
+        
+        # Find the dependency indicated by *dependency_name* and execute *method* on it.
+        # Execution must be wrapped in the dependency's with_deactivated_objects_scope for activate! to work.
+        #
+        def execute_on_dependency(dependency_name, method)
+          self.class.reflections[dependency_name].klass.send(:with_exclusive_scope) do
+            dependency = self.__send__(dependency_name)          
+            dependency.respond_to?(:map) ? dependency.map(&method) : dependency.__send__(method)
+          end
+        end
+        
+        def with_transaction
+          self.class.transaction do
+             yield
+          end
+        end
+        
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  include ActiveRecord::Acts::Deactivatable
+end

data/test/deactivatable_dependency.rb

@@ -0,0 +1,5 @@
+class DeactivatableDependency < ActiveRecord::Base
+
+  acts_as_deactivatable
+  
+end

data/test/deactivatable_item.rb

@@ -0,0 +1,7 @@
+class DeactivatableItem < ActiveRecord::Base
+
+  has_many :deactivatable_dependencies
+
+  acts_as_deactivatable :dependencies => [:deactivatable_dependencies]
+  
+end

data/test/deactivatable_test.rb

@@ -0,0 +1,94 @@
+require 'test_helper'
+
+class DeactivatableTest < Test::Unit::TestCase
+  
+  context "An inactive item, @item" do
+    setup do
+      @inactive_item = DeactivatableItem.new
+      @inactive_item.deactivated_at = Time.now
+      @inactive_item.save!
+    end
+    
+    should "not be returned on find" do
+      assert !DeactivatableItem.exists?(@inactive_item.id)
+    end
+    
+    should "be findable in using the deactivated_objects_scope" do
+      assert DeactivatableItem.with_deactivated_objects_scope { DeactivatableItem.exists?(@inactive_item.id) }
+    end
+    
+    should "return true on deactivated?" do
+      assert @inactive_item.deactivated?
+    end
+    
+    context "when activated" do
+      setup do
+        @inactive_item.activate!
+      end
+      
+      should "be findable" do
+        assert DeactivatableItem.exists?(@inactive_item.id)
+      end
+    end #when reactivated    
+  end #An inactive item, @inactive_item
+  
+  context "An active item, @item" do
+    setup do
+      @item = DeactivatableItem.create!
+    end
+
+    should "have a null deactivated_at" do
+      assert_nil @item.deactivated_at
+    end
+    
+    context "when deactivated" do
+      setup do
+        @item.deactivate!
+      end
+      
+      should "set deactivated_at" do
+        assert_not_nil @item.deactivated_at
+      end
+      
+      should "not be findable" do
+        assert !DeactivatableItem.exists?(@item.id)
+      end      
+    end #when deactivated
+    
+    context "with dependencies, @dependencies" do
+      setup do
+        @dependencies = (0..5).map { DeactivatableDependency.new }
+        @item.deactivatable_dependencies = @dependencies
+      end
+
+      context "on a call to deactivate!" do
+        setup do
+          @item.deactivate!
+        end
+        
+        should "render dependency unfindable" do
+          @dependencies.each { |dependency| assert !DeactivatableDependency.exists?(dependency.id) }
+        end
+        
+        should "set deactivate on dependency post" do
+          DeactivatableDependency.send(:with_exclusive_scope) do
+            @dependencies.map(&:reload)
+            @dependencies.each {|dependency| assert_not_nil(dependency.deactivated_at) }
+          end
+        end
+        
+        context "when reactivated" do
+          setup do
+            @item.activate!
+          end
+          
+          should "reactivate all dependencies" do
+            @dependencies.each { |dependency| assert(DeactivatableDependency.exists?(dependency.id)) }
+          end
+        end #when reactivated
+        
+      end #on a call to deactivate!
+    end #with dependencies, @dependencies
+  end #An active item, @item
+
+end

data/test/test_helper.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'activerecord'
+require 'deactivatable'
+require 'deactivatable_dependency'
+require 'deactivatable_item'
+
+class Test::Unit::TestCase
+  ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :dbfile => ":memory:")
+
+  ActiveRecord::Schema.define(:version => 1) do
+    create_table :deactivatable_items do |t|
+      t.datetime :deactivated_at
+    end    
+  end
+  
+  ActiveRecord::Schema.define(:version => 1) do
+    create_table :deactivatable_dependencies do |t|
+      t.datetime :deactivated_at
+      t.belongs_to :deactivatable_item
+    end    
+  end
+  
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: deactivatable
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Greg Fitzgerald
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-06 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "2.3"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: "Deactivatable provides methods and a default_scope to allow ActiveRecord objects to be deactivated instead of deleted.\n      This is useful if an object needs to be removed from general use, but it's data needs to be retained.\n      Additionally, Deactivatable provides the ability to specify dependencies which also need to be deactivated.\n      Deactivation is determined by populating a deactivated_at field with the date time at which deactivation happened.\n    "
+email: greg_fitz@yahoo.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/deactivatable.rb
+- test/deactivatable_dependency.rb
+- test/deactivatable_item.rb
+- test/deactivatable_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/gregfitz23/deactivatable
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: Adds methods and scopes to ActiveRecord objects to allow deactivation instead of deletion.
+test_files: 
+- test/deactivatable_dependency.rb
+- test/deactivatable_item.rb
+- test/deactivatable_test.rb
+- test/test_helper.rb