mongoid_paranoia 0.1.2

data/spec/app/models/address.rb

@@ -0,0 +1,71 @@
+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_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
+
+  belongs_to :account
+
+  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/appointment.rb

@@ -0,0 +1,7 @@
+class Appointment
+  include Mongoid::Document
+  field :active, type: Boolean, default: true
+  field :timed, type: Boolean, default: true
+  embedded_in :person
+  default_scope ->{where(active: true)}
+end

data/spec/app/models/author.rb

@@ -0,0 +1,6 @@
+class Author
+  include Mongoid::Document
+  field :name, type: String
+
+  belongs_to :post, class_name: "ParanoidPost"
+end

data/spec/app/models/fish.rb

@@ -0,0 +1,8 @@
+class Fish
+  include Mongoid::Document
+  include Mongoid::Paranoia
+
+  def self.fresh
+    where(fresh: true)
+  end
+end

data/spec/app/models/paranoid_phone.rb

@@ -0,0 +1,25 @@
+class ParanoidPhone
+  include Mongoid::Document
+  include Mongoid::Paranoia
+
+  attr_accessor :after_destroy_called, :before_destroy_called
+
+  field :number, type: String
+
+  embedded_in :person
+
+  before_destroy :before_destroy_stub, :halt_me
+  after_destroy :after_destroy_stub
+
+  def before_destroy_stub
+    self.before_destroy_called = true
+  end
+
+  def after_destroy_stub
+    self.after_destroy_called = true
+  end
+
+  def halt_me
+    person.age == 42 ? false : true
+  end
+end

data/spec/app/models/paranoid_post.rb

@@ -0,0 +1,53 @@
+class ParanoidPost
+  include Mongoid::Document
+  include Mongoid::Paranoia
+
+  field :title, type: String
+
+  attr_accessor :after_destroy_called, :before_destroy_called,
+                :after_restore_called, :before_restore_called,
+                :around_before_restore_called, :around_after_restore_called
+
+  belongs_to :person
+
+  has_and_belongs_to_many :tags
+  has_many :authors, dependent: :delete, inverse_of: :post
+  has_many :titles, dependent: :restrict
+
+  scope :recent, -> {where(created_at: { "$lt" => Time.now, "$gt" => 30.days.ago })}
+
+  before_destroy :before_destroy_stub
+  after_destroy  :after_destroy_stub
+
+  before_restore :before_restore_stub
+  after_restore  :after_restore_stub
+  around_restore :around_restore_stub
+
+  def before_destroy_stub
+    self.before_destroy_called = true
+  end
+
+  def after_destroy_stub
+    self.after_destroy_called = true
+  end
+
+  def before_restore_stub
+    self.before_restore_called = true
+  end
+
+  def after_restore_stub
+    self.after_restore_called = true
+  end
+
+  def around_restore_stub
+    self.around_before_restore_called = true
+    yield
+    self.around_after_restore_called = true
+  end
+
+  class << self
+    def old
+      where(created_at: { "$lt" => 30.days.ago })
+    end
+  end
+end

data/spec/app/models/person.rb

