jnunemaker-mongomapper 0.1.2 → 0.2.0

data/lib/mongomapper/document.rb

@@ -1,28 +1,33 @@
-module MongoMapper  
+require 'set'
+
+module MongoMapper
   module Document
     def self.included(model)
       model.class_eval do
-        include MongoMapper::EmbeddedDocument
+        include EmbeddedDocument
         include InstanceMethods
+        include Observing
+        include Callbacks
         include SaveWithValidation
         include RailsCompatibility
         extend ClassMethods
-        
+
         key :_id, String
         key :created_at, Time
         key :updated_at, Time
-        
-        define_callbacks  :before_create,  :after_create, 
-                          :before_update,  :after_update,
-                          :before_save,    :after_save,
-                          :before_destroy, :after_destroy
       end
+
+      descendants << model
+    end
+
+    def self.descendants
+      @descendants ||= Set.new
     end
-    
+ 
     module ClassMethods
       def find(*args)
         options = args.extract_options!
-        
+
         case args.first
           when :first then find_first(options)
           when :last  then find_last(options)
@@ -30,41 +35,44 @@ module MongoMapper
           else             find_from_ids(args)
         end
       end
-      
+
       def first(options={})
         find_first(options)
       end
-      
+
       def last(options={})
         find_last(options)
       end
-      
+
       def all(options={})
         find_every(options)
       end
-      
+
       def find_by_id(id)
         if doc = collection.find_first({:_id => id})
           new(doc)
         end
       end
-      
+
       # TODO: remove the rescuing when ruby driver works correctly
       def count(conditions={})
-        collection.count(conditions)
+        collection.count(FinderOptions.to_mongo_criteria(conditions))
       end
-      
+
       def create(*docs)
         instances = []
-        docs.flatten.each { |attrs| instances << new(attrs).save }
+        docs.flatten.each do |attrs|
+          doc = new(attrs); doc.save
+          instances << doc
+        end
         instances.size == 1 ? instances[0] : instances
       end
-      
+
       # For updating single document
       #   Person.update(1, {:foo => 'bar'})
       #
       # For updating multiple documents at once:
-      #   Person.update({'1' => {:foo => 'bar'}, '2' => {:baz => 'wick'}}) 
+      #   Person.update({'1' => {:foo => 'bar'}, '2' => {:baz => 'wick'}})
       def update(*args)
         updating_multiple = args.length == 1
         if updating_multiple
@@ -74,23 +82,23 @@ module MongoMapper
           update_single(id, attributes)
         end
       end
-      
+
       def delete(*ids)
         collection.remove(:_id => {'$in' => ids.flatten})
       end
-      
+
       def delete_all(conditions={})
-        collection.remove(conditions)
+        collection.remove(FinderOptions.to_mongo_criteria(conditions))
       end
-      
+
       def destroy(*ids)
         find_some(ids.flatten).each(&:destroy)
       end
-      
+
       def destroy_all(conditions={})
         find(:all, :conditions => conditions).each(&:destroy)
       end
-      
+
       def connection(mongo_connection=nil)
         if mongo_connection.nil?
           @connection ||= MongoMapper.connection
@@ -99,7 +107,7 @@ module MongoMapper
         end
         @connection
       end
-      
+
       def database(name=nil)
         if name.nil?
           @database ||= MongoMapper.database
@@ -108,7 +116,7 @@ module MongoMapper
         end
         @database
       end
-      
+
       def collection(name=nil)
         if name.nil?
           @collection ||= database.collection(self.to_s.demodulize.tableize)
@@ -117,7 +125,19 @@ module MongoMapper
         end
         @collection
       end
+
+      def validates_uniqueness_of(*args)
+        add_validations(args, MongoMapper::Validations::ValidatesUniquenessOf)
+      end
       
+      def validates_exclusion_of(*args)
+        add_validations(args, MongoMapper::Validations::ValidatesExclusionOf)
+      end
+
+      def validates_inclusion_of(*args)
+        add_validations(args, MongoMapper::Validations::ValidatesInclusionOf)
+      end
+
     private
       def find_every(options)
         criteria, options = FinderOptions.new(options).to_a
