chhean-mongoid 2.0.1.beta1

data/MIT_LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Durran Jordan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,49 @@
+= Overview
+
+== About Mongoid
+
+Mongoid is an ODM (Object-Document-Mapper) framework for MongoDB in Ruby.
+
+== Project Tracking
+
+* {Mongoid on Pivotal Tracker}[http://www.pivotaltracker.com/projects/27482]
+* {Mongoid Google Group}[http://groups.google.com/group/mongoid]
+* {Mongoid on CI Joe}[http://ci.mongoid.org/]
+* {Mongoid Website and Documentation}[http://mongoid.org]
+
+== Compatibility
+
+Mongoid is developed against Ruby 1.8.6, 1.8.7, 1.9.1, 1.9.2
+
+= Documentation
+
+Please see the new Mongoid website for up-to-date documentation:
+{mongoid.org}[http://mongoid.org]
+
+= License
+
+Copyright (c) 2009 Durran Jordan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+= Credits
+
+Durran Jordan: durran at gmail dot com

data/lib/mongoid.rb

@@ -0,0 +1,139 @@
+# encoding: utf-8
+# Copyright (c) 2009 Durran Jordan
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+require "rubygems"
+
+gem "activemodel", "3.0.0.beta3"
+gem "will_paginate", "3.0.pre"
+gem "mongo", "~>1.0.1"
+gem "bson", "~>1.0.1"
+
+require "delegate"
+require "singleton"
+require "time"
+require "ostruct"
+require "active_support/core_ext"
+require 'active_support/json'
+require "active_support/inflector"
+require "active_support/time_with_zone"
+require "active_model"
+require "active_model/callbacks"
+require "active_model/conversion"
+require "active_model/deprecated_error_methods"
+require "active_model/errors"
+require "active_model/naming"
+require "active_model/serialization"
+require "active_model/translation"
+require "active_model/validator"
+require "active_model/validations"
+require "will_paginate/collection"
+require "mongo"
+require "mongoid/observable"
+require "mongoid/associations"
+require "mongoid/attributes"
+require "mongoid/callbacks"
+require "mongoid/collection"
+require "mongoid/collections"
+require "mongoid/config"
+require "mongoid/contexts"
+require "mongoid/criteria"
+require "mongoid/cursor"
+require "mongoid/deprecation"
+require "mongoid/dirty"
+require "mongoid/extensions"
+require "mongoid/extras"
+require "mongoid/errors"
+require "mongoid/factory"
+require "mongoid/field"
+require "mongoid/fields"
+require "mongoid/finders"
+require "mongoid/identity"
+require "mongoid/indexes"
+require "mongoid/javascript"
+require "mongoid/matchers"
+require "mongoid/memoization"
+require "mongoid/named_scope"
+require "mongoid/paths"
+require "mongoid/persistence"
+require "mongoid/scope"
+require "mongoid/state"
+require "mongoid/timestamps"
+require "mongoid/validations"
+require "mongoid/versioning"
+require "mongoid/components"
+require "mongoid/document"
+
+module Mongoid #:nodoc
+
+  MONGODB_VERSION = "1.4.0"
+
+  class << self
+
+    # Sets the Mongoid configuration options. Best used by passing a block.
+    #
+    # Example:
+    #
+    #   Mongoid.configure do |config|
+    #     name = "mongoid_test"
+    #     host = "localhost"
+    #     config.allow_dynamic_fields = false
+    #     config.master = Mongo::Connection.new.db(name)
+    #     config.slaves = [
+    #       Mongo::Connection.new(host, 27018, :slave_ok => true).db(name),
+    #       Mongo::Connection.new(host, 27019, :slave_ok => true).db(name)
+    #     ]
+    #   end
+    #
+    # Returns:
+    #
+    # The Mongoid +Config+ singleton instance.
+    def configure
+      config = Mongoid::Config.instance
+      block_given? ? yield(config) : config
+    end
+
+    # Easy convenience method for having an alert generated from the
+    # deprecation module.
+    #
+    # Example:
+    #
+    # <tt>Mongoid.deprecate("Method no longer used")</tt>
+    def deprecate(message)
+      Mongoid::Deprecation.instance.alert(message)
+    end
+
+    alias :config :configure
+  end
+
+  # Take all the public instance methods from the Config singleton and allow
+  # them to be accessed through the Mongoid module directly.
+  #
+  # Example:
+  #
+  # <tt>Mongoid.database = Mongo::Connection.new.db("test")</tt>
+  Mongoid::Config.public_instance_methods(false).each do |name|
+    (class << self; self; end).class_eval <<-EOT
+      def #{name}(*args)
+        configure.send("#{name}", *args)
+      end
+    EOT
+  end
+end

data/lib/mongoid/associations.rb

@@ -0,0 +1,327 @@
+# encoding: utf-8
+require "mongoid/associations/proxy"
+require "mongoid/associations/embedded_in"
+require "mongoid/associations/embeds_many"
+require "mongoid/associations/embeds_one"
+require "mongoid/associations/foreign_key"
+require "mongoid/associations/references_many"
+require "mongoid/associations/references_many_as_array"
+require "mongoid/associations/references_one"
+require "mongoid/associations/referenced_in"
+require "mongoid/associations/options"
+require "mongoid/associations/meta_data"
+
+module Mongoid # :nodoc:
+  module Associations #:nodoc:
+    extend ActiveSupport::Concern
+    included do
+      include ForeignKey
+
+      cattr_accessor :embedded
+      self.embedded = false
+
+      class_inheritable_accessor :associations
+      self.associations = {}
+
+      delegate :embedded, :embedded?, :to => "self.class"
+    end
+
+    module InstanceMethods
+      # Returns the associations for the +Document+.
+      def associations
+        self.class.associations
+      end
+
+      # are we in an embeds_many?
+      def embedded_many?
+        embedded? and _parent.associations[association_name].association == EmbedsMany
+      end
+
+      # Update all the dirty child documents after an update.
+      def update_embedded(name)
+        association = send(name)
+        association.to_a.each { |doc| doc.save if doc.changed? || doc.new_record? } unless association.blank?
+      end
+
+      # Update the one-to-one relational association for the name.
+      def update_association(name)
+        association = send(name)
+        association.save if new_record? && !association.nil?
+      end
+
+      # Updates all the one-to-many relational associations for the name.
+      def update_associations(name)
+        send(name).each { |doc| doc.save } if new_record?
+      end
+    end
+
+    module ClassMethods
+
+      # Adds a relational association from the child Document to a Document in
+      # another database or collection.
+      #
+      # Options:
+      #
+      # name: A +Symbol+ that is the related class name.
+      #
+      # Example:
+      #
+      #   class Game
+      #     include Mongoid::Document
+      #     belongs_to_related :person
+      #   end
+      #
+      def belongs_to_related(name, options = {}, &block)
+        opts = optionize(name, options, fk(name, options), &block)
+        associate(Associations::BelongsToRelated, opts)
+        field(opts.foreign_key, :type => Mongoid.use_object_ids ? BSON::ObjectID : String)
+        index(opts.foreign_key) unless embedded?
+        
+        if options[:polymorphic]
+          field(opts.foreign_type)
+          index(opts.foreign_type)
+        end
+        
+      end
+
+      # Gets whether or not the document is embedded.
+      #
+      # Example:
+      #
+      # <tt>Person.embedded?</tt>
+      #
+      # Returns:
+      #
+      # <tt>true</tt> if embedded, <tt>false</tt> if not.
+      def embedded?
+        !!self.embedded
+      end
+
+      # Adds the association back to the parent document. This macro is
+      # necessary to set the references from the child back to the parent
+      # document. If a child does not define this association calling
+      # persistence methods on the child object will cause a save to fail.
+      #
+      # Options:
+      #
+      # name: A +Symbol+ that matches the name of the parent class.
+      #
+      # Example:
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     embeds_many :addresses
+      #   end
+      #
+      #   class Address
+      #     include Mongoid::Document
+      #     embedded_in :person, :inverse_of => :addresses
+      #   end
+      def embedded_in(name, options = {}, &block)
+        unless options.has_key?(:inverse_of)
+          raise Errors::InvalidOptions.new("Options for embedded_in association must include :inverse_of")
+        end
+        self.embedded = true
+        associate(Associations::EmbeddedIn, optionize(name, options, nil, &block))
+      end
+
+      # Adds the association from a parent document to its children. The name
+      # of the association needs to be a pluralized form of the child class
+      # name.
+      #
+      # Options:
+      #
+      # name: A +Symbol+ that is the plural child class name.
+      #
+      # Example:
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     embeds_many :addresses
+      #   end
+      #
+      #   class Address
+      #     include Mongoid::Document
+      #     embedded_in :person, :inverse_of => :addresses
+      #   end
+      def embeds_many(name, options = {}, &block)
+        associate(Associations::EmbedsMany, optionize(name, options, nil, &block))
+        set_callback(:update, :after) { |document| document.update_embedded(name) } unless name == :versions
+      end
+
+      alias :embed_many :embeds_many
+
+      # Adds the association from a parent document to its child. The name
+      # of the association needs to be a singular form of the child class
+      # name.
+      #
+      # Options:
+      #
+      # name: A +Symbol+ that is the plural child class name.
+     #
+      # Example:
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     embeds_one :name
+      #   end
+      #
+      #   class Name
+      #     include Mongoid::Document
+      #     embedded_in :person
+      #   end
+      def embeds_one(name, options = {}, &block)
+        opts = optionize(name, options, nil, &block)
+        type = Associations::EmbedsOne
+        associate(type, opts)
+        add_builder(type, opts)
+        add_creator(type, opts)
+        set_callback(:update, :after) { |document| document.update_embedded(name) }
+      end
+
+      alias :embed_one :embeds_one
+
+      # Adds a relational association from the child Document to a Document in
+      # another database or collection.
+      #
+      # Options:
+      #
+      # name: A +Symbol+ that is the related class name.
+      #
+      # Example:
+      #
+      #   class Game
+      #     include Mongoid::Document
+      #     referenced_in :person
+      #   end
+      #
+      def referenced_in(name, options = {}, &block)
+        opts = optionize(name, options, constraint(name, options, :in), &block)
+        associate(Associations::ReferencedIn, opts)
+        field(opts.foreign_key, :type => Mongoid.use_object_ids ? BSON::ObjectID : String)
+        index(opts.foreign_key) unless embedded?
+      end
+
+      alias :belongs_to_related :referenced_in
+
+      # Adds a relational association from the Document to many Documents in
+      # another database or collection.
+      #
+      # Options:
+      #
+      # name: A +Symbol+ that is the related class name pluralized.
+      #
+      # Example:
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     references_many :posts
+      #   end
+      #
+      def references_many(name, options = {}, &block)
+        reference_many(name, options, &block)
+        set_callback :save, :before do |document|
+          document.update_associations(name)
+        end
+      end
+
+      alias :has_many_related :references_many
+
+      # Adds a relational association from the Document to one Document in
+      # another database or collection.
+      #
+      # Options:
+      #
+      # name: A +Symbol+ that is the related class name pluralized.
+      #
+      # Example:
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     references_one :game
+      #   end
+      def references_one(name, options = {}, &block)
+        opts = optionize(name, options, constraint(name, options, :one), &block)
+        associate(Associations::ReferencesOne, opts)
+        set_callback :save, :before do |document|
+          document.update_association(name)
+        end
+      end
+
+      alias :has_one_related :references_one
+
+      # Returns the macro associated with the supplied association name. This
+      # will return embeds_on, embeds_many, embedded_in or nil.
+      #
+      # Options:
+      #
+      # name: The association name.
+      #
+      # Example:
+      #
+      # <tt>Person.reflect_on_association(:addresses)</tt>
+      def reflect_on_association(name)
+        association = associations[name.to_s]
+        association ? association.macro : nil
+      end
+
+      protected
+      # Adds the association to the associations hash with the type as the key,
+      # then adds the accessors for the association. The defined setters and
+      # getters for the associations will perform the necessary memoization.
+      #
+      # Example:
+      #
+      # <tt>Person.associate(EmbedsMany, { :name => :addresses })</tt>
+      def associate(type, options)
+        name = options.name.to_s
+        associations[name] = MetaData.new(type, options)
+        define_method(name) { memoized(name) { type.instantiate(self, options) } }
+        define_method("#{name}=") do |object|
+          unmemoize(name)
+          memoized(name) { type.update(object, self, options) }
+        end
+      end
+
+      # Adds a builder for a has_one association. This comes in the form of
+      # build_name(attributes)
+      def add_builder(type, options)
+        name = options.name.to_s
+        define_method("build_#{name}") do |*params|
+          attrs = params[0]
+          attr_options = params[1] || {}
+          reset(name) { type.new(self, (attrs || {}).stringify_keys, options) } unless type == Associations::EmbedsOne && attr_options[:update_only]
+        end
+      end
+
+      # Adds a creator for a has_one association. This comes in the form of
+      # create_name(attributes)
+      def add_creator(type, options)
+        name = options.name.to_s
+        define_method("create_#{name}") do |*params|
+          attrs = params[0]
+          attr_options = params[1] || {}
+          send("build_#{name}", attrs, attr_options).tap(&:save) unless type == Associations::EmbedsOne && attr_options[:update_only]
+        end
+      end
+
+      # build the options given the params.
+      def optionize(name, options, foreign_key, &block)
+        Associations::Options.new(
+          options.merge(:name => name, :foreign_key => foreign_key, :extend => block)
+        )
+      end
+
+      def reference_many(name, options, &block)
+        if (options[:stored_as] == :array)
+          opts = optionize(name, options, constraint(name, options, :many_as_array), &block)
+          field "#{name.to_s.singularize}_ids", :type => Array, :default => []
+          associate(Associations::ReferencesManyAsArray, opts)
+        else
+          opts = optionize(name, options, constraint(name, options, :many), &block)
+          associate(Associations::ReferencesMany, opts)
+        end
+      end
+    end
+  end
+end