crnixon-mongomapper 0.2.0 → 0.3.4

data/lib/mongomapper/associations/belongs_to_polymorphic_proxy.rb

@@ -0,0 +1,34 @@
+module MongoMapper
+  module Associations
+    class BelongsToPolymorphicProxy < Proxy
+      def replace(doc)        
+        if doc
+          doc.save if doc.new?
+          id, type = doc.id, doc.class.name
+        end
+        
+        @owner.send("#{@association.foreign_key}=", id)
+        @owner.send("#{@association.type_key_name}=", type)
+        reset
+      end
+      
+      protected
+        def find_target
+          if proxy_id && proxy_class
+            proxy_class.find_by_id(proxy_id)
+          end
+        end
+        
+        def proxy_id
+          @proxy_id ||= @owner.send(@association.foreign_key)
+        end
+        
+        def proxy_class
+          @proxy_class ||= begin
+            klass = @owner.send(@association.type_key_name)
+            klass && klass.constantize
+          end
+        end
+    end
+  end
+end

data/lib/mongomapper/associations/belongs_to_proxy.rb

@@ -1,26 +1,22 @@
 module MongoMapper
   module Associations
     class BelongsToProxy < Proxy
-      def replace(v)
-        ref_id = "#{@association.name}_id"
-
-        if v
-          v.save if v.new?
-          @owner.__send__(:write_attribute, ref_id, v.id)
-        else
-          @owner.__send__(:write_attribute, ref_id, nil)
+      def replace(doc)
+        if doc
+          doc.save if doc.new?
+          id = doc.id
         end
 
-        reload_target
+        @owner.send("#{@association.foreign_key}=", id)
+        reset
       end
 
       protected
-      def find_target
-        ref = @owner.__send__(:read_attribute, "#{@association.name}_id")
-        if ref
-          @association.klass.find(ref)
+        def find_target
+          if association_id = @owner.send(@association.foreign_key)
+            @association.klass.find_by_id(association_id)
+          end
         end
-      end
     end
   end
 end

data/lib/mongomapper/associations/many_documents_as_proxy.rb

@@ -0,0 +1,27 @@
+module MongoMapper
+  module Associations
+    class ManyDocumentsAsProxy < ManyDocumentsProxy
+      protected
+        def scoped_conditions
+          {as_type_name => @owner.class.name, as_id_name => @owner.id}
+        end
+
+        def apply_scope(doc)
+          ensure_owner_saved
+
+          doc.send("#{as_type_name}=", @owner.class.name)
+          doc.send("#{as_id_name}=", @owner.id)
+
+          doc
+        end
+
+        def as_type_name
+          @as_type_name ||= @association.options[:as].to_s + "_type"
+        end
+
+        def as_id_name
+          @as_id_name ||= @association.options[:as].to_s + "_id"
+        end
+    end
+  end
+end

data/lib/mongomapper/associations/many_documents_proxy.rb

