mongo_mapper-unstable 2010.3.8 → 2010.06.23

data/lib/mongo_mapper/{support/find.rb → plugins/dynamic_querying/dynamic_finder.rb}

@@ -1,29 +1,7 @@
+# encoding: UTF-8
 module MongoMapper
-  module Support
-    # @api private
-    module Find
-      def dynamic_find(finder, args)
-        attributes = {}
-
-        finder.attributes.each_with_index do |attr, index|
-          attributes[attr] = args[index]
-        end
-
-        options = args.extract_options!.merge(attributes)
-
-        if result = send(finder.finder, options)
-          result
-        else
-          if finder.raise?
-            raise DocumentNotFound, "Couldn't find Document with #{attributes.inspect} in collection named #{collection.name}"
-          end
-
-          if finder.instantiator
-            self.send(finder.instantiator, attributes)
-          end
-        end
-      end
-
+  module Plugins
+    module DynamicQuerying
       class DynamicFinder
         attr_reader :method, :attributes, :finder, :bang, :instantiator
 
@@ -61,17 +39,6 @@ module MongoMapper
             @attributes = names && names.split('_and_')
           end
       end
-
-      protected
-        def method_missing(method, *args, &block)
-          finder = DynamicFinder.new(method)
-
-          if finder.found?
-            dynamic_find(finder, args)
-          else
-            super
-          end
-        end
     end
   end
 end

data/lib/mongo_mapper/plugins/dynamic_querying.rb

@@ -0,0 +1,43 @@
+# encoding: UTF-8
+require 'mongo_mapper/plugins/dynamic_querying/dynamic_finder'
+
+module MongoMapper
+  module Plugins
+    module DynamicQuerying
+      module ClassMethods
+        def dynamic_find(finder, args)
+          attributes = {}
+
+          finder.attributes.each_with_index do |attr, index|
+            attributes[attr] = args[index]
+          end
+
+          options = args.extract_options!.merge(attributes)
+
+          if result = send(finder.finder, options)
+            result
+          else
+            if finder.raise?
+              raise DocumentNotFound, "Couldn't find Document with #{attributes.inspect} in collection named #{collection.name}"
+            end
+
+            if finder.instantiator
+              self.send(finder.instantiator, attributes)
+            end
+          end
+        end
+
+        protected
+          def method_missing(method, *args, &block)
+            finder = DynamicFinder.new(method)
+
+            if finder.found?
+              dynamic_find(finder, args)
+            else
+              super
+            end
+          end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/embedded_document.rb

@@ -0,0 +1,49 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module EmbeddedDocument
+      def self.configure(model)
+        model.class_eval do
+          attr_reader :_root_document, :_parent_document
+        end
+      end
+
+      module ClassMethods
+        def embeddable?
+          true
+        end
+
+        def embedded_in(owner_name)
+          define_method(owner_name) { _parent_document }
+        end
+      end
+
+      module InstanceMethods
+        def new?
+          _root_document.try(:new?) || @_new
+        end
+
+        def destroyed?
+          !!_root_document.try(:destroyed?)
+        end
+
+        def save(options={})
+          _root_document.try(:save, options).tap do |result|
+            @_new = false if result
+          end
+        end
+
+        def save!(options={})
+          _root_document.try(:save, options).tap do |result|
+            @_new = false if result
+          end
+        end
+
+        def _parent_document=(value)
+          @_root_document   = value._root_document
+          @_parent_document = value
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/equality.rb

@@ -1,19 +1,13 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Equality
       module InstanceMethods
-        def ==(other)
-          other.is_a?(self.class) && _id == other._id
-        end
-        
         def eql?(other)
-          self == other
-        end
-        
-        def equal?(other)
-          object_id === other.object_id
+          other.is_a?(self.class) && _id == other._id
         end
-        
+        alias :== :eql?
+
         def hash
           _id.hash
         end

data/lib/mongo_mapper/plugins/identity_map.rb

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+require 'set'
+
 module MongoMapper
   module Plugins
     module IdentityMap
