mongo_mapper_ign 0.7.4

data/lib/mongo_mapper/embedded_document.rb

@@ -0,0 +1,70 @@
+module MongoMapper
+  module EmbeddedDocument
+    extend Support::DescendantAppends
+
+    def self.included(model)
+      model.class_eval do
+        include InstanceMethods
+        extend  ClassMethods
+        extend  Plugins
+
+        plugin Plugins::Associations
+        plugin Plugins::Clone
+        plugin Plugins::Descendants
+        plugin Plugins::Equality
+        plugin Plugins::Inspect
+        plugin Plugins::Keys
+        plugin Plugins::Logger
+        plugin Plugins::Persistence
+        plugin Plugins::Protected
+        plugin Plugins::Rails
+        plugin Plugins::Serialization
+        plugin Plugins::Validations
+        plugin Plugins::Callbacks
+
+        attr_reader :_root_document, :_parent_document
+      end
+
+      super
+    end
+
+    module ClassMethods
+      def embeddable?
+        true
+      end
+
+      def embedded_in(owner_name)
+        define_method(owner_name) { _parent_document }
+      end
+    end
+
+    module InstanceMethods
+      def destroyed?
+        !!_root_document.try(:destroyed?)
+      end
+
+      def new?
+        _root_document.try(:new?) || @new
+      end
+
+      def save(options={})
+        if result = _root_document.try(:save, options)
+          @new = false
+        end
+        result
+      end
+
+      def save!(options={})
+        if result = _root_document.try(:save!, options)
+          @new = false
+        end
+        result
+      end
+
+      def _parent_document=(value)
+        @_root_document   = value._root_document
+        @_parent_document = value
+      end
+    end # InstanceMethods
+  end # EmbeddedDocument
+end # MongoMapper

data/lib/mongo_mapper/plugins.rb

@@ -0,0 +1,35 @@
+module MongoMapper
+  module Plugins
+    def plugins
+      @plugins ||= []
+    end
+
+    def plugin(mod)
+      extend mod::ClassMethods     if mod.const_defined?(:ClassMethods)
+      include mod::InstanceMethods if mod.const_defined?(:InstanceMethods)
+      mod.configure(self)          if mod.respond_to?(:configure)
+      plugins << mod
+    end
+
+    autoload :Callbacks,      'mongo_mapper/plugins/callbacks'
+    autoload :Clone,          'mongo_mapper/plugins/clone'
+    autoload :Descendants,    'mongo_mapper/plugins/descendants'
+    autoload :Dirty,          'mongo_mapper/plugins/dirty'
+    autoload :Equality,       'mongo_mapper/plugins/equality'
+    autoload :IdentityMap,    'mongo_mapper/plugins/identity_map'
+    autoload :Inspect,        'mongo_mapper/plugins/inspect'
+    autoload :Keys,           'mongo_mapper/plugins/keys'
+    autoload :Logger,         'mongo_mapper/plugins/logger'
+    autoload :Modifiers,      'mongo_mapper/plugins/modifiers'
+    autoload :Persistence,    'mongo_mapper/plugins/persistence'
+    autoload :Protected,      'mongo_mapper/plugins/protected'
+    autoload :Rails,          'mongo_mapper/plugins/rails'
+    autoload :Serialization,  'mongo_mapper/plugins/serialization'
+    autoload :Timestamps,     'mongo_mapper/plugins/timestamps'
+    autoload :Userstamps,     'mongo_mapper/plugins/userstamps'
+    autoload :Validations,    'mongo_mapper/plugins/validations'
+  end
+end
+
+require 'mongo_mapper/plugins/associations'
+require 'mongo_mapper/plugins/pagination'

data/lib/mongo_mapper/plugins/associations.rb

@@ -0,0 +1,114 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      module ClassMethods
+        def belongs_to(association_id, options={}, &extension)
+          create_association(:belongs_to, association_id, options, &extension)
+        end
+
+        def many(association_id, options={}, &extension)
+          create_association(:many, association_id, options, &extension)
+        end
+
+        def one(association_id, options={}, &extension)
+          create_association(:one, association_id, options, &extension)
+        end
+
+        def associations
+          @associations ||= HashWithIndifferentAccess.new
+        end
+
+        def associations=(hash)
+          @associations = hash
+        end
+
+        def inherited(subclass)
+          subclass.associations = associations.dup
+          super
+        end
+
+        private
+          def create_association(type, name, options, &extension)
+            association = Associations::Base.new(type, name, options, &extension)
+            associations[association.name] = association
+
+            define_method(association.name) do
+              get_proxy(association)
+            end
+
+            define_method("#{association.name}=") do |value|
+              get_proxy(association).replace(value)
+              value
+            end
+
+            if association.one? || association.belongs_to?
+              define_method("#{association.name}?") do
+                get_proxy(association).present?
+              end
+            end
+
+            if association.options[:dependent] && association.many? && !association.embeddable?
+              after_destroy do |doc|
+                case association.options[:dependent]
+                  when :destroy
+                    doc.get_proxy(association).destroy_all
+                  when :delete_all
+                    doc.get_proxy(association).delete_all
+                  when :nullify
+                    doc.get_proxy(association).nullify
+                end
+              end
+            end
+          end
+      end
+
+      module InstanceMethods
+        def associations
+          self.class.associations
+        end
+
+        # @api private?
+        def embedded_associations
+          associations.select do |name, association|
+            association.embeddable?
+          end.map do |name, association|
+            association
+          end
+        end
+
+        def get_proxy(association)
+          unless proxy = self.instance_variable_get(association.ivar)
+            proxy = association.proxy_class.new(self, association)
+            self.instance_variable_set(association.ivar, proxy)
+          end
+
+          proxy
+        end
+        
+        def save_to_collection(options = {})
+          super
+          associations.each do |association_name, association|
+            proxy = get_proxy(association)
+            proxy.save_to_collection(options) if proxy.proxy_respond_to?(:save_to_collection)
+          end
+        end
+      end
+
+      autoload :Base,                         'mongo_mapper/plugins/associations/base'
+      autoload :Collection,                   'mongo_mapper/plugins/associations/collection'
+      autoload :EmbeddedCollection,           'mongo_mapper/plugins/associations/embedded_collection'
+      autoload :ManyDocumentsProxy,           'mongo_mapper/plugins/associations/many_documents_proxy'
+      autoload :BelongsToProxy,               'mongo_mapper/plugins/associations/belongs_to_proxy'
+      autoload :BelongsToPolymorphicProxy,    'mongo_mapper/plugins/associations/belongs_to_polymorphic_proxy'
+      autoload :ManyPolymorphicProxy,         'mongo_mapper/plugins/associations/many_polymorphic_proxy'
+      autoload :ManyEmbeddedProxy,            'mongo_mapper/plugins/associations/many_embedded_proxy'
+      autoload :ManyEmbeddedPolymorphicProxy, 'mongo_mapper/plugins/associations/many_embedded_polymorphic_proxy'
+      autoload :ManyDocumentsAsProxy,         'mongo_mapper/plugins/associations/many_documents_as_proxy'
+      autoload :OneProxy,                     'mongo_mapper/plugins/associations/one_proxy'
+      autoload :OneEmbeddedProxy,             'mongo_mapper/plugins/associations/one_embedded_proxy'
+      autoload :InArrayProxy,                 'mongo_mapper/plugins/associations/in_array_proxy'
+    end
+  end
+end
+
+require 'mongo_mapper/plugins/associations/proxy'

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

