mongoid 1.1.3 → 1.1.4

data/.watchr

@@ -1,3 +1,14 @@
+# 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
@@ -7,5 +18,12 @@ def spec(file)
   run "spec -O spec/spec.opts #{file}"
 end
 
-watch("spec/.*/*_spec\.rb")  {|md| p md[0]; spec(md[0]) }
-watch('lib/(.*/.*)\.rb')     {|md| p md[1]; spec("spec/unit/#{md[1]}_spec.rb") }
+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/VERSION

@@ -1 +1 @@
-1.1.3
+1.1.4

data/caliper.yml

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

data/lib/mongoid.rb

@@ -44,7 +44,6 @@ require "mongoid/callbacks"
 require "mongoid/commands"
 require "mongoid/config"
 require "mongoid/contexts"
-require "mongoid/complex_criterion"
 require "mongoid/criteria"
 require "mongoid/extensions"
 require "mongoid/errors"

data/lib/mongoid/associations.rb

@@ -59,14 +59,16 @@ module Mongoid # :nodoc:
       #     include Mongoid::Document
       #     belongs_to :person, :inverse_of => :addresses
       #   end
-      def belongs_to(name, options = {})
+      def belongs_to(name, options = {}, &block)
         unless options.has_key?(:inverse_of)
           raise Errors::InvalidOptions.new("Options for belongs_to association must include :inverse_of")
         end
         self.embedded = true
         add_association(
           Associations::BelongsTo,
-          Associations::Options.new(options.merge(:name => name))
+          Associations::Options.new(
+            options.merge(:name => name, :extend => block)
+          )
         )
       end
 
@@ -84,11 +86,13 @@ module Mongoid # :nodoc:
       #     belongs_to_related :person
       #   end
       #
-      def belongs_to_related(name, options = {})
+      def belongs_to_related(name, options = {}, &block)
         field "#{name.to_s}_id"
         add_association(
           Associations::BelongsToRelated,
-          Associations::Options.new(options.merge(:name => name))
+          Associations::Options.new(
+            options.merge(:name => name, :extend => block)
+          )
         )
       end
 
@@ -111,10 +115,12 @@ module Mongoid # :nodoc:
       #     include Mongoid::Document
       #     belongs_to :person, :inverse_of => :addresses
       #   end
-      def has_many(name, options = {})
+      def has_many(name, options = {}, &block)
         add_association(
           Associations::HasMany,
-          Associations::Options.new(options.merge(:name => name))
+          Associations::Options.new(
+            options.merge(:name => name, :extend => block)
+          )
         )
       end
 
@@ -132,10 +138,12 @@ module Mongoid # :nodoc:
       #     has_many_related :posts
       #   end
       #
-      def has_many_related(name, options = {})
+      def has_many_related(name, options = {}, &block)
         add_association(
           Associations::HasManyRelated,
-          Associations::Options.new(options.merge(:name => name, :parent_key => self.name.foreign_key))
+          Associations::Options.new(
+            options.merge(:name => name, :parent_key => self.name.foreign_key, :extend => block)
+          )
         )
         before_save do |document|
           document.update_associations(name)
@@ -161,8 +169,10 @@ module Mongoid # :nodoc:
       #     include Mongoid::Document
       #     belongs_to :person
       #   end
-      def has_one(name, options = {})
-        opts = Associations::Options.new(options.merge(:name => name))
+      def has_one(name, options = {}, &block)
+        opts = Associations::Options.new(
+          options.merge(:name => name, :extend => block)
+        )
         type = Associations::HasOne
         add_association(type, opts)
         add_builder(type, opts)
@@ -182,10 +192,12 @@ module Mongoid # :nodoc:
       #     include Mongoid::Document
       #     has_one_related :game
       #   end
