mongo_mapper 0.12.0 → 0.13.0.beta1

data/lib/mongo_mapper/plugins/identity_map.rb

@@ -57,37 +57,10 @@ module MongoMapper
           IdentityMap.repository[IdentityMap.key(self, id)]
         end
 
-        module IdentityMapQueryMethods
-          def all(opts={})
-            query = clone.amend(opts)
-            super.tap do |docs|
-              model.remove_documents_from_map(docs) if query.fields?
-            end
-          end
-
-          def find_one(opts={})
-            query = clone.amend(opts)
-
-            if IdentityMap.enabled? && query.simple? && (document = model.get_from_identity_map(query[:_id]))
-              document
-            else
-              super.tap do |doc|
-                model.remove_documents_from_map(doc) if query.fields?
-              end
-            end
-          end
-
-          def find_each(opts={}, &block)
-            query = clone.amend(opts)
-            super(opts) do |doc|
-              model.remove_documents_from_map(doc) if query.fields?
-              block.call(doc) unless block.nil?
-            end
-          end
-        end
-
         def query(opts={})
-          super.extend(IdentityMapQueryMethods)
+          super.tap do |query|
+            query.identity_map = self if Thread.current[:mongo_mapper_identity_map_enabled]
+          end
         end
 
         def remove_documents_from_map(*documents)
@@ -97,10 +70,11 @@ module MongoMapper
         end
 
         def load(attrs)
-          return nil if attrs.nil?
+          return super unless Thread.current[:mongo_mapper_identity_map_enabled]
+          return nil unless attrs
           document = get_from_identity_map(attrs['_id'])
 
-          if document.nil?
+          if !document
             document = super
             document.add_to_identity_map
           end
@@ -133,3 +107,39 @@ module MongoMapper
     end
   end
 end
+
+module PluckyMethods
+  module ClassMethods
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor :identity_map
+
+      # Ensure that these aliased methods in plucky also get overridden.
+      alias_method :first, :find_one
+      alias_method :each, :find_each
+    end
+
+    def find_one(opts={})
+      query = clone.amend(opts)
+
+      if identity_map && query.simple? && (document = identity_map.get_from_identity_map(query[:_id]))
+        document
+      else
+        super.tap do |doc|
+          doc.remove_from_identity_map if doc && query.fields?
+        end
+      end
+    end
+
+    def find_each(opts={})
+      query = clone.amend(opts)
+      super(opts) do |doc|
+        doc.remove_from_identity_map if doc && query.fields?
+        yield doc if block_given?
+      end
+    end
+  end
+end
+
+::MongoMapper::Plugins::Querying::DecoratedPluckyQuery.send :include, ::PluckyMethods::ClassMethods

data/lib/mongo_mapper/plugins/keys.rb

@@ -6,6 +6,8 @@ module MongoMapper
     module Keys
       extend ActiveSupport::Concern
 
+      IS_RUBY_1_9 = method(:const_defined?).arity == 1
+
       included do
         extend ActiveSupport::DescendantsTracker
         key :_id, ObjectId, :default => lambda { BSON::ObjectId.new }
@@ -21,18 +23,37 @@ module MongoMapper
           @keys ||= {}
         end
 
+        def dynamic_keys
+          @dynamic_keys ||= Hash[*unaliased_keys.select {|k, v| v.dynamic? }.flatten(1)]
+        end
+
+        def defined_keys
+          @defined_keys ||= Hash[*unaliased_keys.select {|k, v| !v.dynamic? }.flatten(1)]
+        end
+
+        def unaliased_keys
+          @unaliased_keys ||= Hash[*keys.select {|k, v| k == v.name }.flatten(1)]
+        end
+
         def key(*args)
           Key.new(*args).tap do |key|
             keys[key.name] = key
-            create_accessors_for(key)
+            keys[key.abbr] = key if key.abbr
+            create_accessors_for(key) if key.valid_ruby_name?
             create_key_in_descendants(*args)
             create_indexes_for(key)
             create_validations_for(key)
+            @dynamic_keys = @defined_keys = @unaliased_keys = @object_id_keys = nil
           end
         end
 
+        def persisted_name(name)
+          keys[name.to_s].persisted_name
+        end
+        alias_method :abbr, :persisted_name
+
         def key?(key)