@@ -0,0 +1,103 @@
+module MongoMapper
+  module Associations
+    class ManyDocumentsProxy < Proxy
+      delegate :klass, :to => :@association
+
+      def find(*args)
+        options = args.extract_options!
+        klass.find(*args << scoped_options(options))
+      end
+
+      def paginate(options)
+        klass.paginate(scoped_options(options))
+      end
+
+      def all(options={})
+        find(:all, scoped_options(options))
+      end
+
+      def first(options={})
+        find(:first, scoped_options(options))
+      end
+
+      def last(options={})
+        find(:last, scoped_options(options))
+      end
+
+      def count(conditions={})
+        klass.count(conditions.deep_merge(scoped_conditions))
+      end
+
+      def replace(docs)
+        @target.map(&:destroy) if load_target
+        docs.each { |doc| apply_scope(doc).save }
+        reset
+      end
+
+      def <<(*docs)
+        ensure_owner_saved
+        flatten_deeper(docs).each { |doc| apply_scope(doc).save }
+        reset
+      end
+      alias_method :push, :<<
+      alias_method :concat, :<<
+
+      def build(attrs={})
+        doc = klass.new(attrs)
+        apply_scope(doc)
+        doc
+      end
+
+      def create(attrs={})
+        doc = klass.new(attrs)
+        apply_scope(doc).save
+        doc
+      end
+
+      def destroy_all(conditions={})
+        all(:conditions => conditions).map(&:destroy)
+        reset
+      end
+
+      def delete_all(conditions={})
+        klass.delete_all(conditions.deep_merge(scoped_conditions))
+        reset
+      end
+      
+      def nullify
+        criteria = FinderOptions.to_mongo_criteria(scoped_conditions)
+        all(criteria).each do |doc|
+          doc.update_attributes self.foreign_key => nil
+        end
+        reset
+      end
+
+      protected
+        def scoped_conditions
+          {self.foreign_key => @owner.id}
+        end
+
+        def scoped_options(options)
+          options.deep_merge({:conditions => scoped_conditions})
+        end
+
+        def find_target
+          find(:all)
+        end
+
+        def ensure_owner_saved
+          @owner.save if @owner.new?
+        end
+
+        def apply_scope(doc)
+          ensure_owner_saved
+          doc.send("#{self.foreign_key}=", @owner.id)
+          doc
+        end
+
+        def foreign_key
+          @association.options[:foreign_key] || @owner.class.name.underscore.gsub("/", "_") + "_id"
+        end
+    end
+  end
+end

data/lib/mongomapper/associations/many_embedded_polymorphic_proxy.rb

@@ -0,0 +1,33 @@
+module MongoMapper
+  module Associations
+    class ManyEmbeddedPolymorphicProxy < Proxy      
+      def replace(v)
+        @_values = v.map do |doc_or_hash|
+          if doc_or_hash.kind_of?(EmbeddedDocument)
+            doc = doc_or_hash
+            {@association.type_key_name => doc.class.name}.merge(doc.attributes)
+          else
+            doc_or_hash
+          end
+        end
+        
+        reset
+      end
+
+      protected
+        def find_target
+          (@_values || []).map do |hash|
+            polymorphic_class(hash).new(hash)
+          end
+        end
+        
+        def polymorphic_class(doc)
+          if class_name = doc[@association.type_key_name]
+            class_name.constantize
+          else
+            @association.klass
+          end
+        end
+    end
+  end
+end

data/lib/mongomapper/associations/{has_many_embedded_proxy.rb → many_embedded_proxy.rb}

@@ -1,19 +1,17 @@
 module MongoMapper
   module Associations
-    class HasManyEmbeddedProxy < ArrayProxy
+    class ManyEmbeddedProxy < Proxy
       def replace(v)
         @_values = v.map { |e| e.kind_of?(EmbeddedDocument) ? e.attributes : e }
-        @target = nil
-
-        reload_target
+        reset
       end
 
       protected
-      def find_target
-        (@_values || []).map do |e|
-          @association.klass.new(e)
+        def find_target
+          (@_values || []).map do |e|
+            @association.klass.new(e)
+          end
         end
-      end
     end
   end
 end

data/lib/mongomapper/associations/many_polymorphic_proxy.rb

@@ -0,0 +1,11 @@
+module MongoMapper
+  module Associations
+    class ManyPolymorphicProxy < ManyDocumentsProxy      
+      private
+        def apply_scope(doc)
+          doc.send("#{@association.type_key_name}=", doc.class.name)
+          super
+        end
+    end
+  end
+end

data/lib/mongomapper/associations/{array_proxy.rb → many_proxy.rb}

@@ -1,6 +1,6 @@
 module MongoMapper
   module Associations
-    class ArrayProxy < Proxy
+    class ManyProxy < ManyDocumentsProxy
     end
   end
 end

data/lib/mongomapper/associations/proxy.rb

@@ -1,16 +1,11 @@
 module MongoMapper
   module Associations
