mongoid 1.9.5 → 2.0.0.alpha

data/.gitignore

@@ -0,0 +1,6 @@
+.DS_STORE
+coverage/*
+pkg/*
+scratch_directory/*
+tmp/*
+*.gem

data/.watchr

@@ -0,0 +1,29 @@
+# Watchr is the preferred method to run specs automatically over rspactor for
+# Mongoid. If you are using vim, you can add the file:
+#
+# ~/.vim/ftdetect/watchr.vim
+#
+# This should have only the following line in it:
+#
+# autocmd BufNewFile,BufRead *.watchr setf ruby
+#
+# This will enable vim to recognize this file as ruby code should you wish to
+# edit it.
+def run(cmd)
+  puts cmd
+  system cmd
+end
+
+def spec(file)
+  run "spec -O spec/spec.opts #{file}"
+end
+
+watch("spec/.*/*_spec\.rb") do |match|
+  p match[0]
+  spec(match[0])
+end
+
+watch("lib/(.*/.*)\.rb") do |match|
+  p match[1]
+  spec("spec/unit/#{match[1]}_spec.rb")
+end

data/Rakefile

@@ -0,0 +1,52 @@
+require "rubygems"
+require "rake"
+require "rake/rdoctask"
+require "spec/rake/spectask"
+
+begin
+  require "jeweler"
+  Jeweler::Tasks.new do |gem|
+    gem.name = "mongoid"
+    gem.summary = "ODM framework for MongoDB"
+    gem.email = "durran@gmail.com"
+    gem.homepage = "http://mongoid.org"
+    gem.authors = ["Durran Jordan"]
+
+    gem.add_dependency("activemodel", ">= 3.0.pre")
+    gem.add_dependency("will_paginate", ">= 3.0.pre")
+    gem.add_dependency("mongo", ">= 0.19.1")
+
+    gem.add_development_dependency("rspec", ">= 1.3.0")
+    gem.add_development_dependency("mocha", ">= 0.9.8")
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.pattern = "spec/**/*_spec.rb"
+  spec.spec_opts = ["--options", "spec/spec.opts"]
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << "lib" << "spec"
+  spec.pattern = "spec/**/*_spec.rb"
+  spec.spec_opts = ["--options", "spec/spec.opts"]
+  spec.rcov = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  if File.exist?("VERSION.yml")
+    config = File.read("VERSION")
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title = "mongoid #{version}"
+  rdoc.rdoc_files.include("README*")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+task :default => ["spec"]

data/VERSION

@@ -0,0 +1 @@
+2.0.0.alpha

data/caliper.yml

@@ -0,0 +1,4 @@
+test_directories_to_calculate:
+  - spec/unit
+  - spec/integration
+  - spec/integration/mongoid

data/lib/mongoid.rb

@@ -19,29 +19,41 @@
 # 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.pre"
+gem "will_paginate", ">= 3.0.pre"
+gem "mongo", ">= 0.19.1"
+
 require "delegate"
 require "singleton"
 require "time"
-require "validatable"
-require "active_support/callbacks"
 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/concern"
-require "mongoid/observable"
 require "mongoid/associations"
 require "mongoid/attributes"
 require "mongoid/callbacks"
 require "mongoid/collection"
-require "mongoid/collections"
+require "mongoid/commands"
 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"
@@ -55,19 +67,18 @@ require "mongoid/javascript"
 require "mongoid/matchers"
 require "mongoid/memoization"
 require "mongoid/named_scope"
+require "mongoid/observable"
 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.

data/lib/mongoid/associations.rb

@@ -2,8 +2,8 @@
 require "mongoid/associations/proxy"
 require "mongoid/associations/belongs_to_related"
 require "mongoid/associations/embedded_in"
-require "mongoid/associations/embeds_many"
-require "mongoid/associations/embeds_one"
+require "mongoid/associations/embed_many"
+require "mongoid/associations/embed_one"
 require "mongoid/associations/has_many_related"
 require "mongoid/associations/has_one_related"
 require "mongoid/associations/options"
@@ -13,13 +13,9 @@ module Mongoid # :nodoc:
   module Associations #:nodoc:
     extend ActiveSupport::Concern
     included do
-      cattr_accessor :embedded
-      self.embedded = false
-
+      # Associations need to inherit down the chain.
       class_inheritable_accessor :associations
       self.associations = {}
-
-      delegate :embedded, :embedded?, :to => "self.class"
     end
 
     module InstanceMethods
@@ -28,15 +24,9 @@ module Mongoid # :nodoc:
         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?
+      # 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
 
       # Update the one-to-one relational association for the name.
@@ -44,46 +34,14 @@ module Mongoid # :nodoc:
         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?
-      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
+      # Deprecated: Document.belongs_to will become Document.embedded_in
+      def belongs_to(name, options = {}, &block)
+        Mongoid.deprecate("Document.belongs_to will become Document.embedded_in")
+        embedded_in(name, options, &block)
       end
 
       # Adds the association back to the parent document. This macro is
@@ -99,7 +57,7 @@ module Mongoid # :nodoc:
       #
       #   class Person
       #     include Mongoid::Document
-      #     embeds_many :addresses
+      #     embed_many :addresses
       #   end
       #
       #   class Address
@@ -108,47 +66,48 @@ module Mongoid # :nodoc:
       #   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")