@@ -0,0 +1,190 @@
+class Person
+  include Mongoid::Document
+  attr_accessor :mode
+
+  class_attribute :somebody_elses_important_class_options
+  self.somebody_elses_important_class_options = { keep_me_around: true }
+
+  field :title
+  field :terms, type: Boolean
+  field :pets, type: Boolean, default: false
+  field :age, type: Integer, default: "100"
+  field :dob, type: Date
+  field :employer_id
+  field :lunch_time, type: Time
+  field :aliases, type: Array
+  field :map, type: Hash
+  field :map_with_default, type: Hash, default: {}
+  field :score, type: Integer
+  field :blood_alcohol_content, type: Float, default: ->{ 0.0 }
+  field :last_drink_taken_at, type: Date
+  field :ssn
+  field :owner_id, type: Integer
+  field :security_code
+  field :reading, type: Object
+  field :bson_id, type: BSON::ObjectId
+  field :pattern, type: Regexp
+  field :override_me, type: Integer
+  field :t, as: :test, type: String
+  field :i, as: :inte, type: Integer
+  field :a, as: :array, type: Array
+  field :desc, localize: true
+
+  index age: 1
+  index addresses: 1
+  index dob: 1
+  index name: 1
+  index title: 1
+
+  index({ ssn: 1 }, { unique: true })
+
+  attr_reader :rescored
+
+  embeds_many :phone_numbers, class_name: "Phone", validate: false
+  embeds_many :phones, store_as: :mobile_phones, validate: false
+  embeds_many :addresses, as: :addressable, validate: false do
+    def extension
+      "Testing"
+    end
+    def find_by_street(street)
+      where(street: street).first
+    end
+  end
+
+  embeds_many :appointments, validate: false
+  embeds_many :paranoid_phones, validate: false
+
+  embeds_one :passport, autobuild: true, store_as: :pass, validate: false
+  embeds_one :pet, class_name: "Animal", validate: false
+  embeds_one :name, as: :namable, validate: false do
+    def extension
+      "Testing"
+    end
+    def dawkins?
+      first_name == "Richard" && last_name == "Dawkins"
+    end
+  end
+  embeds_one :quiz, validate: false
+
+  has_one :game, dependent: :destroy, validate: false do
+    def extension
+      "Testing"
+    end
+  end
+
+  has_many \
+    :posts,
+    dependent: :delete,
+    validate: false do
+    def extension
+      "Testing"
+    end
+  end
+  has_many :ordered_posts, order: :rating.desc, validate: false
+  has_and_belongs_to_many \
+    :preferences,
+    index: true,
+    dependent: :nullify,
+    validate: false
+  has_and_belongs_to_many :user_accounts, validate: false
+  has_and_belongs_to_many :houses, validate: false
+  has_and_belongs_to_many :ordered_preferences, order: :value.desc, validate: false
+
+  has_many :drugs, validate: false
+  has_many :paranoid_posts, validate: false
+  has_one :account, validate: false
+  has_one :cat, dependent: :nullify, validate: false
+  has_one :book, autobuild: true, validate: false
+  has_one :home, dependent: :delete, validate: false
+
+  belongs_to :paranoid_post
+
+  has_and_belongs_to_many \
+    :administrated_events,
+    class_name: 'Event',
+    inverse_of: :administrators,
+    dependent:  :nullify,
+    validate: false
+
+  accepts_nested_attributes_for :addresses
+  accepts_nested_attributes_for :name, update_only: true
+  accepts_nested_attributes_for :pet, allow_destroy: true
+  accepts_nested_attributes_for :game, allow_destroy: true
+  accepts_nested_attributes_for :posts
+  accepts_nested_attributes_for :preferences
+  accepts_nested_attributes_for :quiz
+  accepts_nested_attributes_for :paranoid_phones
+
+  scope :minor, ->{where(:age.lt => 18)}
+  scope :without_ssn, ->{without(:ssn)}
+  scope :search, ->(query){ any_of({ title: query }) }
+
+  def score_with_rescoring=(score)
+    @rescored = score.to_i + 20
+    self.score_without_rescoring = score
+  end
+
+  alias_method_chain :score=, :rescoring
+
+  def update_addresses
+    addresses.each do |address|
+      address.street = "Updated Address"
+    end
+  end
+
+  def employer=(emp)
+    self.employer_id = emp.id
+  end
+
+  def set_addresses=(addresses)
+    self.addresses = addresses
+  end
+
+  def override_me
+    read_attribute(:override_me).to_s
+  end
+
+  class << self
+    def accepted
+      scoped.where(terms: true)
+    end
+    def knight
+      scoped.where(title: "Sir")
+    end
+    def old
+      scoped.where(age: { "$gt" => 50 })
+    end
+  end
+
+  def reject_if_city_is_empty(attrs)
+    attrs[:city].blank?
+  end
+
+  def reject_if_name_is_blank(attrs)
+    attrs[:first_name].blank?
+  end
+
+  def foo
+    'i_am_foo'
+  end
+
+  def preference_names=(names)
+    names.split(",").each do |name|
+      preference = Preference.where(name: name).first
+      if preference
+        self.preferences << preference
+      else
+        preferences.build(name: name)
+      end
+    end
+  end
+
+  def set_on_map_with_default=(value)
+    self.map_with_default["key"] = value
+  end
+
+  reset_callbacks(:validate)
+  reset_callbacks(:create)
+  reset_callbacks(:save)
+  reset_callbacks(:destroy)
+end

data/spec/app/models/phone.rb

@@ -0,0 +1,11 @@
+class Phone
+  include Mongoid::Document
+
+  attr_accessor :number_in_observer
+
+  field :_id, type: String, default: ->{ number }
+
+  field :number
+  embeds_one :country_code
+  embedded_in :person
+end

data/spec/app/models/tag.rb

@@ -0,0 +1,6 @@
+class Tag
+  include Mongoid::Document
+  field :text, type: String
+  has_and_belongs_to_many :paranoid_posts
+  has_and_belongs_to_many :related, class_name: "Tag", inverse_of: :related
+end

data/spec/app/models/title.rb

@@ -0,0 +1,4 @@
+class Title
+  include Mongoid::Document
+  belongs_to :paranoid_post
+end

