active_reaper 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+db/*
+pkg/*

data/.rvmrc

@@ -0,0 +1,3 @@
+rvm_gemset_create_on_use_flag=1
+rvm use ruby-1.9.2-p136@active_reaper
+rvm wrapper ruby-1.9.2-p136@active_reaper textmate

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+# CHANGELOG #
+
+## 0.0.1 ##
+* restructured as gem from specs

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,61 @@
+PATH
+  remote: .
+  specs:
+    active_reaper (0.0.1)
+      activerecord
+      activesupport
+      rake
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.1.1)
+      activesupport (= 3.1.1)
+      builder (~> 3.0.0)
+      i18n (~> 0.6)
+    activerecord (3.1.1)
+      activemodel (= 3.1.1)
+      activesupport (= 3.1.1)
+      arel (~> 2.2.1)
+      tzinfo (~> 0.3.29)
+    activesupport (3.1.1)
+      multi_json (~> 1.0)
+    archive-tar-minitar (0.5.2)
+    arel (2.2.1)
+    builder (3.0.0)
+    columnize (0.3.4)
+    diff-lcs (1.1.3)
+    i18n (0.6.0)
+    linecache19 (0.5.12)
+      ruby_core_source (>= 0.1.4)
+    multi_json (1.0.3)
+    rake (0.9.2.2)
+    rspec (2.7.0)
+      rspec-core (~> 2.7.0)
+      rspec-expectations (~> 2.7.0)
+      rspec-mocks (~> 2.7.0)
+    rspec-core (2.7.1)
+    rspec-expectations (2.7.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.7.0)
+    ruby-debug-base19 (0.11.25)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby_core_source (>= 0.1.4)
+    ruby-debug19 (0.11.6)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby-debug-base19 (>= 0.11.19)
+    ruby_core_source (0.1.5)
+      archive-tar-minitar (>= 0.5.2)
+    sqlite3 (1.3.4)
+    tzinfo (0.3.31)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  active_reaper!
+  rspec (>= 2.6)
+  ruby-debug19
+  sqlite3

data/README.md

@@ -0,0 +1,68 @@
+# README #
+
+## Description ##
+
+Mark your ActiveRecord models for deletion after a certain period in a single line.  Keep these kinds of specifications out of other files or rake tasks and in the models where they belong.  A rake task iterates over all participating classes and finds objects/rows ready for deletion.  Useful on Heroku where the rake task can be called from their free daily cron task.  Ideal for objects common to social networking applications that can quickly build up over time (notifications, news feeds, private messages, etc).
+
+## How To Use ##
+
+Within an ActiveRecord class make a call to the "reap" method with an argument to say when a row should be deleted.  ActiveReaper will assume that you intend to base the time calculation on the datetime column 'created_at':
+
+    class PrivateMessage < ActiveRecord::Base
+      # delete private messages 30 days after they've been created
+      reap :after => 30.days
+    end
+
+If you need the time calculation to be based off of another value, in can be the name of a column or an instance method:
+
+    class PrivateMessage < ActiveRecord::Base
+      # delete private messages 30 days after they've been read
+      reap :after => 30.days, :determined_by => :read_at
+    end
+    
+    # == Schema Information
+    #
+    # Table name: private_messages
+    #
+    #  id              :integer(4)      not null, primary key
+    #  sweet_nothings  :text
+    #  read_at         :datetime
+    #  created_at      :datetime
+    #  updated_at      :datetime
+
+The default method used by ActiveReaper is to delete the expired rows using `ActiveRecord::Base.delete()`.  If there are important callbacks or child models in a `has_many :dependent => :destroy` association that need to be taken care of, tell ActiveReaper to use `ActiveRecord::Base.destroy()` instead:
+
+    class Post < ActiveRecord::Base
+      has_many :comments, :dependent => :destroy
+      
+      # delete posts after 3 months, and take all comments with them
+      reap :after => 3.months, :using => :destroy
+    end
+
+If you want to place a guard on top of the expiration time.  The guard can be the name of a column or an instance method (_NOTE: Strings in mysql have a truth value of false_): 
+
+    class Post < ActiveRecord::Base
+      # delete posts after 1 week if it's been flagged
+      reap :after => 1.week, :if => :flagged
+    end
+
+`unless` may also be used:
+
+    class PrivateMessage < ActiveRecord::Base
+      # delete private messages 30 days after they've been created, unless the user wants them saved
+      reap :after => 30.days, :unless => :saved
+    end
+
+## Running The Reap Task ##
+
+Straightforward:
+
+    rake reap
+
+## Don't Fear The Reaper ##
+
+Since the actual deleting of models gets performed in a rake task, performance may not _necessarily_ be an issue, but ActiveReaper is the fastest when using the delete method, and when both the arguments for 'determined\_by' and 'if/unless' are table columns.  Using the destroy method is slower for obvious reasons, and if 'determined\_by' is given as an instance method, then every row has to be instantiated as an ActiveRecord object and evaluated to look for expired objects, making it the slowest strategy.
+
+## Author ##
+
+Christopher Eberz; chris@chriseberz.com; @zortnac

data/Rakefile

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

data/active_reaper.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "active_reaper/version"
+
+Gem::Specification.new do |s|
+  s.name        = "active_reaper"
+  s.version     = ActiveReaper::VERSION
+  s.authors     = ["Chris Eberz"]
+  s.email       = ["chris@chriseberz.com"]
+  s.homepage    = ""
+  s.summary     = %q{Your ActiveRecord models can cleanly mark themsleves for deletion after a specifc time.}
+  s.description = %q{Set ActiveRecord models to delete themselves after a fixed time, or when a certain criteria is met.}
+
+  s.rubyforge_project = "active_reaper"
+
+  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", "spec"]
+
+  s.add_development_dependency "rspec", ">= 2.6"
+  s.add_development_dependency "ruby-debug19"
+  s.add_development_dependency "sqlite3"
+  
+  s.add_runtime_dependency "rake"
+  s.add_runtime_dependency "activerecord"
+  s.add_runtime_dependency "activesupport"
+end

data/lib/active_reaper/active_reaper.rb

@@ -0,0 +1,113 @@
+require "active_support"
+require "active_record"
+
+module ActiveReaper
+  REAPED_CLASSES = {}
+  
+  def self.included(base)
+    base.extend(ClassMethods)  
+  end
+  
+  def self.reap!
+    REAPED_CLASSES.each_pair do |klass, settings|
+      if settings[:determined_by_type] == :column && settings[:condition].nil?
+        ActiveReaper.reap_simply(klass, settings)
+      elsif settings[:determined_by_type] == :column && !settings[:condition].nil? && settings[:condition_type] == :column
+        ActiveReaper.reap_quickly(klass, settings)
+      elsif settings[:determined_by_type] == :column && !settings[:condition].nil? && settings[:condition_type] == :method
+        ActiveReaper.reap_conditionally(klass, settings)
+      elsif settings[:determined_by_type] == :method
+        ActiveReaper.reap_meticulously(klass, settings)
+      end
+    end
+  end
+  
+  module ClassMethods
+    def reap(opts)
+      unless opts[:after].respond_to?(:ago)
+        raise ArgumentError.new("ActiveReaper: option for 'after' must be a FixNum (amount in seconds)")
+      end
+      
+      unless [:delete, :destroy].include? (opts[:using] || :delete)
+        raise ArgumentError.new("ActiveReaper: option for 'using' must be either :delete or :destroy")
+      end
+      
+      unless  self.column_names.include?(opts[:determined_by].to_s) || 
+              self.instance_methods.include?(opts[:determined_by]) ||
+              (opts[:determined_by].nil? && self.column_names.include?('created_at'))
+        raise ArgumentError.new("ActiveReaper: option for 'determined_by' must be either a table column name or an instance method.  If option is left blank, table must have a datetime 'created_at' column.")
+      end
+      
+      unless (opts[:if].nil? && opts[:unless].nil?) || ( !!opts[:if] ^ !!opts[:unless])
+        raise ArgumentError.new("ActiveReaper: Pass only 'if' or 'unless' as a condition")
+      end
+      
+      unless self.column_names.include?(opts[:if].to_s) || (opts[:if].to_s.last=='?' && self.column_names.include?(opts[:if].to_s.chop)) || self.instance_methods.include?(opts[:if]) || opts[:if].nil?
+        raise ArgumentError.new("ActiveReaper: option for 'if' or 'unless' must be either a table column name or an instance method.")
+      end
+      
+      settings = {
+        :after => opts[:after],
+        :using => opts[:using] || :delete,
+        :determined_by => opts[:determined_by].nil? ? :created_at : opts[:determined_by],
+        :determined_by_type => self.column_names.include?(opts[:determined_by].to_s) ? :column : :method,
+        :condition => opts[:if].nil? ? opts[:unless] : opts[:if],
+        :condition_type => nil,
+        :truth_value => nil
+      }
+      
+      if settings[:condition]
+        settings[:truth_value] = opts[:if].nil? ? false : true
+        settings[:condition_type] = self.column_names.include?(settings[:condition].to_s) ? :column : :method
+      end  
+      
+      REAPED_CLASSES[self] = settings
+    end
+  end
+  
+  # run a simple delete_all or destroy_all; no conditions or method-based expiration
+  def self.reap_simply(klass, settings)
+    if settings[:using] == :delete
+      klass.where("#{settings[:determined_by]} < ?", settings[:after].ago.to_s(:db)).delete_all
+    else
+      klass.where("#{settings[:determined_by]} < ?", settings[:after].ago.to_s(:db)).destroy_all
+    end
+  end
+  
+  # run a delete_all or destroy_all with the value of the column given as the condition made part of the query
+  def self.reap_quickly(klass, settings)
+    if settings[:using] == :delete
+      klass.where("#{settings[:determined_by]} < ?", settings[:after].ago.to_s(:db)).where(settings[:condition] => settings[:truth_value]).delete_all
+    else
+      klass.where("#{settings[:determined_by]} < ?", settings[:after].ago.to_s(:db)).where(settings[:condition] => settings[:truth_value]).destroy_all
+    end
+  end
+  
+  # objects can be selected quickly, but have to be individually evaluated for the extra condition
+  def self.reap_conditionally(klass, settings)
+    klass.where("#{settings[:determined_by]} < ?", settings[:after].ago.to_s(:db)).each do |object|
+      if object.send(settings[:condition]) == settings[:truth_value]
+        if settings[:using] == :delete
+          klass.delete(object.id)
+        else
+          klass.destroy(object.id)
+        end
+      end
+    end
+  end
+  
+  # All objects must be iterated over to see which have expired, and then may or may not require an extra condition
+  def self.reap_meticulously(klass, settings)
+    klass.all.each do |object|
+      if (object.send(settings[:determined_by]) < settings[:after].ago) && (settings[:condition].nil? || object.send(settings[:condition]) == settings[:truth_value])
+        if settings[:using] == :delete
+          klass.delete(object.id)
+        else
+          klass.destroy(object.id)
+        end
+      end
+    end
+  end
+end
+
+::ActiveRecord::Base.send(:include, ActiveReaper)

data/lib/active_reaper/railtie.rb

@@ -0,0 +1,9 @@
+require 'rails'
+
+module ActiveReaper
+  class Railtie < Rails::Railtie  
+    rake_tasks do
+      load "tasks/active_reaper.rake"
+    end
+  end
+end

data/lib/active_reaper/version.rb

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

data/lib/active_reaper.rb

@@ -0,0 +1,3 @@
+require "active_reaper/version"
+require "active_reaper/active_reaper"
+require "active_reaper/railtie" if defined?(Rails)

data/spec/active_reaper_spec.rb

@@ -0,0 +1,201 @@
+require 'spec_helper.rb'
+
+ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS 'posts'")
+ActiveRecord::Base.connection.create_table(:posts) do |t|
+    t.string :title
+    t.string :content
+    t.boolean :flagged
+    t.timestamps
+end
+ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS 'comments'")
+ActiveRecord::Base.connection.create_table(:comments) do |t|
+    t.belongs_to :post
+    t.string :content
+end
+
+class Post < ActiveRecord::Base
+  has_many :comments, :dependent => :destroy
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :post
+end
+
+describe ActiveReaper do
+  before do
+      ActiveRecord::Base.connection.increment_open_transactions
+      ActiveRecord::Base.connection.begin_db_transaction
+      
+      @post_to_be_deleted = Post.create
+      @post_that_survives = Post.create
+      @comment = Comment.create(:post_id => @post_to_be_deleted.id)
+  end
+  
+  describe "classes set to be reaped after an expiration date" do
+    before do
+      Post.class_eval do
+        reap :after => 10.days
+      end
+      
+      @post_that_survives.update_attribute :created_at, 9.days.ago
+      @post_to_be_deleted.update_attribute :created_at, 11.days.ago
+    end
+    
+    it "should correctly delete only the instances that have expired" do
+      ActiveReaper.reap!
+      Post.exists?(@post_that_survives.id).should be_true
+      Post.exists?(@post_to_be_deleted.id).should_not be_true
+    end
+  end
+  
+  describe "classes set to be reaped after an expiration date, based on a field" do
+    before do
+      Post.class_eval do
+        reap :after => 10.days, :determined_by => :created_at
+      end
+      
+      @post_that_survives.update_attribute :created_at, 9.days.ago
+      @post_to_be_deleted.update_attribute :created_at, 11.days.ago
+    end
+    
+    it "should correctly delete only the instances that have expired" do
+      ActiveReaper.reap!
+      Post.exists?(@post_that_survives.id).should be_true
+      Post.exists?(@post_to_be_deleted.id).should_not be_true
+    end
+  end
+  
+  describe "classes set to be reaped after an expiration date, based on a value returned by a method" do
+    before do
+      Post.class_eval do
+        def last_looked_at
+          created_at
+        end
+        
+        reap :after => 10.days, :determined_by => :last_looked_at
+      end
+      
+      @post_that_survives.update_attribute :created_at, 9.days.ago
+      @post_to_be_deleted.update_attribute :created_at, 11.days.ago
+    end
+    
+    it "should correctly delete only the instances that have expired" do
+      ActiveReaper.reap!
+      Post.exists?(@post_that_survives.id).should be_true
+      Post.exists?(@post_to_be_deleted.id).should_not be_true
+    end
+  end
+  
+  describe "classes set to be reaped using the default delete method" do
+    before do
+      Post.class_eval do
+        reap :after => 10.days, :determined_by => :created_at
+      end
+      
+      @post_to_be_deleted.update_attribute :created_at, 11.days.ago
+    end
+    
+    it "should leave dependent models behind" do
+      ActiveReaper.reap!
+      Comment.exists?(@comment.id).should be_true
+      Post.exists?(@post_to_be_deleted.id).should_not be_true
+    end
+  end
+  
+  describe "classes set to be reaped using the optional destroy method" do
+    before do
+      Post.class_eval do
+        reap :after => 10.days, :determined_by => :created_at, :using => :destroy
+      end
+      
+      @post_to_be_deleted.update_attribute :created_at, 11.days.ago
+    end
+    
+    it "should also delete dependent models" do
+      ActiveReaper.reap!
+      Comment.exists?(@comment.id).should_not be_true
+      Post.exists?(@post_to_be_deleted.id).should_not be_true
+    end
+  end
+  
+  describe "classes set to be reaped after an expiration date, with a condition based on a field" do
+    before do
+      Post.class_eval do
+        reap :after => 10.days, :determined_by => :created_at, :if => :flagged
+      end
+      
+      @post_that_survives.update_attribute :created_at, 11.days.ago
+      @post_that_survives.update_attribute :flagged, false
+      @post_to_be_deleted.update_attribute :created_at, 11.days.ago
+      @post_to_be_deleted.update_attribute :flagged, true
+    end
+    
+    it "should correctly delete only the instances that have expired" do
+      ActiveReaper.reap!
+      Post.exists?(@post_that_survives.id).should be_true
+      Post.exists?(@post_to_be_deleted.id).should_not be_true
+    end
+  end
+  
+  describe "classes set to be reaped after an expiration date, with a condition based on a method" do
+    before do
+      Post.class_eval do
+        reap :after => 10.days, :determined_by => :created_at, :if => :flagged?
+      end
+      
+      @post_that_survives.update_attribute :created_at, 11.days.ago
+      @post_that_survives.update_attribute :flagged, false
+      @post_to_be_deleted.update_attribute :created_at, 11.days.ago
+      @post_to_be_deleted.update_attribute :flagged, true
+    end
+    
+    it "should correctly delete only the instances that have expired" do
+      ActiveReaper.reap!
+      Post.exists?(@post_that_survives.id).should be_true
+      Post.exists?(@post_to_be_deleted.id).should_not be_true
+    end
+  end
+  
+  describe "classes set to be reaped after an expiration date, with a negative condition based on a field" do
+    before do
+      Post.class_eval do
+        reap :after => 10.days, :determined_by => :created_at, :unless => :flagged
+      end
+      
+      @post_that_survives.update_attribute :created_at, 11.days.ago
+      @post_that_survives.update_attribute :flagged, true
+      @post_to_be_deleted.update_attribute :created_at, 11.days.ago
+      @post_to_be_deleted.update_attribute :flagged, false
+    end
+    
+    it "should correctly delete only the instances that have expired" do
+      ActiveReaper.reap!
+      Post.exists?(@post_that_survives.id).should be_true
+      Post.exists?(@post_to_be_deleted.id).should_not be_true
+    end
+  end
+  
+  describe "classes set to be reaped after an expiration date, with a negative condition based on a method" do
+    before do
+      Post.class_eval do
+        reap :after => 10.days, :determined_by => :created_at, :unless => :flagged?
+      end
+      
+      @post_that_survives.update_attribute :created_at, 11.days.ago
+      @post_that_survives.update_attribute :flagged, true
+      @post_to_be_deleted.update_attribute :created_at, 11.days.ago
+      @post_to_be_deleted.update_attribute :flagged, false
+    end
+    
+    it "should correctly delete only the instances that have expired" do
+      ActiveReaper.reap!
+      Post.exists?(@post_that_survives.id).should be_true
+      Post.exists?(@post_to_be_deleted.id).should_not be_true
+    end
+  end
+
+  after do
+      ActiveRecord::Base.connection.rollback_db_transaction
+      ActiveRecord::Base.connection.decrement_open_transactions
+  end  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'active_reaper'
+
+root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+ActiveRecord::Base.establish_connection(
+  :adapter => "sqlite3",
+  :database => "#{root}/db/activereaper.db"
+)

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: active_reaper
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Chris Eberz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-15 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2157213160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: *2157213160
+- !ruby/object:Gem::Dependency
+  name: ruby-debug19
+  requirement: &2157212740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2157212740
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &2157212280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2157212280
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2157211820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2157211820
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &2157184760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2157184760
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &2157184340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2157184340
+description: Set ActiveRecord models to delete themselves after a fixed time, or when
+  a certain criteria is met.
+email:
+- chris@chriseberz.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- active_reaper.gemspec
+- lib/active_reaper.rb
+- lib/active_reaper/active_reaper.rb
+- lib/active_reaper/railtie.rb
+- lib/active_reaper/version.rb
+- lib/tasks/active_reaper.rake
+- spec/active_reaper_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- spec
+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: active_reaper
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Your ActiveRecord models can cleanly mark themsleves for deletion after a
+  specifc time.
+test_files:
+- spec/active_reaper_spec.rb
+- spec/spec_helper.rb