+          raise Errors::InvalidOptions.new("Options for belongs_to association must include :inverse_of")
         end
         self.embedded = true
-        associate(Associations::EmbeddedIn, optionize(name, options, nil, &block))
+        add_association(
+          Associations::EmbeddedIn,
+          Associations::Options.new(
+            options.merge(:name => name, :extend => block)
+          )
+        )
       end
 
-      alias :belongs_to :embedded_in
-
-      # 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.
+      # Adds a relational association from the child Document to a Document in
+      # another database or collection.
       #
       # Options:
       #
-      # name: A +Symbol+ that is the plural child class name.
+      # name: A +Symbol+ that is the related class name.
       #
       # Example:
       #
-      #   class Person
+      #   class Game
       #     include Mongoid::Document
-      #     embeds_many :addresses
+      #     belongs_to_related :person
       #   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))
-        unless name == :versions
-          after_update do |document|
-            document.update_embedded(name)
-          end
-        end
+      def belongs_to_related(name, options = {}, &block)
+        opts = Associations::Options.new(
+            options.merge(:name => name, :extend => block, :foreign_key => foreign_key(name, options))
+          )
+        add_association(Associations::BelongsToRelated, opts)
+        field(opts.foreign_key, :type => Mongoid.use_object_ids ? Mongo::ObjectID : String)
+        index(opts.foreign_key) unless self.embedded
       end
 
-      alias :embed_many :embeds_many
-      alias :has_many :embeds_many
+      # Deprecated: Document.has_many will become Document.embed_many
+      def has_many(name, options = {}, &block)
+        Mongoid.deprecate("Document.has_many will become Document.embed_many")
+        embed_many(name, options, &block)
+      end
 
-      # 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
+      # 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:
@@ -159,27 +118,22 @@ module Mongoid # :nodoc:
       #
       #   class Person
       #     include Mongoid::Document
-      #     embeds_one :name
+      #     embed_many :addresses
       #   end
       #
-      #   class Name
+      #   class Address
       #     include Mongoid::Document
-      #     embedded_in :person
+      #     embedded_in :person, :inverse_of => :addresses
       #   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)
-        after_update do |document|
-          document.update_embedded(name)
-        end
+      def embed_many(name, options = {}, &block)
+        add_association(
+          Associations::EmbedMany,
+          Associations::Options.new(
+            options.merge(:name => name, :extend => block)
+          )
+        )
       end
 
-      alias :embed_one :embeds_one
-      alias :has_one :embeds_one
-
       # Adds a relational association from the Document to many Documents in
       # another database or collection.
       #
@@ -195,12 +149,51 @@ module Mongoid # :nodoc:
       #   end
       #
       def has_many_related(name, options = {}, &block)
-        associate(Associations::HasManyRelated, optionize(name, options, fk(self.name, options), &block))
+        add_association(Associations::HasManyRelated,
+          Associations::Options.new(
+            options.merge(:name => name, :foreign_key => foreign_key(self.name, options), :extend => block)
+          )
+        )
         before_save do |document|
           document.update_associations(name)
         end
       end
 
+      # Deprecated: Document.has_one will become Document.embed_one
+      def has_one(name, options = {}, &block)
+        Mongoid.deprecate("Document.has_one will become Document.embed_one")
+        embed_one(name, options, &block)
+      end
+
+      # 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
+      #     embed_one :name
+      #   end
+      #
+      #   class Name
+      #     include Mongoid::Document
+      #     embedded_in :person
+      #   end
+      def embed_one(name, options = {}, &block)
+        opts = Associations::Options.new(
+          options.merge(:name => name, :extend => block)
+        )
+        type = Associations::EmbedOne
+        add_association(type, opts)
+        add_builder(type, opts)
+        add_creator(type, opts)
+      end
+
       # Adds a relational association from the Document to one Document in
       # another database or collection.
       #
@@ -215,7 +208,12 @@ module Mongoid # :nodoc:
       #     has_one_related :game
       #   end
       def has_one_related(name, options = {}, &block)
-        associate(Associations::HasOneRelated, optionize(name, options, fk(self.name, options), &block))
+        add_association(
+          Associations::HasOneRelated,
+          Associations::Options.new(
+            options.merge(:name => name, :foreign_key => foreign_key(name, options), :extend => block)
+          )
+        )
         before_save do |document|
           document.update_association(name)
         end
@@ -240,17 +238,14 @@ module Mongoid # :nodoc:
       # 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)
+      def add_association(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
+          memoized(name) { type.instantiate(self, options) }
+        end
         define_method("#{name}=") do |object|
-          unmemoize(name)
-          memoized(name) { type.update(object, self, options) }
+          reset(name) { type.update(object, self, options) }
         end
       end
 
@@ -269,32 +264,14 @@ module Mongoid # :nodoc:
         name = options.name.to_s
         define_method("create_#{name}") do |attrs|
           document = send("build_#{name}", attrs)
-          document.save; document
+          document.run_callbacks(:create) { document.save }; document
         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
-
       # Find the foreign key.
-      def fk(name, options)
+      def foreign_key(name, options)
         options[:foreign_key] || name.to_s.foreign_key
       end
-
-      # Build the association options.
-      def build_options(name, options, &block)
-        Associations::Options.new(
-          options.merge(
-            :name => name,
-            :foreign_key => foreign_key(name, options),
-            :extend => block
-          )
-        )
-      end
     end
   end
 end