mongoid-multi-db 3.0.0

data/lib/mongoid/identity.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  class Identity #:nodoc:
+
+    attr_reader :document
+
+    # Create the identity for the document. The id will be set in either in
+    # the form of a Mongo object id or a composite key set up by defining
+    # a key on the document. The _type will be set to the document's class
+    # name.
+    #
+    # @example Create the id and set the type.
+    #   identity.create
+    def create
+      identify.tap { type }
+    end
+
+    # Create the new identity generator - this will be expanded in the future
+    # to support pk generators.
+    #
+    # @example
+    #   Identity.new(document)
+    #
+    # @param [ Document ] document The document to generate an id for.
+    #
+    # @return [ Identity ] The new identity object.
+    def initialize(document)
+      @document = document
+    end
+
+    private
+
+    # Return the proper id for the document. Will be an object id or its string
+    # representation depending on the configuration.
+    #
+    # @example Generate the id.
+    #   identity.generate_id
+    #
+    # @return [ Object ] The bson object id or its string equivalent.
+    def generate_id
+      id = BSON::ObjectId.new
+      document.using_object_ids? ? id : id.to_s
+    end
+
+    # Sets the id on the document. Will either set a newly generated id or
+    # build the composite key.
+    #
+    # @example Set the id.
+    #   identity.identify
+    def identify
+      document.id = compose.join(" ").identify if document.primary_key
+      document.id = generate_id if document.id.blank?
+      document.id
+    end
+
+    # Set the _type field on the document if the document is hereditary or in a
+    # polymorphic relation.
+    #
+    # @example Set the type.
+    #   identity.type
+    def type
+      document._type = document.class.name if typed?
+    end
+
+    # Generates the array of keys to build the id.
+    #
+    # @example Build the array for the keys.
+    #   identity.compose.
+    #
+    # @return [ Array<Object> ] The array of keys.
+    def compose
+      kf = document.key_formatter
+      document.primary_key.collect do |key|
+        val = document.attributes[key.to_s]
+        val && kf ? kf.call(val) : val
+      end.compact
+    end
+
+    # Determines if the document stores the type information. This is if it is
+    # in a hierarchy, has subclasses, or is in a polymorphic relation.
+    #
+    # @example Check if the document is typed.
+    #   identity.typed?
+    #
+    # @return [ true, false ] True if typed, false if not.
+    def typed?
+      document.hereditary? ||
+        document.class.descendants.any? ||
+        document.polymorphic?
+    end
+  end
+end

data/lib/mongoid/identity_map.rb

