crnixon-mongomapper 0.2.0 → 0.3.4

data/lib/mongomapper/dynamic_finder.rb

@@ -0,0 +1,38 @@
+module MongoMapper
+  class DynamicFinder
+    attr_reader :options
+
+    def initialize(model, method)
+      @model = model
+      @options = {}
+      @options[:method] = method
+      match
+    end
+
+    def valid?
+      @options[:finder].present?
+    end
+
+    protected
+      def match
+        @options[:finder] = :first
+        
+        case @options[:method].to_s
+          when /^find_(all_by|last_by|by)_([_a-zA-Z]\w*)$/
+            @options[:finder] = :last if $1 == 'last_by'
+            @options[:finder] = :all if $1 == 'all_by'
+            names = $2
+          when /^find_by_([_a-zA-Z]\w*)\!$/
+            @options[:bang] = true
+            names = $1
+          when /^find_or_(initialize|create)_by_([_a-zA-Z]\w*)$/
+            @options[:instantiator] = $1 == 'initialize' ? :new : :create
+            names = $2
+          else
+            @options[:finder] = nil
+        end
+        
+        @options[:attribute_names] = names && names.split('_and_')
+      end
+  end
+end

data/lib/mongomapper/embedded_document.rb

@@ -2,8 +2,6 @@ require 'observer'
 
 module MongoMapper
   module EmbeddedDocument
-    class NotImplemented < StandardError; end
-
     def self.included(model)
       model.class_eval do
         extend ClassMethods
@@ -12,22 +10,56 @@ module MongoMapper
         extend Associations::ClassMethods
         include Associations::InstanceMethods
 
+        include RailsCompatibility::EmbeddedDocument
         include Validatable
         include Serialization
+        
+        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 ||= HashWithIndifferentAccess.new
+        @keys ||= if parent = parent_model
+          parent.keys.dup
+        else
+          HashWithIndifferentAccess.new
+        end
       end
 
-      def key(name, type, options={})
-        key = Key.new(name, type, options)
-        keys[key.name] = key
-        apply_validations_for(key)
-        create_indexes_for(key)
-        key
+      def key(*args)
+        key = Key.new(*args)
+        
+        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(*args)
+        return if subclasses.blank?
+
+        subclasses.each do |subclass|
+          subclass.key(*args)
+        end
       end
 
       def ensure_index(name_or_array, options={})
@@ -44,7 +76,42 @@ module MongoMapper
         !self.ancestors.include?(Document)
       end
 
+      def parent_model
+        (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
@@ -55,7 +122,7 @@ module MongoMapper
         if key.options[:required]
           validates_presence_of(attribute)
         end
-        
+
         if key.options[:unique]
           validates_uniqueness_of(attribute)
         end
@@ -81,146 +148,128 @@ 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
+
+        if self.class.embeddable? && read_attribute(:_id).blank?
+          write_attribute :_id, XGen::Mongo::Driver::ObjectID.new.to_s
+        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)
+        attrs.each_pair do |name, value|
+          writer_method = "#{name}="
+          
+          if respond_to?(writer_method)
+            self.send(writer_method, value)
           else
-            writer_method ="#{key_name}="
-            self.send(writer_method, value) if respond_to?(writer_method)
+            self[name.to_s] = value
           end
         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
+        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
+          
+          attrs[name] = value unless value.nil?
         end
+        attrs.merge!(embedded_association_attributes)
       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)
+      
+      def attributes_with_associations
+        self.class.associations.inject(attributes) do |associations, key_hash|
+          name, association = key_hash
+          value = self.send(name).map(&:attributes_with_associations)
+          associations[name] = value unless value.nil?
+          associations
+        end
       end
+      
 
       def [](name)
         read_attribute(name)
       end
 
       def []=(name, value)
+        ensure_key_exists(name)
         write_attribute(name, value)
       end
 
-      def method_missing(method, *args, &block)
-        attribute = method.to_s
+      def ==(other)
+        other.is_a?(self.class) && id == other.id
+      end
 
-        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
+      def id
+        read_attribute(:_id)
       end
 
-      def ==(other)
-        other.is_a?(self.class) && attributes == other.attributes
+      def 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 = 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
+      private
+        def ensure_key_exists(name)
+          self.class.key(name) unless respond_to?("#{name}=")
         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 read_attribute(name)
+          value = self.class.keys[name].get(instance_variable_get("@#{name}"))
+          instance_variable_set "@#{name}", value if !frozen?
+          value
+        end
 
-      def defined_key_names
-        self.class.keys.keys
-      end
+        def read_attribute_before_typecast(name)
+          instance_variable_get("@#{name}_before_typecast")
+        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
-          end
+        def write_attribute(name, value)
+          instance_variable_set "@#{name}_before_typecast", value
+          instance_variable_set "@#{name}", self.class.keys[name].set(value)
         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 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,34 @@ 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 =~ /^\$/            
+            criteria[field] = if operator_present
+                                value
+                              else
+                                {'$in' => value}
+                              end
           when Hash
-            criteria[field] = to_mongo_criteria(value)
-          else
+            criteria[field] = to_mongo_criteria(value, field)
+          else            
             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,15 @@
-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]
 
     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)
+    
+    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)
@@ -23,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)
@@ -43,25 +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 == Date      then Date.parse(value.to_s)
-          elsif type == Boolean   then ['true', 't', '1'].include?(value.to_s.downcase)
+          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