destroyer 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in destroyer.gemspec
+gemspec

data/README.md

@@ -0,0 +1,62 @@
+#Destroyer
+
+Deletes records(without instantiating the records first) based on a block(which returns an array of ids) given and also recursively deletes all their associated records if they are marked as :dependent => :destroy. It is useful for background processing.
+
+## Installing
+
+Add this to your `Gemfile`
+
+    gem 'destroyer'
+
+##How to use it
+
+Add `destroyer` with a `lambda` or `Proc` to the model you want to delete records from which returns an array of ids, like this:
+
+    class User < ActiveRecord::Base
+      destroyer lambda { select("id").where(['created_at < ?', Time.now])] }
+    end
+
+Then, whenever you want to delete the records just call `start_destroyer` on your model, like this:
+
+    User.start_destroyer
+
+You could also send a new block to `destroyer` method:
+
+    User.destroyer( lambda { User.select('id').where('rol_id = 4') })
+
+And then, just call `start_destroyer` on the model and it will execute the process with the block that you just passed to `destroyer` method, keep in mind that the original block will not be overwritten, but be sure to execute `start_destroyer` whenever you pass a new block, otherwise this block will be present(because Destroyer uses class instance variables) the next time you call `start_destroyer` and it will try to delete the records with the ids given in the block, or make sure to set `destroyer_block` to `nil` on the model, like this:
+
+  User.destroyer_block = nil
+
+##Notes
+
+`destroyer` also accepts a hash of options, the only available option is `batch_size`, it is used to delete all records in batches, by default is 1000, make sure to set it to and empty hash if you modified the value and did not call `start_destroyer`, otherwise it will have the last value the next time you call the `start_destroyer` method.
+
+If you do not specify a default block, and later in the code you call your Model.destroyer with a block, that block will become the default block.
+
+
+##Example
+
+    class PurchaseOrder < ActiveRecord::Base
+      has_many :line_items, :dependent => :destroy
+      destroyer lambda { select("id").where(["state = 'deleted' AND created_at < ?", 1.month.ago]) }
+    end
+
+    class LineItem < ActiveRecord::Base
+      has_many :variant_line_items
+      belongs_to :purchase_order
+    end
+
+    class VariantLineItem < ActiveRecord::Base
+      belongs_to :line_item
+    end
+
+    PurchaseOrder.start_destroyer
+
+And that code is going to delete all purchase orders which 'state' is 'deleted' and are older that one month ago, and it will also delete all its related line items as well as all their variant line items.
+
+# About the Author
+
+[Crowd Interactive](http://www.crowdint.com) is a web design and development company that happens to work in Colima, Mexico.
+We specialize in building and growing online retail stores. We don’t work with everyone – just companies we believe in. Call us today to see if there’s a fit.
+Find more info [here](http://www.crowdint.com)!

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/destroyer.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "destroyer/version"
+
+Gem::Specification.new do |s|
+  s.name        = "destroyer"
+  s.version     = Destroyer::VERSION
+  s.authors     = ["Sergio Figueroa"]
+  s.email       = ["sergio.figueroa@crowdint.com"]
+  s.homepage    = ""
+  s.summary     = %q{Deletes records without instantiating the records first}
+  s.description = %q{Deletes records(without instantiating the records first) based on a block(which returns an array of ids) given and also recursively deletes all their associated records if they are marked as :dependent => :destroy. It is useful for background processing.}
+
+  s.rubyforge_project = "destroyer"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'activerecord', '~> 3.0.0'
+
+  s.add_development_dependency 'sqlite3'
+  s.add_development_dependency 'rspec'
+end

data/lib/destroyer.rb

@@ -0,0 +1,6 @@
+require "destroyer/version"
+require "destroyer/destroyer"
+
+class ActiveRecord::Base
+  include Destroyer
+end

data/lib/destroyer/destroyer.rb

@@ -0,0 +1,60 @@
+module Destroyer
+  def self.included(target)
+    target.extend Destroyer::ClassMethods
+  end
+
+  module ClassMethods
+    attr_accessor :destroyer_block, :destroyer_options
+
+    def destroyer(block, options = {})
+      @destroyer_block = block
+      @destroyer_default_block ||= @destroyer_block
+      @destroyer_options = options
+      @destroyer_default_options ||= @destroyer_options
+    end
+
+    def start_destroyer
+      return unless @destroyer_default_block
+      let_the_destroyer_starts((@destroyer_block || @destroyer_default_block).call)
+      @destroyer_block = nil
+      @destroyer_options = {}
+    end
+
+    def has_one_with_destroy
+      @has_one_with_destroy ||= reflect_on_all_associations(:has_one).select {|a| a.options[:dependent] == :destroy && !a.options[:through] }.map(&:klass)
+    end
+
+    def has_many_with_destroy
+      @has_many_with_destroy ||= reflect_on_all_associations(:has_many).select {|a| a.options[:dependent] == :destroy && !a.options[:through] }.map(&:klass)
+    end
+
+    def has_many_through_with_destroy
+      @has_many_through_with_destroy ||= reflect_on_all_associations(:has_many).select {|a| a.options[:dependent] == :destroy && a.options[:through] }.map(&:through_reflection).map(&:klass)
+    end
+
+    def all_destroyables
+      has_one_with_destroy + has_many_with_destroy + has_many_through_with_destroy
+    end
+
+  private
+    def let_the_destroyer_starts(ids)
+      destroy_associations(self, ids)
+      ids.each_slice(destroyer_batch_size) {|group| delete_all(["#{primary_key} IN (?)", group])}
+    end
+
+    def destroy_associations(_class, ids)
+      _class.all_destroyables.each do |association|
+        _foreign_key = _class.reflect_on_association(association).try(:options).try(:[], :foreign_key) || "#{_class.table_name.singularize}_id"
+        association.select("#{association.primary_key}").where(["#{_foreign_key} IN (?)", ids])
+          .find_in_batches(:batch_size => destroyer_batch_size) do |association_ids|
+            destroy_associations(association, association_ids.map(&:id))
+            association.delete_all(["#{_foreign_key} IN (?)", ids])
+        end
+      end
+    end
+
+    def destroyer_batch_size
+      @destroyer_options[:batch_size] || @destroyer_default_options[:batch_size] || 1000
+    end
+  end
+end

data/lib/destroyer/version.rb

@@ -0,0 +1,3 @@
+module Destroyer
+  VERSION = "0.0.1"
+end

data/spec/models.rb

@@ -0,0 +1,45 @@
+class User < ActiveRecord::Base
+  has_one :avatar, :dependent => :destroy
+  has_many :posts, :dependent => :destroy
+  has_one :avatar_history, :through => :avatar
+
+  destroyer lambda { [select("id").first] }
+end
+
+class Category < ActiveRecord::Base
+  has_many :categories_posts
+  has_many :posts, :through => :categories_posts
+end
+
+class CategoriesPost < ActiveRecord::Base
+  belongs_to :category
+  belongs_to :post
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :user
+
+  has_many :categories_posts
+  has_many :categories, :through => :categories_posts, :dependent => :destroy, :class_name => "Category"
+  has_many :comments, :dependent => :destroy
+
+  destroyer lambda { [select("id").first] }
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :post
+  has_one :chair, :dependent => :destroy
+end
+
+class Chair < ActiveRecord::Base
+  belongs_to :comment
+end
+
+class Avatar < ActiveRecord::Base
+  belongs_to :user
+  has_one :avatar_history
+end
+
+class AvatarHistory < ActiveRecord::Base
+  belongs_to :avatar
+end

data/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'active_record'
+require 'destroyer'
+
+RSpec.configure do |config|
+  config.before do
+    ActiveRecord::Base.connection.execute("DELETE FROM users")
+    ActiveRecord::Base.connection.execute("DELETE FROM posts")
+    ActiveRecord::Base.connection.execute("DELETE FROM comments")
+    ActiveRecord::Base.connection.execute("DELETE FROM avatars")
+    ActiveRecord::Base.connection.execute("DELETE FROM categories_posts")
+  end
+end
+
+ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :users, :force => true do |t|
+  end
+  create_table :categories, :force => true do |t|
+  end
+  create_table :posts, :force => true do |t|
+    t.integer :user_id
+  end
+  create_table :categories_posts, :force => true do |t|
+    t.integer :category_id
+    t.integer :post_id
+  end
+  create_table :comments, :force => true do |t|
+    t.integer :post_id
+  end
+  create_table :avatars, :force => true do |t|
+    t.integer :user_id
+  end
+  create_table :avatar_histories, :force => true do |t|
+    t.integer :avatar_id
+  end
+  create_table :chairs, :force => true do |t|
+    t.integer :comment_id
+  end
+end

data/spec/tests_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+require 'models'
+require 'active_support'
+
+ActiveRecord::Base.logger = ActiveSupport::BufferedLogger.new(STDOUT)
+
+categories = [Category.create, Category.create]
+
+describe Destroyer do
+  describe "methods" do
+    it "adds destroyer method to ActiveRecord::Base" do
+      ActiveRecord::Base.public_methods.include?(:destroyer).should be_true
+    end
+    it "adds has_one_with_destroy method to ActiveRecord::Base" do
+      ActiveRecord::Base.public_methods.include?(:has_one_with_destroy).should be_true
+    end
+    it "adds has_many_with_destroy method to ActiveRecord::Base" do
+      ActiveRecord::Base.public_methods.include?(:has_many_with_destroy).should be_true
+    end
+  end
+
+  context "has_one_with_destroy" do
+    describe "User" do
+      it "returns [Avatar]" do
+        User.has_one_with_destroy.should == [Avatar]
+      end
+    end
+    describe "Avatar" do
+      it "returns []" do
+        Avatar.has_one_with_destroy.eql?([]).should be_true
+      end
+    end
+    describe "Category" do
+      it "returns []" do
+        Category.has_one_with_destroy.empty?.should be_true
+      end
+    end
+  end
+
+  context "has_many_with_destroy" do
+    describe "User" do
+      it "returns [Post]" do
+        User.has_many_with_destroy.eql?([Post]).should be_true
+      end
+    end
+    describe "Category" do
+      it "returns []" do
+        Category.has_many_with_destroy.empty?.should be_true
+      end
+    end
+    describe "Post" do
+      it "returns [Comment]" do
+        Post.has_many_with_destroy.eql?([Comment]).should be_true
+      end
+    end
+  end
+
+  context "has_many_through_with_destroy" do
+    describe "Post" do
+      it "returns [CategoriesPost]" do
+        Post.has_many_through_with_destroy.eql?([CategoriesPost]).should be_true
+      end
+    end
+    describe "Category" do
+      it "returns []" do
+        Category.has_many_with_destroy.empty?.should be_true
+      end
+    end
+  end
+
+  context "destroyer in action" do
+    before do
+      # five Users and one Avatar per user
+      # two posts per user = ten posts
+      # three comments per post = thirty comments
+      5.times do
+        user = User.create(:avatar => Avatar.create(:avatar_history => AvatarHistory.create))
+        2.times do
+          post = Post.create(:user => user, :categories => [categories[rand(2)]])
+          3.times do
+            Chair.create(:comment => Comment.create(:post => post))
+          end
+        end
+      end
+    end
+
+    context "has_hone relationships" do
+      describe "default block" do
+        it "destroys one user and its avatar" do
+          User.start_destroyer
+
+          User.count.should be(4)
+          Avatar.count.should be(4)
+        end
+      end
+
+      describe "passing a new block" do
+        it "destroys the users with the ids given in the block, and also destroys their avatar" do
+          users_to_destroy = User.first(2)
+          user_ids = users_to_destroy.map(&:id)
+          avatars_to_destroy = Avatar.where(["user_id IN (?)", user_ids])
+
+          User.destroyer( lambda { user_ids })
+          User.start_destroyer
+
+          User.count.should be(3)
+          Avatar.count.should be(3)
+
+          User.all.map(&:id).any? {|id| user_ids.include?(id)}.should be_false
+          Avatar.all.map(&:id).any? {|id| avatars_to_destroy.map(&:id).include?(id)}.should be_false
+        end
+
+        describe "when the second time a new block is not given" do
+          it "destroys also the first User and its Avatar" do
+            first_user = User.first(:include => :avatar)
+            last_user = User.last(:include => :avatar)
+
+            User.destroyer( lambda { [User.last] } )
+            User.start_destroyer
+
+            User.start_destroyer
+
+            User.all.any? {|user| [first_user.id, last_user.id].include?(user.id) }.should be_false
+            Avatar.all.any? {|avatar| [first_user.avatar.id, last_user.avatar.id].include?(avatar.id) }.should be_false
+          end
+        end
+      end
+    end
+
+    context "has_many through" do
+      describe "default block" do
+        it "destroys one post and its comments" do
+          Post.start_destroyer
+
+          Post.count.should == 9
+          Comment.count.should == 27
+        end
+        it "destroys one record in the categories_posts table, and does not removes any Category" do
+          Post.start_destroyer
+
+          Post.count.should == 9
+          CategoriesPost.count.should == 9
+          Category.count.should == 2
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: destroyer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Sergio Figueroa
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-17 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &2157609960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *2157609960
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &2157609540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2157609540
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2157609080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2157609080
+description: Deletes records(without instantiating the records first) based on a block(which
+  returns an array of ids) given and also recursively deletes all their associated
+  records if they are marked as :dependent => :destroy. It is useful for background
+  processing.
+email:
+- sergio.figueroa@crowdint.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- destroyer.gemspec
+- lib/destroyer.rb
+- lib/destroyer/destroyer.rb
+- lib/destroyer/version.rb
+- spec/models.rb
+- spec/spec_helper.rb
+- spec/tests_spec.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: destroyer
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Deletes records without instantiating the records first
+test_files:
+- spec/models.rb
+- spec/spec_helper.rb
+- spec/tests_spec.rb