mongoid-braxton 2.0.2

data/lib/mongoid/attributes/processing.rb

@@ -0,0 +1,145 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Attributes #:nodoc:
+
+    # This module contains the behavior for processing attributes.
+    module Processing
+
+      # 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 [ Boolean ] guard_protected_attributes False to skip mass assignment protection.
+      #
+      # @since 2.0.0.rc.7
+      def process(attrs = nil, guard_protected_attributes = true)
+        attrs ||= {}
+        attrs = sanitize_for_mass_assignment(attrs) if guard_protected_attributes
+        attrs.each_pair do |key, value|
+          next if pending_attribute?(key, value)
+          process_attribute(key, value)
+        end
+        yield self if block_given?
+        process_pending and setup_modifications
+      end
+
+      protected
+
+      # If the key provided a relation or a nested attribute, where we have to
+      # hold off on the setting of the attribute until everything else has been
+      # set?
+      #
+      # @example Is the attribute pending?
+      #   document.pending_attribute?(:name, "Durran")
+      #
+      # @param [ Synbol ] key The name of the attribute.
+      # @param [ Object ] value The value of the attribute.
+      #
+      # @return [ true, false ] True if pending, false if not.
+      #
+      # @since 2.0.0.rc.7
+      def pending_attribute?(key, value)
+        name = key.to_s
+        if relations.has_key?(name)
+          pending_relations[name] = value
+          return true
+        end
+        if nested_attributes.include?("#{name}=")
+          pending_nested[name] = value
+          return true
+        end
+        return false
+      end
+
+      # Get all the pending relations that need to be set.
+      #
+      # @example Get the pending relations.
+      #   document.pending_relations
+      #
+      # @return [ Hash ] The pending relations in key/value pairs.
+      #
+      # @since 2.0.0.rc.7
+      def pending_relations
+        @pending_relations ||= {}
+      end
+
+      # Get all the pending nested attributes that need to be set.
+      #
+      # @example Get the pending nested attributes.
+      #   document.pending_nested
+      #
+      # @return [ Hash ] The pending nested attributes in key/value pairs.
+      #
+      # @since 2.0.0.rc.7
+      def pending_nested
+        @pending_nested ||= {}
+      end
+
+      # If the attribute is dynamic, add a field for it with a type of object
+      # and then either way set the value.
+      #
+      # @example Process the attribute.
+      #   document.process_attribute(name, value)
+      #
+      # @param [ Symbol ] name The name of the field.
+      # @param [ Object ] value The value of the field.
+      #
+      # @since 2.0.0.rc.7
+      def process_attribute(name, value)
+        if Mongoid.allow_dynamic_fields && !respond_to?("#{name}=")
+          write_attribute(name, value)
+        else
+          send("#{name}=", value)
+        end
+      end
+
+      # Process all the pending nested attributes that needed to wait until
+      # ids were set to fire off.
+      #
+      # @example Process the nested attributes.
+      #   document.process_nested
+      #
+      # @since 2.0.0.rc.7
+      def process_nested
+        pending_nested.each_pair do |name, value|
+          send("#{name}=", value)
+        end
+      end
+
+      # Process all the pending items, then clear them out.
+      #
+      # @example Process the pending items.
+      #   document.process_pending
+      #
+      # @since 2.0.0.rc.7
+      def process_pending
+        process_nested and process_relations
+        pending_nested.clear and pending_relations.clear
+      end
+
+      # Process all the pending relations that needed to wait until ids were set
+      # to fire off.
+      #
+      # @example Process the relations.
+      #   document.process_relations
+      #
+      # @since 2.0.0.rc.7
+      def process_relations
+        pending_relations.each_pair do |name, value|
+          metadata = relations[name]
+          if value.is_a?(Hash)
+            metadata.nested_builder(value, {}).build(self)
+          else
+            send("#{name}=", value, :binding => true)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/mongoid/callbacks.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    CALLBACKS = [
+      :before_validation, :after_validation,
+      :after_initialize,
+      :before_create, :around_create, :after_create,
+      :before_destroy, :around_destroy, :after_destroy,
+      :before_save, :around_save, :after_save,
+      :before_update, :around_update, :after_update,
+    ]
+
+    included do
+      extend ActiveModel::Callbacks
+      include ActiveModel::Validations::Callbacks
+
+      define_model_callbacks :initialize, :only => :after
+      define_model_callbacks :create, :destroy, :save, :update
+    end
+  end
+end

