mongoid-paranoia 0.1.0

data/.gitignore

@@ -0,0 +1,25 @@
+# Because this is a gem, ignore Gemfile.lock:
+
+Gemfile.lock
+
+# And because this is Ruby, ignore the following
+#  (source: https://github.com/github/gitignore/blob/master/Ruby.gitignore):
+
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+
+
+# 0.1.0 (February 26, 2013)
+* First public version.

data/Gemfile

@@ -0,0 +1,7 @@
+ruby '1.9.3'
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rspec'
+gem 'rake'

data/README.md

@@ -0,0 +1,65 @@
+# mongoid-paranoia
+
+There may be times when you don't want documents to actually get deleted from the database, but "flagged" as deleted. Mongoid provides a Paranoia module to give you just that.
+
+## Installation
+
+In your Gemfile:
+
+```ruby
+gem 'mongoid-paranoia'
+```
+
+## 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.
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Copyright
+
+(The MIT license)
+
+Copyright (c) 2013 Mario Uher
+
+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/Rakefile

@@ -0,0 +1,7 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['spec/**/*_spec.rb']
+end
+
+task default: :test

data/lib/mongoid/paranoia.rb

@@ -0,0 +1,133 @@
+# encoding: utf-8
+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
+    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)
+    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
+
+    # 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!
+      Persistence::Operations.remove(self).persist
+    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(options = {})
+      cascade!
+      time = self.deleted_at = Time.now
+      paranoid_collection.find(atomic_selector).
+        update({ "$set" => { paranoid_field => time }})
+      @destroyed = true
+      IdentityMap.remove(self)
+      Threaded.clear_options!
+      true
+    end
+    alias :delete :remove
+
+    # 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
+    #
+    # @return [ Time ] The time the document had been deleted.
+    #
+    # @since 1.0.0
+    def restore
+      paranoid_collection.find(atomic_selector).
+        update({ "$unset" => { paranoid_field => true }})
+      attributes.delete("deleted_at")
+      @destroyed = false
+      true
+    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/version.rb

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

data/mongoid-paranoia.gemspec

@@ -0,0 +1,18 @@
+$: << File.expand_path('../lib', __FILE__)
+require 'mongoid/paranoia/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'mongoid-paranoia'
+  gem.version       = Mongoid::Paranoia::VERSION
+  gem.authors       = 'Mario Uher'
+  gem.email         = 'uher.mario@gmail.com'
+  gem.homepage      = 'https://github.com/haihappen/mongoid-paranoia'
+  gem.summary       = 'Extraction of mongoid-paranoia into its own gem.'
+  gem.description   = "There may be times when you don't want documents to actually get deleted from the database, but \"flagged\" as deleted."
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.require_path  = 'lib'
+
+  gem.add_dependency 'activesupport'
+  gem.add_dependency 'mongoid'
+end

data/spec/app/models/account.rb

@@ -0,0 +1,32 @@
+class Account
+  include Mongoid::Document
+
+  field :_id, type: String, default: ->{ name.try(:parameterize) }
+
+  field :number, type: String
+  field :balance, type: String
+  field :nickname, type: String
+  field :name, type: String
+  field :balanced, type: Boolean, default: ->{ balance? ? true : false }
+
+  field :overridden, type: String
+
+  embeds_many :memberships
+  belongs_to :creator, class_name: "User", foreign_key: :creator_id
+  belongs_to :person
+  has_many :alerts
+  has_and_belongs_to_many :agents
+  has_one :comment, validate: false
+
+  attr_accessible :nickname, as: [ :default, :admin ]
+  attr_accessible :name, as: [ :default, :admin ]
+  attr_accessible :balance, as: :default
+
+  validates_presence_of :name
+  validates_presence_of :nickname, on: :upsert
+  validates_length_of :name, maximum: 10, on: :create
+
+  def overridden
+    self[:overridden] = "not recommended"
+  end
+end

data/spec/app/models/acolyte.rb

@@ -0,0 +1,16 @@
+class Acolyte
+  include Mongoid::Document
+  field :status
+  field :name
+
+  embeds_many :versions, as: :memorable
+  belongs_to :church
+
+  default_scope asc(:name)
+  scope :active, ->{ where(status: "active") }
+  scope :named, ->{ where(:name.exists => true) }
+
+  def callback_test?
+    name == "callback-test"
+  end
+end

data/spec/app/models/actor.rb

@@ -0,0 +1,19 @@
+class Actor
+  include Mongoid::Document
+  field :name
+  field :after_custom_count, type: Integer, default: 0
+  has_and_belongs_to_many :tags
+  embeds_many :things, validate: false, cascade_callbacks: true
+  accepts_nested_attributes_for :things, allow_destroy: true
+
+  define_model_callbacks :custom
+  observable :custom
+
+  def do_something
+    run_callbacks(:custom) do
+      self.name = "custom"
+    end
+  end
+end
+
+require "app/models/actress"

data/spec/app/models/actor_observer.rb

@@ -0,0 +1,15 @@
+class ActorObserver < Mongoid::Observer
+  attr_reader :last_after_create_record
+
+  def after_create(record)
+    @last_after_create_record = record
+  end
+
+  def after_custom(record)
+    record.after_custom_count += 1
+  end
+
+  def before_custom(record)
+    @after_custom_called = true
+  end
+end

data/spec/app/models/actress.rb

@@ -0,0 +1,2 @@
+class Actress < Actor
+end

data/spec/app/models/address.rb

@@ -0,0 +1,72 @@
+class Address
+  include Mongoid::Document
+
+  field :_id, type: String, default: ->{ street.try(:parameterize) }
+
+  attr_accessor :mode
+
+  field :address_type
+  field :number, type: Integer
+  field :street
+  field :city
+  field :state
+  field :post_code
+  field :parent_title
+  field :services, type: Array
+  field :latlng, type: Array
+  field :map, type: Hash
+  field :move_in, type: DateTime
+  field :s, type: String, as: :suite
+  field :name, localize: true
+
+  embeds_many :locations, validate: false
+  embeds_one :code, validate: false
+  embeds_one :target, as: :targetable, validate: false
+
+  embedded_in :addressable, polymorphic: true do
+    def extension
+      "Testing"
+    end
+    def doctor?
+      title == "Dr"
+    end
+  end
+
+  accepts_nested_attributes_for :code, :target
+  accepts_nested_attributes_for :locations, allow_destroy: true
+
+  belongs_to :account
+  belongs_to :band
+
+  scope :without_postcode, where(postcode: nil)
+  scope :rodeo, where(street: "Rodeo Dr") do
+    def mansion?
+      all? { |address| address.street == "Rodeo Dr" }
+    end
+  end
+
+  validates_presence_of :street, on: :update
+  validates_format_of :street, with: /\D/, allow_nil: true
+
+  def set_parent=(set = false)
+    self.parent_title = addressable.title if set
+  end
+
+  def <=>(other)
+    street <=> other.street
+  end
+
+  class << self
+    def california
+      where(state: "CA")
+    end
+
+    def homes
+      where(address_type: "Home")
+    end
+
+    def streets
+      all.map(&:street)
+    end
+  end
+end

data/spec/app/models/address_component.rb

@@ -0,0 +1,5 @@
+class AddressComponent
+  include Mongoid::Document
+  field :street, type: String
+  embedded_in :person
+end