mongo_mapper-unstable 2009.12.30 → 2010.1.4

data/README.rdoc

@@ -13,20 +13,9 @@ Releases are tagged on github and released on gemcutter. Master is pushed to whe
 * Send me a pull request. Bonus points for topic branches.
 
 == Install
-
-MongoMapper is only released on gemcutter. To install, you can setup gemcutter as your default gem source.
-
- $ gem install gemcutter
- $ gem tumble
- 
-Then you can install MM:
  
  $ gem install mongo_mapper
 
-You can also just declare the source:
-
- $ gem install mongo_mapper -s http://gemcutter.org
-
 == Dependencies
 
 * ActiveSupport (typically the latest version)
@@ -37,16 +26,12 @@ You can also just declare the source:
 
 Documentation is lacking right now because if you can't look through the code right now and feel comfortable, this is probably too young for you to use. Wait til it stabilizes a bit more.
 
-http://rdoc.info/projects/jnunemaker/mongomapper
 http://groups.google.com/group/mongomapper
 
 == More Info
 
-You can learn more about mongo here:
-http://www.mongodb.org/
-
-You can learn more about the mongo ruby driver here:
-http://github.com/mongodb/mongo-ruby-driver/tree/master
+* http://www.mongodb.org/
+* http://github.com/mongodb/mongo-ruby-driver/
 
 == Copyright
 

data/Rakefile

@@ -12,7 +12,7 @@ Jeweler::Tasks.new do |gem|
   gem.authors     = ["John Nunemaker"]
   
   gem.add_dependency('activesupport', '>= 2.3')
-  gem.add_dependency('mongo', '0.18.1')
+  gem.add_dependency('mongo', '0.18.2')
   gem.add_dependency('jnunemaker-validatable', '1.8.1')
   
   gem.add_development_dependency('jnunemaker-matchy', '0.4.0')

data/VERSION

@@ -1 +1 @@
-2009.12.30
+2010.01.04

data/lib/mongo_mapper/associations/base.rb

@@ -1,13 +1,10 @@
 module MongoMapper
   module Associations
-    # Base class for keeping track of associations.
-    #
-    # @private
     class Base
       attr_reader :type, :name, :options, :finder_options
 
       # Options that should not be considered MongoDB query options/criteria
-      AssociationOptions = [:as, :class, :class_name, :dependent, :extend, :foreign_key, :polymorphic]
+      AssociationOptions = [:as, :class, :class_name, :dependent, :extend, :foreign_key, :in, :polymorphic]
 
       def initialize(type, name, options={}, &extension)
         @type, @name, @options, @finder_options = type, name, {}, {}
@@ -47,6 +44,10 @@ module MongoMapper
       def belongs_to?
         @belongs_to_type ||= @type == :belongs_to
       end
+      
+      def one?
+        @one_type ||= @type == :one
+      end
 
       def polymorphic?
         !!@options[:polymorphic]
@@ -55,6 +56,14 @@ module MongoMapper
       def as?
         !!@options[:as]
       end
+      
+      def in_array?
+        !!@options[:in]
+      end
+
+      def embeddable?
+        many? && klass.embeddable?
+      end
 
       def type_key_name
         @type_key_name ||= many? ? '_type' : "#{as}_type"
@@ -72,10 +81,6 @@ module MongoMapper
         @ivar ||= "@_#{name}"
       end
 
-      def embeddable?
-        many? && klass.embeddable?
-      end
-
       def proxy_class
         @proxy_class ||= begin
           if many?
@@ -86,15 +91,19 @@ module MongoMapper
                 ManyPolymorphicProxy
               elsif as?
                 ManyDocumentsAsProxy
+              elsif in_array?
+                InArrayProxy
               else
                 ManyDocumentsProxy
               end
             end
+          elsif one?
+            OneProxy
           else
             polymorphic? ? BelongsToPolymorphicProxy : BelongsToProxy
           end
-        end # end begin
-      end # end proxy_class
+        end
+      end
 
       private
 

data/lib/mongo_mapper/associations/in_array_proxy.rb