data/lib/mongoid/collection.rb

@@ -0,0 +1,137 @@
+# encoding: utf-8
+require "mongoid/collections/retry"
+require "mongoid/collections/operations"
+require "mongoid/collections/master"
+
+module Mongoid #:nodoc
+
+  # This class is the Mongoid wrapper to the Mongo Ruby driver's collection
+  # object.
+  class Collection
+    attr_reader :counter, :name
+
+    # All write operations should delegate to the master connection. These
+    # operations mimic the methods on a Mongo:Collection.
+    #
+    # @example Delegate the operation.
+    #   collection.save({ :name => "Al" })
+    Collections::Operations::PROXIED.each do |name|
+      define_method(name) { |*args| master.send(name, *args) }
+    end
+
+    # Find documents from the database given a selector and options.
+    #
+    # @example Find documents in the collection.
+    #   collection.find({ :test => "value" })
+    #
+    # @param [ Hash ] selector The query selector.
+    # @param [ Hash ] options The options to pass to the db.
+    #
+    # @return [ Cursor ] The results.
+    def find(selector = {}, options = {})
+      cursor = Mongoid::Cursor.new(@klass, self, master(options).find(selector, options))
+      if block_given?
+        yield cursor; cursor.close
+      else
+        cursor
+      end
+    end
+
+    # Find the first document from the database given a selector and options.
+    #
+    # @example Find one document.
+    #   collection.find_one({ :test => "value" })
+    #
+    # @param [ Hash ] selector The query selector.
+    # @param [ Hash ] options The options to pass to the db.
+    #
+    # @return [ Document, nil ] A matching document or nil if none found.
+    def find_one(selector = {}, options = {})
+      master(options).find_one(selector, options)
+    end
+
+    # Initialize a new Mongoid::Collection, setting up the master, slave, and
+    # name attributes. Masters will be used for writes, slaves for reads.
+    #
+    # @example Create the new collection.
+    #   Collection.new(masters, slaves, "test")
+    #
+    # @param [ Class ] klass The class the collection is for.
+    # @param [ String ] name The name of the collection.
+    def initialize(klass, name)
+      @klass, @name = klass, name
+    end
+
+    # Inserts one or more documents in the collection.
+    #
+    # @example Insert documents.
+    #   collection.insert(
+    #     { "field" => "value" },
+    #     :safe => true
+    #   )
+    #
+    # @param [ Hash, Array<Hash> ] documents A single document or multiples.
+    # @param [ Hash ] options The options.
+    #
+    # @since 2.0.2, batch-relational-insert
+    def insert(documents, options = {})
+      inserter = Thread.current[:mongoid_batch_insert]
+      if inserter
+        inserter.consume(documents, options)
+      else
+        master(options).insert(documents, options)
+      end
+    end
+
+    # Perform a map/reduce on the documents.
+    #
+    # @example Perform the map/reduce.
+    #   collection.map_reduce(map, reduce)
+    #
+    # @param [ String ] map The map javascript function.
+    # @param [ String ] reduce The reduce javascript function.
+    # @param [ Hash ] options The options to pass to the db.
+    #
+    # @return [ Cursor ] The results.
+    def map_reduce(map, reduce, options = {})
+      master(options).map_reduce(map, reduce, options)
+    end
+    alias :mapreduce :map_reduce
+
+    # Return the object responsible for writes to the database. This will
+    # always return a collection associated with the Master DB.
+    #
+    # @example Get the master connection.
+    #   collection.master
+    #
+    # @return [ Master ] The master connection.
+    def master(options = {})
+      options.delete(:cache)
+      db = Mongoid.databases[@klass.database] || Mongoid.master
+      @master ||= Collections::Master.new(db, @name)
+    end
+
+    # Updates one or more documents in the collection.
+    #
+    # @example Update documents.
+    #   collection.update(
+    #     { "_id" => BSON::OjectId.new },
+    #     { "$push" => { "addresses" => { "_id" => "street" } } },
+    #     :safe => true
+    #   )
+    #
+    # @param [ Hash ] selector The document selector.
+    # @param [ Hash ] document The modifier.
+    # @param [ Hash ] options The options.
+    #
+    # @since 2.0.0
+    def update(selector, document, options = {})
+      updater = Thread.current[:mongoid_atomic_update]
+      if updater
+        updater.consume(selector, document, options)
+      else
+        master(options).update(selector, document, options)
+      end
+    end
+  end
+end

