mark_mapper 0.0.1

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

@@ -0,0 +1,63 @@
+# encoding: UTF-8
+module MarkMapper
+  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/mark_mapper/plugins/associations/many_documents_as_proxy.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+module MarkMapper
+  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/mark_mapper/plugins/associations/many_documents_proxy.rb

@@ -0,0 +1,142 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module Associations
+      class ManyDocumentsProxy < Collection
+        include DynamicQuerying::ClassMethods
+
+        def_delegators :query, *(Querying::Methods - [:each, :to_a, :size, :empty?])
+
+        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)
+          yield doc if block_given?
+          @target ||= [] unless loaded?
+          @target << doc
+          doc
+        end
+
+        def create(attrs={})
+          doc = klass.new(attrs)
+          apply_scope(doc)
+          yield doc if block_given?
+          doc.save
+          reset
+          doc
+        end
+
+        def create!(attrs={})
+          doc = klass.new(attrs)
+          apply_scope(doc)
+          yield doc if block_given?
+          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
+
+        def each(&block)
+          load_target.each(&block)
+        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)
+              case result
+              when MarkMapper::Query
+                query.merge result
+
+              # If we got a single record of this classas a result, return it
+              when klass
+                result
+
+              # If we got an array of this class as a result, return it
+              when Array
+                if result[0].is_a? klass
+                  result
+                else
+                  super
+                end
+              else
+                super
+              end
+            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

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

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+module MarkMapper
+  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, true)
+              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/mark_mapper/plugins/associations/many_embedded_proxy.rb

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module Associations
+      class ManyEmbeddedProxy < EmbeddedCollection
+        def replace(values)
+          @_values = (values || []).compact.map do |v|
+            v.respond_to?(:attributes) ? v.attributes : v
+          end
+          reset
+        end
+
+        private
+          def find_target
+            (@_values ||= []).map do |attrs|
+              klass.load(attrs, true).tap do |child|
+                assign_references(child)
+              end
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+module MarkMapper
+  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/mark_mapper/plugins/associations/one_as_proxy.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+module MarkMapper
+  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/mark_mapper/plugins/associations/one_association.rb

@@ -0,0 +1,48 @@
+# encoding: UTF-8
+module MarkMapper
+  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/mark_mapper/plugins/associations/one_embedded_polymorphic_proxy.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+module MarkMapper
+  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, true)
+              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/mark_mapper/plugins/associations/one_embedded_proxy.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+module MarkMapper
+  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, true)
+          else
+            @target = klass.load(doc, true)
+          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, true).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