jamieorc-mongo_mapper 0.11.1.1

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

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Associations
+      class BelongsToAssociation < SingleAssociation
+        def type_key_name
+          "#{as}_type"
+        end
+
+        def embeddable?
+          false
+        end
+
+        def proxy_class
+          @proxy_class ||= polymorphic? ? BelongsToPolymorphicProxy : BelongsToProxy
+        end
+
+        def setup(model)
+          model.key foreign_key, ObjectId unless model.key?(foreign_key)
+          super
+          add_touch_callbacks if touch?
+        end
+
+        def autosave?
+          options.fetch(:autosave, false)
+        end
+
+        def add_touch_callbacks
+          name        = self.name
+          method_name = "belongs_to_touch_after_save_or_destroy_for_#{name}"
+          touch       = options.fetch(:touch)
+
+          @model.send(:define_method, method_name) do
+            record = send(name)
+
+            unless record.nil?
+              if touch == true
+                record.touch
+              else
+                record.touch(touch)
+              end
+            end
+          end
+
+          @model.after_save(method_name)
+          @model.after_touch(method_name)
+          @model.after_destroy(method_name)
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Associations
+      class BelongsToPolymorphicProxy < Proxy
+        def replace(doc)
+          if doc
+            doc.save unless doc.persisted?
+            id, type = doc.id, doc.class.name
+          end
+
+          proxy_owner[association.foreign_key] = id
+          proxy_owner[association.type_key_name] = type
+          reset
+          unless doc.nil?
+            loaded
+            @target = doc
+          end
+          @target
+        end
+
+        protected
+          def find_target
+            return nil if association_class.nil? || proxy_owner[association.foreign_key].nil?
+            association_class.find_by_id(proxy_owner[association.foreign_key])
+          end
+
+          def association_class
+            proxy_owner[association.type_key_name] ? proxy_owner[association.type_key_name].constantize : nil
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Associations
+      class BelongsToProxy < Proxy
+        def replace(doc)
+          if doc
+            doc.save if !doc.persisted?
+            id = doc.id
+          end
+
+          reset
+          proxy_owner[association.foreign_key] = id
+          unless doc.nil?
+            loaded
+            @target = doc
+          end
+          @target
+        end
+
+        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 save_to_collection(options={})
+          @target.save(options) if @target
+        end
+
+        protected
+          def find_target
+            return nil if proxy_owner[association.foreign_key].nil?
+            klass.find_by_id(proxy_owner[association.foreign_key])
+          end
+
+          def instantiate_target(instantiator, attrs={})
+            @target = klass.send(instantiator, attrs)
+            proxy_owner[association.foreign_key] = @target.id
+            loaded
+            @target
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# encoding: UTF-8
+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 include?(*args)
+          load_target
+          target.include?(*args)
+        end
+
+        def reset
+          super
+          target = []
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Associations
+      class EmbeddedCollection < Collection
+        def build(attributes={})
+          doc = klass.new(attributes)
+          assign_references(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_references(doc)
+            target << doc
+          end
+        end
+        alias_method :push, :<<
+        alias_method :concat, :<<
+
+        def save_to_collection(options={})
+          @target.each { |doc| doc.persist(options) } if @target
+        end
+
+        private
+          def assign_references(*docs)
+            docs.each { |doc| doc._parent_document = proxy_owner }
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Associations
+      class InArrayProxy < Collection
+        include DynamicQuerying::ClassMethods
+
+        def find(*args)
+          query.find(*scoped_ids(args))
+        end
+
+        def find!(*args)
+          query.find!(*scoped_ids(args))
+        end
+
+        def paginate(options)
+          return [] if ids.blank?
+          query.paginate(options)
+        end
+
+        def all(options={})
+          return [] if ids.blank?
+          query(options).all
+        end
+
+        def first(options={})
+          return nil if ids.blank?
+          query(options).first
+        end
+
+        def last(options={})
+          return nil if ids.blank?
+          query(options).last
+        end
+
+        def count(options={})
+          return 0 if ids.blank?
+          options.blank? ? ids.size : query(options).count
+        end
+
+        def destroy_all(options={})
+          all(options).each do |doc|
+            ids.delete(doc.id)
+            doc.destroy
+          end
+          reset
+        end
+
+        def delete_all(options={})
+          docs = query(options).fields(:_id).all
+          docs.each { |doc| ids.delete(doc.id) }
+          klass.delete(docs.map { |d| d.id })
+          reset
+        end
+
+        def nullify
+          replace([])
+          reset
+        end
+
+        def create(attrs={})
+          doc = klass.create(attrs)
+          if doc.persisted?
+            ids << doc.id
+            proxy_owner.save
+            reset
+          end
+          doc
+        end
+
+        def create!(attrs={})
+          doc = klass.create!(attrs)
+          if doc.persisted?
+            ids << doc.id
+            proxy_owner.save
+            reset
+          end
+          doc
+        end
+
+        def <<(*docs)
+          flatten_deeper(docs).each do |doc|
+            doc.save unless doc.persisted?
+            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 unless doc.persisted?
+            doc.id
+          end
+          ids.replace(doc_ids.uniq)
+          reset
+        end
+
+        private
+          def query(options={})
+            klass.
+              query(association.query_options).
+              amend(options).
+              amend(criteria)
+          end
+
+          def criteria
+            {:_id => ids}
+          end
+
+          def scoped_ids(args)
+            valid = args.flatten.select do |id|
+              id = ObjectId.to_mongo(id) if klass.using_object_id?
+              ids.include?(id)
+            end
+            valid.empty? ? nil : valid
+          end
+
+          def find_target
+            return [] if ids.blank?
+            all
+          end
+
+          def ids
+            proxy_owner[options[:in]]
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Associations
+      class ManyAssociation < Base
+
+        def class_name
+          @class_name ||= options[:class_name] || name.to_s.singularize.camelize
+        end
+
+        # hate this, need to revisit
+        def proxy_class
+          @proxy_class ||= if klass.embeddable?
+            polymorphic? ? ManyEmbeddedPolymorphicProxy : ManyEmbeddedProxy
+          else
+            if polymorphic?
+              ManyPolymorphicProxy
+            elsif as?
+              ManyDocumentsAsProxy
+            elsif in_array?
+              InArrayProxy
+            else
+              ManyDocumentsProxy
+            end
+          end
+        end
+
+        def setup(model)
+          model.associations_module.module_eval <<-end_eval
+            def #{name}
+              get_proxy(associations[#{name.inspect}])
+            end
+
+            def #{name}=(value)
+              get_proxy(associations[#{name.inspect}]).replace(value)
+              value
+            end
+          end_eval
+
+          association = self
+          options = self.options
+
+          model.before_destroy do
+            if !association.embeddable?
+              case options[:dependent]
+                when :destroy
+                  self.get_proxy(association).destroy_all
+                when :delete_all
+                  self.get_proxy(association).delete_all
+                when :nullify
+                  self.get_proxy(association).nullify
+              end
+            end
+          end
+        end
+
+        def autosave?
+          options.fetch(:autosave, true)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Associations
+      class ManyDocumentsAsProxy < ManyDocumentsProxy
+        protected
+          def criteria
+            {type_key_name => proxy_owner.class.name, id_key_name => proxy_owner.id}
+          end
+
+          def apply_scope(doc)
+            ensure_owner_saved
+            criteria.each { |key, value| doc[key] = value }
+            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 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Associations
+      class ManyDocumentsProxy < Collection
+        include DynamicQuerying::ClassMethods
+        include Querying::PluckyMethods
+
+        def replace(docs)
+          load_target
+          
+          (target - docs).each do |t|
+            case options[:dependent]
+              when :destroy    then t.destroy
+              when :delete_all then t.delete
+              else t.update_attributes(self.foreign_key => nil)
+            end
+          end
+          
+          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).each { |doc| doc.destroy }
+          reset
+        end
+
+        def delete_all(options={})
+          query(options).remove
+          reset
+        end
+
+        def nullify
+          all.each { |doc| doc.update_attributes(self.foreign_key => nil) }
+          reset
+        end
+
+        def save_to_collection(options={})
+          @target.each { |doc| doc.save(options) } if @target
+        end
+
+        protected
+          def query(options={})
+            klass.
+              query(association.query_options).
+              amend(options).amend(criteria)
+          end
+
+          def method_missing(method, *args, &block)
+            if klass.respond_to?(method)
+              result = klass.send(method, *args, &block)
+              result.is_a?(Plucky::Query) ?
+                query.merge(result) : super
+            else
+              super
+            end
+          end
+
+          def criteria
+            {self.foreign_key => proxy_owner.id}
+          end
+
+          def find_target
+            all
+          end
+
+          def ensure_owner_saved
+            proxy_owner.save unless proxy_owner.persisted?
+          end
+
+          def prepare(doc)
+            klass === doc ? apply_scope(doc) : build(doc)
+          end
+
+          def apply_scope(doc)
+            criteria.each { |key, value| doc[key] = value }
+            doc
+          end
+
+          def foreign_key
+            options[:foreign_key] || proxy_owner.class.name.foreign_key
+          end
+      end
+    end
+  end
+end