djsun-mongomapper 0.3.1.1 → 0.3.3

data/lib/mongomapper/embedded_document.rb

@@ -1,36 +1,36 @@
 require 'observer'
 
 module MongoMapper
-  module EmbeddedDocument    
+  module EmbeddedDocument
     def self.included(model)
       model.class_eval do
         extend ClassMethods
         include InstanceMethods
-        
+
         extend Associations::ClassMethods
         include Associations::InstanceMethods
-        
+
         include RailsCompatibility::EmbeddedDocument
         include Validatable
         include Serialization
         
-        key :_id, MongoID
+        key :_id, String
       end
     end
-    
+
     module ClassMethods
       def inherited(subclass)
         unless subclass.embeddable?
           subclass.collection(self.collection.name)
         end
-        
+
         (@subclasses ||= []) << subclass
       end
-      
+
       def subclasses
         @subclasses
       end
-      
+
       def keys
         @keys ||= if parent = parent_model
           parent.keys.dup
@@ -38,90 +38,104 @@ module MongoMapper
           HashWithIndifferentAccess.new
         end
       end
-      
-      def key(name, type, options={})        
-        key = Key.new(name, type, options)
-        keys[key.name] = key
-        
-        create_accessors_for(key)
-        add_to_subclasses(name, type, options)
-        apply_validations_for(key)
-        create_indexes_for(key)
-        
-        key
-      end
-      
-      def create_accessors_for(key)
-        define_method(key.name) do
-          read_attribute(key.name)
-        end
-        
-        define_method("#{key.name}_before_typecast") do
-          read_attribute_before_typecast(key.name)
-        end
-        
-        define_method("#{key.name}=") do |value|
-          write_attribute(key.name, value)
-        end
+
+      def key(*args)
+        key = Key.new(*args)
         
-        define_method("#{key.name}?") do
-          read_attribute(key.name).present?
+        if keys[key.name].blank?
+          keys[key.name] = key
+          
+          create_accessors_for(key)
+          add_to_subclasses(*args)
+          apply_validations_for(key)
+          create_indexes_for(key)
+          
+          key
         end
       end
-      
-      def add_to_subclasses(name, type, options)
+
+      def add_to_subclasses(*args)
         return if subclasses.blank?
-        
+
         subclasses.each do |subclass|
-          subclass.key name, type, options
+          subclass.key(*args)
         end
       end
-      
+
       def ensure_index(name_or_array, options={})
         keys_to_index = if name_or_array.is_a?(Array)
           name_or_array.map { |pair| [pair[0], pair[1]] }
         else
           name_or_array
         end
-        
+
         collection.create_index(keys_to_index, options.delete(:unique))
       end
-      
+
       def embeddable?
         !self.ancestors.include?(Document)
       end
-      
+
       def parent_model
-        if parent = ancestors[1]
-          parent if parent.ancestors.include?(EmbeddedDocument)
+        (ancestors - [self,EmbeddedDocument]).find do |parent_class|
+          parent_class.ancestors.include?(EmbeddedDocument)
         end
       end
-      
+
     private
