mongo_mapper-rails3 0.7.0.1 → 0.7.2

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

@@ -1,141 +0,0 @@
-module MongoMapper
-  module Plugins
-    module Associations
-      class InArrayProxy < Collection
-        include Support::Find
-
-        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
-            reset
-          end
-          doc
-        end
-
-        def create!(attrs={})
-          doc = klass.create!(attrs)
-          unless doc.new?
-            ids << doc.id
-            owner.save
-            reset
-          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)
-            association.query_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
-end

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

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

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

@@ -1,120 +0,0 @@
-module MongoMapper
-  module Plugins
-    module Associations
-      class ManyDocumentsProxy < Collection
-        include Support::Find
-
-        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)
-          reset
-          doc
-        end
-
-        def create(attrs={})
-          doc = klass.new(attrs)
-          apply_scope(doc).save
-          reset
-          doc
-        end
-
-        def create!(attrs={})
-          doc = klass.new(attrs)
-          apply_scope(doc).save!
-          reset
-          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 = Query.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)
-            association.query_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
-end

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

@@ -1,31 +0,0 @@
-module MongoMapper
-  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)
-              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/mongo_mapper/plugins/associations/many_embedded_proxy.rb

@@ -1,23 +0,0 @@
-module MongoMapper
-  module Plugins
-    module Associations
-      class ManyEmbeddedProxy < EmbeddedCollection
-        def replace(values)
-          @_values = values.map do |v|
-            v.respond_to?(:attributes) ? v.attributes : v
-          end
-          reset
-        end
-
-        private
-          def find_target
-            (@_values || []).map do |v|
-              child = klass.load(v)
-              assign_references(child)
-              child
-            end
-          end
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-module MongoMapper
-  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/mongo_mapper/plugins/associations/one_proxy.rb

@@ -1,68 +0,0 @@
-module MongoMapper
-  module Plugins
-    module Associations
-      class OneProxy < Proxy
-        undef_method :object_id
-        
-        def build(attrs={})
-          instantiate_target(:new, attrs)
-        end
-
-        def create(attrs={})
-          instantiate_target(:create, attrs)
-        end
-
-        def create!(attrs={})
-          instantiate_target(:create!, attrs)
-        end
-
-        def replace(doc)
-          load_target
-
-          if !target.nil? && target != doc
-            if options[:dependent] && !target.new?
-              case options[:dependent]
-                when :delete
-                  target.delete
-                when :destroy
-                  target.destroy
-                when :nullify
-                  target[foreign_key] = nil
-                  target.save
-              end
-            end
-          end
-
-          reset
-
-          unless doc.nil?
-            owner.save if owner.new?
-            doc[foreign_key] = owner.id
-            doc.save if doc.new?
-            loaded
-            @target = doc
-          end
-        end
-
-        protected
-          def find_target
-            target_class.first(association.query_options.merge(foreign_key => owner.id))
-          end
-
-          def instantiate_target(instantiator, attrs={})
-            @target = target_class.send(instantiator, attrs.update(foreign_key => owner.id))
-            loaded
-            @target
-          end
-
-          def target_class
-            @target_class ||= options[:class] || (options[:class_name] || association.name.to_s.camelize).constantize
-          end
-
-          def foreign_key
-            options[:foreign_key] || owner.class.name.foreign_key
-          end
-      end
-    end
-  end
-end

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

@@ -1,119 +0,0 @@
-require 'active_support/core_ext/module/delegation'
-module MongoMapper
-  module Plugins
-    module Associations
-      class Proxy
-        alias :proxy_respond_to? :respond_to?
-        alias :proxy_extend :extend
-
-        instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^object_id$)/ }
-
-        attr_reader :owner, :association, :target
-
-        alias :proxy_owner :owner
-        alias :proxy_target :target
-        alias :proxy_association :association
-
-        delegate :klass, :to => :proxy_association
-        delegate :options, :to => :proxy_association
-        delegate :collection, :to => :klass
-
-        def initialize(owner, association)
-          @owner, @association, @loaded = owner, association, false
-          Array(association.options[:extend]).each { |ext| proxy_extend(ext) }
-          reset
-        end
-
-        def inspect
-          load_target
-          target.inspect
-        end
-
-        def loaded?
-          @loaded
-        end
-
-        def loaded
-          @loaded = true
-        end
-
-        def nil?
-          load_target
-          target.nil?
-        end
-
-        def blank?
-          load_target
-          target.blank?
-        end
-
-        def present?
-          load_target
-          target.present?
-        end
-
-        def reload
-          reset
-          load_target
-          self unless target.nil?
-        end
-
-        def replace(v)
-          raise NotImplementedError
-        end
-
-        def reset
-          @loaded = false
-          @target = nil
-        end
-
-        def respond_to?(*args)
-          proxy_respond_to?(*args) || (load_target && target.respond_to?(*args))
-        end
-
-        def send(method, *args)
-          if proxy_respond_to?(method)
-            super
-          else
-            load_target
-            target.send(method, *args)
-          end
-        end
-
-        def ===(other)
-          load_target
-          other === target
-        end
-
-        protected
-          def method_missing(method, *args, &block)
-            if load_target
-              if block_given?
-                target.send(method, *args)  { |*block_args| block.call(*block_args) }
-              else
-                target.send(method, *args)
-              end
-            end
-          end
-
-          def load_target
-            @target = find_target unless loaded?
-            loaded
-            @target
-          rescue MongoMapper::DocumentNotFound
-            reset
-          end
-
-          def find_target
-            raise NotImplementedError
-          end
-
-          def flatten_deeper(array)
-            array.collect do |element|
-              (element.respond_to?(:flatten) && !element.is_a?(Hash)) ? element.flatten : element
-            end.flatten
-          end
-      end
-    end
-  end
-end