data/spec/mongoid/document_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe Mongoid::Document do
+
+  describe ".paranoid?" do
+
+    context "when Mongoid::Paranoia is included" do
+      subject { ParanoidPost }
+      it "returns true" do
+        expect(subject.paranoid?).to be_truthy
+      end
+    end
+
+    context "when Mongoid::Paranoia not included" do
+      subject { Author }
+      it "returns true" do
+        expect(subject.paranoid?).to be_falsey
+      end
+    end
+  end
+end

data/spec/mongoid/nested_attributes_spec.rb

@@ -0,0 +1,164 @@
+require "spec_helper"
+
+describe Mongoid::Attributes::Nested do
+  describe "##{name}_attributes=" do
+    context "when the parent document is new" do
+      context "when the relation is an embeds many" do
+        context "when ids are passed" do
+
+          let(:person) do
+            Person.create
+          end
+
+          let(:address_one) do
+            Address.new(street: "Unter den Linden")
+          end
+
+          let(:address_two) do
+            Address.new(street: "Kurfeurstendamm")
+          end
+
+          let(:phone_one) do
+            ParanoidPhone.new(number: "1")
+          end
+
+          let(:phone_two) do
+            ParanoidPhone.new(number: "2")
+          end
+
+          before do
+            person.addresses << [ address_one, address_two ]
+          end
+
+          context "when destroy attributes are passed" do
+            context "when the ids match" do
+              context "when allow_destroy is true" do
+                context "when the child is paranoid" do
+
+                  before(:all) do
+                    Person.send(:undef_method, :paranoid_phones_attributes=)
+                    Person.accepts_nested_attributes_for :paranoid_phones,
+                      allow_destroy: true
+                  end
+
+                  after(:all) do
+                    Person.send(:undef_method, :paranoid_phones_attributes=)
+                    Person.accepts_nested_attributes_for :paranoid_phones
+                  end
+
+                  [ 1, "1", true, "true" ].each do |truth|
+
+                    context "when passed a #{truth} with destroy" do
+                      context "when the parent is persisted" do
+
+                        let!(:persisted) do
+                          Person.create do |p|
+                            p.paranoid_phones << [ phone_one, phone_two ]
+                          end
+                        end
+
+                        context "when setting, pulling, and pushing in one op" do
+
+                          before do
+                            persisted.paranoid_phones_attributes =
+                              {
+                              "bar" => { "id" => phone_one.id, "_destroy" => truth },
+                              "foo" => { "id" => phone_two.id, "number" => "3" },
+                              "baz" => { "number" => "4" }
+                            }
+                          end
+
+                          it "removes the first document from the relation" do
+                            expect(persisted.paranoid_phones.size).to eq(2)
+                          end
+
+                          it "does not delete the unmarked document" do
+                            expect(persisted.paranoid_phones.first.number).to eq("3")
+                          end
+
+                          it "adds the new document to the relation" do
+                            expect(persisted.paranoid_phones.last.number).to eq("4")
+                          end
+
+                          it "has the proper persisted count" do
+                            expect(persisted.paranoid_phones.count).to eq(1)
+                          end
+
+                          it "soft deletes the removed document" do
+                            expect(phone_one).to be_destroyed
+                          end
+
+                          context "when saving the parent" do
+
+                            before do
+                              persisted.with(safe: true).save
+                            end
+
+                            it "deletes the marked document from the relation" do
+                              expect(persisted.reload.paranoid_phones.count).to eq(2)
+                            end
+
+                            it "does not delete the unmarked document" do
+                              expect(persisted.reload.paranoid_phones.first.number).to eq("3")
+                            end
+
+                            it "persists the new document to the relation" do
+                              expect(persisted.reload.paranoid_phones.last.number).to eq("4")
+                            end
+                          end
+                        end
+                      end
+                    end
+                  end
+                end
+
+                context "when the child has defaults" do
+
+                  before(:all) do
+                    Person.accepts_nested_attributes_for :appointments, allow_destroy: true
+                  end
+
+                  after(:all) do
+                    Person.send(:undef_method, :appointments_attributes=)
+                  end
+                  context "when the parent is persisted" do
+                    context "when the child returns false in a before callback" do
+                      context "when the child is paranoid" do
+
+                        before(:all) do
+                          Person.accepts_nested_attributes_for :paranoid_phones, allow_destroy: true
+                        end
+
+                        after(:all) do
+                          Person.send(:undef_method, :paranoid_phones=)
+                          Person.accepts_nested_attributes_for :paranoid_phones
+                        end
+
+                        let!(:persisted) do
+                          Person.create(age: 42)
+                        end
+
+                        let!(:phone) do
+                          persisted.paranoid_phones.create
+                        end
+
+                        before do
+                          persisted.paranoid_phones_attributes =
+                            { "foo" => { "id" => phone.id, "number" => 42, "_destroy" => true }}
+                        end
+
+                        it "does not destroy the child" do
+                          expect(persisted.reload.paranoid_phones).not_to be_empty
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end