@@ -0,0 +1,119 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # Defines behaviour for the identity map in Mongoid.
+  class IdentityMap < Hash
+
+    # Get a document from the identity map by its id.
+    #
+    # @example Get the document from the map.
+    #   map.get(Person, id)
+    #
+    # @param [ Class ] klass The class of the document.
+    # @param [ Object, Hash ] idenfier The document id or selector.
+    #
+    # @return [ Document ] The matching document.
+    #
+    # @since 2.1.0
+    def get(klass, identifier)
+      return nil unless Mongoid.identity_map_enabled?
+      documents_for(klass)[identifier]
+    end
+
+    # Remove the document from the identity map.
+    #
+    # @example Remove the document.
+    #   map.removed(person)
+    #
+    # @param [ Document ] document The document to remove.
+    #
+    # @return [ Document, nil ] The removed document.
+    #
+    # @since 2.1.0
+    def remove(document)
+      return nil unless Mongoid.identity_map_enabled? && document && document.id
+      documents_for(document.class).delete(document.id)
+    end
+
+    # Puts a document in the identity map, accessed by it's id.
+    #
+    # @example Put the document in the map.
+    #   identity_map.set(document)
+    #
+    # @param [ Document ] document The document to place in the map.
+    #
+    # @return [ Document ] The provided document.
+    #
+    # @since 2.1.0
+    def set(document)
+      return nil unless Mongoid.identity_map_enabled? && document && document.id
+      documents_for(document.class)[document.id] = document
+    end
+
+    # Set a document in the identity map for the provided selector.
+    #
+    # @example Set the document in the map.
+    #   identity_map.set_selector(document, { :person_id => person.id })
+    #
+    # @param [ Document ] document The document to set.
+    # @param [ Hash ] selector The selector to identify it.
+    #
+    # @return [ Array<Document> ] The documents.
+    #
+    # @since 2.2.0
+    def set_many(document, selector)
+      (documents_for(document.class)[selector] ||= []).push(document)
+    end
+
+    # Set a document in the identity map for the provided selector.
+    #
+    # @example Set the document in the map.
+    #   identity_map.set_selector(document, { :person_id => person.id })
+    #
+    # @param [ Document ] document The document to set.
+    # @param [ Hash ] selector The selector to identify it.
+    #
+    # @return [ Document ] The matching document.
+    #
+    # @since 2.2.0
+    def set_one(document, selector)
+     documents_for(document.class)[selector] = document
+    end
+
+    private
+
+    # Get the documents in the identity map for a specific class.
+    #
+    # @example Get the documents for the class.
+    #   map.documents_for(Person)
+    #
+    # @param [ Class ] klass The class to retrieve.
+    #
+    # @return [ Hash ] The documents.
+    #
+    # @since 2.1.0
+    def documents_for(klass)
+      self[klass] ||= {}
+    end
+
+    class << self
+
+      # For ease of access we provide the same API to the identity map on the
+      # class level, which in turn just gets the identity map that is on the
+      # current thread.
+      #
+      # @example Get a document from the current identity map by id.
+      #   IdentityMap.get(id)
+      #
+      # @example Set a document in the current identity map.
+      #   IdentityMap.set(document)
+      #
+      # @since 2.1.0
+      delegate *(
+        Hash.public_instance_methods(false) +
+        IdentityMap.public_instance_methods(false) <<
+        { :to => :"Mongoid::Threaded.identity_map" }
+      )
+    end
+  end
+end

data/lib/mongoid/indexes.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Indexes #:nodoc
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :index_options
+      self.index_options = {}
+    end
+
+    module ClassMethods #:nodoc
+
+      # Send the actual index creation comments to the MongoDB driver
+      #
+      # @example Create the indexes for the class.
+      #   Person.create_indexes
+      def create_indexes
+        return unless index_options
+        current_collection = self._collection || set_collection
+        index_options.each_pair do |name, options|
+          current_collection.create_index(name, options)
+        end
+      end
+
+      # Add the default indexes to the root document if they do not already
+      # exist. Currently this is only _type.
+      #
+      # @example Add Mongoid internal indexes.
+      #   Person.add_indexes
+      def add_indexes
+        if hereditary? && !index_options[:_type]
+          self.index_options[:_type] = {:unique => false, :background => true}
+        end
+        create_indexes if Mongoid.autocreate_indexes
+      end
+
+      # Adds an index on the field specified. Options can be :unique => true or
+      # :unique => false. It will default to the latter.
+      #
+      # @example Create a basic index.
+      #   class Person
+      #     include Mongoid::Document
+      #     field :name, :type => String
+      #     index :name, :background => true
+      #
+      # @param [ Symbol ] name The name of the field.
+      # @param [ Hash ] options The index options.
+      def index(name, options = { :unique => false })
+        self.index_options[name] = options
+        create_indexes if Mongoid.autocreate_indexes
+      end
+    end
+  end
+end

