mongoid-locomotive 2.0.0.beta9

data/lib/mongoid/document.rb

@@ -0,0 +1,210 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Document
+    extend ActiveSupport::Concern
+    included do
+      include Mongoid::Components
+
+      cattr_accessor :primary_key
+
+      attr_accessor :association_name
+      attr_reader :new_record
+
+      delegate :primary_key, :to => "self.class"
+    end
+
+    module ClassMethods #:nodoc:
+
+      # Perform default behavior but mark the hierarchy as being hereditary.
+      #
+      # This method must remain in the +Document+ module, even though its
+      # behavior affects items in the Hierarchy module.
+      def inherited(subclass)
+        super(subclass)
+        self.hereditary = true
+      end
+
+      # Instantiate a new object, only when loaded from the database or when
+      # the attributes have already been typecast.
+      #
+      # Example:
+      #
+      # <tt>Person.instantiate(:title => "Sir", :age => 30)</tt>
+      def instantiate(attrs = nil, allocating = false)
+        attributes = attrs || {}
+        if attributes["_id"] || allocating
+          document = allocate
+          document.instance_variable_set(:@attributes, attributes)
+          document.setup_modifications
+          return document
+        else
+          return new(attrs)
+        end
+      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:
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     key :first_name, :last_name
+      #   end
+      def key(*fields)
+        self.primary_key = fields
+        set_callback :save, :before, :identify
+      end
+
+      # Returns all types to query for when using this class as the base.
+      # *subclasses* is from activesupport. Note that a bug in *subclasses*
+      # causes the first call to only return direct children, hence
+      # the double call and unique.
+      def _types
+        @_type ||= [subclasses + subclasses + [self.name]].flatten.uniq.map(&:to_s)
+      end
+    end
+
+    # Performs equality checking on the document ids. For more robust
+    # equality checking please override this method.
+    def ==(other)
+      return false unless other.is_a?(Document)
+      id == other.id
+    end
+
+    # Delegates to ==
+    def eql?(comparison_object)
+      self == (comparison_object)
+    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) ]
+    def hash
+      id.hash
+    end
+
+    # Introduces a child object into the +Document+ object graph. This will
+    # set up the relationships between the parent and child and update the
+    # attributes of the parent +Document+.
+    #
+    # Options:
+    #
+    # parent: The +Document+ to assimilate with.
+    # options: The association +Options+ for the child.
+    def assimilate(parent, options)
+      parentize(parent, options.name); notify; self
+    end
+
+    # Return the attributes hash with indifferent access.
+    def attributes
+      @attributes.with_indifferent_access
+    end
+
+    # Clone the current +Document+. This will return all attributes with the
+    # exception of the document's id and versions.
+    def clone
+      self.class.instantiate(@attributes.except("_id").except("versions").dup, true)
+    end
+
+    # Generate an id for this +Document+.
+    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.
+    #
+    # Options:
+    #
+    # attrs: The attributes +Hash+ to set up the document with.
+    def initialize(attrs = nil)
+      @attributes = default_attributes
+      process(attrs)
+      @new_record = true
+      document = yield self if block_given?
+      identify
+    end
+
+    # Returns the class name plus its attributes.
+    def inspect
+      attrs = fields.map { |name, field| "#{name}: #{@attributes[name].inspect}" }
+      if Mongoid.allow_dynamic_fields
+        dynamic_keys = @attributes.keys - fields.keys - associations.keys - ["_id", "_type"]
+        attrs += dynamic_keys.map { |name| "#{name}: #{@attributes[name].inspect}" }
+      end
+      "#<#{self.class.name} _id: #{id}, #{attrs * ', '}>"
+    end
+
+    # Notify parent of an update.
+    #
+    # Example:
+    #
+    # <tt>person.notify</tt>
+    def notify
+      _parent.update_child(self) if _parent
+    end
+
+    # Return the attributes hash.
+    def raw_attributes
+      @attributes
+    end
+
+    # Reloads the +Document+ attributes from the database.
+    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 || {})
+      self.associations.keys.each { |association_name| unmemoize(association_name) }; self
+    end
+
+    # Remove a child document from this parent +Document+. Will reset the
+    # memoized association and notify the parent of the change.
+    def remove(child)
+      name = child.association_name
+      if @building_nested
+        @attributes.remove(name, child.raw_attributes)
+      else
+        reset(name) { @attributes.remove(name, child.raw_attributes) } 
+        notify
+      end
+    end
+    
+    # def remove_without_reset
+    #   name = child.association_name
+    #   @attributes.remove(name, child.raw_attributes)
+    #   notify
+    # end
+
+    # Return an array with this +Document+ only in it.
+    def to_a
+      [ self ]
+    end
+
+    # Recieve a notify call from a child +Document+. This will either update
+    # existing attributes on the +Document+ or clear them out for the child if
+    # the clear boolean is provided.
+    #
+    # Options:
+    #
+    # child: The child +Document+ that sent the notification.
+    # clear: Will clear out the child's attributes if set to true.
+    def update_child(child, clear = false)
+      name = child.association_name
+      attrs = child.instance_variable_get(:@attributes)
+      if clear
+        @attributes.delete(name)
+      else
+        # check good for array only
+        @attributes.insert(name, attrs) unless @attributes[name] && @attributes[name].include?(attrs)
+      end
+    end
+  end
+end