-      def has_one_related(name, options = {})
+      def has_one_related(name, options = {}, &block)
         add_association(
           Associations::HasOneRelated,
-          Associations::Options.new(options.merge(:name => name, :parent_key => self.name.foreign_key))
+          Associations::Options.new(
+            options.merge(:name => name, :parent_key => self.name.foreign_key, :extend => block)
+          )
         )
         before_save do |document|
           document.update_association(name)
@@ -227,7 +239,7 @@ module Mongoid # :nodoc:
       def add_builder(type, options)
         name = options.name.to_s
         define_method("build_#{name}") do |attrs|
-          reset(name) { type.new(self, attrs, options) }
+          reset(name) { type.new(self, attrs.stringify_keys, options) }
         end
       end
 

data/lib/mongoid/associations/belongs_to.rb

@@ -4,10 +4,8 @@ module Mongoid #:nodoc:
     class BelongsTo #:nodoc:
       include Proxy
 
-      attr_reader :document, :options
-
       # Creates the new association by setting the internal
-      # document as the passed in Document. This should be the
+      # target as the passed in Document. This should be the
       # parent.
       #
       # All method calls on this object will then be delegated
@@ -15,22 +13,18 @@ module Mongoid #:nodoc:
       #
       # Options:
       #
-      # document: The parent +Document+
+      # target: The parent +Document+
       # options: The association options
-      def initialize(document, options)
-        @document, @options = document, options
+      def initialize(target, options)
+        @target, @options = target, options
+        extends(options)
       end
 
       # Returns the parent document. The id param is present for
       # compatibility with rails, however this could be overwritten
       # in the future.
       def find(id)
-        @document
-      end
-
-      # Delegate all missing methods over to the parent +Document+.
-      def method_missing(name, *args, &block)
-        @document.send(name, *args, &block)
+        @target
       end
 
       class << self
@@ -43,8 +37,8 @@ module Mongoid #:nodoc:
         # document: The parent +Document+
         # options: The association options
         def instantiate(document, options)
-          parent = document._parent
-          parent.nil? ? nil : new(parent, options)
+          target = document._parent
+          target.nil? ? nil : new(target, options)
         end
 
         # Returns the macro used to create the association.
@@ -55,10 +49,14 @@ module Mongoid #:nodoc:
         # Perform an update of the relationship of the parent and child. This
         # is initialized by setting a parent object as the association on the
         # +Document+. Will properly set a has_one or a has_many.
-        def update(parent, child, options)
-          child.parentize(parent, options.inverse_of)
+        #
+        # Returns:
+        #
+        # A new +BelongsTo+ association proxy.
+        def update(target, child, options)
+          child.parentize(target, options.inverse_of)
           child.notify
-          parent
+          instantiate(child, options)
         end
       end
     end

data/lib/mongoid/associations/belongs_to_related.rb

@@ -4,8 +4,6 @@ module Mongoid #:nodoc:
     class BelongsToRelated #:nodoc:
       include Proxy
 
-      attr_reader :document, :options
-
       # Initializing a related association only requires looking up the object
       # by its id.
       #
@@ -13,13 +11,10 @@ module Mongoid #:nodoc:
       #
       # document: The +Document+ that contains the relationship.
       # options: The association +Options+.
-      def initialize(document, foreign_key, options)
-        @document = options.klass.find(foreign_key)
-      end
-
-      # Delegate all missing methods over to the +Document+.
-      def method_missing(name, *args)
-        @document.send(name, *args)
+      def initialize(document, foreign_key, options, target = nil)
+        @options = options
+        @target = target || options.klass.find(foreign_key)
+        extends(options)
       end
 
       class << self
@@ -31,9 +26,9 @@ module Mongoid #:nodoc:
         #
         # document: The +Document+ that contains the relationship.
         # options: The association +Options+.
-        def instantiate(document, options)
+        def instantiate(document, options, target = nil)
           foreign_key = document.send(options.foreign_key)
