zombie_record 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8fffbb5b3d7304492d0999ef54eb7db4fc783cb5
+  data.tar.gz: 121cc7d9627e7450500d076f025b501b52f31687
+SHA512:
+  metadata.gz: e45075a3ee932ef550c34120d0be0d92d601e7839a16e06d418e949e4fba0673738a7f8e830e6d4be35aaca08f3ea5aa6bd95d66db594a22fd09258d794222a1
+  data.tar.gz: 38833db59a21a4bba05c96ba4d31fb34aefea3cd4d85912b9e5cbc1a3a71fa2dd3bb5d8c6217f82aa39d764a0b03f5c6144daf34d0f03bac67ad773d4b730dd3

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.0.0

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+###### v0.4.0
+
+* Allow accessing associated records on deleted objects, even if they themselves
+  are deleted, e.g.
+
+    # The post, comments, and category are all deleted.
+    post = Post.with_deleted.find(...)
+    post.comments
+    post.category

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in zombie_record.gemspec
+gemspec
+
+gem "byebug"

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Daniel Schierbeck
+
+MIT License
+
+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.md

@@ -0,0 +1,51 @@
+# Zombie Record
+
+Allows restoring your Active Records from the dead!
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'zombie_record'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install zombie_record
+
+## Usage
+
+Simply include the `ZombieRecord::Restorable` in your model class:
+
+```ruby
+class Book < ActiveRecord::Base
+  include ZombieRecord::Restorable
+end
+```
+
+Zombie Record assumes the model's table has a `deleted_at` column with the `timestamp` type.
+
+You can now delete and restore Book records:
+
+```ruby
+book = Book.find(42)
+book.destroy
+
+Book.find(42) # raises ActiveRecord::RecordNotFound.
+
+book = Book.deleted.find(42)
+book.restore!
+
+Book.find(42) # returns the Book record.
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/zombie_record.rb

@@ -0,0 +1,7 @@
+require 'active_support'
+require 'zombie_record/version'
+
+module ZombieRecord
+end
+
+require 'zombie_record/restorable'

data/lib/zombie_record/restorable.rb

@@ -0,0 +1,195 @@
+module ZombieRecord
+  module Restorable
+    extend ActiveSupport::Concern
+
+    included do
+      default_scope { where(deleted_at: nil) }
+
+      define_callbacks :restore
+    end
+
+    # Override Rails' #destroy for soft-delete functionality
+    # When changing to Rails 4, override #destroy_row with a one-liner instead.
+    def destroy
+      run_callbacks :destroy do
+        destroy_associations
+
+        if persisted?
+          time = current_time_from_proper_timezone
+          update_column(:deleted_at, time)
+
+          if self.class.column_names.include?("updated_at")
+            update_column(:updated_at, time)
+          end
+        end
+
+        @destroyed = true
+        freeze
+      end
+    end
+
+    # Restores a destroyed record.
+    #
+    # Returns nothing.
+    def restore!
+      if frozen?
+        raise "cannot restore an object that has been destroyed directly; " <<
+              "please make sure to load it from the database again."
+      end
+
+      run_callbacks :restore do
+        update_column(:deleted_at, nil)
+
+        restore_associated_records!
+      end
+    end
+
+    # Whether the record has been destroyed.
+    #
+    # Returns true if the record is deleted, false otherwise.
+    def deleted?
+      !deleted_at.nil?
+    end
+
+    # Allows accessing deleted associations from the record.
+    #
+    # Example
+    #
+    #   book = Book.first.with_deleted_associations
+    #
+    #   # Even deleted chapters are returned!
+    #   book.chapters #=> [...]
+    #
+    # Returns a wrapped ActiveRecord::Base object.
+    def with_deleted_associations
+      if deleted?
+        WithDeletedAssociations.new(self)
+      else
+        self
+      end
+    end
+
+    private
+
+    def restore_associated_records!
+      self.class.reflect_on_all_associations.each do |association|
+        # Only restore associations that are automatically destroyed alongside
+        # the record.
+        next unless association.options[:dependent] == :destroy
+
+        # Don't try to restore models that are not restorable.
+        next unless association.klass.ancestors.include?(Restorable)
+
+        records = deleted_records_for_association(association)
+
+        records.each do |record|
+          record.restore!
+        end
+      end
+    end
+
+    def deleted_records_for_association(association)
+      if association.macro == :has_one
+        foreign_key = association.foreign_key
+        association.klass.deleted.where(foreign_key => id)
+      elsif association.macro == :has_many
+        public_send(association.name).deleted
+      elsif association.macro == :belongs_to
+        associated_id = public_send(association.foreign_key)
+        return [] unless associated_id.present?
+        association.klass.deleted.where(:id => associated_id)
+      else
+        raise "association type #{association.macro} not supported"
+      end
+    end
+
+    # Wraps a deleted record and makes sure that any associated record is
+    # available even if it is deleted. This is done by intercepting the method
+    # calls, checking if the method is an association access, and then ensuring
+    # that deleted records are included in the resulting query.
+    class WithDeletedAssociations < BasicObject
+      def initialize(record)
+        @record = record
+      end
+
+      def method_missing(name, *args, &block)
+        delegate_to_record(name) { @record.public_send(name, *args, &block) }
+      end
+
+      # We want *all* methods to be delegated.
+      BasicObject.instance_methods.each do |name|
+        define_method(name) do |*args, &block|
+          @record.public_send(name, *args, &block)
+        end
+      end
+
+      private
+
+      def delegate_to_record(name, &block)
+        if reflection = reflect_on(name)
+          with_deleted_associations(reflection, &block)
+        else
+          block.call
+        end
+      end
+
+      def reflect_on(name)
+        reflection = @record.class.reflect_on_association(name)
+
+        if reflection && restorable_reflection?(reflection)
+          reflection
+        end
+      end
+
+      def associated_record_class(reflection)
+        # Polymorphic associations don't have an easy way to access the class,
+        # so we'll have to do it ourselves.
+        if reflection.options[:polymorphic]
+          @record.public_send(reflection.foreign_type).constantize
+        else
+          reflection.klass
+        end
+      end
+
+      def restorable_reflection?(reflection)
+        associated_record_class(reflection).ancestors.include?(Restorable)
+      end
+
+      def with_deleted_associations(reflection, &block)
+        case reflection.macro
+        when :has_one, :belongs_to
+          associated_record_class(reflection).unscoped(&block).with_deleted_associations
+        when :has_many
+          block.call.with_deleted
+        else
+          raise "invalid macro #{reflection.macro.inspect}"
+        end
+      end
+    end
+
+    module WithDeletedAssociationsWrapper
+      def to_a
+        super.map(&:with_deleted_associations)
+      end
+    end
+
+    module ClassMethods
+
+      # Scopes the relation to only include deleted records.
+      #
+      # Returns an ActiveRecord::Relation.
+      def deleted
+        with_deleted.where("#{quoted_table_name}.deleted_at IS NOT NULL")
+      end
+
+      # Scopes the relation to include both active and deleted records.
+      #
+      # Returns an ActiveRecord::Relation.
+      def with_deleted
+        scoped.
+          tap {|relation| relation.default_scoped = false }.
+          extending(WithDeletedAssociationsWrapper)
+      end
+    end
+  end
+end

data/lib/zombie_record/version.rb

@@ -0,0 +1,3 @@
+module ZombieRecord
+  VERSION = "0.4.0"
+end

data/spec/restorable_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+
+describe ZombieRecord::Restorable do
+  context "when the record is deleted" do
+    it "allows accessing a deleted has_one association" do
+      book = Book.create!
+      cover = Cover.create!(book: book)
+
+      book.destroy
+      book = Book.with_deleted.first
+
+      book.cover.should == cover.reload
+    end
+
+    it "allows accessing deleted belongs_to associations" do
+      book = Book.create!
+      chapter = book.chapters.create!
+
+      book.destroy
+      chapter = Chapter.with_deleted.first
+
+      chapter.book.should == book
+    end
+
+    it "allows accessing deleted polymorphic belongs_to associations" do
+      book = Book.create!
+      tag = Tag.create!(name: "jelly", taggable: book)
+
+      tag.destroy
+      tag = Tag.with_deleted.first
+
+      tag.taggable.should == book
+    end
+
+    it "ensures deleted associations themselves allow access to deleted records" do
+      book = Book.create!
+      chapter = book.chapters.create!
+      book.bookmarks.create!
+
+      book.destroy
+      bookmark = Bookmark.with_deleted.first
+
+      bookmark.book.chapters.should == [chapter]
+      chapter = bookmark.book.chapters.first
+
+      chapter.book.should == book
+    end
+
+    it "forwards normal method calls" do
+      book = Book.create!(title: "The Odyssey")
+      book.destroy
+      book = Book.with_deleted.first
+
+      book.title.should == "The Odyssey"
+    end
+  end
+
+  describe ".deleted" do
+    it "scopes the query to only deleted records" do
+      book1 = Book.create!
+      book2 = Book.create!
+
+      book1.destroy
+
+      Book.deleted.should == [book1]
+    end
+
+    it "respects associations" do
+      author = Author.create!
+      book = Book.create!(author: author)
+      other_book = Book.create!
+
+      book.destroy
+      other_book.destroy
+
+      author.books.deleted.should == [book]
+    end
+  end
+
+  describe "#destroy" do
+    it "sets #updated_at if it is defined" do
+      book = Timecop.travel(2.days.ago) { Book.create! }
+      updated_at = book.updated_at
+
+      book.destroy
+
+      book.updated_at.should_not == updated_at
+    end
+
+    it "does not set #updated_at if it is not defined" do
+      bookmark = Timecop.travel(2.days.ago) { Bookmark.create! }
+      expect { bookmark.destroy }.to_not raise_exception
+    end
+  end
+
+  describe "#restore!" do
+    let(:book) { Book.create! }
+    let(:deleted_book) { Book.deleted.find(book.id) }
+
+    it "restores the record" do
+      book.destroy
+
+      deleted_book.restore!
+      deleted_book.deleted_at.should be_nil
+    end
+
+    it "also restores restorable has_many associated records" do
+      chapter = book.chapters.create!
+
+      book.destroy
+      deleted_book.restore!
+
+      deleted_chapter = Chapter.with_deleted.find(chapter.id)
+      deleted_chapter.deleted_at.should be_nil
+    end
+
+    it "also restores restorable has_one associated records" do
+      cover = book.create_cover!
+
+      book.destroy
+      deleted_book.restore!
+
+      deleted_cover = Cover.with_deleted.find(cover.id)
+      deleted_cover.deleted_at.should be_nil
+    end
+
+    it "also restores restorable belongs_to associated records" do
+      author = Author.create!
+      book.update_attribute(:author, author)
+
+      book.destroy
+      deleted_book.restore!
+
+      deleted_author = Author.with_deleted.find(author.id)
+      deleted_author.deleted_at.should be_nil
+    end
+
+    it "does not restore hard deleted associated records" do
+      note = book.notes.create!
+
+      book.destroy
+      deleted_book.restore!
+
+      Note.where(id: note.id).should_not exist
+    end
+
+    it "does not restore an association if it is not destroy dependent" do
+      library = Library.create!
+      book.update_attribute(:library, library)
+
+      book.destroy
+      library.destroy
+      deleted_book.restore!
+
+      library_after_deletion = Library.with_deleted.find(library.id)
+      library_after_deletion.deleted_at.should_not be_nil
+    end
+
+    it "fails if the object itself has been destroyed" do
+      book.destroy
+
+      expect { book.restore! }.to raise_exception(RuntimeError)
+    end
+  end
+
+  describe "#deleted?" do
+    let(:book) { Book.create! }
+
+    it "returns true if the record is deleted" do
+      book.destroy
+
+      book.should be_deleted
+    end
+
+    it "returns false if the record is not deleted" do
+      book.should_not be_deleted
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,138 @@
+require 'bundler/setup'
+require 'active_record'
+require 'timecop'
+require 'byebug'
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'zombie_record'
+
+class Book < ActiveRecord::Base
+  include ZombieRecord::Restorable
+
+  belongs_to :library
+  belongs_to :author, dependent: :destroy
+  has_one :cover, dependent: :destroy
+
+  has_many :chapters, dependent: :destroy
+  has_many :bookmarks, dependent: :destroy
+  has_many :notes, dependent: :destroy
+end
+
+class Chapter < ActiveRecord::Base
+  include ZombieRecord::Restorable
+
+  belongs_to :book
+end
+
+class Bookmark < ActiveRecord::Base
+  include ZombieRecord::Restorable
+
+  belongs_to :book
+end
+
+class Note < ActiveRecord::Base
+  belongs_to :book
+end
+
+class Author < ActiveRecord::Base
+  include ZombieRecord::Restorable
+
+  has_many :books
+end
+
+class Tag < ActiveRecord::Base
+  include ZombieRecord::Restorable
+
+  belongs_to :taggable, polymorphic: true, dependent: :destroy
+end
+
+class Cover < ActiveRecord::Base
+  include ZombieRecord::Restorable
+
+  belongs_to :book
+end
+
+
+class Library < ActiveRecord::Base
+  include ZombieRecord::Restorable
+
+  has_many :book
+end
+
+RSpec.configure do |config|
+  config.around do |example|
+    ActiveRecord::Base.transaction do
+      example.run
+      raise ActiveRecord::Rollback
+    end
+  end
+
+  config.before :suite do
+    ActiveRecord::Base.establish_connection(
+      adapter: "mysql2",
+      username: "root",
+      host: "127.0.0.1",
+      port: 3306,
+      password: ""
+    )
+
+    ActiveRecord::Base.connection.create_database("zombie_record")
+    ActiveRecord::Base.connection.execute("use zombie_record;")
+
+    ActiveRecord::Schema.define do
+      self.verbose = false
+
+      create_table :books do |t|
+        t.integer :author_id
+        t.integer :library_id
+        t.timestamps
+        t.string :title
+        t.timestamp :deleted_at
+      end
+
+      create_table :chapters do |t|
+        t.integer :book_id
+        t.timestamps
+        t.timestamp :deleted_at
+      end
+
+      create_table :bookmarks do |t|
+        t.integer :book_id
+        t.timestamp :created_at
+        t.timestamp :deleted_at
+      end
+
+      create_table :notes do |t|
+        t.integer :book_id
+        t.timestamps
+      end
+
+      create_table :tags do |t|
+        t.string :name
+        t.string :taggable_type
+        t.integer :taggable_id
+        t.timestamp :deleted_at
+      end
+
+      create_table :covers do |t|
+        t.integer :book_id
+        t.timestamps
+        t.timestamp :deleted_at
+      end
+
+      create_table :authors do |t|
+        t.timestamps
+        t.timestamp :deleted_at
+      end
+
+      create_table :libraries do |t|
+        t.timestamps
+        t.timestamp :deleted_at
+      end
+    end
+  end
+
+  config.after :suite do
+    ActiveRecord::Base.connection.drop_database("zombie_record") rescue nil
+  end
+end

data/zombie_record.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'zombie_record/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "zombie_record"
+  spec.version       = ZombieRecord::VERSION
+  spec.authors       = ["Daniel Schierbeck"]
+  spec.email         = ["dasch@zendesk.com"]
+  spec.description   = %q{Allows restoring your Active Records from the dead!}
+  spec.summary       = %q{Allows restoring your Active Records from the dead!}
+  spec.homepage      = "https://github.com/dasch/zombie_record"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", "~> 3.2.15"
+  spec.add_dependency "mysql2"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "timecop", "~> 0.7.0"
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: zombie_record
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- Daniel Schierbeck
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.15
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.15
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+description: Allows restoring your Active Records from the dead!
+email:
+- dasch@zendesk.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/zombie_record.rb
+- lib/zombie_record/restorable.rb
+- lib/zombie_record/version.rb
+- spec/restorable_spec.rb
+- spec/spec_helper.rb
+- zombie_record.gemspec
+homepage: https://github.com/dasch/zombie_record
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Allows restoring your Active Records from the dead!
+test_files:
+- spec/restorable_spec.rb
+- spec/spec_helper.rb
+has_rdoc: