mongo_mapper-rails3 0.7.0.1 → 0.7.2

data/lib/mongo_mapper/embedded_document.rb

@@ -1,68 +0,0 @@
-module MongoMapper
-  module EmbeddedDocument
-    extend Support::DescendantAppends
-    extend ActiveSupport::Concern
-    included do
-      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::Protected
-      plugin Plugins::Rails
-      plugin Plugins::Serialization
-      plugin Plugins::Validations
-
-      attr_accessor :_root_document, :_parent_document
-    end
-
-    module ClassMethods
-      def embeddable?
-        true
-      end
-
-      def embedded_in(owner_name)
-        define_method(owner_name) { _parent_document }
-      end
-    end
-
-    module InstanceMethods
-      def initialize(attrs={}, from_database=false)
-        unless attrs.nil?
-          provided_keys = attrs.keys.map { |k| k.to_s }
-          unless provided_keys.include?('_id') || provided_keys.include?('id')
-            write_key :_id, Mongo::ObjectID.new
-          end
-        end
-
-        assign_type_if_present
-
-        if from_database
-          @new = false
-          self.attributes = attrs
-        else
-          @new = true
-          assign(attrs)
-        end
-      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
-    end # InstanceMethods
-  end # EmbeddedDocument
-end # MongoMapper

data/lib/mongo_mapper/plugins.rb

@@ -1,30 +0,0 @@
-module MongoMapper
-  module Plugins
-    def plugins
-      @plugins ||= []
-    end
-
-    def plugin(mod)
-      include mod
-      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 :Protected,      'mongo_mapper/plugins/protected'
-    autoload :Rails,          'mongo_mapper/plugins/rails'
-    autoload :Serialization,  'mongo_mapper/plugins/serialization'
-    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

@@ -1,106 +0,0 @@
-module MongoMapper
-  module Plugins
-    module Associations
-      extend ActiveSupport::Concern
-      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
-      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 :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

@@ -1,123 +0,0 @@
-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?
-          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?
-              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

@@ -1,30 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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 _root_document
-            if owner.respond_to?(:_root_document)
-              owner._root_document
-            else
-              owner
-            end
-          end
-
-          def assign_references(*docs)
-            docs.each do |doc|
-              doc._root_document = _root_document
-              doc._parent_document = owner
-            end
-          end
-      end
-    end
-  end
-end