-    class Proxy
+    class Proxy < BasicObject
       attr_reader :owner, :association
-
-      instance_methods.each do |m|
-        undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^object_id$)/
-      end
-
+      
       def initialize(owner, association)
-        @owner= owner
+        @owner = owner
         @association = association
-
         reset
       end
 
@@ -38,23 +33,31 @@ module MongoMapper
       end
 
       protected
-      def method_missing(method, *args)
-        if load_target
-          if block_given?
-            @target.send(method, *args)  { |*block_args| yield(*block_args) }
-          else
-            @target.send(method, *args)
+        def method_missing(method, *args)
+          if load_target
+            if block_given?
+              @target.send(method, *args)  { |*block_args| yield(*block_args) }
+            else
+              @target.send(method, *args)
+            end
           end
         end
-      end
 
-      def load_target
-        @target ||= find_target
-      end
+        def load_target
+          @target ||= find_target
+        end
 
-      def find_target
-        raise NotImplementedError
-      end
+        def find_target
+          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
+          end.flatten
+        end
     end
   end
 end

data/lib/mongomapper/callbacks.rb

@@ -90,7 +90,7 @@ module MongoMapper
       def callback(method)
         result = run_callbacks(method) { |result, object| false == result }
         
-        if result != false && respond_to_without_attributes?(method)
+        if result != false && respond_to?(method)
           result = send(method)
         end
         

data/lib/mongomapper/document.rb

@@ -9,12 +9,8 @@ module MongoMapper
         include Observing
         include Callbacks
         include SaveWithValidation
-        include RailsCompatibility
+        include RailsCompatibility::Document
         extend ClassMethods
-
-        key :_id, String
-        key :created_at, Time
-        key :updated_at, Time
       end
 
       descendants << model
@@ -23,7 +19,7 @@ module MongoMapper
     def self.descendants
       @descendants ||= Set.new
     end
- 
+
     module ClassMethods
       def find(*args)
         options = args.extract_options!
@@ -32,10 +28,23 @@ module MongoMapper
           when :first then find_first(options)
           when :last  then find_last(options)
           when :all   then find_every(options)
-          else             find_from_ids(args)
+          else             find_from_ids(args, options)
         end
       end
 
+      def paginate(options)
+        per_page      = options.delete(:per_page)
+        page          = options.delete(:page)
+        total_entries = count(options[:conditions] || {})
+        collection    = Pagination::PaginationProxy.new(total_entries, page, per_page)
+
+        options[:limit]   = collection.limit
+        options[:offset]  = collection.offset
+
+        collection.subject = find_every(options)
+        collection
+      end
+
       def first(options={})
         find_first(options)
       end
@@ -49,18 +58,19 @@ module MongoMapper
       end
 
       def find_by_id(id)
-        if doc = collection.find_first({:_id => id})
+        criteria = FinderOptions.to_mongo_criteria(:_id => id)
+        if doc = collection.find_first(criteria)
           new(doc)
         end
       end
 
-      # TODO: remove the rescuing when ruby driver works correctly
       def count(conditions={})
         collection.count(FinderOptions.to_mongo_criteria(conditions))
       end
 
       def create(*docs)
         instances = []
+        docs = [{}] if docs.blank?
         docs.flatten.each do |attrs|
           doc = new(attrs); doc.save
           instances << doc
@@ -84,11 +94,13 @@ module MongoMapper
       end
 
       def delete(*ids)
-        collection.remove(:_id => {'$in' => ids.flatten})
+        criteria = FinderOptions.to_mongo_criteria(:_id => ids.flatten)
+        collection.remove(criteria)
       end
 
       def delete_all(conditions={})
-        collection.remove(FinderOptions.to_mongo_criteria(conditions))
+        criteria = FinderOptions.to_mongo_criteria(conditions)
+        collection.remove(criteria)
       end
 
       def destroy(*ids)
@@ -125,11 +137,18 @@ module MongoMapper
         end
         @collection
       end
