mongo_mapper 0.6.10 → 0.7.0

data/lib/mongo_mapper/associations.rb

@@ -1,78 +0,0 @@
-module MongoMapper
-  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
-
-      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
-  end
-end

data/lib/mongo_mapper/associations/base.rb

@@ -1,119 +0,0 @@
-module MongoMapper
-  module Associations
-    class Base
-      attr_reader :type, :name, :options, :finder_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, @finder_options = type, name, {}, {}
-        options.symbolize_keys!
-
-        options[:extend] = modulized_extensions(extension, options[:extend])
-
-        options.each_pair do |key, value|
-          if AssociationOptions.include?(key)
-            @options[key] = value
-          else
-            @finder_options[key] = value
-          end
-        end
-      end
-
-      def class_name
-        @class_name ||= begin
-          if cn = options[:class_name]
-            cn
-          elsif many?
-            name.to_s.singularize.camelize
-          else
-            name.to_s.camelize
-          end
-        end
-      end
-
-      def klass
-        @klass ||= options[:class] || class_name.constantize
-      end
-
-      def many?
-        @many_type ||= @type == :many
-      end
-
-      def belongs_to?
-        @belongs_to_type ||= @type == :belongs_to
-      end
-      
-      def one?
-        @one_type ||= @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
-        @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
-
-      def proxy_class
-        @proxy_class ||= begin
-          if many?
-            if self.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
-      end
-
-      private
-
-        # @param [Array<Module, Proc>] extensions a collection of Modules or 
-        #   Procs that extend the behaviour of this association.
-        def modulized_extensions(*extensions)
-          extensions.flatten.compact.map do |extension|
-            Proc === extension ? Module.new(&extension) : extension
-          end
-        end
-    end
-  end
-end

data/lib/mongo_mapper/associations/belongs_to_polymorphic_proxy.rb

@@ -1,26 +0,0 @@
-module MongoMapper
-  module Associations
-    class BelongsToPolymorphicProxy < Proxy
-      def replace(doc)
-        if doc
-          doc.save if doc.new?
-          id, type = doc.id, doc.class.name
-        end
-        
-        owner[reflection.foreign_key] = id
-        owner[reflection.type_key_name] = type
-        reset
-      end
-      
-      protected
-        def find_target
-          return nil if association_class.nil? || owner[reflection.foreign_key].nil?
-          association_class.first(:id => owner[reflection.foreign_key])
-        end
-        
-        def association_class
-          proxy_owner[reflection.type_key_name] ? proxy_owner[reflection.type_key_name].constantize : nil
-        end
-    end
-  end
-end

data/lib/mongo_mapper/associations/belongs_to_proxy.rb

@@ -1,21 +0,0 @@
-module MongoMapper
-  module Associations
-    class BelongsToProxy < Proxy
-      def replace(doc)
-        if doc
-          doc.save if doc.new?
-          id = doc.id
-        end
-        
-        owner[reflection.foreign_key] = id
-        reset
-      end
-
-      protected
-        def find_target
-          return nil if owner[reflection.foreign_key].nil?
-          klass.first(:id => owner[reflection.foreign_key])
-        end
-    end
-  end
-end

data/lib/mongo_mapper/associations/collection.rb

@@ -1,19 +0,0 @@
-module MongoMapper
-  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

data/lib/mongo_mapper/associations/in_array_proxy.rb

@@ -1,137 +0,0 @@
-module MongoMapper
-  module Associations
-    class InArrayProxy < Collection
-      include ::MongoMapper::Finders
-      
-      def find(*args)
-        options = args.extract_options!
-        
-        case args.first
-          when :first
-            first(options)
-          when :last
-            last(options)
-          when :all
-            all(options)
-          else
-            klass.find(*scoped_ids(args) << scoped_options(options))
-        end
-      end
-      
-      def find!(*args)
-        options = args.extract_options!
-        
-        case args.first
-          when :first
-            first(options)
-          when :last
-            last(options)
-          when :all
-            all(options)
-          else
-            klass.find!(*scoped_ids(args) << scoped_options(options))
-        end
-      end
-
-      def paginate(options)
-        klass.paginate(scoped_options(options))
-      end
-
-      def all(options={})
-        klass.all(scoped_options(options))
-      end
-
-      def first(options={})
-        klass.first(scoped_options(options))
-      end
-
-      def last(options={})
-        klass.last(scoped_options(options))
-      end
-      
-      def count(options={})
-        options.blank? ? ids.size : klass.count(scoped_options(options))
-      end
-      
-      def destroy_all(options={})
-        all(options).each do |doc|
-          ids.delete(doc.id)
-          doc.destroy
-        end
-        reset
-      end
-
-      def delete_all(options={})
-        docs = all(options.merge(:select => ['_id']))
-        docs.each { |doc| ids.delete(doc.id) }
-        klass.delete(docs.map(&:id))
-        reset
-      end
-      
-      def nullify
-        replace([])
-        reset
-      end
-      
-      def create(attrs={})
-        doc = klass.create(attrs)
-        unless doc.new?
-          ids << doc.id
-          owner.save
-        end
-        doc
-      end
-      
-      def create!(attrs={})
-        doc = klass.create!(attrs)
-        unless doc.new?
-          ids << doc.id
-          owner.save
-        end
-        doc
-      end
-      
-      def <<(*docs)
-        flatten_deeper(docs).each do |doc|
-          doc.save if doc.new?
-          unless ids.include?(doc.id)
-            ids << doc.id
-          end
-        end
-        reset
-      end
-      alias_method :push, :<<
-      alias_method :concat, :<<
-      
-      def replace(docs)
-        doc_ids = docs.map do |doc|
-          doc.save if doc.new?
-          doc.id
-        end
-        ids.replace(doc_ids.uniq)
-        reset
-      end
-      
-      private
-        def scoped_conditions
-          {:_id => ids}
-        end
-        
-        def scoped_options(options)
-          reflection.finder_options.merge(options).merge(scoped_conditions)
-        end
-        
-        def scoped_ids(args)
-          args.flatten.reject { |id| !ids.include?(id) }
-        end
-        
-        def find_target
-          ids.blank? ? [] : all
-        end
-        
-        def ids
-          owner[options[:in]]
-        end
-    end
-  end
-end