data/lib/mongoid/errors.rb

@@ -0,0 +1,131 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Errors #:nodoc
+
+    # Default parent Mongoid error for all custom errors
+    class MongoidError < StandardError; end
+
+    # 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, :indentifiers
+      def initialize(klass, ids)
+        @klass = klass
+        @identifiers = ids.is_a?(Array) ? ids.join(", ") : ids
+        super("Document not found for class #{@klass} with id(s) #{@identifiers}")
+      end
+    end
+
+    # Raised when invalid options are passed into a constructor or method.
+    #
+    # Example:
+    #
+    # <tt>InvalidOptions.new</tt>
+    class InvalidOptions < MongoidError; end
+
+    # 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
+      attr_reader :database
+      def initialize(database)
+        @database = database
+        super("Database should be a Mongo::DB, not #{@database.class.name}")
+      end
+    end
+
+    # 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("Field was defined as a(n) #{klass.name}, but received a #{value.class.name} " +
+              "with the value #{value.inspect}.")
+      end
+    end
+
+    # 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("MongoDB #{version} not supported, please upgrade to #{Mongoid::MONGODB_VERSION}")
+      end
+    end
+
+    # Raised when a persisence 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("Validation Failed: #{@document.errors.full_messages.join(", ")}")
+      end
+    end
+
+    # This error is raised when trying to access a Mongo::Collection from an
+    # embedded document.
+    #
+    # Example:
+    #
+    # <tt>InvalidCollection.new(Address)</tt>
+    class InvalidCollection < MongoidError
+      attr_reader :klass
+      def initialize(klass)
+        @klass = klass
+        super("Access to the collection for #{@klass.name} is not allowed " +
+              "since it is an embedded document, please access a collection from " +
+              "the root document")
+      end
+    end
+
+    # 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
+      attr_reader :name
+      def initialize(name)
+        @name = name
+        super("Defining a field named '#{@name}' is not allowed. " +
+              "Do not define fields that conflict with Mongoid internal attributes " +
+              "or method names. Use Document#instance_methods to see what " +
+              "names this includes.")
+      end
+    end
+
+    # This error is raised when trying to create set nested records above the
+    # specified :limit
+    #
+    # Example:
+    #
+    #<tt>TooManyNestedAttributeRecords.new('association', limit)
+    class TooManyNestedAttributeRecords < MongoidError
+      attr_reader :association, :limit
+      def initialize(association, limit)
+        @association, @limit = association.to_s.humanize.capitalize, limit
+        super("Accept Nested Attributes for #{@association} is limited to #{@limit} records")
+      end
+    end
+  end
+end

