mongo_mapper_ign 0.7.4

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

@@ -0,0 +1,144 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      class InArrayProxy < Collection
+        include Support::Find
+
+        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
+            reset
+          end
+          doc
+        end
+
+        def create!(attrs={})
+          doc = klass.create!(attrs)
+          unless doc.new?
+            ids << doc.id
+            owner.save
+            reset
+          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)
+            association.query_options.merge(options).merge(scoped_conditions)
+          end
+
+          def scoped_ids(args)
+            args.flatten.select do |id|
+              id = ObjectId.to_mongo(id) if klass.using_object_id?
+              ids.include?(id)
+            end
+          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,129 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      class ManyDocumentsProxy < Collection
+        include Support::Find
+
+        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| prepare(doc).save }
+          reset
+        end
+
+        def <<(*docs)
+          ensure_owner_saved
+          flatten_deeper(docs).each { |doc| prepare(doc).save }
+          reset
+        end
+        alias_method :push, :<<
+        alias_method :concat, :<<
+
+        def build(attrs={})
+          doc = klass.new(attrs)
+          apply_scope(doc)
+          @target ||= [] unless loaded?
+          @target << doc
+          doc
+        end
+
+        def create(attrs={})
+          doc = klass.new(attrs)
+          apply_scope(doc).save
+          reset
+          doc
+        end
+
+        def create!(attrs={})
+          doc = klass.new(attrs)
+          apply_scope(doc).save!
+          reset
+          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 = Query.new(klass, scoped_conditions).criteria
+          all(criteria).each do |doc|
+            doc.update_attributes(self.foreign_key => nil)
+          end
+          reset
+        end
+        
+        def save_to_collection(options = {})
+          @target.each { |doc| doc.save(options) } if @target
+        end
+
+        protected
+          def scoped_conditions
+            {self.foreign_key => owner.id}
+          end
+
+          def scoped_options(options)
+            association.query_options.merge(options).merge(scoped_conditions)
+          end
+
+          def find_target
+            all
+          end
+
+          def ensure_owner_saved
+            owner.save if owner.new?
+          end
+
+          def prepare(doc)
+            klass === doc ? apply_scope(doc) : build(doc)
+          end
+
+          def apply_scope(doc)
+            ensure_owner_saved
+            doc[foreign_key] = owner.id
+            doc
+          end
+
+          def foreign_key
+            options[:foreign_key] || owner.class.name.to_s.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(association.type_key_name => v.class.name) : v
+          end
+          reset
+        end
+
+        protected
+          def find_target
+            (@_values || []).map do |hash|
+              child = polymorphic_class(hash).load(hash)
+              assign_references(child)
+              child
+            end
+          end
+
+          def polymorphic_class(doc)
+            if class_name = doc[association.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 |attrs|
+              klass.load(attrs).tap do |child|
+                assign_references(child)
+              end
+            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[association.type_key_name] = doc.class.name
+            super
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      class OneEmbeddedProxy < Proxy
+        undef_method :object_id
+
+        def build(attributes={})
+          @target = klass.new(attributes)
+          assign_references(@target)
+          loaded
+          @target
+        end
+
+        def replace(doc)
+          if doc.respond_to?(:attributes)
+            @target = klass.load(doc.attributes)
+          else
+            @target = klass.load(doc)
+          end
+          assign_references(@target)
+          loaded
+          @target
+        end
+
+        protected
+
+          def find_target
+            if @value
+              klass.load(@value).tap do |child|
+                assign_references(child)
+              end
+            end
+          end
+
+          def assign_references(doc)
+            doc._parent_document = owner
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      class OneProxy < Proxy
+        undef_method :object_id
+        
+        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 = klass.new(doc) unless klass === doc
+            doc[foreign_key] = owner.id
+            doc.save if doc.new?
+            loaded
+            @target = doc
+          end
+        end
+
+        protected
+          def find_target
+            target_class.first(association.query_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] || association.name.to_s.camelize).constantize
+          end
+
+          def foreign_key
+            options[:foreign_key] || owner.class.name.foreign_key
+          end
+      end
+    end
+  end
+end