-          keys.keys.include?(key.to_s)
+          keys.key? key.to_s
         end
 
         def using_object_id?
@@ -40,7 +61,7 @@ module MongoMapper
         end
 
         def object_id_keys
-          keys.keys.select { |key| keys[key].type == ObjectId }.map { |k| k.to_sym }
+          @object_id_keys ||= unaliased_keys.keys.select { |key| keys[key].type == ObjectId }.map(&:to_sym)
         end
 
         def object_id_key?(name)
@@ -48,20 +69,18 @@ module MongoMapper
         end
 
         def to_mongo(instance)
-          return nil if instance.nil?
-          instance.to_mongo
+          instance && instance.to_mongo
         end
 
         def from_mongo(value)
-          return nil if value.nil?
-          value.is_a?(self) ? value : load(value)
+          value && (value.instance_of?(self) ? value : load(value))
         end
 
         # load is overridden in identity map to ensure same objects are loaded
         def load(attrs)
           return nil if attrs.nil?
           begin
-            attrs['_type'].present? ? attrs['_type'].constantize : self
+            attrs['_type'] ? attrs['_type'].constantize : self
           rescue NameError
             self
           end.allocate.initialize_from_database(attrs)
@@ -69,11 +88,13 @@ module MongoMapper
 
         private
           def key_accessors_module_defined?
-            if method(:const_defined?).arity == 1 # Ruby 1.9 compat check
+            # :nocov:
+            if IS_RUBY_1_9
               const_defined?('MongoMapperKeys')
             else
               const_defined?('MongoMapperKeys', false)
             end
+            # :nocov:
           end
 
           def accessors_module
