mongo_mapper-unstable 2010.1.6 → 2010.1.12

data/lib/mongo_mapper/finder_options.rb

@@ -17,15 +17,17 @@ module MongoMapper
 
     def initialize(model, options)
       raise ArgumentError, "Options must be a hash" unless options.is_a?(Hash)
-      options = options.symbolize_keys
 
       @model      = model
       @options    = {}
-      @conditions = options.delete(:conditions) || {}
+      @conditions = {}
 
       options.each_pair do |key, value|
+        key = key.respond_to?(:to_sym) ? key.to_sym : key
         if OptionKeys.include?(key)
           @options[key] = value
+        elsif key == :conditions
+          @conditions.merge!(value)
         else
           @conditions[key] = value
         end
@@ -39,10 +41,10 @@ module MongoMapper
     end
 
     def options
-      fields = @options.delete(:fields) || @options.delete(:select)
-      skip   = @options.delete(:skip)   || @options.delete(:offset) || 0
-      limit  = @options.delete(:limit)  || 0
-      sort   = @options.delete(:sort)   || convert_order_to_sort(@options.delete(:order))
+      fields = @options[:fields] || @options[:select]
+      skip   = @options[:skip]   || @options[:offset] || 0
+      limit  = @options[:limit]  || 0
+      sort   = @options[:sort]   || convert_order_to_sort(@options[:order])
 
       {:fields => to_mongo_fields(fields), :skip => skip.to_i, :limit => limit.to_i, :sort => sort}
     end
@@ -62,8 +64,8 @@ module MongoMapper
             value = Mongo::ObjectID.from_string(value)
           end
           
-          if field.is_a?(FinderOperator)
-            criteria.update(field.to_criteria(value))
+          if field.is_a?(SymbolOperator)
+            criteria.update(field.to_mm_criteria(value))
             next
           end
           
@@ -106,10 +108,10 @@ module MongoMapper
       def convert_order_to_sort(sort)
         return if sort.blank?
         
-        if sort.respond_to?(:all?) && sort.all? { |s| s.respond_to?(:to_order) }
-          sort.map { |s| s.to_order }
-        elsif sort.respond_to?(:to_order)
-          [sort.to_order]
+        if sort.respond_to?(:all?) && sort.all? { |s| s.respond_to?(:to_mm_order) }
+          sort.map { |s| s.to_mm_order }
+        elsif sort.respond_to?(:to_mm_order)
+          [sort.to_mm_order]
         else
           pieces = sort.split(',')
           pieces.map { |s| to_mongo_sort_piece(s) }
@@ -122,24 +124,4 @@ module MongoMapper
         [field, direction]
       end
   end
-  
-  class FinderOperator
-    def initialize(field, operator)
-      @field, @operator = field, operator
-    end
-    
-    def to_criteria(value)
-      {FinderOptions.normalized_field(@field) => {@operator => value}}
-    end
-  end
-  
-  class OrderOperator
-    def initialize(field, direction)
-      @field, @direction = field, direction
-    end
-    
-    def to_order
-      [@field.to_s, FinderOptions.normalized_order_direction(@direction)]
-    end
-  end
-end
+end

data/lib/mongo_mapper/plugins/associations/base.rb

@@ -0,0 +1,121 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      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, :in, :polymorphic]
+
+        def initialize(type, name, options={}, &extension)
+          @type, @name, @options, @finder_options = type, name, {}, {}
+          options.symbolize_keys!
+
+          options[:extend] = modulized_extensions(extension, options[:extend])
+
+          options.each_pair do |key, value|
+            if AssociationOptions.include?(key)
+              @options[key] = value
+            else
+              @finder_options[key] = value
+            end
+          end
+        end
+
+        def class_name
+          @class_name ||= begin
+            if cn = options[:class_name]
+              cn
+            elsif many?
+              name.to_s.singularize.camelize
+            else
+              name.to_s.camelize
+            end
+          end
+        end
+
+        def klass
+          @klass ||= options[:class] || class_name.constantize
+        end
+
+        def many?
+          @many_type ||= @type == :many
+        end
+
+        def belongs_to?
+          @belongs_to_type ||= @type == :belongs_to
+        end
+
+        def one?
+          @one_type ||= @type == :one
+        end
+
+        def polymorphic?
+          !!@options[:polymorphic]
+        end
+
+        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"
+        end
+
+        def as
+          @options[:as] || self.name
+        end
+
+        def foreign_key
+          @options[:foreign_key] || "#{name}_id"
+        end
+
+        def ivar
+          @ivar ||= "@_#{name}"
+        end
+
+        def proxy_class
+          @proxy_class ||= begin
+            if many?
+              if self.klass.embeddable?
+                polymorphic? ? ManyEmbeddedPolymorphicProxy : ManyEmbeddedProxy
+              else
+                if polymorphic?
+                  ManyPolymorphicProxy
+                elsif as?
+                  ManyDocumentsAsProxy
+                elsif in_array?
+                  InArrayProxy
+                else
+                  ManyDocumentsProxy
+                end
+              end
+            elsif one?
+              OneProxy
+            else
+              polymorphic? ? BelongsToPolymorphicProxy : BelongsToProxy
+            end
+          end
+        end
+
+        private
+
+          # @param [Array<Module, Proc>] extensions a collection of Modules or 
+          #   Procs that extend the behaviour of this association.
+          def modulized_extensions(*extensions)
+            extensions.flatten.compact.map do |extension|
+              Proc === extension ? Module.new(&extension) : extension
+            end
+          end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/associations/belongs_to_polymorphic_proxy.rb