@@ -0,0 +1,137 @@
+module MongoMapper
+  module Associations
+    class InArrayProxy < Collection
+      include ::MongoMapper::Finders
+      
+      def find(*args)
+        options = args.extract_options!
+        
+        case args.first
+          when :first
+            first(options)
+          when :last
+            last(options)
+          when :all
+            all(options)
+          else
+            klass.find(*scoped_ids(args) << scoped_options(options))
+        end
+      end
+      
+      def find!(*args)
+        options = args.extract_options!
+        
+        case args.first
+          when :first
+            first(options)
+          when :last
+            last(options)
+          when :all
+            all(options)
+          else
+            klass.find!(*scoped_ids(args) << scoped_options(options))
+        end
+      end
+
+      def paginate(options)
+        klass.paginate(scoped_options(options))
+      end
+
+      def all(options={})
+        klass.all(scoped_options(options))
+      end
+
+      def first(options={})
+        klass.first(scoped_options(options))
+      end
+
+      def last(options={})
+        klass.last(scoped_options(options))
+      end
+      
+      def count(options={})
+        options.blank? ? ids.size : klass.count(scoped_options(options))
+      end
+      
+      def destroy_all(options={})
+        all(options).each do |doc|
+          ids.delete(doc.id)
+          doc.destroy
+        end
+        reset
+      end
+
+      def delete_all(options={})
+        docs = all(options.merge(:select => ['_id']))
+        docs.each { |doc| ids.delete(doc.id) }
+        klass.delete(docs.map(&:id))
+        reset
+      end
+      
+      def nullify
+        replace([])
+        reset
+      end
+      
+      def create(attrs={})
+        doc = klass.create(attrs)
+        unless doc.new?
+          ids << doc.id
+          owner.save
+        end
+        doc
+      end
+      
+      def create!(attrs={})
+        doc = klass.create!(attrs)
+        unless doc.new?
+          ids << doc.id
+          owner.save
+        end
+        doc
+      end
+      
+      def <<(*docs)
+        flatten_deeper(docs).each do |doc|
+          doc.save if doc.new?
+          unless ids.include?(doc.id)
+            ids << doc.id
+          end
+        end
+        reset
+      end
+      alias_method :push, :<<
+      alias_method :concat, :<<
+      
+      def replace(docs)
+        doc_ids = docs.map do |doc|
+          doc.save if doc.new?
+          doc.id
+        end
+        ids.replace(doc_ids.uniq)
+        reset
+      end
+      
+      private
+        def scoped_conditions
+          {:_id => ids}
+        end
+        
+        def scoped_options(options)
+          reflection.finder_options.merge(options).merge(scoped_conditions)
+        end
+        
+        def scoped_ids(args)
+          args.flatten.reject { |id| !ids.include?(id) }
+        end
+        
+        def find_target
+          ids.blank? ? [] : all
+        end
+        
+        def ids
+          owner[options[:in]]
+        end
+    end
+  end
+end

data/lib/mongo_mapper/associations/one_proxy.rb

@@ -0,0 +1,64 @@
+module MongoMapper
+  module Associations
+    class OneProxy < Proxy
+      def build(attrs={})
+        instantiate_target(:new, attrs)
+      end
+      
+      def create(attrs={})
+        instantiate_target(:create, attrs)
+      end
+      
+      def create!(attrs={})
+        instantiate_target(:create!, attrs)
+      end
+      
+      def replace(doc)
+        load_target
+        
+        if !target.nil? && target != doc
+          if options[:dependent] && !target.new?
+            case options[:dependent]
+              when :delete
+                target.delete
+              when :destroy
+                target.destroy
+              when :nullify
+                target[foreign_key] = nil
+                target.save
+            end
+          end
+        end
+        
+        reset
+        
+        unless doc.nil?
+          owner.save if owner.new?
+          doc[foreign_key] = owner.id
+          doc.save if doc.new?
+          loaded
+          @target = doc
+        end
+      end
+
+      protected
+        def find_target
+          target_class.first(reflection.finder_options.merge(foreign_key => owner.id))
+        end
+        
+        def instantiate_target(instantiator, attrs={})
+          @target = target_class.send(instantiator, attrs.update(foreign_key => owner.id))
+          loaded
+          @target
+        end
+        
+        def target_class
+          @target_class ||= options[:class] || (options[:class_name] || reflection.name.to_s.camelize).constantize
+        end
+        
+        def foreign_key
+          options[:foreign_key] || owner.class.name.foreign_key
+        end
+    end
+  end
+end

data/lib/mongo_mapper/associations/proxy.rb

@@ -17,7 +17,7 @@ module MongoMapper
       delegate :collection, :to => :klass
       
       def initialize(owner, reflection)