-
+      
+      def timestamps!
+        key :created_at, Time
+        key :updated_at, Time
+        
+        class_eval { before_save :update_timestamps }
+      end
+      
       def validates_uniqueness_of(*args)
         add_validations(args, MongoMapper::Validations::ValidatesUniquenessOf)
       end
-      
+
       def validates_exclusion_of(*args)
         add_validations(args, MongoMapper::Validations::ValidatesExclusionOf)
       end
@@ -137,59 +156,125 @@ module MongoMapper
       def validates_inclusion_of(*args)
         add_validations(args, MongoMapper::Validations::ValidatesInclusionOf)
       end
+      
+      protected
+        def method_missing(method, *args)
+          finder = DynamicFinder.new(self, method)
+          
+          if finder.valid?
+            meta_def(finder.options[:method]) do |*args|
+              find_with_args(args, finder.options)
+            end
+            
+            send(finder.options[:method], *args)
+          else
+            super
+          end
+        end
 
-    private
-      def find_every(options)
-        criteria, options = FinderOptions.new(options).to_a
-        collection.find(criteria, options).to_a.map { |doc| new(doc) }
-      end
+      private
+        def find_every(options)
+          criteria, options = FinderOptions.new(options).to_a
+          collection.find(criteria, options).to_a.map { |doc| new(doc) }
+        end
 
-      def find_first(options)
-        find_every(options.merge(:limit => 1, :order => 'created_at')).first
-      end
+        def find_first(options)
+          options.merge!(:limit => 1)
+          find_every({:order => '$natural asc'}.merge(options))[0]
+        end
 
-      def find_last(options)
-        find_every(options.merge(:limit => 1, :order => 'created_at desc')).first
-      end
+        def find_last(options)
+          options.merge!(:limit => 1)
+          options[:order] = invert_order_clause(options)
+          find_every(options)[0]
+          #find_every({:order => '$natural desc'}.merge(invert_order_clause(options)))[0]
+        end
 
-      def find_some(ids)
-        documents = find_every(:conditions => {'_id' => ids})
-        if ids.size == documents.size
-          documents
-        else
-          raise DocumentNotFound, "Couldn't find all of the ids (#{ids.to_sentence}). Found #{documents.size}, but was expecting #{ids.size}"
+        def invert_order_clause(options)
+          return '$natural desc' unless options[:order]
+          options[:order].split(',').map do |order_segment| 
+            if order_segment =~ /\sasc/i
+              order_segment.sub /\sasc/i, ' desc'
+            elsif order_segment =~ /\sdesc/i
+              order_segment.sub /\sdesc/i, ' asc'
+            else
+              "#{order_segment.strip} desc"
+            end
+          end.join(',')
         end
-      end
 
-      def find_from_ids(*ids)
-        ids = ids.flatten.compact.uniq
+        def find_some(ids, options={})
+          documents = find_every(options.deep_merge(:conditions => {'_id' => ids}))
+          if ids.size == documents.size
+            documents
+          else
+            raise DocumentNotFound, "Couldn't find all of the ids (#{ids.to_sentence}). Found #{documents.size}, but was expecting #{ids.size}"
+          end
+        end
 
-        case ids.size
-          when 0
-            raise(DocumentNotFound, "Couldn't find without an ID")
-          when 1
-            find_by_id(ids[0]) || raise(DocumentNotFound, "Document with id of #{ids[0]} does not exist in collection named #{collection.name}")
+        def find_one(id, options={})
+          if doc = find_every(options.deep_merge(:conditions => {:_id => id})).first
+            doc
           else
-            find_some(ids)
+            raise DocumentNotFound, "Document with id of #{id} does not exist in collection named #{collection.name}"
+          end
         end
-      end
 