data/lib/mongoid/extensions.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+require "mongoid/extensions/time_conversions"
+require "mongoid/extensions/array/accessors"
+require "mongoid/extensions/array/assimilation"
+require "mongoid/extensions/array/conversions"
+require "mongoid/extensions/array/parentization"
+require "mongoid/extensions/set/conversions"
+require "mongoid/extensions/big_decimal/conversions"
+require "mongoid/extensions/binary/conversions"
+require "mongoid/extensions/boolean/conversions"
+require "mongoid/extensions/date/conversions"
+require "mongoid/extensions/datetime/conversions"
+require "mongoid/extensions/false_class/equality"
+require "mongoid/extensions/float/conversions"
+require "mongoid/extensions/hash/accessors"
+require "mongoid/extensions/hash/assimilation"
+require "mongoid/extensions/hash/conversions"
+require "mongoid/extensions/hash/criteria_helpers"
+require "mongoid/extensions/hash/scoping"
+require "mongoid/extensions/integer/conversions"
+require "mongoid/extensions/nil/assimilation"
+require "mongoid/extensions/object/conversions"
+require "mongoid/extensions/proc/scoping"
+require "mongoid/extensions/string/conversions"
+require "mongoid/extensions/string/inflections"
+require "mongoid/extensions/symbol/inflections"
+require "mongoid/extensions/true_class/equality"
+require "mongoid/extensions/objectid/conversions"
+
+class Array #:nodoc
+  include Mongoid::Extensions::Array::Accessors
+  include Mongoid::Extensions::Array::Assimilation
+  include Mongoid::Extensions::Array::Conversions
+  include Mongoid::Extensions::Array::Parentization
+end
+
+class Set #:nodoc
+  include Mongoid::Extensions::Set::Conversions
+end
+
+class BigDecimal #:nodoc
+  extend Mongoid::Extensions::BigDecimal::Conversions
+end
+
+class Binary #:nodoc
+  extend Mongoid::Extensions::Binary::Conversions
+end
+
+class Boolean #:nodoc
+  include Mongoid::Extensions::Boolean::Conversions
+end
+
+class DateTime #:nodoc
+  extend Mongoid::Extensions::TimeConversions
+  extend Mongoid::Extensions::DateTime::Conversions
+end
+
+class Date #:nodoc
+  extend Mongoid::Extensions::TimeConversions
+  extend Mongoid::Extensions::Date::Conversions
+end
+
+class FalseClass #:nodoc
+  include Mongoid::Extensions::FalseClass::Equality
+end
+
+class Float #:nodoc
+  extend Mongoid::Extensions::Float::Conversions
+end
+
+class Hash #:nodoc
+  include Mongoid::Extensions::Hash::Accessors
+  include Mongoid::Extensions::Hash::Assimilation
+  include Mongoid::Extensions::Hash::CriteriaHelpers
+  include Mongoid::Extensions::Hash::Scoping
+  include Mongoid::Extensions::Hash::Conversions
+end
+
+class Integer #:nodoc
+  extend Mongoid::Extensions::Integer::Conversions
+end
+
+class NilClass #:nodoc
+  include Mongoid::Extensions::Nil::Assimilation
+end
+
+class Object #:nodoc:
+  include Mongoid::Extensions::Object::Conversions
+end
+
+class Proc #:nodoc:
+  include Mongoid::Extensions::Proc::Scoping
+end
+
+class String #:nodoc
+  include Mongoid::Extensions::String::Inflections
+  extend Mongoid::Extensions::String::Conversions
+end
+
+class Symbol #:nodoc
+  remove_method :size if instance_methods.include? :size # temporal fix for ruby 1.9
+  include Mongoid::Extensions::Symbol::Inflections
+end
+
+class Time #:nodoc
+  extend Mongoid::Extensions::TimeConversions
+end
+
+class TrueClass #:nodoc
+  include Mongoid::Extensions::TrueClass::Equality
+end
+
+class BSON::ObjectID #:nodoc
+  extend Mongoid::Extensions::ObjectID::Conversions
+end