stonegao-mongoid 2.0.0.rc.6

data/lib/mongoid/document.rb

@@ -0,0 +1,256 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # This is the base module for all domain objects that need to be persisted to
+  # the database as documents.
+  module Document
+    extend ActiveSupport::Concern
+    include Mongoid::Components
+    include Mongoid::MultiDatabase
+
+    included do
+      attr_reader :new_record
+    end
+
+    # Default comparison is via the string version of the id.
+    #
+    # @example Compare two documents.
+    #   person <=> other_person
+    #
+    # @param [ Document ] other The document to compare with.
+    #
+    # @return [ Integer ] -1, 0, 1.
+    def <=>(other)
+      id.to_s <=> other.id.to_s
+    end
+
+    # Performs equality checking on the document ids. For more robust
+    # equality checking please override this method.
+    #
+    # @example Compare for equality.
+    #   document == other
+    #
+    # @param [ Document, Object ] other The other object to compare with.
+    #
+    # @return [ true, false ] True if the ids are equal, false if not.
+    def ==(other)
+      return false unless other.is_a?(Document)
+      id == other.id || equal?(other)
+    end
+
+    # Performs class equality checking.
+    #
+    # @example Compare the classes.
+    #   document === other
+    #
+    # @param [ Document, Object ] other The other object to compare with.
+    #
+    # @return [ true, false ] True if the classes are equal, false if not.
+    def ===(other)
+      self.class == other.class
+    end
+
+    # Delegates to ==. Used when needing checks in hashes.
+    #
+    # @example Perform equality checking.
+    #   document.eql?(other)
+    #
+    # @param [ Document, Object ] other The object to check against.
+    #
+    # @return [ true, false ] True if equal, false if not.
+    def eql?(other)
+      self == (other)
+    end
+
+    # Delegates to id in order to allow two records of the same type and id to
+    # work with something like:
+    #
+    #   [ Person.find(1), Person.find(2), Person.find(3) ] &
+    #   [ Person.find(1), Person.find(4) ] # => [ Person.find(1) ]
+    #
+    # @example Get the hash.
+    #   document.hash
+    #
+    # @return [ Integer ] The hash of the document's id.
+    def hash
+      id.hash
+    end
+
+    # Return the attributes hash with indifferent access. Used mostly for
+    # convenience - use +Document#raw_attributes+ where you dont care if the
+    # keys are all strings.
+    #
+    # @example Get the attributes.
+    #   person.attributes
+    #
+    # @return [ HashWithIndifferentAccess ] The attributes.
+    def attributes
+      @attributes.with_indifferent_access
+    end
+
+    # Generate an id for this +Document+.
+    #
+    # @example Create the id.
+    #   person.identify
+    #
+    # @return [ BSON::ObjectId, String ] A newly created id.
+    def identify
+      Identity.new(self).create
+    end
+
+    # Instantiate a new +Document+, setting the Document's attributes if
+    # given. If no attributes are provided, they will be initialized with
+    # an empty +Hash+.
+    #
+    # If a primary key is defined, the document's id will be set to that key,
+    # otherwise it will be set to a fresh +BSON::ObjectId+ string.
+    #
+    # @example Create a new document.
+    #   Person.new(:title => "Sir")
+    #
+    # @param [ Hash ] attrs The attributes to set up the document with.
+    #
+    # @return [ Document ] A new document.
+    def initialize(attrs = nil)
+      @new_record = true
+      @attributes = default_attributes
+      # @todo: Durran: We know the document is polymorphic here but we have no
+      #   metadata... Can we pass the document to the field setter and get the
+      #   foreign key setter to set the type?
+      process(attrs) do |document|
+        yield self if block_given?
+        identify
+        run_callbacks(:initialize) { document }
+      end
+    end
+
+    # Return the attributes hash.
+    #
+    # @example Get the untouched attributes.
+    #   person.raw_attributes
+    #
+    # @return [ Hash ] This document's attributes.
+    def raw_attributes
+      @attributes
+    end
+
+    # Reloads the +Document+ attributes from the database. If the document has
+    # not been saved then an error will get raised if the configuration option
+    # was set.
+    #
+    # @example Reload the document.
+    #   person.reload
+    #
+    # @raise [ Errors::DocumentNotFound ] If the document was deleted.
+    #
+    # @return [ Document ] The document, reloaded.
+    def reload
+      reloaded = collection.find_one(:_id => id)
+      if Mongoid.raise_not_found_error
+        raise Errors::DocumentNotFound.new(self.class, id) if reloaded.nil?
+      end
+      @attributes = {}.merge(reloaded || {})
+      tap do
+        relations.keys.each do |name|
+          if relation_exists?(name)
+            remove_instance_variable("@#{name}")
+          end
+        end
+      end
+    end
+
+    # Remove a child document from this parent. If an embeds one then set to
+    # nil, otherwise remove from the embeds many.
+    #
+    # This is called from the +RemoveEmbedded+ persistence command.
+    #
+    # @example Remove the child.
+    #   document.remove_child(child)
+    #
+    # @param [ Document ] child The child (embedded) document to remove.
+    def remove_child(child)
+      name = child.metadata.name
+      if child.embedded_one?
+        remove_instance_variable("@#{name}") if instance_variable_defined?("@#{name}")
+      else
+        send(name).delete(child)
+      end
+    end
+
+    # Return an array with this +Document+ only in it.
+    #
+    # @example Return the document in an array.
+    #   document.to_a
+    #
+    # @return [ Array<Document> ] An array with the document as its only item.
+    def to_a
+      [ self ]
+    end
+
+    # Return a hash of the entire document hierarchy from this document and
+    # below. Used when the attributes are needed for everything and not just
+    # the current document.
+    #
+    # @example Get the full hierarchy.
+    #   person.to_hash
+    #
+    # @return [ Hash ] A hash of all attributes in the hierarchy.
+    def to_hash
+      attributes = @attributes
+      attributes.tap do |attrs|
+        relations.select { |name, meta| meta.embedded? }.each do |name, meta|
+          relation = send(name, false, :continue => false)
+          attrs[name] = relation.to_hash unless relation.blank?
+        end
+      end
+    end
+
+    module ClassMethods #:nodoc:
+
+      # Performs class equality checking.
+      #
+      # @example Compare the classes.
+      #   document === other
+      #
+      # @param [ Document, Object ] other The other object to compare with.
+      #
+      # @return [ true, false ] True if the classes are equal, false if not.
+      #
+      # @since 2.0.0.rc.4
+      def ===(other)
+        self == (other.is_a?(Class) ? other : other.class)
+      end
+
+      # Instantiate a new object, only when loaded from the database or when
+      # the attributes have already been typecast.
+      #
+      # @example Create the document.
+      #   Person.instantiate(:title => "Sir", :age => 30)
+      #
+      # @param [ Hash ] attrs The hash of attributes to instantiate with.
+      #
+      # @return [ Document ] A new document.
+      def instantiate(attrs = nil)
+        attributes = attrs || {}
+        if attributes["_id"]
+          allocate.tap do |doc|
+            doc.instance_variable_set(:@attributes, attributes)
+            doc.setup_modifications
+          end
+        else
+          new(attrs)
+        end
+      end
+
+      # Returns all types to query for when using this class as the base.
+      #
+      # @example Get the types.
+      #   document._types
+      #
+      # @return [ Array<Class> ] All subclasses of the current document.
+      def _types
+        @_type ||= [descendants + [self]].flatten.uniq.map(&:to_s)
+      end
+    end
+  end
+end

