mongoid-multi-db 3.0.0

data/lib/mongoid/multi_database.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # Adds multiple database support to documents.
+  module MultiDatabase
+    extend ActiveSupport::Concern
+
+    module ClassMethods #:nodoc:
+
+      # Gets the database from the class.
+      #
+      # @example Get the database.
+      #   Model.database
+      #
+      # @return [ Mongo::DB ] The database.
+      def database; @database end
+
+      # Set the database name.
+      #
+      # @example Set the database name.
+      #   Model.set_database(:testing)
+      #
+      # @param [ Symbol ] name The database name.
+      #
+      # @return [ String ] The database name.
+      def set_database(name)
+        @database = name.to_s
+      end
+    end
+  end
+end

data/lib/mongoid/multi_parameter_attributes.rb

@@ -0,0 +1,106 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # Adds Rails' multi-parameter attribute support to Mongoid.
+  #
+  # @todo: Durran: This module needs an overhaul.
+  module MultiParameterAttributes
+
+    module Errors #:nodoc:
+
+      # Raised when an error occurred while doing a mass assignment to an
+      # attribute through the <tt>attributes=</tt> method. The exception
+      # has an +attribute+ property that is the name of the offending attribute.
+      class AttributeAssignmentError < Mongoid::Errors::MongoidError
+        attr_reader :exception, :attribute
+
+        def initialize(message, exception, attribute)
+          @exception = exception
+          @attribute = attribute
+          @message = message
+        end
+      end
+
+      # Raised when there are multiple errors while doing a mass assignment
+      # through the +attributes+ method. The exception has an +errors+
+      # property that contains an array of AttributeAssignmentError
+      # objects, each corresponding to the error while assigning to an
+      # attribute.
+      class MultiparameterAssignmentErrors < Mongoid::Errors::MongoidError
+        attr_reader :errors
+
+        def initialize(errors)
+          @errors = errors
+        end
+      end
+    end
+
+    # Process the provided attributes casting them to their proper values if a
+    # field exists for them on the document. This will be limited to only the
+    # attributes provided in the suppied +Hash+ so that no extra nil values get
+    # put into the document's attributes.
+    #
+    # @example Process the attributes.
+    #   person.process(:title => "sir", :age => 40)
+    #
+    # @param [ Hash ] attrs The attributes to set.
+    # @param [ Symbol ] role A role for scoped mass assignment.
+    # @param [ Boolean ] guard_protected_attributes False to skip mass assignment protection.
+    #
+    # @since 2.0.0.rc.7
+    def process(attrs = nil, role = :default, guard_protected_attributes = true)
+      if attrs
+        errors = []
+        attributes = {}
+        multi_parameter_attributes = {}
+
+        attrs.each_pair do |key, value|
+          if key =~ /^([^\(]+)\((\d+)([if])\)$/
+            key, index = $1, $2.to_i
+            (multi_parameter_attributes[key] ||= {})[index] = value.empty? ? nil : value.send("to_#{$3}")
+          else
+            attributes[key] = value
+          end
+        end
+
+        multi_parameter_attributes.each_pair do |key, values|
+          begin
+            values = (values.keys.min..values.keys.max).map { |i| values[i] }
+            field = self.class.fields[key]
+            attributes[key] = instantiate_object(field, values)
+          rescue => e
+            errors << Errors::AttributeAssignmentError.new(
+              "error on assignment #{values.inspect} to #{key}", e, key
+            )
+          end
+        end
+
+        unless errors.empty?
+          raise(
+            Errors::MultiparameterAssignmentErrors.new(errors),
+            "#{errors.size} error(s) on assignment of multiparameter attributes"
+          )
+        end
+
+        super attributes, role, guard_protected_attributes
+      else
+        super
+      end
+    end
+
+    protected
+
+    def instantiate_object(field, values_with_empty_parameters)
+      return nil if values_with_empty_parameters.all? { |v| v.nil? }
+      values = values_with_empty_parameters.collect { |v| v.nil? ? 1 : v }
+      klass = field.type
+      if klass == DateTime || klass == Date || klass == Time
+        field.serialize(values)
+      elsif klass
+        klass.new *values
+      else
+        values
+      end
+    end
+  end
+end

data/lib/mongoid/named_scope.rb

@@ -0,0 +1,146 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # This module contains the named scoping behaviour.
+  module NamedScope
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :scopes
+      self.scopes = {}
+    end
+
+    module ClassMethods #:nodoc:
+
+      # Gets either the last scope on the stack or creates a new criteria.
+      #
+      # @example Get the last or new.
+      #   Person.scoping(true)
+      #
+      # @param [ true, false ] embedded Is this scope for an embedded doc?
+      # @param [ true, false ] scoped Are we applying default scoping?
+      #
+      # @return [ Criteria ] The last scope or a new one.
+      #
+      # @since 2.0.0
+      def criteria(embedded = false, scoped = true)
+        scope_stack.last || Criteria.new(self, embedded).tap do |crit|
+          return crit.fuse(default_scoping) if default_scoping && scoped
+        end
+      end
+
+      # Creates a named_scope for the +Document+, similar to ActiveRecord's
+      # named_scopes. +NamedScopes+ are proxied +Criteria+ objects that can be
+      # chained.
+      #
+      # @example Create named scopes.
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     field :active, :type => Boolean
+      #     field :count, :type => Integer
+      #
+      #     scope :active, :where => { :active => true }
+      #     scope :count_gt_one, :where => { :count.gt => 1 }
+      #     scope :at_least_count, lambda { |count| { :where => { :count.gt => count } } }
+      #   end
+      #
+      # @param [ Symbol ] name The name of the scope.
+      # @param [ Hash, Criteria ] conditions The conditions of the scope.
+      #
+      # @since 1.0.0
+      def scope(name, conditions = {}, &block)
+        name = name.to_sym
+        valid_scope_name?(name)
+        scopes[name] = Scope.new(conditions, &block)
+        (class << self; self; end).class_eval <<-EOT
+          def #{name}(*args)
+            scope = scopes[:#{name}]
+            scope.extend(criteria.fuse(scope.conditions.scoped(*args)))
+          end
+        EOT
+      end
+      alias :named_scope :scope
+
+      # Get a criteria object for the class, scoped to the default if defined.
+      #
+      # @example Get a scoped criteria.
+      #   Person.scoped
+      #
+      # @param [ true, false ] embedded Is the criteria for embedded docs?
+      #
+      # @return [ Criteria ] The scoped criteria.
+      #
+      # @since 2.0.0
+      def scoped(embedded = false)
+        criteria(embedded, true)
+      end
+
+      # Initializes and returns the current scope stack.
+      #
+      # @example Get the scope stack.
+      #   Person.scope_stack
+      #
+      # @return [ Array<Criteria> ] The scope stack.
+      #
+      # @since 1.0.0
+      def scope_stack
+        Threaded.scope_stack[object_id] ||= []
+      end
+
+      # Get a criteria object for the class, ignoring default scoping.
+      #
+      # @example Get an unscoped criteria.
+      #   Person.scoped
+      #
+      # @param [ true, false ] embedded Is the criteria for embedded docs?
+      #
+      # @return [ Criteria ] The unscoped criteria.
+      #
+      # @since 2.0.0
+      def unscoped(embedded = false)
+        criteria(embedded, false)
+      end
+
+      # Pushes the provided criteria onto the scope stack, and removes it after the
+      # provided block is yielded.
+      #
+      # @example Yield to the criteria.
+      #   Person.with_scope(criteria)
+      #
+      # @param [ Criteria ] criteria The criteria to apply.
+      #
+      # @return [ Criteria ] The yielded criteria.
+      #
+      # @since 1.0.0
+      def with_scope(criteria)
+        scope_stack = self.scope_stack
+        scope_stack << criteria
+        begin
+          yield criteria
+        ensure
+          scope_stack.pop
+        end
+      end
+
+      protected
+
+      # Warns if overriding another scope or method.
+      #
+      # @example Warn if name exists.
+      #   Model.valid_scope_name?("test")
+      #
+      # @param [ String, Symbol ] name The name of the scope.
+      def valid_scope_name?(name)
+        if scopes[name] || respond_to?(name, true)
+          if Mongoid.logger
+            Mongoid.logger.warn(
+              "Creating scope :#{name}. " +
+              "Overwriting existing method #{self.name}.#{name}."
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/nested_attributes.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # Mongoid's implementation of Rails' nested attributes.
+  module NestedAttributes
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :nested_attributes
+      self.nested_attributes = []
+    end
+
+    module ClassMethods #:nodoc:
+
+      REJECT_ALL_BLANK_PROC = proc { |attributes| attributes.all? { |_, value| value.blank? } }
+
+      # Used when needing to update related models from a parent relation. Can
+      # be used on embedded or referenced relations.
+      #
+      # @example Defining nested attributes.
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #
+      #     embeds_many :addresses
+      #     embeds_one :game
+      #     references_many :posts
+      #
+      #     accepts_nested_attributes_for :addresses, :game, :posts
+      #   end
+      #
+      # @param [ Array<Symbol>, Hash ] *args A list of relation names, followed
+      #   by a hash of options.
+      #
+      # @option *args [ true, false ] :allow_destroy Can deletion occur?
+      # @option *args [ Proc, Symbol ] :reject_if Block or symbol pointing to a class method to reject documents with.
+      # @option *args [ Integer ] :limit The max number to create.
+      # @option *args [ true, false ] :update_only Only update existing docs.
+      def accepts_nested_attributes_for(*args)
+        options = args.extract_options!
+        options[:reject_if] = REJECT_ALL_BLANK_PROC if options[:reject_if] == :all_blank
+        args.each do |name|
+          self.nested_attributes += [ "#{name}_attributes=" ]
+          define_method("#{name}_attributes=") do |attrs|
+            _assigning do
+              relation = relations[name.to_s]
+              relation.nested_builder(attrs, options).build(self)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/observer.rb

@@ -0,0 +1,170 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # 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_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
+
+    # Instantiate the new observer. Will add all child observers as well.
+    #
+    # @example Instantiate the observer.
+    #   Mongoid::Observer.new
+    #
+    # @since 2.0.0.rc.8
+    def initialize
+      super and observed_descendants.each { |klass| add_observer!(klass) }
+    end
+
+    protected
+
+    # Get all the child observers.
+    #
+    # @example Get the children.
+    #   observer.observed_descendants
+    #
+    # @return [ Array<Class> ] The children.
+    #
+    # @since 2.0.0.rc.8
+    def observed_descendants
+      observed_classes.sum([]) { |klass| klass.descendants }
+    end
+
+    # Adds the specified observer to the class.
+    #
+    # @example Add the observer.
+    #   observer.add_observer!(Document)
+    #
+    # @param [ Class ] klass The child observer to add.
+    #
+    # @since 2.0.0.rc.8
+    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.
+    #
+    # @since 2.0.0.rc.8
+    def define_callbacks(klass)
+      tap do |observer|
+        observer_name = observer.class.name.underscore.gsub('/', '__')
+        Mongoid::Callbacks::CALLBACKS.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|
+              observer.send(callback, self, &block)
+            end
+            klass.send(callback, callback_meth)
+          end
+        end
+      end
+    end
+  end
+end