+      def accessors_module
+        if const_defined?('MongoMapperKeys') && constants.include?( 'MongoMapperKeys' )
+          const_get 'MongoMapperKeys'
+        else 
+          const_set 'MongoMapperKeys', Module.new
+        end
+      end
+
+      def create_accessors_for(key)
+        accessors_module.module_eval <<-end_eval
+          def #{key.name}
+            read_attribute( :'#{key.name}' )
+          end
+
+          def #{key.name}_before_typecast
+            read_attribute_before_typecast(:'#{key.name}')
+          end
+
+          def #{key.name}=(value)
+            write_attribute(:'#{key.name}', value)
+          end
+
+          def #{key.name}?
+            read_attribute(:#{key.name}).present?
+          end
+        end_eval
+        include accessors_module
+      end
+      
       def create_indexes_for(key)
         ensure_index key.name if key.options[:index]
       end
-      
+
       def apply_validations_for(key)
         attribute = key.name.to_sym
-        
+
         if key.options[:required]
           validates_presence_of(attribute)
         end
-        
+
         if key.options[:unique]
           validates_uniqueness_of(attribute)
         end
-        
+
         if key.options[:numeric]
           number_options = key.type == Integer ? {:only_integer => true} : {}
           validates_numericality_of(attribute, number_options)
         end
-        
+
         if key.options[:format]
           validates_format_of(attribute, :with => key.options[:format])
         end
-        
+
         if key.options[:length]
           length_options = case key.options[:length]
           when Integer
@@ -135,7 +149,7 @@ module MongoMapper
         end
       end
     end
-    
+
     module InstanceMethods
       def initialize(attrs={})
         unless attrs.nil?
@@ -144,90 +158,104 @@ module MongoMapper
               send("#{association.name}=", collection)
             end
           end
-          
+
           self.attributes = attrs
         end
-        
+
         if self.class.embeddable? && read_attribute(:_id).blank?
-          write_attribute :_id, XGen::Mongo::Driver::ObjectID.new
+          write_attribute :_id, XGen::Mongo::Driver::ObjectID.new.to_s
         end
       end
-      
+
       def attributes=(attrs)
         return if attrs.blank?
-        attrs.each_pair do |method, value|
-          self.send("#{method}=", value)
+        attrs.each_pair do |name, value|
+          writer_method = "#{name}="
+          
+          if respond_to?(writer_method)
+            self.send(writer_method, value)
+          else
+            self[name.to_s] = value
+          end
         end
       end
-      
+
       def attributes
-        returning HashWithIndifferentAccess.new do |attributes|
-          self.class.keys.each_pair do |name, key|
-            value = value_for_key(key)
-            attributes[name] = value unless value.nil?
-          end
+        attrs = HashWithIndifferentAccess.new
+        self.class.keys.each_pair do |name, key|
+          value = 
+            if key.native?
+              read_attribute(key.name)
+            else
+              if embedded_document = read_attribute(key.name)
+                embedded_document.attributes
+              end
+            end
           
-          attributes.merge!(embedded_association_attributes)
+          attrs[name] = value unless value.nil?
         end
+        attrs.merge!(embedded_association_attributes)
       end
-      
+
       def [](name)
         read_attribute(name)
       end
-      
+
       def []=(name, value)
+        ensure_key_exists(name)
         write_attribute(name, value)
       end
-      
+
       def ==(other)
         other.is_a?(self.class) && id == other.id
       end
-      
+
       def id
-        self._id.to_s
+        read_attribute(:_id)
       end
-      
+
       def id=(value)
-        self._id = value
+        @using_custom_id = true
+        write_attribute :_id, value
       end
       
+      def using_custom_id?
+        !!@using_custom_id
+      end
+
       def inspect
         attributes_as_nice_string = self.class.keys.keys.collect do |name|
           "#{name}: #{read_attribute(name)}"
         end.join(", ")
         "#<#{self.class} #{attributes_as_nice_string}>"
       end
-      
+
       private
-        def value_for_key(key)
-          if key.native?
-            read_attribute(key.name)
-          else
-            embedded_document = read_attribute(key.name)
-            embedded_document && embedded_document.attributes
-          end
+        def ensure_key_exists(name)
+          self.class.key(name) unless respond_to?("#{name}=")
         end
-      
+
         def read_attribute(name)
-          val = self.class.keys[name].get(instance_variable_get("@#{name}"))
-          instance_variable_set "@#{name}", val
+          value = self.class.keys[name].get(instance_variable_get("@#{name}"))
+          instance_variable_set "@#{name}", value if !frozen?
+          value
         end
-      
+
         def read_attribute_before_typecast(name)
           instance_variable_get("@#{name}_before_typecast")
         end
-      
+
         def write_attribute(name, value)
           instance_variable_set "@#{name}_before_typecast", value
           instance_variable_set "@#{name}", self.class.keys[name].set(value)
         end
-      
+
         def embedded_association_attributes
           returning HashWithIndifferentAccess.new do |attrs|
             self.class.associations.each_pair do |name, association|
               next unless association.embeddable?
               next unless documents = instance_variable_get(association.ivar)
-            
+
               attrs[name] = documents.collect { |doc| doc.attributes }
             end
           end

data/lib/mongomapper/finder_options.rb

@@ -7,26 +7,15 @@ module MongoMapper
       conditions.each_pair do |field, value|
         case value
           when Array
-            operator_present = field.to_s =~ /^\$/
-            
-            dealing_with_ids =  field.to_s == '_id' || 
-                                (parent_key && parent_key.to_s == '_id')
-            
-            criteria[field] = if dealing_with_ids
-                                ids = value.map { |id| MongoID.mm_typecast(id) }
-                                operator_present ? ids : {'$in' => ids}
-                              elsif operator_present
+            operator_present = field.to_s =~ /^\$/            
+            criteria[field] = if operator_present
                                 value
                               else
                                 {'$in' => value}
                               end
           when Hash
             criteria[field] = to_mongo_criteria(value, field)
-          else
-            if field.to_s == '_id'
-              value = MongoID.mm_typecast(value)
-            end
-            
+          else            
             criteria[field] = value
         end
       end

data/lib/mongomapper/key.rb

@@ -1,12 +1,13 @@
 module MongoMapper
   class Key
     # DateTime and Date are currently not supported by mongo's bson so just use Time
-    NativeTypes = [String, Float, Time, Integer, Boolean, Array, Hash, MongoID]
+    NativeTypes = [String, Float, Time, Integer, Boolean, Array, Hash]
 
     attr_accessor :name, :type, :options, :default_value
-
-    def initialize(name, type, options={})
-      @name, @type = name.to_s, type
+    
+    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
@@ -20,11 +21,11 @@ module MongoMapper
     end
 
     def native?
-      @native ||= NativeTypes.include?(type)
+      @native ||= NativeTypes.include?(type) || type.nil?
     end
 
     def embedded_document?
-      type.ancestors.include?(EmbeddedDocument) && !type.ancestors.include?(Document)
+      type.respond_to?(:embeddable?) && type.embeddable?
     end
 
     def get(value)
@@ -40,26 +41,21 @@ module MongoMapper
 
     private
       def typecast(value)
+        return value if type.nil?
         return HashWithIndifferentAccess.new(value) if value.is_a?(Hash) && type == Hash
+        return value.utc if type == Time && value.kind_of?(type)
         return value if value.kind_of?(type) || value.nil?
         begin
           if    type == String    then value.to_s
           elsif type == Float     then value.to_f
           elsif type == Array     then value.to_a
-          elsif type == Time      then Time.parse(value.to_s)
-          elsif type == MongoID   then MongoID.mm_typecast(value)
-          #elsif type == Date      then Date.parse(value.to_s)
+          elsif type == Time      then Time.parse(value.to_s).utc
           elsif type == Boolean   then Boolean.mm_typecast(value)
           elsif type == Integer
             # ganked from datamapper
             value_to_i = value.to_i
-            if value_to_i == 0 && value != '0'
-              value_to_s = value.to_s
-              begin
-                Integer(value_to_s =~ /^(\d+)/ ? $1 : value_to_s)
-              rescue ArgumentError
-                nil
-              end
+            if value_to_i == 0
+              value.to_s =~ /^(0x|0b)?0+/ ? 0 : nil
             else
               value_to_i
             end

data/lib/mongomapper/serializers/json_serializer.rb

@@ -50,18 +50,8 @@ module MongoMapper #:nodoc:
     #         "created_at": "2006/08/01", "awesome": true,
     #         "permalink": "1-konata-izumi"}
     def to_json(options = {})
-      unless options[:only]
-        o = options[:methods]
-        if o && o.is_a?(Array)
-          o << :id
-        elsif o
-          o = [o, :id]
-        else
-          o = :id
-        end
-        options[:methods] = o
-      end
-      options.reverse_merge!(:except => :_id)
+      apply_to_json_defaults(options)
+      
       if include_root_in_json
         "{#{self.class.json_class_name}: #{JsonSerializer.new(self, options).to_s}}"
       else
@@ -85,5 +75,18 @@ module MongoMapper #:nodoc:
         @json_class_name ||= name.demodulize.underscore.inspect
       end
     end
+    
+    private
+      def apply_to_json_defaults(options)
+        unless options[:only]
+          methods = [options.delete(:methods)].flatten.compact
+          methods << :id
+          options[:methods] = methods.uniq
+        end
+
+        except = [options.delete(:except)].flatten.compact
+        except << :_id
+        options[:except] = except
+      end
   end
 end

data/lib/mongomapper/support.rb

@@ -0,0 +1,30 @@
+class BasicObject #:nodoc:
+  instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|instance_eval|proxy_|^object_id$)/ }
+end unless defined?(BasicObject)
+
+class Boolean
+  def self.mm_typecast(value)
+    ['true', 't', '1'].include?(value.to_s.downcase)
+  end
+end
+
+class Object
+  # The hidden singleton lurks behind everyone
+  def metaclass
+    class << self; self end
+  end
+
+  def meta_eval(&blk)
+    metaclass.instance_eval(&blk)
+  end
+
+  # Adds methods to a metaclass
+  def meta_def(name, &blk)
+    meta_eval { define_method(name, &blk) }
+  end
+
+  # Defines an instance method within a class
+  def class_def(name, &blk)
+    class_eval { define_method(name, &blk) }
+  end
+end