data/lib/mongoid/errors/document_not_found.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Errors #:nodoc
+
+    # Raised when querying the database for a document by a specific id which
+    # does not exist. If multiple ids were passed then it will display all of
+    # those.
+    #
+    # Example:
+    #
+    # <tt>DocumentNotFound.new(Person, ["1", "2"])</tt>
+    class DocumentNotFound < MongoidError
+
+      attr_reader :klass, :identifiers
+
+      def initialize(klass, ids)
+        @klass = klass
+        @identifiers = ids.is_a?(Array) ? ids.join(", ") : ids
+
+        super(
+          translate(
+            "document_not_found",
+            { :klass => klass.name, :identifiers => @identifiers }
+          )
+        )
+      end
+    end
+  end
+end

data/lib/mongoid/errors/invalid_collection.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Errors #:nodoc
+
+    # This error is raised when trying to access a Mongo::Collection from an
+    # embedded document.
+    #
+    # Example:
+    #
+    # <tt>InvalidCollection.new(Address)</tt>
+    class InvalidCollection < MongoidError
+      def initialize(klass)
+        super(
+          translate("invalid_collection", { :klass => klass.name })
+        )
+      end
+    end
+  end
+end

data/lib/mongoid/errors/invalid_database.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Errors #:nodoc
+
+    # Raised when the database connection has not been set up properly, either
+    # by attempting to set an object on the db that is not a +Mongo::DB+, or
+    # not setting anything at all.
+    #
+    # Example:
+    #
+    # <tt>InvalidDatabase.new("Not a DB")</tt>
+    class InvalidDatabase < MongoidError
+      def initialize(database)
+        super(
+          translate("invalid_database", { :name => database.class.name })
+        )
+      end
+    end
+  end
+end

