active_mongoid 0.1.0

data/lib/active_mongoid/associations/document_relation/associations.rb

@@ -0,0 +1,33 @@
+require "active_mongoid/associations/document_relation/macros"
+require "active_mongoid/associations/document_relation/accessors"
+require "active_mongoid/associations/document_relation/builders"
+require "active_mongoid/associations/document_relation/auto_save"
+require "active_mongoid/associations/document_relation/dependent"
+require "active_mongoid/associations/document_relation/bindings/one"
+require "active_mongoid/associations/document_relation/bindings/in"
+require "active_mongoid/associations/document_relation/bindings/many"
+require "active_mongoid/associations/document_relation/referenced/one"
+require "active_mongoid/associations/document_relation/referenced/in"
+require "active_mongoid/associations/document_relation/referenced/many"
+
+module ActiveMongoid
+  module Associations
+    module DocumentRelation
+      module Associations
+        extend ActiveSupport::Concern
+
+        attr_accessor :__metadata__
+
+        included do
+          include DocumentRelation::Accessors
+          include DocumentRelation::Macros
+          include DocumentRelation::Builders
+          include DocumentRelation::AutoSave
+          include DocumentRelation::Dependent
+        end
+
+      end
+    end
+  end
+end
+

data/lib/active_mongoid/associations/document_relation/auto_save.rb

@@ -0,0 +1,31 @@
+module ActiveMongoid
+  module Associations
+    module DocumentRelation
+      module AutoSave
+        extend ActiveSupport::Concern
+
+        def document_changed_for_autosave?(obj)
+          obj.new_record? || obj.changed? || obj.marked_for_destruction?
+        end
+
+        module ClassMethods
+
+          def autosave_documents(metadata)
+            if metadata.autosave?
+              save_method = :"autosave_documents_for_#{metadata.name}"
+              define_method(save_method) do
+                if relation = instance_variable_get("@#{metadata.name}")
+                  Array(relation).each { |d| d.save if document_changed_for_autosave?(d) }
+                end
+              end
+
+              after_save save_method
+            end
+          end
+
+
+        end
+      end
+    end
+  end
+end

data/lib/active_mongoid/associations/document_relation/bindings/in.rb

@@ -0,0 +1,48 @@
+module ActiveMongoid
+  module Associations
+    module DocumentRelation
+      module Bindings
+        class In < Associations::Binding
+
+          def bind_one
+            check_inverse!(target)
+            bind_foreign_key(base, record_id(target))
+            bind_polymorphic_inverse_type(base, target.class.name)
+            unless _binding?
+              _binding do
+                if inverse = __metadata__.inverse(target)
+                  if set_base_metadata
+                    if base.referenced_many_records?
+                      target.__send__(inverse).push(base)
+                    else
+                      target.set_record_relation(inverse, base)
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          def unbind_one
+            inverse = __metadata__.inverse(target)
+            bind_foreign_key(base, nil)
+            bind_polymorphic_inverse_type(base, nil)
+            unless _binding?
+              _binding do
+                if inverse
+                  set_base_metadata
+                  if base.referenced_many_records?
+                    target.__send__(inverse).delete(base)
+                  else
+                    target.set_record_relation(inverse, nil)
+                  end
+                end
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/active_mongoid/associations/document_relation/bindings/many.rb

@@ -0,0 +1,19 @@
+module ActiveMongoid
+  module Associations
+    module DocumentRelation
+      module Bindings
+        class Many < Associations::Binding
+
+          def bind_one(doc)
+            bind_from_relational_parent(doc)
+          end
+
+          def unbind_one(doc)
+            unbind_from_relational_parent(doc)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/active_mongoid/associations/document_relation/bindings/one.rb

@@ -0,0 +1,19 @@
+module ActiveMongoid
+  module Associations
+    module DocumentRelation
+      module Bindings
+        class One < Associations::Binding
+
+          def bind_one
+            bind_from_relational_parent(target)
+          end
+
+          def unbind_one
+            unbind_from_relational_parent(target)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/active_mongoid/associations/document_relation/builders.rb

@@ -0,0 +1,31 @@
+module ActiveMongoid
+  module Associations
+    module DocumentRelation
+      module Builders
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def document_builder(name, metadata)
+            define_method("build_#{name}") do |attributes = {}|
+              record = metadata.klass.new(attributes)
+              send("#{name}=", record)
+            end
+            self
+          end
+
+          def document_creator(name, metadata)
+            define_method("create_#{name}") do |attributes = {}|
+              record = metadata.klass.new(attributes)
+              obj = send("#{name}=", record)
+              record.save
+              save if metadata.stores_foreign_key?
+              obj
+            end
+            self
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/active_mongoid/associations/document_relation/dependent.rb

@@ -0,0 +1,26 @@
+module ActiveMongoid
+  module Associations
+    module DocumentRelation
+      module Dependent
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+          def dependent_documents(metadata)
+            if metadata.dependent
+              dependent_method = :"dependent_documents_for_#{metadata.name}"
+              define_method(dependent_method) do
+                relation = get_document_relation(metadata.name, metadata, nil, true)
+                Array(relation).each { |d| d.send(metadata.dependent) }
+              end
+
+              before_destroy dependent_method
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/active_mongoid/associations/document_relation/macros.rb

