jnunemaker-mongomapper 0.2.0 → 0.3.0

data/lib/mongomapper/embedded_document.rb

@@ -1,57 +1,104 @@
 require 'observer'
 
 module MongoMapper
-  module EmbeddedDocument
-    class NotImplemented < StandardError; end
-
+  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
       end
     end
-
+    
     module ClassMethods
+      def inherited(subclass)
+        (@subclasses ||= []) << subclass
+      end
+      
+      def subclasses
+        @subclasses
+      end
+      
       def keys
-        @keys ||= HashWithIndifferentAccess.new
+        @keys ||= if parent = parent_model
+          parent.keys.dup
+        else
+          HashWithIndifferentAccess.new
+        end
       end
-
-      def key(name, type, options={})
+      
+      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
+        
+        define_method("#{key.name}?") do
+          read_attribute(key.name).present?
+        end
+      end
+      
+      def add_to_subclasses(name, type, options)
+        return if subclasses.blank?
+        
+        subclasses.each do |subclass|
+          subclass.key name, type, options
+        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)
+        end
+      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
@@ -59,16 +106,16 @@ module MongoMapper
         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
@@ -81,147 +128,91 @@ module MongoMapper
           validates_length_of(attribute, length_options)
         end
       end
-
     end
-
+    
     module InstanceMethods
       def initialize(attrs={})
         unless attrs.nil?
-          initialize_associations(attrs)
+          self.class.associations.each_pair do |name, association|
+            if collection = attrs.delete(name)
+              send("#{association.name}=", collection)
+            end
+          end
+          
           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)
-          else
-            writer_method ="#{key_name}="
-            self.send(writer_method, value) if respond_to?(writer_method)
-          end
+        attrs.each_pair do |method, value|
+          self.send("#{method}=", value)
         end
       end
-
+      
       def attributes
-        self.class.keys.inject(HashWithIndifferentAccess.new) do |attributes, key_hash|
-          name, key = key_hash
-          value = value_for_key(key)
-          attributes[name] = value unless value.nil?
-          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
+          
+          attributes.merge!(embedded_association_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 method_missing(method, *args, &block)
-        attribute = method.to_s
-
-        if reader?(attribute)
-          read_attribute(attribute)
-        elsif writer?(attribute)
-          write_attribute(attribute.chop, args[0])
-        elsif before_typecast_reader?(attribute)
-          read_attribute_before_typecast(attribute.gsub(/_before_typecast$/, ''))
-        else
-          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|
+        attributes_as_nice_string = self.class.keys.keys.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
-      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
-      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)
-      end
-
-      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|
-          if association.type == :many && association.klass.embeddable?
-            vals = instance_variable_get(association.ivar)
-            attributes[name] = vals.collect { |item| item.attributes } if vals
+      
+      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
         end
-
-        attributes
-      end
-
-      def initialize_associations(attrs={})
-        self.class.associations.each_pair do |name, association|
-          if collection = attrs.delete(name)
-            __send__("#{association.name}=", collection)
+      
+        def read_attribute(name)
+          self.class.keys[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}", 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
         end
-      end
-    end
-  end
-end
+    end # InstanceMethods
+  end # EmbeddedDocument
+end # MongoMapper

data/lib/mongomapper/finder_options.rb

@@ -2,30 +2,45 @@ module MongoMapper
   class FinderOptions
     attr_reader :options
     
-    def self.to_mongo_criteria(conditions)
-      conditions = conditions.dup
+    def self.to_mongo_criteria(conditions, parent_key=nil)
       criteria = {}
       conditions.each_pair do |field, value|
         case value
           when Array
-            criteria[field] = {'$in' => value}
+            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
+                                value
+                              else
+                                {'$in' => value}
+                              end
           when Hash
-            criteria[field] = to_mongo_criteria(value)
+            criteria[field] = to_mongo_criteria(value, field)
           else
+            if field.to_s == '_id'
+              value = MongoID.mm_typecast(value)
+            end
+            
             criteria[field] = value
         end
       end
       
       criteria
     end
-    
+        
     def self.to_mongo_options(options)
       options = options.dup
       {
         :fields => to_mongo_fields(options.delete(:fields) || options.delete(:select)),
         :offset => (options.delete(:offset) || 0).to_i,
         :limit  => (options.delete(:limit) || 0).to_i,
-        :sort   => to_mongo_sort(options.delete(:order))
+        :sort   => options.delete(:sort) || to_mongo_sort(options.delete(:order))
       }
     end
     

data/lib/mongomapper/key.rb

@@ -1,17 +1,14 @@
-class Boolean; end
-class Ref; end
-
 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, Ref]
+    NativeTypes = [String, Float, Time, Integer, Boolean, Array, Hash, MongoID]
 
     attr_accessor :name, :type, :options, :default_value
 
     def initialize(name, type, options={})
       @name, @type = name.to_s, type
-      self.options = options.symbolize_keys
-      self.default_value = options.delete(:default)
+      self.options = (options || {}).symbolize_keys
+      self.default_value = self.options.delete(:default)
     end
 
     def ==(other)
@@ -50,8 +47,9 @@ module MongoMapper
           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 == Boolean   then ['true', 't', '1'].include?(value.to_s.downcase)
+          elsif type == Boolean   then Boolean.mm_typecast(value)
           elsif type == Integer
             # ganked from datamapper
             value_to_i = value.to_i

data/lib/mongomapper/observing.rb

@@ -7,39 +7,8 @@ module MongoMapper
     def self.included(model)
       model.class_eval do
         extend Observable
-        extend ClassMethods
       end      
     end
-
-    module ClassMethods
-      def observers=(*observers)
-        @observers = observers.flatten
-      end
-
-      def observers
-        @observers ||= []
-      end
-
-      def instantiate_observers
-        return if @observers.blank?
-        @observers.each do |observer|
-          if observer.respond_to?(:to_sym) # Symbol or String
-            observer.to_s.camelize.constantize.instance
-          elsif observer.respond_to?(:instance)
-            observer.instance
-          else
-            raise ArgumentError, "#{observer} must be a lowercase, underscored class name (or an instance of the class itself) responding to the instance method. Example: Person.observers = :big_brother # calls BigBrother.instance"
-          end
-        end
-      end
-
-      protected
-        def inherited(subclass)
-          super
-          changed
-          notify_observers :observed_class_inherited, subclass
-        end
-    end
   end
 
   class Observer
@@ -62,27 +31,18 @@ module MongoMapper
     end
 
     def initialize
-      Set.new(observed_classes + observed_subclasses).each { |klass| add_observer! klass }
+      Set.new(observed_classes).each { |klass| add_observer! klass }
     end
 
     def update(observed_method, object) #:nodoc:
       send(observed_method, object) if respond_to?(observed_method)
     end
 
-    def observed_class_inherited(subclass) #:nodoc:
-      self.class.observe(observed_classes + [subclass])
-      add_observer!(subclass)
-    end
-
     protected
       def observed_classes
         Set.new([self.class.observed_class].compact.flatten)
       end
       
-      def observed_subclasses
-        observed_classes.sum([]) { |klass| klass.send(:subclasses) }
-      end
-      
       def add_observer!(klass)
         klass.add_observer(self)
       end