data/lib/mongoid/inspection.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+
+  # Contains the bahviour around inspecting documents via
+  # <tt>Object#inspect</tt>.
+  module Inspection
+
+    # Returns the class name plus its attributes. If using dynamic fields will
+    # include those as well.
+    #
+    # @example Inspect the document.
+    #   person.inspect
+    #
+    # @return [ String ] A nice pretty string to look at.
+    def inspect
+      inspection = []
+      inspection.concat(inspect_fields).concat(inspect_dynamic_fields)
+      "#<#{self.class.name} _id: #{id}, #{inspection * ', '}>"
+    end
+
+    private
+
+    # Get an array of inspected fields for the document.
+    #
+    # @example Inspect the defined fields.
+    #   document.inspect_fields
+    #
+    # @return [ String ] An array of pretty printed field values.
+    def inspect_fields
+      fields.map do |name, field|
+        unless name == "_id"
+          "#{name}: #{@attributes[name].inspect}"
+        end
+      end.compact
+    end
+
+    # Get an array of inspected dynamic fields for the document.
+    #
+    # @example Inspect the dynamic fields.
+    #   document.inspect_dynamic_fields
+    #
+    # @return [ String ] An array of pretty printed dynamic field values.
+    def inspect_dynamic_fields
+      if Mongoid.allow_dynamic_fields
+        keys = @attributes.keys - fields.keys - relations.keys - ["_id", "_type"]
+        return keys.map do |name|
+          "#{name}: #{@attributes[name].inspect}"
+        end
+      else
+        []
+      end
+    end
+  end
+end

data/lib/mongoid/javascript.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  class Javascript
+    # Constant for the file that defines all the js functions.
+    FUNCTIONS = File.join(File.dirname(__FILE__), "javascript", "functions.yml")
+
+    # Load the javascript functions and define a class method for each one,
+    # that memoizes the value.
+    #
+    # @example Get the function.
+    #   Mongoid::Javascript.aggregate
+    YAML.load(File.read(FUNCTIONS)).each_pair do |key, function|
+      (class << self; self; end).class_eval <<-EOT
+        def #{key}
+          @#{key} ||= "#{function}"
+        end
+      EOT
+    end
+  end
+end

data/lib/mongoid/javascript/functions.yml

@@ -0,0 +1,63 @@
+aggregate:
+  "function(obj, prev) {
+     prev.count++;
+   }"
+
+group:
+  "function(obj, prev) {
+     prev.group.push(obj);
+   }"
+
+max:
+  "function(obj, prev) {
+     if (obj.[field] && prev.max == 'start') {
+       prev.max = obj.[field];
+     }
+     if (obj.[field] && prev.max < obj.[field]) {
+       prev.max = obj.[field];
+     }
+   }"
+
+max_finalize:
+  "function(obj) {
+     if (obj.max == 'start' || isNaN(obj.max)) {
+       obj.max = 0;
+     }
+     return obj;
+   }"
+
+min:
+  "function(obj, prev) {
+     if (obj.[field] && prev.min == 'start') {
+       prev.min = obj.[field];
+     }
+     if (obj.[field] && prev.min > obj.[field]) {
+       prev.min = obj.[field];
+     }
+   }"
+
+min_finalize:
+  "function(obj) {
+     if (obj.min == 'start' || isNaN(obj.min)) {
+       obj.min = 0;
+     }
+     return obj;
+   }"
+
+sum:
+  "function(obj, prev) {
+     if (prev.sum == 'start') {
+       prev.sum = 0;
+     }
+     if (obj.[field]) {
+       prev.sum += obj.[field];
+     }
+  }"
+
+sum_finalize:
+  "function(obj) {
+     if (obj.sum == 'start' || isNaN(obj.sum)) {
+       obj.sum = 0;
+     }
+     return obj;
+   }"

data/lib/mongoid/json.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  # This module is for hooking in to +ActiveModel+s serialization to let
+  # configuring the ability to include the root in JSON happen from the Mongoid
+  # config.
+  module JSON
+    extend ActiveSupport::Concern
+
+    # We need to redefine where the JSON configuration is getting defined,
+    # similar to +ActiveRecord+.
+    included do
+      undef_method :include_root_in_json
+      delegate :include_root_in_json, :to => ::Mongoid
+    end
+  end
+end

data/lib/mongoid/keys.rb