@@ -153,15 +173,15 @@ module MongoMapper
             find_some(ids)
         end
       end
-      
+
       def update_single(id, attrs)
         if id.blank? || attrs.blank? || !attrs.is_a?(Hash)
           raise ArgumentError, "Updating a single document requires an id and a hash of attributes"
         end
-        
+
         find(id).update_attributes(attrs)
       end
-      
+
       def update_multiple(docs)
         unless docs.is_a?(Hash)
           raise ArgumentError, "Updating multiple documents takes 1 argument and it must be hash"
@@ -171,63 +191,72 @@ module MongoMapper
         instances
       end
     end
-    
+
     module InstanceMethods
       def collection
         self.class.collection
       end
-    
+
       def new?
         read_attribute('_id').blank? || self.class.find_by_id(id).blank?
       end
-        
+
       def save
-        run_callbacks(:before_save)
-        new? ? create : update
-        run_callbacks(:after_save)
-        self
+        create_or_update
+      end
+      
+      def save!
+        create_or_update || raise(DocumentNotValid.new(self))
       end
-    
+
       def update_attributes(attrs={})
         self.attributes = attrs
         save
+        self
       end
-    
+
       def destroy
-        run_callbacks(:before_destroy)
         collection.remove(:_id => id) unless new?
-        run_callbacks(:after_destroy)
         freeze
       end
-    
+
       def ==(other)
         other.is_a?(self.class) && id == other.id
       end
-    
+ 
+      def id
+        read_attribute('_id')
+      end
+
     private
+      def create_or_update
+        result = new? ? create : update
+        result != false
+      end
+      
       def create
         write_attribute('_id', generate_id) if read_attribute('_id').blank?
         update_timestamps
-        run_callbacks(:before_create)
-        collection.insert(attributes.merge!(embedded_association_attributes))
-        run_callbacks(:after_create)
+        save_to_collection
       end
-    
+
       def update
         update_timestamps
-        run_callbacks(:before_update)
-        collection.modify({:_id => id}, attributes.merge!(embedded_association_attributes))
-        run_callbacks(:after_update)
+        save_to_collection
       end
-    
+
+      def save_to_collection
+        collection.save(attributes.merge!(embedded_association_attributes))
+      end
+
       def update_timestamps
         write_attribute('created_at', Time.now.utc) if new?
         write_attribute('updated_at', Time.now.utc)
       end
-    
+
       def generate_id
         XGen::Mongo::Driver::ObjectID.new
       end
     end
   end # Document
-end # MongoMapper
+end # MongoMapper

data/lib/mongomapper/embedded_document.rb

@@ -1,96 +1,64 @@
+require 'observer'
+
 module MongoMapper
   module EmbeddedDocument
     class NotImplemented < StandardError; end
-    
+
     def self.included(model)
       model.class_eval do
-        include InstanceMethods
         extend ClassMethods
+        include InstanceMethods
+
+        extend Associations::ClassMethods
+        include Associations::InstanceMethods
+
         include Validatable
-        include ActiveSupport::Callbacks
-        include MongoMapper::Serialization
+        include Serialization
       end
     end
-    
+
     module ClassMethods
-      class Association
-        attr_accessor :name
-        
-        def initialize(name)
-          @name = name.to_s
-        end
-        
-        def klass
-          @klass ||= name.classify.constantize
-        end
-        
-        def ivar
-          @ivar ||= "@#{name}"
-        end
-      end
-      
-      def many(association_name)
-        association = Association.new(association_name)
-        associations[association.name] = association
-        class_eval <<-EOS
-          def #{association.name}
-            #{association.ivar} ||= []
-            #{association.ivar}
-          end
-        EOS
-      end
-      
-      def associations
-        @associations ||= HashWithIndifferentAccess.new
-      end
-      
       def keys
         @keys ||= HashWithIndifferentAccess.new
       end
-      
+
       def key(name, type, options={})
         key = Key.new(name, type, options)
         keys[key.name] = key
         apply_validations_for(key)
-        define_embedded_document_accessors_for(key)
         create_indexes_for(key)
         key
       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