@@ -8,7 +11,7 @@ module MongoMapper
       def self.clear
         models.each { |m| m.identity_map.clear }
       end
-      
+
       def self.configure(model)
         IdentityMap.models << model
       end
@@ -27,28 +30,41 @@ module MongoMapper
           @identity_map = v
         end
 
-        def find_one(options={})
-          criteria, query_options = to_query(options)
+        module IdentityMapQueryMethods
+          def all(opts={})
+            query = clone.update(opts)
+            super.tap do |docs|
+              model.remove_documents_from_map(docs) if query.fields?
+            end
+          end
 
-          if simple_find?(criteria) && identity_map.key?(criteria[:_id])
-            identity_map[criteria[:_id]]
-          else
-            super.tap do |document|
-              remove_documents_from_map(document) if selecting_fields?(query_options)
+          def find_one(opts={})
+            query = clone.update(opts)
+
+            if query.simple? && model.identity_map[query[:_id]]
+              model.identity_map[query[:_id]]
+            else
+              super.tap do |doc|
+                model.remove_documents_from_map(doc) if query.fields?
+              end
             end
           end
         end
 
-        def find_many(options)
-          criteria, query_options = to_query(options)
-          super.tap do |documents|
-            remove_documents_from_map(documents) if selecting_fields?(query_options)
+        def query(opts={})
+          super.extend(IdentityMapQueryMethods)
+        end
+
+        def remove_documents_from_map(*documents)
+          documents.flatten.compact.each do |document|
+            identity_map.delete(document['_id'])
           end
         end
 
         def load(attrs)
+          return nil if attrs.nil?
           document = identity_map[attrs['_id']]
-          
+
           if document.nil? || identity_map_off?
             document = super
             identity_map[document._id] = document if identity_map_on?
@@ -85,16 +101,6 @@ module MongoMapper
         end
 
         private
-          def remove_documents_from_map(*documents)
-            documents.flatten.compact.each do |document|
-              identity_map.delete(document._id)
-            end
-          end
-
-          def simple_find?(criteria)
-            criteria.keys == [:_id] || criteria.keys.to_set == [:_id, :_type].to_set
-          end
-
           def selecting_fields?(options)
             !options[:fields].nil?
           end

data/lib/mongo_mapper/plugins/indexes.rb

@@ -0,0 +1,12 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Indexes
+      module ClassMethods
+        def ensure_index(spec, options={})
+          collection.create_index(spec, options)
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/inspect.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Inspect

data/lib/mongo_mapper/plugins/keys/key.rb

@@ -0,0 +1,55 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Keys
+      class Key
+        attr_accessor :name, :type, :options, :default_value
+
+        def initialize(*args)
+          options = args.extract_options!
+          @name, @type = args.shift.to_s, args.shift
+          self.options = (options || {}).symbolize_keys
+          self.default_value = self.options[:default]
+        end
+
+        def ==(other)
+          @name == other.name && @type == other.type
+        end
+
+        def embeddable?
+          return false unless type.respond_to?(:embeddable?)
+          type.embeddable?
+        end
+
+        def number?
+          [Integer, Float].include?(type)
+        end
+
+        def get(value)
+          if value.nil? && !default_value.nil?
+            if default_value.respond_to?(:call)
+              return default_value.call
+            else
+              return default_value
+            end
+          end
+
+          type.from_mongo(value)
+        end
+
+        def set(value)
+          type.to_mongo(value).tap do |values|
+            if options[:typecast].present?
+              values.map! { |v| typecast_class.to_mongo(v) }
+            end
+          end
+        end
+        
+        private
+          def typecast_class
+            @typecast_class ||= options[:typecast].constantize
+          end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/keys.rb

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+require 'mongo_mapper/plugins/keys/key'
+
 module MongoMapper
   module Plugins
     module Keys
@@ -16,24 +19,29 @@ module MongoMapper
         end
 
         def key(*args)