data/lib/mongoid/collections.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  # The collections module is used for providing functionality around setting
+  # up and updating collections.
+  module Collections
+    extend ActiveSupport::Concern
+    included do
+      cattr_accessor :_collection, :collection_name
+      self.collection_name = self.name.collectionize
+
+      delegate :collection, :db, :to => "self.class"
+    end
+
+    module ClassMethods #:nodoc:
+      # Returns the collection associated with this +Document+. If the
+      # document is embedded, there will be no collection associated
+      # with it.
+      #
+      # Returns: <tt>Mongo::Collection</tt>
+      def collection
+        raise Errors::InvalidCollection.new(self) if embedded? && !cyclic
+        self._collection || set_collection
+        add_indexes; self._collection
+      end
+
+      # Return the database associated with this collection.
+      #
+      # Example:
+      #
+      # <tt>Person.db</tt>
+      def db
+        collection.db
+      end
+
+      # Convenience method for getting index information from the collection.
+      #
+      # Example:
+      #
+      # <tt>Person.index_information</tt>
+      def index_information
+        collection.index_information
+      end
+
+      # The MongoDB logger is not exposed through the driver to be changed
+      # after initialization of the connection, this is a hacky way around that
+      # if logging needs to be changed at runtime.
+      #
+      # Example:
+      #
+      # <tt>Person.logger = Logger.new($stdout)</tt>
+      def logger=(logger)
+        db.connection.instance_variable_set(:@logger, logger)
+      end
+
+      # Macro for setting the collection name to store in.
+      #
+      # Example:
+      #
+      # <tt>Person.store_in :population</tt>
+      def store_in(name)
+        self.collection_name = name.to_s
+        set_collection
+      end
+
+      protected
+      def set_collection
+        self._collection = Mongoid::Collection.new(self, self.collection_name)
+      end
+    end
+  end
+end

data/lib/mongoid/collections/master.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Collections #:nodoc:
+
+    # This class wraps the MongoDB master database.
+    class Master
+      include Mongoid::Collections::Retry
+
+      attr_reader :collection
+
+      # All read and write operations should delegate to the master connection.
+      # These operations mimic the methods on a Mongo:Collection.
+      #
+      # @example Proxy the driver save.
+      #   collection.save({ :name => "Al" })
+      Operations::ALL.each do |name|
+        define_method(name) do |*args|
+          retry_on_connection_failure do
+            collection.send(name, *args)
+          end
+        end
+      end
+
+      # Create the new database writer. Will create a collection from the
+      # master database.
+      #
+      # @example Create a new wrapped master.
+      #   Master.new(db, "testing")
+      #
+      # @param [ Mongo::DB ] master The master database.
+      # @param [ String ] name The name of the database.
+      def initialize(master, name)
+        @collection = master.collection(name)
+      end
+    end
+  end
+end

data/lib/mongoid/collections/operations.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Collections #:nodoc:
+    module Operations #:nodoc:
+      # Constant definining all the read operations available for a
+      # Mongo:Collection. This is used in delegation.
+      READ = [
+        :[],
+        :db,
+        :count,
+        :distinct,
+        :find,
+        :find_one,
+        :group,
+        :index_information,
+        :map_reduce,
+        :mapreduce,
+        :stats,
+        :options
+      ]
+
+      # Constant definining all the write operations available for a
+      # Mongo:Collection. This is used in delegation.
+      WRITE = [
+        :<<,
+        :create_index,
+        :drop,
+        :drop_index,
+        :drop_indexes,
+        :insert,
+        :remove,
+        :rename,
+        :save,
+        :update
+      ]
+
+      # Convenience constant for getting back all collection operations.
+      ALL = (READ + WRITE)
+      PROXIED = ALL - [ :find, :find_one, :map_reduce, :mapreduce, :update ]
+    end
+  end
+end