@@ -0,0 +1,123 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      class Base
+        attr_reader :type, :name, :options, :query_options
+
+        # Options that should not be considered MongoDB query options/criteria
+        AssociationOptions = [:as, :class, :class_name, :dependent, :extend, :foreign_key, :in, :polymorphic]
+
+        def initialize(type, name, options={}, &extension)
+          @type, @name, @options, @query_options, @original_options = type, name, {}, {}, options
+          options.symbolize_keys!
+          options[:extend] = modularized_extensions(extension, options[:extend])
+          separate_options_and_conditions
+        end
+
+        def class_name
+          return @class_name if defined?(@class_name)
+          
+          @class_name = 
+            if cn = options[:class_name]
+              cn
+            elsif many?
+              name.to_s.singularize.camelize
+            else
+              name.to_s.camelize
+            end
+        end
+
+        def klass
+          @klass ||= options[:class] || class_name.constantize
+        end
+
+        def many?
+          @type == :many
+        end
+
+        def belongs_to?
+          @type == :belongs_to
+        end
+
+        def one?
+          @type == :one
+        end
+
+        def polymorphic?
+          !!@options[:polymorphic]
+        end
+
+        def as?
+          !!@options[:as]
+        end
+
+        def in_array?
+          !!@options[:in]
+        end
+
+        def embeddable?
+          (one? || many?) && klass.embeddable?
+        end
+
+        def type_key_name
+          many? ? '_type' : "#{as}_type"
+        end
+
+        def as
+          @options[:as] || self.name
+        end
+
+        def foreign_key
+          @options[:foreign_key] || "#{name}_id"
+        end
+
+        def ivar
+          @ivar ||= "@_#{name}"
+        end
+
+        # hate this, need to revisit
+        def proxy_class
+          return @proxy_class if defined?(@proxy_class)
+          
+          @proxy_class = 
+            if many?
+              if klass.embeddable?
+                polymorphic? ? ManyEmbeddedPolymorphicProxy : ManyEmbeddedProxy
+              else
+                if polymorphic?
+                  ManyPolymorphicProxy
+                elsif as?
+                  ManyDocumentsAsProxy
+                elsif in_array?
+                  InArrayProxy
+                else
+                  ManyDocumentsProxy
+                end
+              end
+            elsif one?
+              klass.embeddable? ? OneEmbeddedProxy : OneProxy
+            else
+              polymorphic? ? BelongsToPolymorphicProxy : BelongsToProxy
+            end
+        end
+
+        private
+          def separate_options_and_conditions
+            @original_options.each_pair do |key, value|
+              if AssociationOptions.include?(key)
+                @options[key] = value
+              else
+                @query_options[key] = value
+              end
+            end
+          end
+
+          def modularized_extensions(*extensions)
+            extensions.flatten.compact.map do |extension|
+              Proc === extension ? Module.new(&extension) : extension
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      class BelongsToPolymorphicProxy < Proxy
+        undef_method :object_id
+        
+        def replace(doc)
+          if doc
+            doc.save if doc.new?
+            id, type = doc.id, doc.class.name
+          end
+
+          owner[association.foreign_key] = id
+          owner[association.type_key_name] = type
+          reset
+        end
+
+        protected
+          def find_target
+            return nil if association_class.nil? || owner[association.foreign_key].nil?
+            association_class.find_by_id(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,25 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      class BelongsToProxy < Proxy
+        undef_method :object_id
+        
+        def replace(doc)
+          if doc
+            doc.save if doc.new?
+            id = doc.id
+          end
+
+          owner[association.foreign_key] = id
+          reset
+        end
+
+        protected
+          def find_target
+            return nil if owner[association.foreign_key].nil?
+            klass.find_by_id(owner[association.foreign_key])
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+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 reset
+          super
+          target = []
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+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, :<<
+
+        private
+          def assign_references(*docs)
+            docs.each { |doc| doc._parent_document = owner }
+          end
+      end
+    end
+  end
+end