data/lib/mongomapper.rb

@@ -2,43 +2,17 @@ require 'pathname'
 require 'rubygems'
 
 gem 'activesupport'
-gem 'mongodb-mongo', '0.10.1'
+gem 'mongodb-mongo', '0.11.1'
 gem 'jnunemaker-validatable', '1.7.2'
 
 require 'activesupport'
 require 'mongo'
 require 'validatable'
 
-class BasicObject #:nodoc:
-  instance_methods.each { |m| undef_method m unless m =~ /^__|instance_eval/ }
-end unless defined?(BasicObject)
-
-class Boolean
-  def self.mm_typecast(value)
-    ['true', 't', '1'].include?(value.to_s.downcase)
-  end
-end
-
-class MongoID < XGen::Mongo::Driver::ObjectID
-  def self.mm_typecast(value)
-    begin
-      if value.is_a?(XGen::Mongo::Driver::ObjectID)
-        value
-      else
-        XGen::Mongo::Driver::ObjectID::from_string(value.to_s)
-      end
-    rescue => exception
-      if exception.message == 'illegal ObjectID format'
-        raise MongoMapper::IllegalID
-      else
-        raise exception
-      end
-    end
-  end
-end
-
 dir = Pathname(__FILE__).dirname.expand_path + 'mongomapper'
 
