mongoid_paranoia 0.1.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NjFjZDkxZDIzNmM0MzRjMDNiODYyNmRkOGZjNWNiMzljZmI1NGU2Yg==
+  data.tar.gz: !binary |-
+    NjAxNjc2MjRiYjAxNWE5ZTc5M2UyYTRiNTQ4ZmZmODRmMzJhYjY5YQ==
+SHA512:
+  metadata.gz: !binary |-
+    YjBiYmQ2Zjc3MjEyZjAzZTVkNTM2ZDQ4NWI4NzYwM2YzMWIzODRjY2NmYmNl
+    ZDIxZmVjNDE1NTI0ZTYzOTBmNWI2NGE0YzQ4ZDVhOTA5NjhhZGMwNDgwMmFh
+    MGFhZDNhYTkwZTQ0ZTc3ZTNlNGNiOWE3MThmMWY1NTNkOGNiMzA=
+  data.tar.gz: !binary |-
+    NjkzMTE1N2UxMDY1ZWEyYWJmNjA0Njg1Zjk0MWYxMmRkZjExZDEyNWQzZjE2
+    YzA0ZmUyNzRlZjc3YjRiM2M0NTI3ZTE2MzQ2NTNjOWJiMGExZTJiMWI4ZmZm
+    Zjc1MGM1MTU2YTgxZjNiOGY2NGExOGI4OTdlMjY5YjBjNWVkMWY=

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Josef Šimánek
+
+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,110 @@
+# Paranoid Documents for Mongoid 4 [![Build Status](https://travis-ci.org/simi/mongoid-paranoia.png?branch=master)](https://travis-ci.org/simi/mongoid-paranoia)
+
+`Mongoid::Paranoia` enables a "soft delete" of Mongoid documents. Instead of being removed from the database, paranoid docs are flagged with a `deleted_at` timestamp and are ignored from queries by default.
+
+The `Mongoid::Paranoia` functionality was originally supported in Mongoid itself, but was dropped from version 4.0.0 onwards. This gem was extracted from the [Mongoid 3.0.0-stable branch](https://github.com/simi/mongoid-paranoia/tree/3.0.0-stable). This gem should not be used with Mongoid versions 3.x and prior.
+
+**Caution:** This repo/gem `mongoid_paranoia` (underscored) is different than `mongoid-paranoia` (hyphenated).
+The owner of `mongoid-paranoia` (hyphenated) is not accepting enhancements and has declined our requests
+to share maintenance of the gem.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mongoid_paranoia'
+```
+
+## Changes in 4.0
+
+### Uniqueness validator is not overriden
+
+#### Old syntax:
+```ruby
+validates_uniqueness_of :title
+validates :title, :uniqueness => true
+```
+
+#### New syntax:
+```ruby
+validates :title, uniqueness: { conditions: -> { where(deleted_at: nil) } }
+```
+
+## Usage
+
+```ruby
+class Person
+  include Mongoid::Document
+  include Mongoid::Paranoia
+end
+
+person.delete   # Sets the deleted_at field to the current time, ignoring callbacks.
+person.delete!  # Permanently deletes the document, ignoring callbacks.
+person.destroy  # Sets the deleted_at field to the current time, firing callbacks.
+person.destroy! # Permanently deletes the document, firing callbacks.
+person.restore  # Brings the "deleted" document back to life.
+```
+
+The documents that have been "flagged" as deleted (soft deleted) can be accessed at any time by calling the deleted class method on the class.
+
+```ruby
+Person.deleted # Returns documents that have been "flagged" as deleted.
+```
+
+You can also access all documents (both deleted and non-deleted) at any time by using the `unscoped` class method:
+
+```ruby
+Person.unscoped.all # Returns all documents, both deleted and non-deleted
+```
+
+### Callbacks ([@zhouguangming](https://github.com/zhouguangming))
+
+`before_restore`, `after_restore` and `around_restore` callbacks are added to your model. They work similarly to the `before_destroy`, `after_destroy` and `around_destroy` callbacks.
+
+```ruby
+class User
+  include Mongoid::Document
+  include Mongoid::Paranoia
+  
+  before_restore :before_restore_action
+  after_restore  :after_restore_action
+  around_restore :around_restore_action
+
+  private
+
+  def before_restore_action
+    puts "BEFORE"
+  end
+
+  def after_restore_action
+    puts "AFTER"
+  end
+  
+  def around_restore_action
+    puts "AROUND - BEFORE"
+    yield # restoring
+    puts "AROUND - AFTER"
+  end
+end
+```
+
+## TODO
+- get rid of [monkey_patches.rb](https://github.com/simi/mongoid-paranoia/blob/master/lib/mongoid/paranoia/monkey_patches.rb)
+- [review persisted? behaviour](https://github.com/simi/mongoid-paranoia/issues/2)
+
+## Authors
+
+* original [Mongoid](https://github.com/mongoid/mongoid) implementation by [@durran](https://github.com/durran)
+* extracted from [Mongoid](https://github.com/mongoid/mongoid) by [@simi](https://github.com/simi)
+* [documentation improvements](https://github.com/simi/mongoid-paranoia/pull/3) by awesome [@loopj](https://github.com/loopj)
+* [latest mongoid support, restore_callback support](https://github.com/simi/mongoid-paranoia/pull/8) by fabulous [@zhouguangming](https://github.com/zhouguangming)
+
+
+## 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/lib/mongoid-paranoia.rb

@@ -0,0 +1 @@
+require "mongoid/paranoia"

data/lib/mongoid/paranoia.rb

@@ -0,0 +1,154 @@
+# encoding: utf-8
+require 'mongoid/paranoia/monkey_patches'
+require 'active_support'
+require 'active_support/deprecation'
+
+module Mongoid
+
+  # Include this module to get soft deletion of root level documents.
+  # This will add a deleted_at field to the +Document+, managed automatically.
+  # Potentially incompatible with unique indices. (if collisions with deleted items)
+  #
+  # @example Make a document paranoid.
+  #   class Person
+  #     include Mongoid::Document
+  #     include Mongoid::Paranoia
+  #   end
+  module Paranoia
+    include Mongoid::Persistable::Deletable
+    extend ActiveSupport::Concern
+
+    included do
+      field :deleted_at, type: Time
+      self.paranoid = true
+
+      default_scope -> { where(deleted_at: nil) }
+      scope :deleted, -> { ne(deleted_at: nil) }
+      define_model_callbacks :restore
+    end
+
+    # Delete the paranoid +Document+ from the database completely. This will
+    # run the destroy callbacks.
+    #
+    # @example Hard destroy the document.
+    #   document.destroy!
+    #
+    # @return [ true, false ] If the operation succeeded.
+    #
+    # @since 1.0.0
+    def destroy!
+      run_callbacks(:destroy) { delete! }
+    end
+
+    # Override the persisted method to allow for the paranoia gem.
+    # If a paranoid record is selected, then we only want to check
+    # if it's a new record, not if it is "destroyed"
+    #
+    # @example
+    #   document.persisted?
+    #
+    # @return [ true, false ] If the operation succeeded.
+    #
+    # @since 4.0.0
+    def persisted?
+      !new_record?
+    end
+
+    # Delete the +Document+, will set the deleted_at timestamp and not actually
+    # delete it.
+    #
+    # @example Soft remove the document.
+    #   document.remove
+    #
+    # @param [ Hash ] options The database options.
+    #
+    # @return [ true ] True.
+    #
+    # @since 1.0.0
+    def remove_with_paranoia(options = {})
+      cascade!
+      time = self.deleted_at = Time.now
+      paranoid_collection.find(atomic_selector).
+        update({ "$set" => { paranoid_field => time }})
+      @destroyed = true
+      true
+    end
+    alias_method_chain :remove, :paranoia
+    alias :delete :remove
+
+    # Delete the paranoid +Document+ from the database completely.
+    #
+    # @example Hard delete the document.
+    #   document.delete!
+    #
+    # @return [ true, false ] If the operation succeeded.
+    #
+    # @since 1.0.0
+    def delete!
+      remove_without_paranoia
+    end
+
+    # Determines if this document is destroyed.
+    #
+    # @example Is the document destroyed?
+    #   person.destroyed?
+    #
+    # @return [ true, false ] If the document is destroyed.
+    #
+    # @since 1.0.0
+    def destroyed?
+      (@destroyed ||= false) || !!deleted_at
+    end
+    alias :deleted? :destroyed?
+
+    # Restores a previously soft-deleted document. Handles this by removing the
+    # deleted_at flag.
+    #
+    # @example Restore the document from deleted state.
+    #   document.restore
+    #
+    # TODO: @return [ Time ] The time the document had been deleted.
+    #
+    # @since 1.0.0
+    def restore
+      run_callbacks(:restore) do
+        paranoid_collection.find(atomic_selector).
+          update({ "$unset" => { paranoid_field => true }})
+        attributes.delete("deleted_at")
+        @destroyed = false
+        true
+      end
+    end
+
+    # Returns a string representing the documents's key suitable for use in URLs.
+    def to_param
+      new_record? ? nil : to_key.join('-')
+    end
+
+    private
+
+    # Get the collection to be used for paranoid operations.
+    #
+    # @example Get the paranoid collection.
+    #   document.paranoid_collection
+    #
+    # @return [ Collection ] The root collection.
+    #
+    # @since 2.3.1
+    def paranoid_collection
+      embedded? ? _root.collection : self.collection
+    end
+
+    # Get the field to be used for paranoid operations.
+    #
+    # @example Get the paranoid field.
+    #   document.paranoid_field
+    #
+    # @return [ String ] The deleted at field.
+    #
+    # @since 2.3.1
+    def paranoid_field
+      embedded? ? "#{atomic_position}.deleted_at" : "deleted_at"
+    end
+  end
+end

data/lib/mongoid/paranoia/monkey_patches.rb

@@ -0,0 +1,113 @@
+# encoding: utf-8
+module Mongoid
+  module Paranoia
+    module Document
+      extend ActiveSupport::Concern
+
+      included do
+        # Indicates whether or not the document includes Mongoid::Paranoia.
+        # In Mongoid 3, this method was defined on all Mongoid::Documents.
+        # In Mongoid 4, it is no longer defined, hence we are shimming it here.
+        class_attribute :paranoid
+      end
+    end
+  end
+end
+
+Mongoid::Document.send(:include, Mongoid::Paranoia::Document)
+
+module Mongoid
+  module Relations
+    module Builders
+      module NestedAttributes
+        class Many < NestedBuilder
+          # Destroy the child document, needs to do some checking for embedded
+          # relations and delay the destroy in case parent validation fails.
+          #
+          # @api private
+          #
+          # @example Destroy the child.
+          #   builder.destroy(parent, relation, doc)
+          #
+          # @param [ Document ] parent The parent document.
+          # @param [ Proxy ] relation The relation proxy.
+          # @param [ Document ] doc The doc to destroy.
+          #
+          # @since 3.0.10
+          def destroy(parent, relation, doc)
+            doc.flagged_for_destroy = true
+            if !doc.embedded? || parent.new_record? || doc.paranoid?
+              destroy_document(relation, doc)
+            else
+              parent.flagged_destroys.push(->{ destroy_document(relation, doc) })
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+module Mongoid
+  module Relations
+    module Embedded
+      # This class handles the behaviour for a document that embeds many other
+      # documents within in it as an array.
+      class Many < Relations::Many
+        # Delete the supplied document from the target. This method is proxied
+        # in order to reindex the array after the operation occurs.
+        #
+        # @example Delete the document from the relation.
+        #   person.addresses.delete(address)
+        #
+        # @param [ Document ] document The document to be deleted.
+        #
+        # @return [ Document, nil ] The deleted document or nil if nothing deleted.
+        #
+        # @since 2.0.0.rc.1
+        def delete(document)
+          execute_callback :before_remove, document
+          doc = target.delete_one(document)
+          if doc && !_binding?
+            _unscoped.delete_one(doc) unless doc.paranoid?
+            if _assigning?
+              if doc.paranoid?
+                doc.destroy(suppress: true)
+              else
+                base.add_atomic_pull(doc)
+              end
+            else
+              doc.delete(suppress: true)
+              unbind_one(doc)
+            end
+          end
+          reindex
+          execute_callback :after_remove, document
+          doc
+        end
+      end
+    end
+  end
+end
+
+module Mongoid
+  module Relations
+    module Embedded
+      class Many < Relations::Many
+        # For use only with Mongoid::Paranoia - will be removed in 4.0.
+        #
+        # @example Get the deleted documents from the relation.
+        #   person.paranoid_phones.deleted
+        #
+        # @return [ Criteria ] The deleted documents.
+        #
+        # @since 3.0.10
+        def deleted
+          unscoped.deleted
+        end
+        # This class handles the behaviour for a document that embeds many other
+        # documents within in it as an array.
+      end
+    end
+  end
+end

data/lib/mongoid/paranoia/version.rb

@@ -0,0 +1,5 @@
+module Mongoid
+  module Paranoia
+    VERSION = '0.1.2'
+  end
+end

data/lib/mongoid_paranoia.rb

@@ -0,0 +1 @@
+require "mongoid/paranoia"

data/perf/scope.rb

@@ -0,0 +1,64 @@
+require 'bundler/setup'
+require 'mongoid'
+require 'mongoid/paranoia'
+require 'benchmark'
+
+
+Mongoid.configure do |config|
+  config.connect_to('my_little_test')
+end
+
+class Model
+  include Mongoid::Document
+  field :text, type: String
+
+  index({ text: "text" })
+end
+
+class ParanoidModel
+  include Mongoid::Document
+  include Mongoid::Paranoia
+  field :text, type: String
+
+  index({ text: "text" })
+end
+
+class MetaParanoidModel
+  include Mongoid::Document
+  field :text, type: String
+  field :deleted_at, type: Time
+  default_scope -> { where(deleted_at: nil) }
+
+  index({ text: "text" })
+end
+
+if ENV['FORCE']
+  Mongoid.purge!
+  ::Mongoid::Tasks::Database.create_indexes
+
+  n = 50_000
+  n.times {|i| Model.create(text: "text #{i}")}
+  n.times {|i| ParanoidModel.create(text: "text #{i}")}
+  n.times {|i| MetaParanoidModel.create(text: "text #{i}")}
+end
+
+n = 100
+
+puts "text_search benchmark ***"
+Benchmark.bm(20) do |x|
+  x.report("without") { n.times { Model.text_search("text").execute } }
+  x.report("with")    { n.times { ParanoidModel.text_search("text").execute } }
+  x.report("meta")    { n.times { MetaParanoidModel.text_search("text").execute } }
+  x.report("unscoped meta")    { n.times { MetaParanoidModel.unscoped.text_search("text").execute } }
+  x.report("unscoped paranoid")    { n.times { ParanoidModel.unscoped.text_search("text").execute } }
+end
+
+puts ""
+puts "Pluck all ids benchmark ***"
+Benchmark.bm(20) do |x|
+  x.report("without") { n.times { Model.all.pluck(:id) } }
+  x.report("with")    { n.times { ParanoidModel.all.pluck(:id) } }
+  x.report("meta")    { n.times { MetaParanoidModel.all.pluck(:id) } }
+  x.report("unscoped meta")    { n.times { MetaParanoidModel.unscoped.all.pluck(:id) } }
+  x.report("unscoped paranoid")    { n.times { ParanoidModel.unscoped.all.pluck(:id) } }
+end