data/lib/mongoid/errors/invalid_field.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Errors #:nodoc
+
+    # This error is raised when trying to create a field that conflicts with
+    # a Mongoid internal attribute or method.
+    #
+    # Example:
+    #
+    # <tt>InvalidField.new('collection')</tt>
+    class InvalidField < MongoidError
+      def initialize(name)
+        super(
+          translate("invalid_field", { :name => name })
+        )
+      end
+    end
+  end
+end

data/lib/mongoid/errors/invalid_options.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Errors #:nodoc
+
+    # Raised when invalid options are passed into a constructor or method.
+    #
+    # Example:
+    #
+    # <tt>InvalidOptions.new</tt>
+    class InvalidOptions < MongoidError
+      def initialize(key, options)
+        super(translate(key, options))
+      end
+    end
+  end
+end

data/lib/mongoid/errors/invalid_type.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Errors #:nodoc
+
+    # Raised when trying to get or set a value for a defined field, where the
+    # type of the object does not match the defined field type.
+    #
+    # Example:
+    #
+    # <tt>InvalidType.new(Array, "Not an Array")</tt>
+    class InvalidType < MongoidError
+      def initialize(klass, value)
+        super(
+          translate(
+            "invalid_type",
+            {
+              :klass => klass.name,
+              :other => value.class.name,
+              :value => value.inspect
+            }
+          )
+        )
+      end
+    end
+  end
+end

data/lib/mongoid/errors/mongoid_error.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Errors #:nodoc
+
+    # Default parent Mongoid error for all custom errors. This handles the base
+    # key for the translations and provides the convenience method for
+    # translating the messages.
+    class MongoidError < StandardError
+      BASE_KEY = "mongoid.errors.messages"
+
+      # Given the key of the specific error and the options hash, translate the
+      # message.
+      #
+      # Options:
+      #
+      # key: The key of the error in the locales.
+      # options: The objects to pass to create the message.
+      #
+      # Returns:
+      #
+      # A localized error message string.
+      def translate(key, options)
+        ::I18n.translate("#{BASE_KEY}.#{key}", options)
+      end
+    end
+  end
+end

data/lib/mongoid/errors/too_many_nested_attribute_records.rb

@@ -0,0 +1,21 @@
+module Mongoid #:nodoc
+  module Errors #:nodoc
+
+    # This error is raised when trying to create set nested records above the
+    # specified :limit
+    #
+    # Example:
+    #
+    #<tt>TooManyNestedAttributeRecords.new('association', limit)
+    class TooManyNestedAttributeRecords < MongoidError
+      def initialize(association, limit)
+        super(
+          translate(
+            "too_many_nested_attribute_records",
+            { :association => association, :limit => limit }
+          )
+        )
+      end
+    end
+  end
+end

data/lib/mongoid/errors/unsaved_document.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Errors #:nodoc
+
+    # Raised when attempting to call create or create! through a
+    # references_many when the parent document has not been saved. This
+    # prevents the child from getting presisted and immediately being orphaned.
+    class UnsavedDocument < MongoidError
+
+      attr_reader :base, :document
+
+      def initialize(base, document)
+        @base, @document = base, document
+        super(
+          translate(
+            "unsaved_document",
+            { :base => base.class.name, :document => document.class.name }
+          )
+        )
+      end
+    end
+  end
+end