+require dir + 'support'
+
 require dir + 'associations'
 require dir + 'associations/base'
 
@@ -54,6 +28,7 @@ require dir + 'associations/many_embedded_polymorphic_proxy'
 
 require dir + 'callbacks'
 require dir + 'finder_options'
+require dir + 'dynamic_finder'
 require dir + 'key'
 require dir + 'observing'
 require dir + 'pagination'
@@ -68,16 +43,15 @@ require dir + 'embedded_document'
 require dir + 'document'
 
 module MongoMapper
-  DocumentNotFound = Class.new(StandardError)
-  IllegalID        = Class.new(StandardError)
+  DocumentNotFound  = Class.new(StandardError)
   
-  DocumentNotValid = Class.new(StandardError) do
+  DocumentNotValid  = Class.new(StandardError) do
     def initialize(document)
       @document = document
       super("Validation failed: #{@document.errors.full_messages.join(", ")}")
     end
   end
-
+  
   def self.connection
     @@connection ||= XGen::Mongo::Driver::Mongo.new
   end

data/mongomapper.gemspec

@@ -1,12 +1,15 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
   s.name = %q{mongomapper}
-  s.version = "0.3.1.1"
+  s.version = "0.3.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["John Nunemaker"]
-  s.date = %q{2009-08-06}
+  s.date = %q{2009-08-16}
   s.default_executable = %q{mmconsole}
   s.email = %q{nunemaker@gmail.com}
   s.executables = ["mmconsole"]
@@ -35,6 +38,7 @@ Gem::Specification.new do |s|
      "lib/mongomapper/associations/proxy.rb",
      "lib/mongomapper/callbacks.rb",
      "lib/mongomapper/document.rb",