-        @owner, @reflection = owner, reflection
+        @owner, @reflection, @loaded = owner, reflection, false
         Array(reflection.options[:extend]).each { |ext| proxy_extend(ext) }
         reset
       end
@@ -45,6 +45,11 @@ module MongoMapper
         target.blank?
       end
       
+      def present?
+        load_target
+        target.present?
+      end
+      
       def reload
         reset
         load_target
@@ -57,7 +62,7 @@ module MongoMapper
 
       def reset
         @loaded = false
-        target = nil
+        @target = nil
       end
 
       def respond_to?(*args)
@@ -101,8 +106,6 @@ module MongoMapper
           raise NotImplementedError
         end
         
-        # Array#flatten has problems with recursive arrays. Going one level
-        # deeper solves the majority of the problems.
         def flatten_deeper(array)
           array.collect do |element|
             (element.respond_to?(:flatten) && !element.is_a?(Hash)) ? element.flatten : element

data/lib/mongo_mapper/associations.rb

@@ -3,12 +3,14 @@ module MongoMapper
     module ClassMethods
       def belongs_to(association_id, options={}, &extension)
         create_association(:belongs_to, association_id, options, &extension)
-        self
       end
 
       def many(association_id, options={}, &extension)
         create_association(:many, association_id, options, &extension)
-        self
+      end
+      
+      def one(association_id, options={}, &extension)
+        create_association(:one, association_id, options, &extension)
       end
       
       def associations
@@ -38,6 +40,12 @@ module MongoMapper
             value
           end
           
+          if association.one? || association.belongs_to?
+            define_method("#{association.name}?") do
+              get_proxy(association).present?
+            end
+          end
+          
           if association.options[:dependent] && association.many? && !association.embeddable?
             after_destroy do |doc|
               case association.options[:dependent]
@@ -61,7 +69,7 @@ module MongoMapper
       def get_proxy(association)
         unless proxy = self.instance_variable_get(association.ivar)
           proxy = association.proxy_class.new(self, association)
-          self.instance_variable_set(association.ivar, proxy) if !frozen?
+          self.instance_variable_set(association.ivar, proxy)
         end
         proxy
       end

data/lib/mongo_mapper/callbacks.rb

@@ -1,108 +1,60 @@
 module MongoMapper
-  # This module is mixed into the Document module to provide call-backs before 
-  # and after the following events:
-  #
-  # * save
-  # * create
-  # * update
-  # * validation
-  # ** every validation
-  # ** validation when created
-  # ** validation when updated
-  # * destruction
-  #
-  # @see ActiveSupport::Callbacks
   module Callbacks
-    def self.included(model) #:nodoc:
+    def self.included(model)
       model.class_eval do
-        extend Observable
         include ActiveSupport::Callbacks
 