-          key = Key.new(*args)
-          keys[key.name] = key
-
-          create_accessors_for(key)
-          create_key_in_descendants(*args)
-          create_indexes_for(key)
-          create_validations_for(key)
+          Key.new(*args).tap do |key|
+            keys[key.name] = key
+            create_accessors_for(key)
+            create_key_in_descendants(*args)
+            create_indexes_for(key)
+            create_validations_for(key)
+          end
+        end
 
-          key
+        def key?(key)
+          keys.keys.include?(key.to_s)
         end
 
         def using_object_id?
           object_id_key?(:_id)
         end
 
+        def object_id_keys
+          keys.keys.select { |key| keys[key].type == ObjectId }.map(&:to_sym)
+        end
+
         def object_id_key?(name)
-          key = keys[name.to_s]
-          key && key.type == ObjectId
+          object_id_keys.include?(name.to_sym)
         end
 
         def to_mongo(instance)
@@ -48,6 +56,7 @@ module MongoMapper
 
         # load is overridden in identity map to ensure same objects are loaded
         def load(attrs)
+          return nil if attrs.nil?
           begin
             klass = attrs['_type'].present? ? attrs['_type'].constantize : self
             klass.new(attrs, true)
@@ -57,14 +66,16 @@ module MongoMapper
         end
 
         private
-          def accessors_module
-            module_defined =  if method(:const_defined?).arity == 1 # Ruby 1.9 compat check
-                                const_defined?('MongoMapperKeys')
-                              else
-                                const_defined?('MongoMapperKeys', false)
-                              end
+          def key_accessors_module_defined?
+            if method(:const_defined?).arity == 1 # Ruby 1.9 compat check
+              const_defined?('MongoMapperKeys')
+            else
+              const_defined?('MongoMapperKeys', false)
+            end
+          end
 
-            if module_defined
+          def accessors_module
+            if key_accessors_module_defined?
               const_get 'MongoMapperKeys'
             else
               const_set 'MongoMapperKeys', Module.new
@@ -94,7 +105,6 @@ module MongoMapper
           end
 
           def create_key_in_descendants(*args)
-            return if descendants.blank?
             descendants.each { |descendant| descendant.key(*args) }
           end
 
@@ -146,60 +156,50 @@ module MongoMapper
 
       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
+          default_id_value(attrs)
 
           if from_database
-            @new = false
-            self.attributes = attrs
+            @_new = false
+            load_from_database(attrs)
           else
-            @new = true
+            @_new = true
             assign(attrs)
           end
         end
 
-        def new?
-          @new
+        def persisted?
+          !new? && !destroyed?
         end
 
         def attributes=(attrs)
           return if attrs.blank?
 
-          attrs.each_pair do |name, value|
-            writer_method = "#{name}="
-
-            if respond_to?(writer_method)
-              if writer_method == '_root_document='
-                puts "_root_document= #{value.inspect}"
-              end
-              self.send(writer_method, value)
+          attrs.each_pair do |key, value|
+            if respond_to?(:"#{key}=")
+              self.send(:"#{key}=", value)
             else
-              self[name.to_s] = value
+              self[key] = value
             end
           end
         end
 
         def attributes
-          attrs = HashWithIndifferentAccess.new
-
-          keys.each_pair do |name, key|
-            value = key.set(self[key.name])
-            attrs[name] = value
-          end
+          HashWithIndifferentAccess.new.tap do |attrs|
+            keys.each_pair do |name, key|
+              value = key.set(self[key.name])
+              attrs[name] = value
+            end
 
-          embedded_associations.each do |association|
-            if documents = instance_variable_get(association.ivar)
-              attrs[association.name] = documents.map { |document| document.to_mongo }
+            embedded_associations.each do |association|
+              if documents = instance_variable_get(association.ivar)
+                if association.one?
+                  attrs[association.name] = documents.to_mongo
+                else
+                  attrs[association.name] = documents.map { |document| document.to_mongo }
+                end
+              end
             end
           end