@@ -0,0 +1,51 @@
+module ActiveMongoid
+  module Associations
+    module DocumentRelation
+      module Macros
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+          def belongs_to_document(name, options = {})
+            meta = characterize_association(name, Referenced::In, options)
+            relate_one_to_one_document(name, meta)
+          end
+
+          def has_one_document(name, options = {})
+            meta = characterize_association(name, Referenced::One, options)
+            relate_one_to_one_document(name, meta)
+          end
+
+          def has_many_documents(name, options = {})
+            meta = characterize_association(name, Referenced::Many, options)
+            relate_document(name, meta)
+            # document_ids_setter(name, metadata)
+            # document_ids_getter(name, metadata)
+          end
+
+          private
+
+          def relate_one_to_one_document(name, metadata)
+            relate_document(name, metadata)
+            document_builder(name, metadata)
+            document_creator(name, metadata)
+            document_id_setter(name, metadata)
+            document_id_getter(name, metadata)
+          end
+
+          def relate_document(name, metadata)
+            self.am_relations = am_relations.merge(name.to_s => metadata)
+            document_getter(name, metadata)
+            document_setter(name, metadata)
+            autosave_documents(metadata)
+            dependent_documents(metadata)
+            existence_check(name)
+          end
+
+        end
+
+      end
+
+    end
+  end
+end

data/lib/active_mongoid/associations/document_relation/referenced/in.rb

@@ -0,0 +1,72 @@
+module ActiveMongoid
+  module Associations
+    module DocumentRelation
+      module Referenced
+        class In < Associations::One
+
+          def initialize(base, target, metadata)
+            init(base, target, metadata) do
+              bind_one
+            end
+          end
+
+          def substitute(replacement)
+            unbind_one
+            return nil unless replacement
+            self.target = normalize(replacement)
+            bind_one
+            self
+          end
+
+          private
+
+          def binding
+            Bindings::In.new(base, target, __metadata__)
+          end
+
+          def normalize(replacement)
+            return replacement if replacement.is_a?(::Mongoid::Document)
+            __metadata__.builder(klass, replacement).build
+          end
+
+          class << self
+
+            def stores_foreign_key?
+              true
+            end
+
+            def foreign_key(name)
+              "#{name}#{foreign_key_suffix}"
+            end
+
+            def foreign_key_default
+              nil
+            end
+
+            def foreign_key_suffix
+              "_id"
+            end
+
+            def primary_key_default
+              "_id"
+            end
+
+            def macro
+              :belongs_to_document
+            end
+
+            def builder(base, meta, object)
+              ActiveMongoid::Associations::Builders::In.new(base, meta, object)
+            end
+
+            def criteria(metadata, object, type = nil)
+              type.where(metadata.primary_key => object)
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/active_mongoid/associations/document_relation/referenced/many.rb

@@ -0,0 +1,125 @@
+module ActiveMongoid
+  module Associations
+    module DocumentRelation
+      module Referenced
+        class Many < Associations::Many
+
+          private
+
+          def criteria
+            Many.criteria(__metadata__, base.send(__metadata__.primary_key), base.class)
+          end
+
+          def binding
+            Bindings::Many.new(base, target, __metadata__)
+          end
+
+
+          def collection
+            klass.collection
+          end
+
+          def persist_delayed(docs, inserts)
+            unless docs.empty?
+              collection.insert(inserts)
+              docs.each do |doc|
+                doc.new_record = false
+              end
+            end
+          end
+
+          def save_or_delay(doc, docs, inserts)
+            if doc.new_record? && doc.valid?(:create)
+              doc.run_callbacks(:save)
+              doc.run_callbacks(:create)
+              docs.push(doc)
+              inserts.push(doc.as_document)
+            else
+              doc.save
+            end
+          end
+
+          def remove_all(conditions = nil, method = :delete_all)
+            selector = conditions || {}
+            removed = klass.send(method, selector.merge!(criteria.selector))
+            target.delete_if do |obj|
+              if obj.matches?(selector)
+                unbind_one(obj) and true
+              end
+            end
+            removed
+          end
+
+          def remove_not_in(ids)
+            removed = criteria.not_in(_id: ids)
+            if __metadata__.destructive?
+              removed.delete_all
+            else
+              removed.update_all(__metadata__.foreign_key => nil)
+            end
+            in_memory.each do |obj|
+              if !ids.include?(obj.id)
+                unbind_one(obj)
+                target.delete(obj)
+                if __metadata__.destructive?
+                  obj.destroyed = true
+                end
+              end
+            end
+          end
+
+          def method_missing(name, *args, &block)
+            if target.respond_to?(name)
+              target.send(name, *args, &block)
+            else
+              klass.send(:with_scope, criteria) do
+                criteria.public_send(name, *args, &block)
+              end
+            end
+          end
+
+          class << self
+
+            def stores_foreign_key?
+              false
+            end
+
+            def foreign_key(name)
+              "#{name}#{foreign_key_suffix}"
+            end
+
+            def foreign_key_default
+              nil
+            end
+
+            def foreign_key_suffix
+              "_id"
+            end
+
+            def primary_key_default
+              "id"
+            end
+
+            def macro
+              :has_many_documents
+            end
+
+            def builder(base, meta, object)
+              ActiveMongoid::Associations::Builders::Many.new(base, meta, object || [])
+            end
+
+            def criteria(metadata, object, type = nil)
+              crit = metadata.klass.where(metadata.foreign_key => object)
+              if metadata.polymorphic?
+                crit = crit.where(metadata.type => type.name)
+              end
+              crit
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end