@@ -0,0 +1,144 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # This module defines the behaviour for overriding the default ids on
+  # documents.
+  module Keys
+    extend ActiveSupport::Concern
+
+    attr_reader :identifier
+
+    included do
+      cattr_accessor :primary_key, :using_object_ids, :key_formatter
+      self.using_object_ids = true
+    end
+
+    # Get the document's primary key.
+    #
+    # @note Refactored from using delegate for class load performance.
+    #
+    # @example Get the primary key.
+    #   model.primary_key
+    #
+    # @return [ Array ] The primary key
+    def primary_key
+      self.class.primary_key
+    end
+
+    # Is the document using object ids?
+    #
+    # @note Refactored from using delegate for class load performance.
+    #
+    # @example Is the document using object ids?
+    #   model.using_object_ids?
+    #
+    # @return [ true, false ] Using object ids.
+    def using_object_ids?
+      self.class.using_object_ids?
+    end
+
+    private
+
+    # Determines if any field that the document id is composed of has changed.
+    #
+    # @example Has any key field changed?
+    #   document.key_field_changed?
+    #
+    # @return [ true, false ] Has a key field changed?
+    #
+    # @since 2.0.0
+    def key_field_changed?
+      primary_key.any? { |field| changed.include?(field.to_s) }
+    end
+
+    # Sits around a save when composite keys are in play to handle the id magic
+    # if a key field has changed.
+    #
+    # @example Set the composite key.
+    #   document.set_composite_key
+    #
+    # @param [ Proc ] block The block this surrounds.
+    #
+    # @since 2.0.0
+    def set_composite_key(&block)
+      if persisted? && key_field_changed?
+        swap_composite_keys(&block)
+      else
+        identify and block.call
+      end
+    end
+
+    # Swap out the composite key only after the document has been saved.
+    #
+    # @example Swap out the keys.
+    #   document.swap_composite_keys
+    #
+    # @param [ Proc ] block The save block getting called.
+    #
+    # @since 2.0.0
+    def swap_composite_keys(&block)
+      @identifier, new_id = id.dup, identify
+      block.call
+      @identifier = nil
+    end
+
+    module ClassMethods #:nodoc:
+
+      # Used for telling Mongoid on a per model basis whether to override the
+      # default +BSON::ObjectId+ and use a different type. This will be
+      # expanded in the future for requiring a PkFactory if the type is not a
+      # +BSON::ObjectId+ or +String+.
+      #
+      # @example Change the documents key type.
+      #   class Person
+      #     include Mongoid::Document
+      #     identity :type => String
+      #   end
+      #
+      # @param [ Hash ] options The options.
+      #
+      # @option options [ Class ] :type The type of the id.
+      #
+      # @since 2.0.0.beta.1
+      def identity(options = {})
+        type = options[:type]
+        replace_field("_id", type)
+        self.using_object_ids = (type == BSON::ObjectId)
+      end
+
+      # Defines the field that will be used for the id of this +Document+. This
+      # set the id of this +Document+ before save to a parameterized version of
+      # the field that was supplied. This is good for use for readable URLS in
+      # web applications.
+      #
+      # @example Create a composite id.
+      #   class Person
+      #     include Mongoid::Document
+      #     key :first_name, :last_name
+      #   end
+      #
+      # @param [ Array<Symbol> ] The fields the key is composed of.
+      #
+      # @since 1.0.0
+      def key(*fields)
+        self.primary_key = fields
+        self.key_formatter = block_given? ? Proc.new : nil
+        identity(:type => String)
+        set_callback(:save, :around, :set_composite_key)
+      end
+
+      # Convenience method for determining if we are using +BSON::ObjectIds+ as
+      # our id.
+      #
+      # @example Does this class use object ids?
+      #   person.using_object_ids?
+      #
+      # @return [ true, false ] If the class uses BSON::ObjectIds for the id.
+      #
+      # @since 1.0.0
+      def using_object_ids?
+        using_object_ids
+      end
+    end
+  end
+end