-      
-    private
-      def define_embedded_document_accessors_for(key)
-        return unless key.embedded_document?
-        instance_var = "@#{key.name}"
-        
-        define_method(key.name) do
-          key.get(instance_variable_get(instance_var))
-        end
-        
-        define_method("#{key.name}=") do |value|
-          instance_variable_set(instance_var, key.get(value))
-        end
+
+      def embeddable?
+        !self.ancestors.include?(Document)
       end
-      
+
+    private
       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} : {}
@@ -114,15 +82,18 @@ module MongoMapper
         end
       end
 
-    end                                 
-                                        
+    end
+
     module InstanceMethods
       def initialize(attrs={})
-        initialize_embedded_associations(attrs)
-        self.attributes = attrs
+        unless attrs.nil?
+          initialize_associations(attrs)
+          self.attributes = attrs
+        end
       end
-      
+
       def attributes=(attrs)
+        return if attrs.blank?
         attrs.each_pair do |key_name, value|
           if writer?(key_name)
             write_attribute(key_name, value)
@@ -132,7 +103,7 @@ module MongoMapper
           end
         end
       end
-    
+
       def attributes
         self.class.keys.inject(HashWithIndifferentAccess.new) do |attributes, key_hash|
           name, key = key_hash
@@ -141,36 +112,32 @@ module MongoMapper
           attributes
         end
       end
-    
+
       def reader?(name)
         defined_key_names.include?(name.to_s)
       end
-    
+
       def writer?(name)
         name = name.to_s
         name = name.chop if name.ends_with?('=')
         reader?(name)
       end
-    
+
       def before_typecast_reader?(name)
         name.to_s.match(/^(.*)_before_typecast$/) && reader?($1)
       end
-    
+
       def [](name)
         read_attribute(name)
       end
-    
+
       def []=(name, value)
         write_attribute(name, value)
       end
-    
-      def id
-        read_attribute('_id')
-      end
-    
+
       def method_missing(method, *args, &block)
         attribute = method.to_s
-        
+
         if reader?(attribute)
           read_attribute(attribute)
         elsif writer?(attribute)
@@ -181,24 +148,26 @@ module MongoMapper
           super
         end
       end
-    
+
       def ==(other)
         other.is_a?(self.class) && attributes == other.attributes
       end
-      
+
       def inspect
         attributes_as_nice_string = defined_key_names.collect do |name|
           "#{name}: #{read_attribute(name)}"
         end.join(", ")
         "#<#{self.class} #{attributes_as_nice_string}>"
       end
-    
+
+      alias :respond_to_without_attributes? :respond_to?
+
       def respond_to?(method, include_private=false)
         return true if reader?(method) || writer?(method) || before_typecast_reader?(method)
         super
       end
-      
-    private      
+
+    private
       def value_for_key(key)
         if key.native?
           read_attribute(key.name)
@@ -207,15 +176,15 @@ module MongoMapper
           embedded_document && embedded_document.attributes
         end
       end
-      
+
       def read_attribute(name)
         defined_key(name).get(instance_variable_get("@#{name}"))
       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}", defined_key(name).set(value)
@@ -224,34 +193,35 @@ module MongoMapper
       def defined_key(name)
         self.class.keys[name]
       end
-  
+
       def defined_key_names
         self.class.keys.keys
       end
-  
+
       def only_defined_keys(hash={})
         defined_key_names = defined_key_names()
         hash.delete_if { |k, v| !defined_key_names.include?(k.to_s) }
       end
-      
+
       def embedded_association_attributes
         attributes = HashWithIndifferentAccess.new
         self.class.associations.each_pair do |name, association|
-          attributes[name] = send(name).collect { |item| item.attributes }
+          if association.type == :many && association.klass.embeddable?
+            vals = instance_variable_get(association.ivar)
+            attributes[name] = vals.collect { |item| item.attributes } if vals
+          end
         end
+
         attributes
       end
-      
-      def initialize_embedded_associations(attrs={})
+
+      def initialize_associations(attrs={})
         self.class.associations.each_pair do |name, association|
           if collection = attrs.delete(name)
-            association_value = collection.collect do |item|
-              association.klass.new(item)
-            end
-            instance_variable_set(association.ivar, association_value)
+            __send__("#{association.name}=", collection)
           end
         end
       end
     end
   end
-end
+end