+     "lib/mongomapper/dynamic_finder.rb",
      "lib/mongomapper/embedded_document.rb",
      "lib/mongomapper/finder_options.rb",
      "lib/mongomapper/key.rb",
@@ -45,6 +49,7 @@ Gem::Specification.new do |s|
      "lib/mongomapper/save_with_validation.rb",
      "lib/mongomapper/serialization.rb",
      "lib/mongomapper/serializers/json_serializer.rb",
+     "lib/mongomapper/support.rb",
      "lib/mongomapper/validations.rb",
      "mongomapper.gemspec",
      "test/NOTE_ON_TESTING",
@@ -68,7 +73,6 @@ Gem::Specification.new do |s|
      "test/unit/test_embedded_document.rb",
      "test/unit/test_finder_options.rb",
      "test/unit/test_key.rb",
-     "test/unit/test_mongo_id.rb",
      "test/unit/test_mongomapper.rb",
      "test/unit/test_observing.rb",
      "test/unit/test_pagination.rb",
@@ -103,7 +107,6 @@ Gem::Specification.new do |s|
      "test/unit/test_embedded_document.rb",
      "test/unit/test_finder_options.rb",
      "test/unit/test_key.rb",
-     "test/unit/test_mongo_id.rb",
      "test/unit/test_mongomapper.rb",
      "test/unit/test_observing.rb",
      "test/unit/test_pagination.rb",
@@ -118,20 +121,20 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<activesupport>, [">= 0"])
-      s.add_runtime_dependency(%q<mongodb-mongo>, ["= 0.10.1"])
+      s.add_runtime_dependency(%q<mongodb-mongo>, ["= 0.11.1"])
       s.add_runtime_dependency(%q<jnunemaker-validatable>, ["= 1.7.2"])
       s.add_development_dependency(%q<mocha>, ["= 0.9.4"])
       s.add_development_dependency(%q<jnunemaker-matchy>, ["= 0.4.0"])
     else
       s.add_dependency(%q<activesupport>, [">= 0"])
-      s.add_dependency(%q<mongodb-mongo>, ["= 0.10.1"])
+      s.add_dependency(%q<mongodb-mongo>, ["= 0.11.1"])
       s.add_dependency(%q<jnunemaker-validatable>, ["= 1.7.2"])
       s.add_dependency(%q<mocha>, ["= 0.9.4"])
       s.add_dependency(%q<jnunemaker-matchy>, ["= 0.4.0"])
     end
   else
     s.add_dependency(%q<activesupport>, [">= 0"])
-    s.add_dependency(%q<mongodb-mongo>, ["= 0.10.1"])
+    s.add_dependency(%q<mongodb-mongo>, ["= 0.11.1"])
     s.add_dependency(%q<jnunemaker-validatable>, ["= 1.7.2"])
     s.add_dependency(%q<mocha>, ["= 0.9.4"])
     s.add_dependency(%q<jnunemaker-matchy>, ["= 0.4.0"])

data/test/functional/associations/test_belongs_to_polymorphic_proxy.rb

@@ -36,4 +36,18 @@ class BelongsToPolymorphicProxyTest < Test::Unit::TestCase
     from_db.target_id.should be_nil
     from_db.target.should be_nil
   end
+  
+  context "association id set but document not found" do
+    setup do
+      @status = Status.new
+      project = Project.new(:name => "mongomapper")
+      @status.target = project
+      @status.save.should be_true
+      project.destroy
+    end
+
+    should "return nil instead of raising error" do
+      @status.target.should be_nil
+    end
+  end
 end

data/test/functional/associations/test_belongs_to_proxy.rb

@@ -32,4 +32,14 @@ class BelongsToProxyTest < Test::Unit::TestCase
     from_db.project = nil
     from_db.project.should be_nil
   end
+  
+  context "association id set but document not found" do
+    setup do
+      @status = Status.new(:name => 'Foo', :project_id => '1234')
+    end
+
+    should "return nil instead of raising error" do
+      @status.project.should be_nil
+    end
+  end
 end