jamieorc-mongo_mapper 0.11.1.1

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

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+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,24 @@
+# encoding: UTF-8
+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,14 @@
+# encoding: UTF-8
+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_as_proxy.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Associations
+      class OneAsProxy < OneProxy
+        protected
+          def criteria
+            {type_key_name => proxy_owner.class.name, id_key_name => proxy_owner.id}
+          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/one_association.rb

@@ -0,0 +1,48 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Associations
+      class OneAssociation < SingleAssociation
+        def embeddable?
+          klass.embeddable?
+        end
+
+        def proxy_class
+          @proxy_class ||=
+            if klass.embeddable?
+              polymorphic? ? OneEmbeddedPolymorphicProxy : OneEmbeddedProxy
+            elsif as?
+              OneAsProxy
+            else
+              OneProxy
+            end
+        end
+
+        def setup(model)
+          super
+
+          association = self
+          options = self.options
+
+          model.before_destroy do
+            if !association.embeddable?
+              proxy = self.get_proxy(association)
+
+              unless proxy.nil?
+                case options[:dependent]
+                  when :destroy then proxy.destroy
+                  when :delete  then proxy.delete
+                  else proxy.nullify
+                end
+              end
+            end
+          end
+        end
+
+        def autosave?
+          options.fetch(:autosave, embeddable?)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Associations
+      class OneEmbeddedPolymorphicProxy < OneEmbeddedProxy
+        def replace(value)
+          @value = value.respond_to?(:attributes) ? value.attributes.merge(association.type_key_name => value.class.name) : value
+          reset
+        end
+        
+        protected
+          def find_target
+            if @value
+              child = polymorphic_class(@value).load(@value)
+              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/one_embedded_proxy.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Associations
+      class OneEmbeddedProxy < Proxy
+        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
+
+        def save_to_collection(options={})
+          @target.persist(options) if @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 = proxy_owner if doc
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    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 target.persisted?
+              case options[:dependent]
+                when :delete  then target.delete
+                when :destroy then target.destroy
+                else
+                  nullify_scope(target)
+                  target.save
+              end
+            end
+          end
+          
+          unless doc.nil?
+            proxy_owner.save unless proxy_owner.persisted?
+            doc = klass.new(doc) unless doc.is_a?(klass)
+            apply_scope(doc)
+            doc.save unless doc.persisted?
+          end
+
+          loaded
+          @target = doc
+        end
+        
+        def destroy
+          target.destroy
+          reset
+        end
+        
+        def delete
+          target.delete
+          reset
+        end
+        
+        def nullify
+          nullify_scope(target)
+          target.save
+          reset
+        end
+
+        protected
+          def find_target
+            target_class.first(association.query_options.merge(criteria))
+          end
+
+          def instantiate_target(instantiator, attrs={})
+            @target = target_class.send(instantiator, attrs.update(criteria))
+            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] || proxy_owner.class.name.foreign_key
+          end
+
+          def criteria
+            {self.foreign_key => proxy_owner.id}
+          end
+
+          def nullify_scope(doc)
+            criteria.each { |key, value| doc[key] = nil }
+            doc
+          end
+
+          def apply_scope(doc)
+            criteria.each { |key, value| doc[key] = value }
+            doc
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# encoding: UTF-8
+require 'forwardable'
+module MongoMapper
+  module Plugins
+    module Associations
+      class Proxy
+        extend Forwardable
+
+        alias :proxy_respond_to? :respond_to?
+        alias :proxy_extend :extend
+
+        instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^respond_to_missing\?$|^object_id$)/ }
+
+        attr_reader :proxy_owner, :association, :target
+
+        alias :proxy_target :target
+        alias :proxy_association :association
+
+        def_delegators :proxy_association, :klass, :options
+        def_delegator  :klass, :collection
+
+        def initialize(owner, association)
+          @proxy_owner, @association, @loaded = owner, association, false
+          Array(association.options[:extend]).each { |ext| proxy_extend(ext) }
+          reset
+        end
+
+        # Active support in rails 3 beta 4 can override to_json after this is loaded,
+        # at least when run in mongomapper tests. The implementation was changed in master
+        # some time after this, so not sure whether this is still a problem.
+        #
+        # In rails 2, this isn't a problem however it also solves an issue where
+        # to_json isn't forwarded because it supports to_json itself
+        def to_json(*options)
+          load_target
+          target.to_json(*options)
+        end
+
+        # see comments to to_json
+        def as_json(*options)
+          load_target
+          target.as_json(*options)
+        end
+
+        def inspect
+          load_target
+          target.inspect
+        end
+
+        def loaded?
+          @loaded
+        end
+
+        def loaded
+          @loaded = true
+        end
+
+        def nil?
+          load_target
+          target.nil?
+        end
+
+        def blank?
+          load_target
+          target.blank?
+        end
+
+        def present?
+          load_target
+          target.present?
+        end
+
+        def reload
+          reset
+          load_target
+          self unless target.nil?
+        end
+
+        def replace(v)
+          raise NotImplementedError
+        end
+
+        def reset
+          @loaded = false
+          @target = nil
+        end
+
+        def respond_to?(*args)
+          proxy_respond_to?(*args) || (load_target && target.respond_to?(*args))
+        end
+
+        def send(method, *args)
+          if proxy_respond_to?(method)
+            super
+          else
+            load_target
+            target.send(method, *args)
+          end
+        end
+
+        protected
+          def method_missing(method, *args, &block)
+            if load_target
+              target.send(method, *args, &block)
+            end
+          end
+
+          def load_target
+            unless loaded?
+              if @target.is_a?(Array) && @target.any?
+                @target = find_target + @target.find_all { |record| !record.persisted? }
+              else
+                @target = find_target
+              end
+              loaded
+            end
+            @target
+          rescue MongoMapper::DocumentNotFound
+            reset
+          end
+
+          def find_target
+            raise NotImplementedError
+          end
+
+          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
+end