mongoid-braxton 2.0.2

data/lib/mongoid/multi_database.rb

@@ -0,0 +1,11 @@
+module Mongoid::MultiDatabase
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+
+    def database; @database end
+    def set_database(name)
+      @database = name.to_s
+    end
+  end
+end

data/lib/mongoid/multi_parameter_attributes.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # @todo: Durran: This module needs an overhaul.
+  module MultiParameterAttributes
+    module Errors
+      # 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
+
+    def process(attrs = nil, 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] }
+            klass = self.class.fields[key].try(:type)
+            attributes[key] = instantiate_object(klass, 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, guard_protected_attributes
+      else
+        super
+      end
+    end
+
+  protected
+
+    def instantiate_object(klass, 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 }
+
+      if klass == DateTime || klass == Date || klass == Time
+        klass.send(:convert_to_time, values)
+      elsif klass
+        klass.new *values
+      else
+        values
+      end
+    end
+
+  end
+end

data/lib/mongoid/named_scope.rb

@@ -0,0 +1,137 @@
+# 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
+        scope_stack_for = Thread.current[:mongoid_scope_stack] ||= {}
+        scope_stack_for[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
+
+      def valid_scope_name?(name)
+        if !scopes[name] && respond_to?(name, true)
+          Mongoid.logger.warn "Creating scope :#{name}. " \
+                                    "Overwriting existing method #{self.name}.#{name}." if Mongoid.logger
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/nested_attributes.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module NestedAttributes
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :nested_attributes
+      self.nested_attributes = []
+
+      delegate :nested_attributes, :to => "self.class"
+    end
+
+    module ClassMethods
+      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 ] :reject_if Block 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|
+            relation = relations[name.to_s]
+            relation.nested_builder(attrs, options).build(self)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/observer.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # Mongoid observers hook into the lifecycle of documents.
+  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
+    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
+    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
+    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
+    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

data/lib/mongoid/paranoia.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  # 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)
+  #
+  # To use:
+  #
+  #   class Person
+  #     include Mongoid::Document
+  #     include Mongoid::Paranoia
+  #   end
+  module Paranoia
+    extend ActiveSupport::Concern
+
+    included do
+      field :deleted_at, :type => Time
+    end
+
+    # Delete the paranoid +Document+ from the database completely. This will
+    # run the destroy callbacks.
+    #
+    # Example:
+    #
+    # <tt>document.destroy!</tt>
+    def destroy!
+      run_callbacks(:destroy) { delete! }
+    end
+
+    # Delete the paranoid +Document+ from the database completely.
+    #
+    # Example:
+    #
+    # <tt>document.delete!</tt>
+    def delete!
+      @destroyed = true
+      Mongoid::Persistence::Remove.new(self).persist
+    end
+
+    # Delete the +Document+, will set the deleted_at timestamp and not actually
+    # delete it.
+    #
+    # Example:
+    #
+    # <tt>document.remove</tt>
+    #
+    # Returns:
+    #
+    # true
+    def remove(options = {})
+      now = Time.now
+      collection.update({ :_id => id }, { '$set' => { :deleted_at => now } })
+      @attributes["deleted_at"] = now
+      true
+    end
+
+    alias :delete :remove
+
+    # Determines if this document is destroyed.
+    #
+    # Returns:
+    #
+    # true if the +Document+ was destroyed.
+    def destroyed?
+      @destroyed || !!deleted_at
+    end
+
+    # Restores a previously soft-deleted document. Handles this by removing the
+    # deleted_at flag.
+    #
+    # Example:
+    #
+    # <tt>document.restore</tt>
+    def restore
+      collection.update({ :_id => id }, { '$unset' => { :deleted_at => true } })
+      @attributes.delete("deleted_at")
+    end
+
+    module ClassMethods #:nodoc:
+
+      # Override the default +Criteria+ accessor to only get existing
+      # documents. Passes all arguments up to +NamedScope.criteria+
+      #
+      # Returns:
+      #
+      # A +Criteria+ for deleted_at not existing.
+      def criteria(*args)
+        super.where(:deleted_at.exists => false)
+      end
+
+      # Find deleted documents
+      #
+      # Examples:
+      #
+      #   <tt>Person.deleted</tt>  # all deleted employees
+      #   <tt>Company.first.employees.deleted</tt>  # works with a join
+      #   <tt>Person.deleted.find("4c188dea7b17235a2a000001").first</tt>
+      def deleted
+        where(:deleted_at.exists => true)
+      end
+    end
+  end
+end