mongoid-observers 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 97a99e1dcf3791371c919044d09c214b1ac22bc8
+  data.tar.gz: 26f5fd4d534d5eaf1ac0285ad0fc515d66e93b4e
+SHA512:
+  metadata.gz: efd60e17bff3b6f9644b1ae730f2aaca2246c63e988b269e8f6e830e6238951e148bb1c6dc80c48ef42ffcf2ab6851b66f6861f3e4e63f73e7d6430273c77ebf
+  data.tar.gz: 2de69d89aa581ad857c323dcf67ccae78cc2ad38a5b1a539d43cc33d5e4b374b28adf679f389e8a888cee44e5510f6cdd2c6d4c15e7e8844352cd735d47e502a

data/.coveralls.yml

@@ -0,0 +1,2 @@
+service_name: travis-ci
+repo_token: rr717xFYVzxOS32gtsbWXR5QaxG4CBpIr

data/.gitignore

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

data/.rspec

@@ -0,0 +1 @@
+--colour

data/.ruby-gemset

@@ -0,0 +1 @@
+mongoid-observers

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.1.1

data/.travis.yml

@@ -0,0 +1,15 @@
+services: mongodb
+language: ruby
+script: "bundle exec rake spec"
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.1.1
+env:
+  - CODECLIMATE_REPO_TOKEN=f506e465f1ed0571aeaa5e1cb9c14214c9f7567a92d1af70903f3d0bc8015ed6
+notifications:
+  email: false
+addons:
+  code_climate:
+    repo_token: f506e465f1ed0571aeaa5e1cb9c14214c9f7567a92d1af70903f3d0bc8015ed6

data/Gemfile