data/lib/mongoid/errors/unsupported_version.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Errors #:nodoc
+
+    # Raised when the database version is not supported by Mongoid.
+    #
+    # Example:
+    #
+    # <tt>UnsupportedVersion.new(Mongo::ServerVersion.new("1.3.1"))</tt>
+    class UnsupportedVersion < MongoidError
+      def initialize(version)
+        super(
+          translate(
+            "unsupported_version",
+            { :version => version, :mongo_version => Mongoid::MONGODB_VERSION }
+          )
+        )
+      end
+    end
+  end
+end

data/lib/mongoid/errors/validations.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Errors #:nodoc
+
+    # Raised when a persistence method ending in ! fails validation. The message
+    # will contain the full error messages from the +Document+ in question.
+    #
+    # Example:
+    #
+    # <tt>Validations.new(person.errors)</tt>
+    class Validations < MongoidError
+      attr_reader :document
+      def initialize(document)
+        @document = document
+        super(
+          translate(
+            "validations",
+            { :errors => document.errors.full_messages.join(", ") }
+          )
+        )
+      end
+    end
+  end
+end

data/lib/mongoid/errors.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+require "mongoid/errors/mongoid_error"
+require "mongoid/errors/document_not_found"
+require "mongoid/errors/invalid_collection"
+require "mongoid/errors/invalid_database"
+require "mongoid/errors/invalid_field"
+require "mongoid/errors/invalid_options"
+require "mongoid/errors/invalid_type"
+require "mongoid/errors/too_many_nested_attribute_records"
+require "mongoid/errors/unsaved_document"
+require "mongoid/errors/unsupported_version"
+require "mongoid/errors/validations"

data/lib/mongoid/extensions/array/conversions.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Array #:nodoc:
+      # This module converts arrays into mongoid related objects.
+      module Conversions #:nodoc:
+        extend ActiveSupport::Concern
+
+        module ClassMethods #:nodoc:
+          def raise_or_return(value)
+            unless value.nil? || value.is_a?(::Array)
+              raise Mongoid::Errors::InvalidType.new(::Array, value)
+            end
+            value
+          end
+
+          alias :get :raise_or_return
+          alias :set :raise_or_return
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/extensions/array/parentization.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Array #:nodoc:
+      module Parentization #:nodoc:
+        # Adds the parent document to each element in the array.
+        def parentize(parent)
+          each { |obj| obj.parentize(parent) }
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/extensions/big_decimal/conversions.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+require "bigdecimal"
+
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module BigDecimal #:nodoc:
+      module Conversions #:nodoc:
+        # Get the string as a +BigDecimal+
+        def get(value)
+          value ? ::BigDecimal.new(value) : value
+        end
+        # Set the value in the hash as a string.
+        def set(value)
+          value ? value.to_s : value
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/extensions/binary/conversions.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Binary #:nodoc:
+      module Conversions #:nodoc:
+        # Get the value from the db hash.
+        def get(value)
+          value
+        end
+        # Set the value in the db hash.
+        def set(value)
+          value
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/extensions/boolean/conversions.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Boolean #:nodoc:
+      module Conversions #:nodoc:
+        extend ActiveSupport::Concern
+
+        BOOLEAN_MAP = {
+          true => true, "true" => true, "TRUE" => true, "1" => true, 1 => true, 1.0 => true,
+          false => false, "false" => false, "FALSE" => false, "0" => false, 0 => false, 0.0 => false
+        }
+
+        module ClassMethods #:nodoc
+
+          def set(value)
+            value = BOOLEAN_MAP[value]
+            value.nil? ? nil : value
+          end
+
+          def get(value)
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/extensions/date/conversions.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Date #:nodoc:
+      module Conversions #:nodoc:
+        def get(value)
+          return nil if value.blank?
+          if Mongoid::Config.use_utc?
+            value.to_date
+          else
+            ::Date.new(value.year, value.month, value.day)
+          end
+        end
+
+        protected
+
+        def convert_to_time(value)
+          value = ::Date.parse(value) if value.is_a?(::String)
+          value = ::Date.civil(*value) if value.is_a?(::Array)
+          ::Time.utc(value.year, value.month, value.day)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/extensions/datetime/conversions.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module DateTime #:nodoc:
+      module Conversions #:nodoc:
+        def get(value)
+          super.try(:to_datetime)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/extensions/false_class/equality.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module FalseClass #:nodoc:
+      module Equality #:nodoc:
+        def is_a?(other)
+          return true if other.name == "Boolean"
+          super(other)
+        end
+      end
+    end
+  end
+end