-        callbacks = %w(
-          before_save
-          after_save
-          before_create
-          after_create
-          before_update
-          after_update
-          before_validation
-          after_validation
-          before_validation_on_create
-          after_validation_on_create
-          before_validation_on_update
-          after_validation_on_update
-          before_destroy
-          after_destroy
+        define_callbacks(
+          :before_save, :after_save, 
+          :before_create, :after_create, 
+          :before_update, :after_update, 
+          :before_validation, :after_validation, 
+          :before_validation_on_create, :after_validation_on_create, 
+          :before_validation_on_update, :after_validation_on_update, 
+          :before_destroy, :after_destroy
         )
-
-        define_callbacks(*callbacks)
-
-        callbacks.each do |callback|
-          define_method(callback.to_sym) {}
-        end
       end
     end
 
-    def valid? #:nodoc:
-      return false if callback(:before_validation) == false
-      result = new? ? callback(:before_validation_on_create) : callback(:before_validation_on_update)
-      return false if false == result
-
+    def valid?
+      action = new? ? 'create' : 'update'
+      
+      run_callbacks(:before_validation)
+      run_callbacks("before_validation_on_#{action}".to_sym)
       result = super
-      callback(:after_validation)
-
-      new? ? callback(:after_validation_on_create) : callback(:after_validation_on_update)
-      return result
+      run_callbacks("after_validation_on_#{action}".to_sym)
+      run_callbacks(:after_validation)
+      
+      result
     end
 
-    # Here we override the +destroy+ method to allow for the +before_destroy+ 
-    # and +after_destroy+ call-backs. Note that the +destroy+ call is aborted 
-    # if the +before_destroy+ call-back returns +false+.
-    #
-    # @return the result of calling +destroy+ on the document
-    def destroy #:nodoc:
-      return false if callback(:before_destroy) == false
+    def destroy
+      run_callbacks(:before_destroy)
       result = super
-      callback(:after_destroy)
+      run_callbacks(:after_destroy)
       result
     end
 
     private
-      def callback(method)
-        result = run_callbacks(method) { |result, object| false == result }
-
-        if result != false && respond_to?(method)
-          result = send(method)
-        end
-
-        notify(method)
-        return result
-      end
-
-      def notify(method) #:nodoc:
-        self.class.changed
-        self.class.notify_observers(method, self)
-      end
-
-      def create_or_update #:nodoc:
-        return false if callback(:before_save) == false
+      def create_or_update(*args)
+        run_callbacks(:before_save)
         if result = super
-          callback(:after_save)
+          run_callbacks(:after_save)
         end
         result
       end
 
-      def create #:nodoc:
-        return false if callback(:before_create) == false
+      def create(*args)
+        run_callbacks(:before_create)
         result = super
-        callback(:after_create)
+        run_callbacks(:after_create)
         result
       end
 
-      def update(*args) #:nodoc:
-        return false if callback(:before_update) == false
+      def update(*args)
+        run_callbacks(:before_update)
         result = super
-        callback(:after_update)
+        run_callbacks(:after_update)
         result
       end
   end

data/lib/mongo_mapper/dirty.rb

@@ -30,18 +30,10 @@ module MongoMapper
       !changed_keys.empty?
     end
 
-    # List of keys with unsaved changes.
-    #   person.changed # => []
-    #   person.name = 'bob'
-    #   person.changed # => ['name']
     def changed
       changed_keys.keys
     end
 
-    # Map of changed attrs => [original value, new value].
-    #   person.changes # => {}
-    #   person.name = 'bob'
-    #   person.changes # => { 'name' => ['bill', 'bob'] }
     def changes
       changed.inject({}) { |h, attribute| h[attribute] = key_change(attribute); h }
     end
@@ -51,7 +43,6 @@ module MongoMapper
       changed_keys.clear unless new?
     end
 
-    # Attempts to +save+ the record and clears changed keys if successful.
     def save(*args)
       if status = super
         changed_keys.clear
@@ -59,19 +50,17 @@ module MongoMapper
       status
     end
 
-    # Attempts to <tt>save!</tt> the record and clears changed keys if successful.
     def save!(*args)
       status = super
       changed_keys.clear
       status
     end
 
-    # <tt>reload</tt> the record and clears changed keys.
-    # def reload(*args) #:nodoc:
-    #   record = super
-    #   changed_keys.clear
-    #   record
-    # end
+    def reload(*args)
+      record = super
+      changed_keys.clear
+      record
+    end
 
     private
       def clone_key_value(attribute_name)
@@ -81,36 +70,29 @@ module MongoMapper
         value
       end
       
-      # Map of change <tt>attr => original value</tt>.
       def changed_keys
         @changed_keys ||= {}
       end
 
-      # Handle <tt>*_changed?</tt> for +method_missing+.
       def key_changed?(attribute)
         changed_keys.include?(attribute)
       end
 
-      # Handle <tt>*_change</tt> for +method_missing+.
       def key_change(attribute)
         [changed_keys[attribute], __send__(attribute)] if key_changed?(attribute)
       end
 
-      # Handle <tt>*_was</tt> for +method_missing+.
       def key_was(attribute)
         key_changed?(attribute) ? changed_keys[attribute] : __send__(attribute)
       end
 
-      # Handle <tt>*_will_change!</tt> for +method_missing+.
       def key_will_change!(attribute)
         changed_keys[attribute] = clone_key_value(attribute)
       end
 
-      # Wrap write_attribute to remember original key value.
       def write_attribute(attribute, value)
         attribute = attribute.to_s
 
-        # The key already has an unsaved change.
         if changed_keys.include?(attribute)
           old = changed_keys[attribute]
           changed_keys.delete(attribute) unless value_changed?(attribute, old, value)
@@ -119,7 +101,6 @@ module MongoMapper
           changed_keys[attribute] = old if value_changed?(attribute, old, value)
         end
 
-        # Carry on.
         super(attribute, value)
       end