-          foreign_key.blank? ? nil : new(document, foreign_key, options)
+          foreign_key.blank? ? nil : new(document, foreign_key, options, target)
         end
 
         # Returns the macro used to create the association.
@@ -53,9 +48,12 @@ module Mongoid #:nodoc:
         # Example:
         #
         # <tt>BelongsToRelated.update(game, person, options)</tt>
-        def update(related, parent, options)
-          parent.send("#{options.foreign_key}=", related.id) if related
-          related
+        def update(target, parent, options)
+          if target
+            parent.send("#{options.foreign_key}=", target.id)
+            return instantiate(parent, options, target)
+          end
+          target
         end
       end
 

data/lib/mongoid/associations/has_many.rb

@@ -4,44 +4,43 @@ module Mongoid #:nodoc:
     class HasMany
       include Proxy
 
-      attr_accessor :association_name, :klass, :options
+      attr_accessor :association_name, :klass
 
       # Appends the object to the +Array+, setting its parent in
       # the process.
       def <<(*objects)
         objects.flatten.each do |object|
           object.parentize(@parent, @association_name)
-          @documents << object
+          @target << object
           object.notify
         end
       end
 
+      alias :concat :<<
+      alias :push :<<
+
       # Clears the association, and notifies the parents of the removal.
       def clear
-        unless @documents.empty?
-          object = @documents.first
+        unless @target.empty?
+          object = @target.first
           object.changed(true)
           object.notify_observers(object, true)
-          @documents.clear
+          @target.clear
         end
       end
 
-      # Appends the object to the +Array+, setting its parent in
-      # the process.
-      def concat(*objects)
-        self << objects
-      end
-
       # Builds a new Document and adds it to the association collection. The
       # document created will be of the same class as the others in the
       # association, and the attributes will be passed into the constructor.
       #
-      # Returns the newly created object.
+      # Returns:
+      #
+      # The newly created Document.
       def build(attrs = {}, type = nil)
         object = type ? type.instantiate : @klass.instantiate
         object.parentize(@parent, @association_name)
         object.write_attributes(attrs)
-        @documents << object
+        @target << object
         object
       end
 
@@ -50,7 +49,9 @@ module Mongoid #:nodoc:
       # association, and the attributes will be passed into the constructor and
       # the new object will then be saved.
       #
-      # Returns the newly created object.
+      # Returns:
+      #
+      # Rhe newly created Document.
       def create(attrs = {}, type = nil)
         object = build(attrs, type)
         object.save
@@ -58,10 +59,16 @@ module Mongoid #:nodoc:
       end
 
       # Finds a document in this association.
+      #
       # If :all is passed, returns all the documents
+      #
       # If an id is passed, will return the document for that id.
+      #
+      # Returns:
+      #
+      # Array or single Document.
       def find(param)
-        return @documents if param == :all
+        return @target if param == :all
         return detect { |document| document.id == param }
       end
 
@@ -72,27 +79,29 @@ module Mongoid #:nodoc:
       #
       # This then delegated all methods to the array class since this is
       # essentially a proxy to an array itself.
-      def initialize(document, options)
-        @parent, @association_name, @klass, @options = document, options.name, options.klass, options
-        attributes = document.raw_attributes[@association_name]
-        @documents = attributes ? attributes.collect do |attrs|
-          type = attrs["_type"]
-          child = type ? type.constantize.instantiate(attrs) : @klass.instantiate(attrs)
-          child.parentize(@parent, @association_name)
-          child
-        end : []
+      #
+      # Options:
+      #
+      # parent: The parent document to the association.
+      # options: The association options.
+      def initialize(parent, options)
+        @parent, @association_name = parent, options.name
+        @klass, @options = options.klass, options
+        initialize_each(parent.raw_attributes[@association_name])
+        extends(options)
       end
 