@@ -0,0 +1,28 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      class BelongsToPolymorphicProxy < Proxy
+        def replace(doc)
+          if doc
+            doc.save if doc.new?
+            id, type = doc.id, doc.class.name
+          end
+
+          owner[reflection.foreign_key] = id
+          owner[reflection.type_key_name] = type
+          reset
+        end
+
+        protected
+          def find_target
+            return nil if association_class.nil? || owner[reflection.foreign_key].nil?
+            association_class.first(:id => owner[reflection.foreign_key])
+          end
+
+          def association_class
+            proxy_owner[reflection.type_key_name] ? proxy_owner[reflection.type_key_name].constantize : nil
+          end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/associations/belongs_to_proxy.rb

@@ -0,0 +1,23 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      class BelongsToProxy < Proxy
+        def replace(doc)
+          if doc
+            doc.save if doc.new?
+            id = doc.id
+          end
+
+          owner[reflection.foreign_key] = id
+          reset
+        end
+
+        protected
+          def find_target
+            return nil if owner[reflection.foreign_key].nil?
+            klass.first(:id => owner[reflection.foreign_key])
+          end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/associations/collection.rb

@@ -0,0 +1,21 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      class Collection < Proxy
+        def to_ary
+          load_target
+          if target.is_a?(Array)
+            target.to_ary
+          else
+            Array(target)
+          end
+        end
+
+        def reset
+          super
+          target = []
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/associations/embedded_collection.rb

@@ -0,0 +1,49 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      class EmbeddedCollection < Collection
+        def build(attributes={})
+          doc = klass.new(attributes)
+          assign_root_document(doc)
+          self << doc
+          doc
+        end
+
+        def find(id)
+          load_target
+          target.detect { |item| item.id.to_s == id || item.id == id }
+        end
+
+        def count
+          load_target
+          target.size
+        end
+
+        def <<(*docs)
+          load_target
+          docs.each do |doc|
+            assign_root_document(doc)
+            target << doc
+          end
+        end
+        alias_method :push, :<<
+        alias_method :concat, :<<
+
+        private
+          def _root_document
+            if owner.respond_to?(:_root_document)
+              owner._root_document
+            else
+              owner
+            end
+          end
+
+          def assign_root_document(*docs)
+            docs.each do |doc|
+              doc._root_document = _root_document
+            end
+          end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/associations/in_array_proxy.rb

@@ -0,0 +1,139 @@
+module MongoMapper
+  module Plugins
+    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
+end

data/lib/mongo_mapper/plugins/associations/many_documents_as_proxy.rb

@@ -0,0 +1,28 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      class ManyDocumentsAsProxy < ManyDocumentsProxy
+        protected
+          def scoped_conditions
+            {type_key_name => owner.class.name, id_key_name => owner.id}
+          end
+
+          def apply_scope(doc)
+            ensure_owner_saved
+            doc[type_key_name] = owner.class.name
+            doc[id_key_name] = owner.id
+            doc
+          end
+
+        private
+          def type_key_name
+            "#{options[:as]}_type"
+          end
+
+          def id_key_name
+            "#{options[:as]}_id"
+          end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/associations/many_documents_proxy.rb

@@ -0,0 +1,117 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      class ManyDocumentsProxy < Collection
+        include ::MongoMapper::Finders
+
+        def find(*args)
+          options = args.extract_options!
+          klass.find(*args << scoped_options(options))
+        end
+
+        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={})
+          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={})
+          klass.count(scoped_options(options))
+        end
+
+        def replace(docs)
+          load_target
+          target.map(&:destroy)
+          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 create!(attrs={})
+          doc = klass.new(attrs)
+          apply_scope(doc).save!
+          doc
+        end
+
+        def destroy_all(options={})
+          all(options).map(&:destroy)
+          reset
+        end
+
+        def delete_all(options={})
+          klass.delete_all(options.merge(scoped_conditions))
+          reset
+        end
+
+        def nullify
+          criteria = FinderOptions.new(klass, scoped_conditions).criteria
+          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)
+            reflection.finder_options.merge(options).merge(scoped_conditions)
+          end
+
+          def find_target
+            all
+          end
+
+          def ensure_owner_saved
+            owner.save if owner.new?
+          end
+
+          def apply_scope(doc)
+            ensure_owner_saved
+            doc[foreign_key] = owner.id
+            doc
+          end
+
+          def foreign_key
+            options[:foreign_key] || owner.class.name.underscore.gsub("/", "_") + "_id"
+          end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/associations/many_embedded_polymorphic_proxy.rb

@@ -0,0 +1,31 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      class ManyEmbeddedPolymorphicProxy < EmbeddedCollection
+        def replace(values)
+          @_values = values.map do |v|
+            v.respond_to?(:attributes) ? v.attributes.merge(reflection.type_key_name => v.class.name) : v
+          end
+          reset
+        end
+
+        protected
+          def find_target
+            (@_values || []).map do |hash|
+              child = polymorphic_class(hash).new(hash)
+              assign_root_document(child)
+              child
+            end
+          end
+
+          def polymorphic_class(doc)
+            if class_name = doc[reflection.type_key_name]
+              class_name.constantize
+            else
+              klass
+            end
+          end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/associations/many_embedded_proxy.rb

@@ -0,0 +1,23 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      class ManyEmbeddedProxy < EmbeddedCollection
+        def replace(values)
+          @_values = values.map do |v|
+            v.respond_to?(:attributes) ? v.attributes : v
+          end
+          reset
+        end
+
+        private
+          def find_target
+            (@_values || []).map do |v|
+              child = klass.new(v)
+              assign_root_document(child)
+              child
+            end
+          end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/associations/many_polymorphic_proxy.rb

@@ -0,0 +1,13 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      class ManyPolymorphicProxy < ManyDocumentsProxy
+        private
+          def apply_scope(doc)
+            doc[reflection.type_key_name] = doc.class.name
+            super
+          end
+      end
+    end
+  end
+end