@@ -90,10 +111,6 @@ module MongoMapper
                 read_key(:#{key.name})
               end
 
-              def #{key.name}_before_type_cast
-                read_key_before_type_cast(:#{key.name})
-              end
-
               def #{key.name}=(value)
                 write_key(:#{key.name}, value)
               end
@@ -103,6 +120,12 @@ module MongoMapper
               end
             end_eval
 
+            if block_given?
+              accessors_module.module_eval do
+                yield
+              end
+            end
+
             include accessors_module
           end
 
@@ -165,11 +188,16 @@ module MongoMapper
 
       def initialize(attrs={})
         @_new = true
+        init_ivars
+        initialize_default_values(attrs)
         self.attributes = attrs
+        yield self if block_given?
       end
 
       def initialize_from_database(attrs={})
         @_new = false
+        init_ivars
+        initialize_default_values(attrs)
         load_from_database(attrs)
         self
       end
@@ -179,7 +207,7 @@ module MongoMapper
       end
 
       def attributes=(attrs)
-        return if attrs.blank?
+        return if attrs == nil || attrs.blank?
 
         attrs.each_pair do |key, value|
           if respond_to?(:"#{key}=")
@@ -190,25 +218,30 @@ module MongoMapper
         end
       end
 
-      def attributes
-        HashWithIndifferentAccess.new.tap do |attrs|
-          keys.select { |name,key| !self[key.name].nil? || key.type == ObjectId }.each do |name, key|
-            value = key.set(self[key.name])
-            attrs[name] = value
+      def to_mongo(include_abbreviatons = true)
+        BSON::OrderedHash.new.tap do |attrs|
+          self.class.unaliased_keys.each do |name, key|
+            value = self.read_key(key.name)
+            if key.type == ObjectId || !value.nil?
+              attrs[include_abbreviatons && key.persisted_name || name] = key.set(value)
+            end
           end
 
           embedded_associations.each do |association|
             if documents = instance_variable_get(association.ivar)
-              if association.is_a?(Associations::OneAssociation)
+              if association.instance_of?(Associations::OneAssociation)
                 attrs[association.name] = documents.to_mongo
               else
-                attrs[association.name] = documents.map { |document| document.to_mongo }
+                attrs[association.name] = documents.map(&:to_mongo)
               end
             end
           end
         end
       end
-      alias :to_mongo :attributes
+
+      def attributes
+        to_mongo(false).with_indifferent_access
+      end
 
       def assign(attrs={})
         warn "[DEPRECATION] #assign is deprecated, use #attributes="
@@ -231,7 +264,7 @@ module MongoMapper
       end
 
       def id
-        _id
+        self[:_id]
       end
 
       def id=(value)
@@ -242,72 +275,118 @@ module MongoMapper
         self[:_id] = value
       end
 
-      def [](name)
-        read_key(name)
+      def keys
+        self.class.keys
       end
 
-      def []=(name, value)
-        ensure_key_exists(name)
-        write_key(name, value)
+      def read_key(key_name)
+        key_name_sym = key_name.to_sym
+        if @_dynamic_attributes && @_dynamic_attributes.key?(key_name_sym)
+          @_dynamic_attributes[key_name_sym]
+        elsif key = keys[key_name.to_s]
+          if key.ivar && instance_variable_defined?(key.ivar)
+            value = instance_variable_get(key.ivar)
+          else
+            if key.ivar
+              instance_variable_set key.ivar, key.get(nil)
+            else
+              @_dynamic_attributes[key_name_sym] = key.get(nil)
+            end
+          end
+        end
       end
 
-      def keys
-        self.class.keys
+      alias_method :[], :read_key
+      alias_method :attribute, :read_key
+
+      def []=(name, value)
+        write_key(name, value)
       end
 
       def key_names
-        keys.keys
+        @key_names ||= keys.keys
       end
 
       def non_embedded_keys
-        keys.values.select { |key| !key.embeddable? }
+        @non_embedded_keys ||= keys.values.select { |key| !key.embeddable? }
       end
 
       def embedded_keys
-        keys.values.select { |key| key.embeddable? }
+        @embedded_keys ||= keys.values.select(&:embeddable?)
+      end
+
+      protected
+
+      def unalias_key(name)
+        name = name.to_s
+        if key = keys[name]
+          key.name
+        else
+          name
+        end
       end
 
       private
+
+        def init_ivars
+          @__mm_keys = self.class.keys                                # Not dumpable
+          @__mm_default_keys = @__mm_keys.values.select(&:default?)   # Not dumpable
+          @_dynamic_attributes = {}                                      # Dumpable
+        end
+
         def load_from_database(attrs)
-          return if attrs.blank?
+          return if attrs == nil || attrs.blank?
+
           attrs.each do |key, value|
-            if respond_to?(:"#{key}=") && !self.class.key?(key)
+            if !@__mm_keys.key?(key) && respond_to?(:"#{key}=")
               self.send(:"#{key}=", value)
             else
-              self[key] = value
+              internal_write_key key, value, false
             end
           end
         end
 
-        def ensure_key_exists(name)
-          self.class.key(name) unless respond_to?("#{name}=")
-        end
-
         def set_parent_document(key, value)
-          if key.embeddable? && value.is_a?(key.type)
+          if key.type and value.instance_of?(key.type) && key.embeddable? && value.respond_to?(:_parent_document)
             value._parent_document = self
           end
         end
 
-        def read_key(key_name)
-          if key = keys[key_name.to_s]
-            value = key.get(instance_variable_get(:"@#{key_name}"))
-            set_parent_document(key, value)
-            instance_variable_set(:"@#{key_name}", value)
+        # This exists to be patched over by plugins, while letting us still get to the undecorated
+        # version of the method.
+        def write_key(name, value)
+          init_ivars unless @__mm_keys
+          internal_write_key(name.to_s, value)
+        end
+
+        def internal_write_key(name, value, cast = true)
+          key         = @__mm_keys[name] || dynamic_key(name)
+          as_mongo    = cast ? key.set(value) : value
+          as_typecast = key.get(as_mongo)
+          if key.ivar
+            if key.embeddable?
+              set_parent_document(key, value)
+              set_parent_document(key, as_typecast)
+            end
+            instance_variable_set key.ivar, as_typecast
+          else
+            @_dynamic_attributes[key.name.to_sym] = as_typecast
           end
+          @attributes = nil
         end
 
-        def read_key_before_type_cast(name)
-          instance_variable_get(:"@#{name}_before_type_cast")
+        def dynamic_key(name)
+          self.class.key(name, :__dynamic => true)
         end
 
-        def write_key(name, value)
-          key = keys[name.to_s]
-          set_parent_document(key, value)
-          instance_variable_set :"@#{name}_before_type_cast", value
-          instance_variable_set :"@#{name}", key.set(value)
+        def initialize_default_values(except = {})
+          @__mm_default_keys.each do |key|
+            if !(except && except.key?(key.name))
+              internal_write_key key.name, key.default_value, false
+            end
+          end
         end
+      #end private
     end
   end
 end
-

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

@@ -3,58 +3,104 @@ module MongoMapper
   module Plugins
     module Keys
       class Key
-        attr_accessor :name, :type, :options, :default_value
+        attr_accessor :name, :type, :options, :default, :ivar, :abbr
+
+        ID_STR = '_id'
 
         def initialize(*args)
-          options = args.extract_options!
+          options_from_args = args.extract_options!
           @name, @type = args.shift.to_s, args.shift
-          self.options = (options || {}).symbolize_keys
-          self.default_value = self.options[:default]
+          self.options = (options_from_args || {}).symbolize_keys
+          @dynamic     = !!options[:__dynamic]
+          @embeddable  = type.respond_to?(:embeddable?) ? type.embeddable? : false
+          @is_id       = @name == ID_STR
+          @typecast    = @options[:typecast]
+          @has_default  = !!options.key?(:default)
+          self.default = self.options[:default] if default?
+
+          if abbr = @options[:abbr] || @options[:alias] || @options[:field_name]
+            @abbr = abbr.to_s
+          elsif @name.match(/^[A-Z]/) and !dynamic?
+            @abbr = @name
+            @name = @name.gsub(/^([A-Z])/) {|m| m.downcase }
+            Kernel.warn "Key names may not start with uppercase letters. If your field starts " +
+                 "with an uppercase letter, use :field_name to specify the real field name. " +
+                 "Accessors called `#{@name}` have been created instead."
+          end
+          @ivar = :"@#{name}" if valid_ruby_name?
+          validate_key_name! unless dynamic?
+        end
+
+        def persisted_name
+          @abbr || @name
         end
 
         def ==(other)
-          @name == other.name && @type == other.type
+          @name == other.name && @type == other.type && @abbr == other.abbr
         end
 
         def embeddable?
-          return false unless type.respond_to?(:embeddable?)
-          type.embeddable?
+          @embeddable
         end
 
         def number?
           type == Integer || type == Float
         end
 
+        def default?
+          @has_default
+        end
+
+        def dynamic?
+          @dynamic
+        end
+
         def get(value)
-          if value.nil? && !default_value.nil?
-            if default_value.respond_to?(:call)
-              return default_value.call
-            else
-              # Using Marshal is easiest way to get a copy of mutable objects
-              # without getting an error on immutable objects
-              return Marshal.load(Marshal.dump(default_value))
-            end
-          end
+          # Special Case: Generate default _id on access
+          value = default_value if @is_id and !value
 
-          if options[:typecast].present?
-            type.from_mongo(value).map! { |v| typecast_class.from_mongo(v) }
+          if @typecast
+            klass = typecast_class  # Don't make this lookup on every call
+            type.from_mongo(value).map! { |v| klass.from_mongo(v) }
           else
             type.from_mongo(value)
           end
         end
 
         def set(value)
-          type.to_mongo(value).tap do |values|
-            if options[:typecast].present?
-              values.map! { |v| typecast_class.to_mongo(v) }
-            end
+          # Avoid tap here so we don't have to create a block binding.
+          values = type.to_mongo(value)
+          values.map! { |v| typecast_class.to_mongo(v) } if @typecast
+          values
+        end
+
+        def default_value
+          return unless default?
+          if default.instance_of? Proc
+            type.to_mongo default.call
+          else
+            # Using Marshal is easiest way to get a copy of mutable objects
+            # without getting an error on immutable objects
+            type.to_mongo Marshal.load(Marshal.dump(default))
           end
         end
 
+        def valid_ruby_name?
+          !!@name.match(/\A[a-z_][a-z0-9_]*\z/i)
+        end
+
         private
           def typecast_class
             @typecast_class ||= options[:typecast].constantize
           end
+
+          def validate_key_name!
+            if %w( id ).include? @name
+              raise MongoMapper::InvalidKey.new("`#{@name}` is a reserved key name (did you mean to use _id?)")
+            elsif !valid_ruby_name?
+              raise MongoMapper::InvalidKey.new("`#{@name}` is not a valid key name. Keys must match [a-z][a-z0-9_]*")
+            end
+          end
       end
     end
   end