@@ -0,0 +1,14 @@
+source "https://rubygems.org"
+
+gem "bundler",          "~> 1.5.3"
+gem "rake",             "~> 10.2.2"
+gem "rspec",            "~> 2.14.1"
+gem "pry",              "~> 0.9.12.6"
+gem "simplecov",        "~> 0.8.2"
+gem "coveralls",        "~> 0.7.0", require: false
+gem "codeclimate-test-reporter"
+gem "ammeter",          "~> 1.0.0"
+gem "railties"
+
+# Specify your gem's dependencies in mongoid-observers.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Chamnap Chhorn
+
+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,141 @@
+# Mongoid::Observers [![Build Status](https://travis-ci.org/chamnap/mongoid-observers.svg?branch=master)](https://travis-ci.org/chamnap/mongoid-observers)[![Code Climate](https://codeclimate.com/github/chamnap/mongoid-observers.png)](https://codeclimate.com/github/chamnap/mongoid-observers)[![Coverage Status](https://coveralls.io/repos/chamnap/mongoid-observers/badge.png?branch=master)](https://coveralls.io/r/chamnap/mongoid-observers?branch=master)[![Dependency Status](https://gemnasium.com/chamnap/mongoid-observers.svg)](https://gemnasium.com/chamnap/mongoid-observers)
+
+Mongoid Observers (removed from core in Mongoid 4.0). Because this gem doesn't exist and I need to use it very often. Therefore, I extract the code from mongoid on my own. It's basically the same code from mongoid before it's removed.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'mongoid-observers'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mongoid-observers
+
+## Usage
+
+Observer classes respond to life cycle callbacks to implement trigger-like
+behavior outside the original class. This is a great way to reduce the
+clutter that normally comes when the model class is burdened with
+functionality that doesn't pertain to the core responsibility of the
+class. Mongoid's observers work similar to ActiveRecord's. Example:
+
+```ruby
+  class CommentObserver < Mongoid::Observer
+    def after_save(comment)
+      Notifications.comment(
+        "admin@do.com", "New comment was posted", comment
+      ).deliver
+    end
+  end
+```
+
+This Observer sends an email when a Comment#save is finished.
+
+```ruby
+  class ContactObserver < Mongoid::Observer
+    def after_create(contact)
+      contact.logger.info('New contact added!')
+    end
+
+    def after_destroy(contact)
+      contact.logger.warn("Contact with an id of #{contact.id} was destroyed!")
+    end
+  end
+```
+
+This Observer uses logger to log when specific callbacks are triggered.
+
+#### Observing a class that can't be inferred
+
+Observers will by default be mapped to the class with which they share a
+name. So CommentObserver will be tied to observing Comment,
+ProductManagerObserver to ProductManager, and so on. If you want to
+name your observer differently than the class you're interested in
+observing, you can use the Observer.observe class method which takes
+either the concrete class (Product) or a symbol for that class (:product):
+
+```ruby
+  class AuditObserver < Mongoid::Observer
+    observe :account
+
+    def after_update(account)
+      AuditTrail.new(account, "UPDATED")
+    end
+  end
+```
+
+If the audit observer needs to watch more than one kind of object,
+this can be specified with multiple arguments:
+
+```ruby
+  class AuditObserver < Mongoid::Observer
+    observe :account, :balance
+
+    def after_update(record)
+      AuditTrail.new(record, "UPDATED")
+    end
+  end
+```
+
+The AuditObserver will now act on both updates to Account and Balance
+by treating them both as records.
+
+#### Available callback methods
+
+* after_initialize
+* before_validation
+* after_validation
+* before_create
+* around_create
+* after_create
+* before_update
+* around_update
+* after_update
+* before_upsert
+* around_upsert
+* after_upsert
+* before_save
+* around_save
+* after_save
+* before_destroy
+* around_destroy
+* after_destroy
+
+#### Storing Observers in Rails
+
+If you're using Mongoid within Rails, observer classes are usually stored
+in `app/models` with the naming convention of `app/models/audit_observer.rb`.
+
+#### Configuration
+
+In order to activate an observer, list it in the `config.mongoid.observers`
+configuration setting in your `config/application.rb` file.
+
+```ruby
+  config.mongoid.observers = :comment_observer, :signup_observer
+```
+
+Observers will not be invoked unless you define them in your
+application configuration.
+
+#### Loading
+
+Observers register themselves with the model class that they observe,
+since it is the class that notifies them of events when they occur.
+As a side-effect, when an observer is loaded, its corresponding model
+class is loaded.
+
+Observers are loaded after the application initializers, so that
+observed models can make use of extensions. If by any chance you are
+using observed models in the initialization, you can
+still load their observers by calling `ModelObserver.instance` before.
+Observers are singletons and that call instantiates and registers them.
+
+## Authors
+
+* [Chamnap Chhorn](https://github.com/chamnap)

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+
+require "rspec/core"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList["spec/**/*_spec.rb"]
+end
+
+task :default => "spec"

data/lib/generators/mongoid/observer/observer_generator.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+require "rails/generators"
+require "rails/generators/mongoid_generator"
+
+module Mongoid
+  module Generators
+    class ObserverGenerator < Base
+      check_class_collision suffix: "Observer"
+
+      def self.source_root
+        File.expand_path("../templates", __FILE__)
+      end
+
+      def create_observer_file
+        template "observer.rb.tt", File.join("app/models", class_path, "#{file_name}_observer.rb")
+      end
+
+      hook_for :test_framework
+    end
+  end
+end

data/lib/generators/mongoid/observer/templates/observer.rb.tt

@@ -0,0 +1,4 @@
+<% module_namespacing do -%>
+class <%= class_name %>Observer < Mongoid::Observer
+end
+<% end -%>

data/lib/mongoid-observers.rb

@@ -0,0 +1,15 @@
+require "active_support"
+require "rails/observers/active_model"
+
+require "mongoid"
+require "mongoid/observers/config"
+require "mongoid/observers/interceptable"
+require "mongoid/observers/railtie" if defined? Rails
+require "mongoid/observer"
+
+module Mongoid
+  include ActiveModel::Observing
+
+  delegate(*ActiveModel::Observing::ClassMethods.public_instance_methods(false) <<
+    { to: Config })
+end

data/lib/mongoid/observer.rb

@@ -0,0 +1,186 @@
+# encoding: utf-8
+module Mongoid
+
+  # Observer classes respond to life cycle callbacks to implement trigger-like
+  # behavior outside the original class. This is a great way to reduce the
+  # clutter that normally comes when the model class is burdened with
+  # functionality that doesn't pertain to the core responsibility of the
+  # class. Mongoid's observers work similar to ActiveRecord's. Example:
+  #
+  #   class CommentObserver < Mongoid::Observer
+  #     def after_save(comment)
+  #       Notifications.comment(
+  #         "admin@do.com", "New comment was posted", comment
+  #       ).deliver
+  #     end
+  #   end
+  #
+  # This Observer sends an email when a Comment#save is finished.
+  #
+  #   class ContactObserver < Mongoid::Observer
+  #     def after_create(contact)
+  #       contact.logger.info('New contact added!')
+  #     end
+  #
+  #     def after_destroy(contact)
+  #       contact.logger.warn("Contact with an id of #{contact.id} was destroyed!")
+  #     end
+  #   end
+  #
+  # This Observer uses logger to log when specific callbacks are triggered.
+  #
+  # == Observing a class that can't be inferred
+  #
+  # Observers will by default be mapped to the class with which they share a
+  # name. So CommentObserver will be tied to observing Comment,
+  # ProductManagerObserver to ProductManager, and so on. If you want to
+  # name your observer differently than the class you're interested in
+  # observing, you can use the Observer.observe class method which takes
+  # either the concrete class (Product) or a symbol for that class (:product):
+  #
+  #   class AuditObserver < Mongoid::Observer
+  #     observe :account
+  #
+  #     def after_update(account)
+  #       AuditTrail.new(account, "UPDATED")
+  #     end
+  #   end
+  #
+  # If the audit observer needs to watch more than one kind of object,
+  # this can be specified with multiple arguments:
+  #
+  #   class AuditObserver < Mongoid::Observer
+  #     observe :account, :balance
+  #
+  #     def after_update(record)
+  #       AuditTrail.new(record, "UPDATED")
+  #     end
+  #   end
+  #
+  # The AuditObserver will now act on both updates to Account and Balance
+  # by treating them both as records.
+  #
+  # == Available callback methods
+  #
+  # * after_initialize
+  # * before_validation
+  # * after_validation
+  # * before_create
+  # * around_create
+  # * after_create
+  # * before_update
+  # * around_update
+  # * after_update
+  # * before_upsert
+  # * around_upsert
+  # * after_upsert
+  # * before_save
+  # * around_save
+  # * after_save
+  # * before_destroy
+  # * around_destroy
+  # * after_destroy
+  #
+  # == Storing Observers in Rails
+  #
+  # If you're using Mongoid within Rails, observer classes are usually stored
+  # in +app/models+ with the naming convention of +app/models/audit_observer.rb+.
+  #
+  # == Configuration
+  #
+  # In order to activate an observer, list it in the +config.mongoid.observers+
+  # configuration setting in your +config/application.rb+ file.
+  #
+  #   config.mongoid.observers = :comment_observer, :signup_observer
+  #
+  # Observers will not be invoked unless you define them in your
+  # application configuration.
+  #
+  # == Loading
+  #
+  # Observers register themselves with the model class that they observe,
+  # since it is the class that notifies them of events when they occur.
+  # As a side-effect, when an observer is loaded, its corresponding model
+  # class is loaded.
+  #
+  # Observers are loaded after the application initializers, so that
+  # observed models can make use of extensions. If by any chance you are
+  # using observed models in the initialization, you can
+  # still load their observers by calling +ModelObserver.instance+ before.
+  # Observers are singletons and that call instantiates and registers them.
+  class Observer < ActiveModel::Observer
+
+    private
+
+    # Adds the specified observer to the class.
+    #
+    # @example Add the observer.
+    #   observer.add_observer!(Document)
+    #
+    # @param [ Class ] klass The child observer to add.
+    def add_observer!(klass)
+      super and define_callbacks(klass)
+    end
+
+    # Defines all the callbacks for each observer of the model.
+    #
+    # @example Define all the callbacks.
+    #   observer.define_callbacks(Document)
+    #
+    # @param [ Class ] klass The model to define them on.
+    def define_callbacks(klass)
+      observer = self
+      observer_name = observer.class.name.underscore.gsub('/', '__')
+      Mongoid::Interceptable.observables.each do |callback|
+        next unless respond_to?(callback)
+        callback_meth = :"_notify_#{observer_name}_for_#{callback}"
+        unless klass.respond_to?(callback_meth)
+          klass.send(:define_method, callback_meth) do |&block|
+            if value = observer.update(callback, self, &block)
+              value
+            else
+              block.call if block
+            end
+          end
+          klass.send(callback, callback_meth)
+        end
+      end
+      self
+    end
+
+    # Are the observers disabled for the object?
+    #
+    # @api private
+    #
+    # @example If the observer disabled?
+    #   Observer.disabled_for(band)
+    #
+    # @param [ Document ] object The model instance.
+    #
+    # @return [ true, false ] If the observer is disabled.
+    def disabled_for?(object)
+      klass = object.class
+      return false unless klass.respond_to?(:observers)
+      klass.observers.disabled_for?(self) || Mongoid.observers.disabled_for?(self)
+    end
+
+    class << self
+
+      # Attaches the observer to the specified classes.
+      #
+      # @example Attach the BandObserver to the class Artist.
+      #   class BandObserver < Mongoid::Observer
+      #     observe :artist
+      #   end
+      #
+      # @param [ Array<Symbol> ] models The names of the models.
+      def observe(*models)
+        models.flatten!
+        models.collect! do |model|
+          model.respond_to?(:to_sym) ? model.to_s.camelize.constantize : model
+        end
+        singleton_class.redefine_method(:observed_classes) { models }
+      end
+    end
+  end
+end

data/lib/mongoid/observers/config.rb

@@ -0,0 +1,5 @@
+module Mongoid
+  module Config
+    include ActiveModel::Observing
+  end
+end

data/lib/mongoid/observers/interceptable.rb

@@ -0,0 +1,52 @@
+module Mongoid
+  module Interceptable
+    include ActiveModel::Observing
+
+    class << self
+
+      # Get all callbacks that can be observed.
+      #
+      # @example Get the observables.
+      #   Interceptable.observables
+      #
+      # @return [ Array<Symbol> ] The names of the observables.
+      def observables
+        CALLBACKS + registered_observables
+      end
+
+      # Get all registered callbacks that can be observed, not included in
+      # Mongoid's defaults.
+      #
+      # @example Get the observables.
+      #   Interceptable.registered_observables
+      #
+      # @return [ Array<Symbol> ] The names of the registered observables.
+      def registered_observables
+        @registered_observables ||= []
+      end
+    end
+
+    module ClassMethods
+
+      # Set a custom callback as able to be observed.
+      #
+      # @example Set a custom callback as observable.
+      #   class Band
+      #     include Mongoid::Document
+      #
+      #     define_model_callbacks :notification
+      #     observable :notification
+      #   end
+      #
+      # @param [ Array<Symbol> ] args The names of the observable callbacks.
+      #
+      # @since 3.0.1
+      def observable(*args)
+        observables = args.flat_map do |name|
+          [ :"before_#{name}", :"after_#{name}", :"around_#{name}" ]
+        end
+        Interceptable.registered_observables.concat(observables).uniq
+      end
+    end
+  end
+end

data/lib/mongoid/observers/railtie.rb

@@ -0,0 +1,27 @@
+require "rails/railtie"
+
+module Mongoid
+  module Observers
+    class Railtie < ::Rails::Railtie
+      initializer "mongoid.observer" do |app|
+        ActiveSupport.on_load(:mongoid) do
+          if app.config.respond_to?(:mongoid)
+            ::Mongoid.observers = app.config.mongoid.observers
+          end
+        end
+      end
+
+      # Instantitate any registered observers after Rails initialization and
+      # instantiate them after being reloaded in the development environment
+      config.after_initialize do |app|
+        ActiveSupport.on_load(:mongoid) do
+          ::Mongoid::instantiate_observers
+
+          ActionDispatch::Reloader.to_prepare do
+            ::Mongoid.instantiate_observers
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/observers/version.rb

@@ -0,0 +1,5 @@
+module Mongoid
+  module Observers
+    VERSION = "0.1.0"
+  end
+end

data/mongoid-observers.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mongoid/observers/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mongoid-observers"
+  spec.version       = Mongoid::Observers::VERSION
+  spec.authors       = ["Chamnap Chhorn"]
+  spec.email         = ["chamnapchhorn@gmail.com"]
+  spec.summary       = %q{Mongoid observer (removed in Mongoid 4.0)}
+  spec.description   = %q{Mongoid::Observer removed from Mongoid 4.0}
+  spec.homepage      = "https://github.com/chamnap/mongoid-observer"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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 "rails-observers", "~> 0.1.2"
+  spec.add_dependency "mongoid", "~> 4.0.0.beta1"
+end

data/spec/app/models/actor.rb

@@ -0,0 +1,14 @@
+class Actor
+  include Mongoid::Document
+  field :name
+  field :after_custom_count, type: Integer, default: 0
+
+  define_model_callbacks :custom
+  observable :custom
+
+  def do_something
+    run_callbacks(:custom) do
+      self.name = "custom"
+    end
+  end
+end

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/callback_recorder.rb

@@ -0,0 +1,25 @@
+class CallbackRecorder < Mongoid::Observer
+  observe :actor
+
+  attr_reader :last_callback, :call_count, :last_record
+
+  def initialize
+    reset
+    super
+  end
+
+  def reset
+    @last_callback = nil
+    @call_count = Hash.new(0)
+    @last_record = {}
+  end
+
+  Mongoid::Interceptable.observables.each do |callback|
+    define_method(callback) do |record, &block|
+      @last_callback = callback
+      @call_count[callback] += 1
+      @last_record[callback] = record
+      block ? block.call : true
+    end
+  end
+end

data/spec/app/models/person.rb

@@ -0,0 +1,34 @@
+class Person
+  include Mongoid::Document
+
+  field :username, default: -> { "arthurnn#{rand(0..10)}" }
+  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, default: ->{ 1.day.ago.in_time_zone("Alaska") }
+  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 :at, as: :aliased_timestamp, type: Time
+  field :t, as: :test, type: String
+  field :i, as: :inte, type: Integer
+  field :a, as: :array, type: Array
+  field :desc, localize: true
+
+
+  embeds_many :phone_numbers, class_name: "Phone", validate: false
+
+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/phone_observer.rb

@@ -0,0 +1,6 @@
+class PhoneObserver < Mongoid::Observer
+
+  def after_save(phone)
+    phone.number_in_observer = phone.number
+  end
+end

data/spec/app/models/record.rb

@@ -0,0 +1,42 @@
+class Record
+  include Mongoid::Document
+  field :name, type: String
+
+  field :before_create_called, type: Boolean, default: false
+  field :before_save_called, type: Boolean, default: false
+  field :before_update_called, type: Boolean, default: false
+  field :before_validation_called, type: Boolean, default: false
+  field :before_destroy_called, type: Boolean, default: false
+
+  before_create :before_create_stub
+  before_save :before_save_stub
+  before_update :before_update_stub
+  before_validation :before_validation_stub
+  before_destroy :before_destroy_stub
+
+  after_destroy :access_band
+
+  def before_create_stub
+    self.before_create_called = true
+  end
+
+  def before_save_stub
+    self.before_save_called = true
+  end
+
+  def before_update_stub
+    self.before_update_called = true
+  end
+
+  def before_validation_stub
+    self.before_validation_called = true
+  end
+
+  def before_destroy_stub
+    self.before_destroy_called = true
+  end
+
+  def access_band
+    band.name
+  end
+end

data/spec/config/mongoid.yml

@@ -0,0 +1,6 @@
+test:
+  sessions:
+    default:
+      database: mongoid_observers_test
+      hosts:
+        - localhost:27017

data/spec/generators/mongoid/observer/observer_generator_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+# Generators are not automatically loaded by Rails
+require "generators/mongoid/observer/observer_generator"
+
+describe Mongoid::Generators::ObserverGenerator do
+  # Tell the generator where to put its output (what it thinks of as Rails.root)
+  destination File.expand_path("../../../../../spec/tmp", __FILE__)
+
+  before do
+    prepare_destination
+  end
+
+  it "observer without namespace" do
+    run_generator %w(product)
+    expect(file("app/models/product_observer.rb")).to exist
+    expect(file("app/models/product_observer.rb")).to contain(/class ProductObserver < Mongoid::Observer/)
+  end
+
+  it "observer with namespace" do
+    run_generator %w(admin/account)
+    expect(file("app/models/admin/account_observer.rb")).to exist
+    expect(file("app/models/admin/account_observer.rb")).to contain(/class Admin::AccountObserver < Mongoid::Observer/)
+  end
+end

data/spec/mongoid/observer_spec.rb

@@ -0,0 +1,290 @@
+require "spec_helper"
+
+describe Mongoid::Observer do
+
+  let(:recorder) do
+    CallbackRecorder.instance
+  end
+
+  after do
+    recorder.reset
+  end
+
+  it "is an instance of an active model observer" do
+    ActorObserver.instance.should be_a_kind_of(ActiveModel::Observer)
+  end
+
+  context "when the oberserver observes a different class" do
+
+    before(:all) do
+      class BandObserver < Mongoid::Observer
+        observe :record
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, :BandObserver)
+    end
+
+    it "returns the proper observed classes" do
+      BandObserver.observed_classes.should eq([ Record ])
+    end
+  end
+
+  context "when the observer is for an embedded document" do
+
+    before do
+      PhoneObserver.instance
+    end
+
+    let(:person) do
+      Person.create
+    end
+
+    let!(:phone) do
+      person.phone_numbers.create(number: "0152-1111-1111")
+    end
+
+    context "when updating the embedded document" do
+
+      before do
+        phone.update_attribute(:number, "0152-2222-2222")
+      end
+
+      it "contains the updated value in the observer" do
+        phone.number_in_observer.should eq("0152-2222-2222")
+      end
+    end
+  end
+
+  context "when the observer has descendants" do
+
+    let!(:observer) do
+      ActorObserver.instance
+    end
+
+    let!(:actress) do
+      Actress.create!(name: "Tina Fey")
+    end
+
+    it "observes descendent class" do
+      observer.last_after_create_record.try(:name).should eq(actress.name)
+    end
+  end
+
+  context "when the observer is disabled" do
+
+    let!(:observer) do
+      ActorObserver.instance
+    end
+
+    let(:actor) do
+      Actor.create!(name: "Johnny Depp")
+    end
+
+    it "does not fire the observer" do
+      Actor.observers.disable(:all) do
+        actor and observer.last_after_create_record.should_not eq(actor)
+      end
+    end
+  end
+
+  context "when all observers are disabled" do
+
+    let!(:observer) do
+      ActorObserver.instance
+    end
+
+    let(:actor) do
+      Actor.create!(name: "Johnny Depp")
+    end
+
+    it "does not fire the observer" do
+      Mongoid.observers.disable(:all) do
+        actor and observer.last_after_create_record.should_not eq(actor)
+      end
+    end
+  end
+
+  context "when the document is new" do
+
+    let!(:actor) do
+      Actor.new
+    end
+
+    it "observes after initialize" do
+      recorder.last_callback.should eq(:after_initialize)
+    end
+
+    it "calls after initialize once" do
+      recorder.call_count[:after_initialize].should eq(1)
+    end
+
+    it "contains the model of the callback" do
+      recorder.last_record[:after_initialize].should eq(actor)
+    end
+  end
+
+  context "when the document is being created" do
+
+    let!(:actor) do
+      Actor.create!
+    end
+
+    [ :before_create,
+      :after_create,
+      :around_create,
+      :before_save,
+      :after_save,
+      :around_save ].each do |callback|
+
+      it "observes #{callback}" do
+        recorder.call_count[callback].should eq(1)
+      end
+
+      it "contains the model of the callback" do
+        recorder.last_record[callback].should eq(actor)
+      end
+    end
+  end
+
+  context "when the document is being updated" do
+
+    let!(:actor) do
+      Actor.create!
+    end
+
+    [ :before_update,
+      :after_update,
+      :around_update,
+      :before_save,
+      :after_save,
+      :around_save ].each do |callback|
+
+      before do
+        recorder.reset
+        actor.update_attributes!(name: "Johnny Depp")
+      end
+
+      it "observes #{callback}" do
+        recorder.call_count[callback].should eq(1)
+      end
+
+      it "contains the model of the callback" do
+        recorder.last_record[callback].should eq(actor)
+      end
+    end
+  end
+
+  context "when the document is being upserted" do
+
+    let!(:actor) do
+      Actor.create!
+    end
+
+    [ :before_upsert,
+      :after_upsert,
+      :around_upsert ].each do |callback|
+
+      before do
+        recorder.reset
+        actor.upsert
+      end
+
+      it "observes #{callback}" do
+        recorder.call_count[callback].should eq(1)
+      end
+
+      it "contains the model of the callback" do
+        recorder.last_record[callback].should eq(actor)
+      end
+    end
+  end
+
+  context "when custom callbacks are being fired" do
+
+    let!(:actor) do
+      Actor.create!
+    end
+
+    [ :before_custom,
+      :after_custom,
+      :around_custom ].each do |callback|
+
+      before do
+        recorder.reset
+        actor.run_callbacks(:custom) do
+        end
+      end
+
+      it "observes #{callback}" do
+        recorder.call_count[callback].should eq(1)
+      end
+
+      it "contains the model of the callback" do
+        recorder.last_record[callback].should eq(actor)
+      end
+    end
+  end
+
+  context "when the document is being destroyed" do
+
+    let!(:actor) do
+      Actor.create!
+    end
+
+    [ :before_destroy, :after_destroy, :around_destroy ].each do |callback|
+
+      before do
+        recorder.reset
+        actor.destroy
+      end
+
+      it "observes #{callback}" do
+        recorder.call_count[callback].should eq(1)
+      end
+
+      it "contains the model of the callback" do
+        recorder.last_record[callback].should eq(actor)
+      end
+    end
+  end
+
+  context "when the document is being validated" do
+
+    let!(:actor) do
+      Actor.new
+    end
+
+    [:before_validation, :after_validation].each do |callback|
+
+      before do
+        recorder.reset
+        actor.valid?
+      end
+
+      it "observes #{callback}" do
+        recorder.call_count[callback].should eq(1)
+      end
+
+      it "contains the model of the callback" do
+        recorder.last_record[callback].should eq(actor)
+      end
+    end
+  end
+
+  context "when using a custom callback" do
+
+    let(:actor) do
+      Actor.new
+    end
+
+    before do
+      actor.do_something
+    end
+
+    it "notifies the observers once" do
+      actor.after_custom_count.should eq(1)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,40 @@
+require "simplecov"
+require "coveralls"
+require "codeclimate-test-reporter"
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  Coveralls::SimpleCov::Formatter,
+  SimpleCov::Formatter::HTMLFormatter,
+  CodeClimate::TestReporter::Formatter
+]
+
+SimpleCov.start do
+  add_filter "/spec/"
+end
+
+MODELS = File.join(File.dirname(__FILE__), "app/models")
+$LOAD_PATH.unshift(MODELS)
+
+require "pry"
+require "rails"
+require "mongoid-observers"
+require "ammeter/init"
+
+# mongoid connection
+Mongoid.load! File.dirname(__FILE__) + "/config/mongoid.yml", :test
+
+# Autoload every model for the test suite that sits in spec/app/models.
+Dir[ File.join(MODELS, "*.rb") ].sort.each do |file|
+  name = File.basename(file, ".rb")
+  autoload name.camelize.to_sym, name
+end
+
+RSpec.configure do |config|
+  config.filter_run focus: true
+  config.run_all_when_everything_filtered = true
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+
+  config.before(:each) do
+    Mongoid.purge!
+  end
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: mongoid-observers
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chamnap Chhorn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails-observers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0.beta1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0.beta1
+description: Mongoid::Observer removed from Mongoid 4.0
+email:
+- chamnapchhorn@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".coveralls.yml"
+- ".gitignore"
+- ".rspec"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/generators/mongoid/observer/observer_generator.rb
+- lib/generators/mongoid/observer/templates/observer.rb.tt
+- lib/mongoid-observers.rb
+- lib/mongoid/observer.rb
+- lib/mongoid/observers/config.rb
+- lib/mongoid/observers/interceptable.rb
+- lib/mongoid/observers/railtie.rb
+- lib/mongoid/observers/version.rb
+- mongoid-observers.gemspec
+- spec/app/models/actor.rb
+- spec/app/models/actor_observer.rb
+- spec/app/models/actress.rb
+- spec/app/models/callback_recorder.rb
+- spec/app/models/person.rb
+- spec/app/models/phone.rb
+- spec/app/models/phone_observer.rb
+- spec/app/models/record.rb
+- spec/config/mongoid.yml
+- spec/generators/mongoid/observer/observer_generator_spec.rb
+- spec/mongoid/observer_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/chamnap/mongoid-observer
+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: Mongoid observer (removed in Mongoid 4.0)
+test_files:
+- spec/app/models/actor.rb
+- spec/app/models/actor_observer.rb
+- spec/app/models/actress.rb
+- spec/app/models/callback_recorder.rb
+- spec/app/models/person.rb
+- spec/app/models/phone.rb
+- spec/app/models/phone_observer.rb
+- spec/app/models/record.rb
+- spec/config/mongoid.yml
+- spec/generators/mongoid/observer/observer_generator_spec.rb
+- spec/mongoid/observer_spec.rb
+- spec/spec_helper.rb