-
-          attrs
         end
         alias :to_mongo :attributes
 
@@ -223,7 +223,7 @@ module MongoMapper
 
         def id=(value)
           if self.class.using_object_id?
-            value = MongoMapper.normalize_object_id(value)
+            value = ObjectId.to_mongo(value)
           end
 
           self[:_id] = value
@@ -238,98 +238,73 @@ module MongoMapper
           write_key(name, value)
         end
 
-        # @api public
         def keys
           self.class.keys
         end
 
-        # @api private?
         def key_names
           keys.keys
         end
 
-        # @api private?
         def non_embedded_keys
           keys.values.select { |key| !key.embeddable? }
         end
 
-        # @api private?
         def embedded_keys
           keys.values.select { |key| key.embeddable? }
         end
 
         private
-          def assign_type_if_present
-            self._type = self.class.name if respond_to?(:_type=)
-          end
-
-          def ensure_key_exists(name)
-            self.class.key(name) unless respond_to?("#{name}=")
+          def load_from_database(attrs)
+            return if attrs.blank?
+            attrs.each do |key, value|
+              if respond_to?(:"#{key}=") && !self.class.key?(key)
+                self.send(:"#{key}=", value)
+              else
+                self[key] = value
+              end
+            end
           end
 
-          def read_key(name)
-            if key = keys[name]
-              var_name = "@#{name}"
-              value = key.get(instance_variable_get(var_name))
-              instance_variable_set(var_name, value)
-            else
-              raise KeyNotFound, "Could not find key: #{name.inspect}"
+          def default_id_value(attrs)
+            unless attrs.nil?
+              provided_keys = attrs.keys.map { |k| k.to_s }
+              unless provided_keys.include?('_id') || provided_keys.include?('id')
+                write_key :_id, BSON::ObjectID.new
+              end
             end
           end
 
-          def read_key_before_typecast(name)
-            instance_variable_get("@#{name}_before_typecast")
+          def ensure_key_exists(name)
+            self.class.key(name) unless respond_to?("#{name}=")
           end
 
-          def write_key(name, value)
-            key = keys[name]
-
+          def set_parent_document(key, value)
             if key.embeddable? && value.is_a?(key.type)
               value._parent_document = self
             end
-
-            instance_variable_set "@#{name}_before_typecast", value
-            instance_variable_set "@#{name}", key.set(value)
           end
-      end
-
-      class Key
-        attr_accessor :name, :type, :options, :default_value
-
-        def initialize(*args)
-          options = args.extract_options!
-          @name, @type = args.shift.to_s, args.shift
-          self.options = (options || {}).symbolize_keys
-          self.default_value = self.options.delete(:default)
-        end
 
-        def ==(other)
-          @name == other.name && @type == other.type
-        end
-
-        def embeddable?
-          type.respond_to?(:embeddable?) && type.embeddable? ? true : false
-        end
-
-        def number?
-          [Integer, Float].include?(type)
-        end
-
-        def get(value)
-          if value.nil? && !default_value.nil?
-            if default_value.respond_to?(:call)
-              return default_value.call
+          def read_key(key_name)
+            if key = keys[key_name]
+              value = key.get(instance_variable_get(:"@#{key_name}"))
+              set_parent_document(key, value)
+              instance_variable_set(:"@#{key_name}", value)
             else
-              return default_value
+              raise KeyNotFound, "Could not find key: #{key_name.inspect}"
             end
           end
 
-          type.from_mongo(value)
-        end
+          def read_key_before_typecast(name)
+            instance_variable_get(:"@#{name}_before_typecast")
+          end
 
-        def set(value)
-          type.to_mongo(value)
-        end
+          def write_key(name, value)
+            key = keys[name.to_s]
+            set_parent_document(key, value)
+            instance_variable_set :"@#{name}_before_typecast", value
+            instance_variable_set :"@#{name}", key.set(value)
+          end
       end
     end
   end

data/lib/mongo_mapper/plugins/logger.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Logger