data/lib/mongo_mapper/associations/many_documents_as_proxy.rb

@@ -1,26 +0,0 @@
-module MongoMapper
-  module Associations
-    class ManyDocumentsAsProxy < ManyDocumentsProxy
-      protected
-        def scoped_conditions
-          {type_key_name => owner.class.name, id_key_name => owner.id}
-        end
-
-        def apply_scope(doc)
-          ensure_owner_saved
-          doc[type_key_name] = owner.class.name
-          doc[id_key_name] = owner.id
-          doc
-        end
-        
-      private
-        def type_key_name
-          "#{options[:as]}_type"
-        end
-        
-        def id_key_name
-          "#{options[:as]}_id"
-        end
-    end
-  end
-end

data/lib/mongo_mapper/associations/many_documents_proxy.rb

@@ -1,115 +0,0 @@
-module MongoMapper
-  module Associations
-    class ManyDocumentsProxy < Collection
-      include ::MongoMapper::Finders
-      
-      def find(*args)
-        options = args.extract_options!
-        klass.find(*args << scoped_options(options))
-      end
-      
-      def find!(*args)
-        options = args.extract_options!
-        klass.find!(*args << scoped_options(options))
-      end
-
-      def paginate(options)
-        klass.paginate(scoped_options(options))
-      end
-
-      def all(options={})
-        klass.all(scoped_options(options))
-      end
-
-      def first(options={})
-        klass.first(scoped_options(options))
-      end
-
-      def last(options={})
-        klass.last(scoped_options(options))
-      end
-
-      def count(options={})
-        klass.count(scoped_options(options))
-      end
-
-      def replace(docs)
-        load_target
-        target.map(&:destroy)
-        docs.each { |doc| apply_scope(doc).save }
-        reset
-      end
-
-      def <<(*docs)
-        ensure_owner_saved
-        flatten_deeper(docs).each { |doc| apply_scope(doc).save }
-        reset
-      end
-      alias_method :push, :<<
-      alias_method :concat, :<<
-
-      def build(attrs={})
-        doc = klass.new(attrs)
-        apply_scope(doc)
-        doc
-      end
-
-      def create(attrs={})
-        doc = klass.new(attrs)
-        apply_scope(doc).save
-        doc
-      end
-      
-      def create!(attrs={})
-        doc = klass.new(attrs)
-        apply_scope(doc).save!
-        doc
-      end
-
-      def destroy_all(options={})
-        all(options).map(&:destroy)
-        reset
-      end
-
-      def delete_all(options={})
-        klass.delete_all(options.merge(scoped_conditions))
-        reset
-      end
-      
-      def nullify
-        criteria = FinderOptions.new(klass, scoped_conditions).criteria
-        all(criteria).each do |doc|
-          doc.update_attributes(self.foreign_key => nil)
-        end
-        reset
-      end
-
-      protected
-        def scoped_conditions
-          {self.foreign_key => owner.id}
-        end
-        
-        def scoped_options(options)
-          reflection.finder_options.merge(options).merge(scoped_conditions)
-        end
-
-        def find_target
-          all
-        end
-
-        def ensure_owner_saved
-          owner.save if owner.new?
-        end
-
-        def apply_scope(doc)
-          ensure_owner_saved
-          doc[foreign_key] = owner.id
-          doc
-        end
-
-        def foreign_key
-          options[:foreign_key] || owner.class.name.underscore.gsub("/", "_") + "_id"
-        end
-    end
-  end
-end