-      # Delegate all missing methods over to the documents array unless a
-      # criteria or named scope exists on the association class. If that is the
-      # case then call that method.
+      # If the target array does not respond to the supplied method then try to
+      # find a named scope or criteria on the class and send the call there.
+      #
+      # If the method exists on the array, use the default proxy behavior.
       def method_missing(name, *args, &block)
-        unless @documents.respond_to?(name)
+        unless @target.respond_to?(name)
           criteria = @klass.send(name, *args)
-          criteria.documents = @documents
+          criteria.documents = @target
           return criteria
         end
-        @documents.send(name, *args, &block)
+        super
       end
 
       # Used for setting associations via a nested attributes setter from the
@@ -101,16 +110,25 @@ module Mongoid #:nodoc:
       # Options:
       #
       # attributes: A +Hash+ of integer keys and +Hash+ values.
+      #
+      # Returns:
+      #
+      # The newly build target Document.
       def nested_build(attributes)
         attributes.values.each do |attrs|
           build(attrs)
         end
       end
 
-      # Appends the object to the +Array+, setting its parent in
-      # the process.
-      def push(*objects)
-        self << objects
+      protected
+      # Initializes each of the attributes in the hash.
+      def initialize_each(attributes)
+        @target = attributes ? attributes.collect do |attrs|
+          klass = attrs.klass
+          child = klass ? klass.instantiate(attrs) : @klass.instantiate(attrs)
+          child.parentize(@parent, @association_name)
+          child
+        end : []
       end
 
       class << self
@@ -137,7 +155,7 @@ module Mongoid #:nodoc:
         def update(children, parent, options)
           parent.remove_attribute(options.name)
           children.assimilate(parent, options)
-          new(parent, options)
+          instantiate(parent, options)
         end
       end
 

data/lib/mongoid/associations/has_many_related.rb

@@ -4,14 +4,12 @@ module Mongoid #:nodoc:
     class HasManyRelated #:nodoc:
       include Proxy
 
-      attr_reader :klass
-
       # Appends the object to the +Array+, setting its parent in
       # the process.
       def <<(*objects)
         objects.flatten.each do |object|
           object.send("#{@foreign_key}=", @parent.id)
-          @documents << object
+          @target << object
           object.save unless @parent.new_record?
         end
       end
@@ -24,7 +22,7 @@ module Mongoid #:nodoc:
       def build(attributes = {})
         name = @parent.class.to_s.underscore
         object = @klass.instantiate(attributes.merge(name => @parent))
-        @documents << object
+        @target << object
         object
       end
 
@@ -59,15 +57,11 @@ module Mongoid #:nodoc:
       #
       # document: The +Document+ that contains the relationship.
       # options: The association +Options+.
-      def initialize(document, options)
+      def initialize(document, options, target = nil)
         @parent, @klass = document, options.klass
         @foreign_key = document.class.to_s.foreign_key
-        @documents = @klass.all(:conditions => { @foreign_key => document.id })
-      end
-
-      # Delegate all missing methods over to the documents array.
-      def method_missing(name, *args, &block)
-        @documents.send(name, *args, &block)
+        @target = target || @klass.all(:conditions => { @foreign_key => document.id })
+        extends(options)
       end
 
       # Delegates to <<
@@ -82,8 +76,8 @@ module Mongoid #:nodoc:
         #
         # document: The +Document+ that contains the relationship.
         # options: The association +Options+.
-        def instantiate(document, options)
-          new(document, options)
+        def instantiate(document, options, target = nil)
+          new(document, options, target)
         end
 
         # Returns the macro used to create the association.
@@ -103,9 +97,10 @@ module Mongoid #:nodoc:
         # Example:
         #
         # <tt>RelatesToOne.update(game, person, options)</tt>
-        def update(related, document, options)
+        def update(target, document, options)
           name = document.class.to_s.underscore
-          related.each { |child| child.send("#{name}=", document) }
+          target.each { |child| child.send("#{name}=", document) }
+          instantiate(document, options, target)
         end
       end