-      def update_single(id, attrs)
-        if id.blank? || attrs.blank? || !attrs.is_a?(Hash)
-          raise ArgumentError, "Updating a single document requires an id and a hash of attributes"
+        def find_from_ids(ids, options={})
+          ids = ids.flatten.compact.uniq
+
+          case ids.size
+            when 0
+              raise(DocumentNotFound, "Couldn't find without an ID")
+            when 1
+              find_one(ids[0], options)
+            else
+              find_some(ids, options)
+          end
+        end
+        
+        def find_with_args(args, options)
+          attributes,  = {}
+          find_options = args.extract_options!.deep_merge(:conditions => attributes)
+          
+          options[:attribute_names].each_with_index do |attr, index|
+            attributes[attr] = args[index]
+          end
+
+          result = find(options[:finder], find_options)
+          
+          if result.nil?
+            if options[:bang]
+              raise DocumentNotFound, "Couldn't find Document with #{attributes.inspect} in collection named #{collection.name}"
+            end
+            
+            if options[:instantiator]
+              self.send(options[:instantiator], attributes)
+            end
+          else
+            result
+          end
         end
 
-        find(id).update_attributes(attrs)
-      end
+        def update_single(id, attrs)
+          if id.blank? || attrs.blank? || !attrs.is_a?(Hash)
+            raise ArgumentError, "Updating a single document requires an id and a hash of attributes"
+          end
 
-      def update_multiple(docs)
-        unless docs.is_a?(Hash)
-          raise ArgumentError, "Updating multiple documents takes 1 argument and it must be hash"
+          doc = find(id)
+          doc.update_attributes(attrs)
+          doc
+        end
+
+        def update_multiple(docs)
+          unless docs.is_a?(Hash)
+            raise ArgumentError, "Updating multiple documents takes 1 argument and it must be hash"
+          end
+
+          instances = []
+          docs.each_pair { |id, attrs| instances << update(id, attrs) }
+          instances
         end
-        instances = []
-        docs.each_pair { |id, attrs| instances << update(id, attrs) }
-        instances
-      end
     end
 
     module InstanceMethods
@@ -198,13 +283,13 @@ module MongoMapper
       end
 
       def new?
-        read_attribute('_id').blank? || self.class.find_by_id(id).blank?
+        read_attribute('_id').blank? || using_custom_id?
       end
 
       def save
         create_or_update
       end
-      
+
       def save!
         create_or_update || raise(DocumentNotValid.new(self))
       end
@@ -212,20 +297,14 @@ module MongoMapper
       def update_attributes(attrs={})
         self.attributes = attrs
         save
-        self
       end
 
       def destroy
-        collection.remove(:_id => id) unless new?
-        freeze
-      end
+        return false if frozen?
 
-      def ==(other)
-        other.is_a?(self.class) && id == other.id
-      end
- 
-      def id
-        read_attribute('_id')
+        criteria = FinderOptions.to_mongo_criteria(:_id => id)
+        collection.remove(criteria) unless new?
+        freeze
       end
 
     private
@@ -233,29 +312,36 @@ module MongoMapper
         result = new? ? create : update
         result != false
       end
-      
+
       def create
-        write_attribute('_id', generate_id) if read_attribute('_id').blank?
-        update_timestamps
+        assign_id
         save_to_collection
       end
+      
+      def assign_id
+        if read_attribute(:_id).blank?
+          write_attribute(:_id, XGen::Mongo::Driver::ObjectID.new.to_s)
+        end
+      end
 
       def update
-        update_timestamps
         save_to_collection
       end
 
+      # collection.save returns mongoid
       def save_to_collection
-        collection.save(attributes.merge!(embedded_association_attributes))
+        clear_custom_id_flag
+        collection.save(attributes)
       end
 
       def update_timestamps
-        write_attribute('created_at', Time.now.utc) if new?
-        write_attribute('updated_at', Time.now.utc)
+        now = Time.now.utc
+        write_attribute('created_at', now) if new?
+        write_attribute('updated_at', now)
       end
-
-      def generate_id
-        XGen::Mongo::Driver::ObjectID.new
+      
+      def clear_custom_id_flag
+        @using_custom_id = nil
       end
     end
   end # Document