mongo_mapper-unstable 2009.10.11

data/lib/mongo_mapper/document.rb

@@ -0,0 +1,340 @@
+require 'set'
+
+module MongoMapper
+  module Document
+    def self.included(model)
+      model.class_eval do
+        include EmbeddedDocument
+        include InstanceMethods
+        include Observing
+        include Callbacks
+        include SaveWithValidation
+        include Dirty
+        include RailsCompatibility::Document
+        extend Validations::Macros
+        extend ClassMethods
+        extend Finders
+        
+        def self.per_page
+          25
+        end unless respond_to?(:per_page)
+      end
+      
+      descendants << model
+    end
+
+    def self.descendants
+      @descendants ||= Set.new
+    end
+
+    module ClassMethods
+      def key(*args)
+        key = super
+        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
+        
+        MongoMapper.ensure_index(self, keys_to_index, options)
+      end
+      
+      def find(*args)
+        options = args.extract_options!
+        case args.first
+          when :first then first(options)
+          when :last  then last(options)
+          when :all   then find_every(options)
+          when Array  then find_some(args, options)
+          else
+            case args.size
+              when 0
+                raise DocumentNotFound, "Couldn't find without an ID"
+              when 1
+                find_one(args[0], options)
+              else
+                find_some(args, options)
+            end
+        end
+      end
+
+      def paginate(options)
+        per_page      = options.delete(:per_page) ||  self.per_page
+        page          = options.delete(:page)
+        total_entries = count(options[:conditions] || {})
+        collection    = Pagination::PaginationProxy.new(total_entries, page, per_page)
+
+        options[:limit] = collection.limit
+        options[:skip]  = collection.skip
+
+        collection.subject = find_every(options)
+        collection
+      end
+
+      def first(options={})
+        options.merge!(:limit => 1)
+        find_every(options)[0]
+      end
+
+      def last(options={})
+        if options[:order].blank?
+          raise ':order option must be provided when using last'
+        end
+        
+        options.merge!(:limit => 1)
+        options[:order] = invert_order_clause(options[:order])
+        find_every(options)[0]
+      end
+
+      def all(options={})
+        find_every(options)
+      end
+
+      def find_by_id(id)
+        criteria = FinderOptions.to_mongo_criteria(:_id => id)
+        if doc = collection.find_one(criteria)
+          new(doc)
+        end
+      end
+
+      def count(conditions={})
+        collection.find(FinderOptions.to_mongo_criteria(conditions)).count
+      end
+
+      def exists?(conditions={})
+        !count(conditions).zero?
+      end
+
+      def create(*docs)
+        instances = []
+        docs = [{}] if docs.blank?
+        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'}})
+      def update(*args)
+        updating_multiple = args.length == 1
+        if updating_multiple
+          update_multiple(args[0])
+        else
+          id, attributes = args
+          update_single(id, attributes)
+        end
+      end
+
+      def delete(*ids)
+        criteria = FinderOptions.to_mongo_criteria(:_id => ids.flatten)
+        collection.remove(criteria)
+      end
+
+      def delete_all(conditions={})
+        criteria = FinderOptions.to_mongo_criteria(conditions)
+        collection.remove(criteria)
+      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
+        else
+          @connection = mongo_connection
+        end
+        @connection
+      end
+
+      def database(name=nil)
+        if name.nil?
+          @database ||= MongoMapper.database
+        else
+          @database = connection.db(name)
+        end
+        @database
+      end
+      
+      # Changes the collection name from the default to whatever you want
+      def set_collection_name(name=nil)
+        @collection = nil
+        @collection_name = name
+      end
+      
+      # Returns the collection name, if not set, defaults to class name tableized
+      def collection_name
+        @collection_name ||= self.to_s.demodulize.tableize
+      end
+
+      # Returns the mongo ruby driver collection object
+      def collection
+        @collection ||= database.collection(collection_name)
+      end
+      
+      def timestamps!
+        key :created_at, Time
+        key :updated_at, Time
+        
+        class_eval { before_save :update_timestamps }
+      end
+      
+      protected
+        def method_missing(method, *args)
+          finder = DynamicFinder.new(method)
+          
+          if finder.found?
+            meta_def(finder.method) { |*args| dynamic_find(finder, args) }
+            send(finder.method, *args)
+          else
+            super
+          end
+        end
+
+      private
+        def create_indexes_for(key)
+          ensure_index key.name if key.options[:index]
+        end
+        
+        def find_every(options)
+          criteria, options = FinderOptions.new(options).to_a
+          collection.find(criteria, options).to_a.map do |doc|
+            begin
+              klass = doc['_type'].present? ? doc['_type'].constantize : self
+              klass.new(doc)
+            rescue NameError
+              new(doc)
+            end
+          end
+        end
+
+        def invert_order_clause(order)
+          order.split(',').map do |order_segment| 
+            if order_segment =~ /\sasc/i
+              order_segment.sub /\sasc/i, ' desc'
+            elsif order_segment =~ /\sdesc/i
+              order_segment.sub /\sdesc/i, ' asc'
+            else
+              "#{order_segment.strip} desc"
+            end
+          end.join(',')
+        end
+
+        def find_some(ids, options={})
+          ids = ids.flatten.compact.uniq
+          documents = find_every(options.deep_merge(:conditions => {'_id' => ids}))
+          
+          if ids.size == documents.size
+            documents
+          else
+            raise DocumentNotFound, "Couldn't find all of the ids (#{ids.to_sentence}). Found #{documents.size}, but was expecting #{ids.size}"
+          end
+        end
+
+        def find_one(id, options={})
+          if doc = find_every(options.deep_merge(:conditions => {:_id => id})).first
+            doc
+          else
+            raise DocumentNotFound, "Document with id of #{id} does not exist in collection named #{collection.name}"
+          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
+
+          doc = find(id)
+          doc.update_attributes(attrs)
+          doc
+        end
+
+        def update_multiple(docs)
+          unless docs.is_a?(Hash)
+            raise ArgumentError, "Updating multiple documents takes 1 argument and it must be hash"
+          end
+
+          instances = []
+          docs.each_pair { |id, attrs| instances << update(id, attrs) }
+          instances
+        end
+    end
+
+    module InstanceMethods      
+      def collection
+        self.class.collection
+      end
+
+      def new?
+        read_attribute('_id').blank? || using_custom_id?
+      end
+
+      def save
+        create_or_update
+      end
+
+      def save!
+        create_or_update || raise(DocumentNotValid.new(self))
+      end
+
+      def destroy
+        return false if frozen?
+
+        criteria = FinderOptions.to_mongo_criteria(:_id => id)
+        collection.remove(criteria) unless new?
+        freeze
+      end
+
+    private
+      def create_or_update
+        result = new? ? create : update
+        result != false
+      end
+
+      def create
+        assign_id
+        save_to_collection
+      end
+      
+      def assign_id
+        if read_attribute(:_id).blank?
+          write_attribute(:_id, Mongo::ObjectID.new.to_s)
+        end
+      end
+
+      def update
+        save_to_collection
+      end
+
+      def save_to_collection
+        clear_custom_id_flag
+        collection.save(to_mongo)
+      end
+
+      def update_timestamps
+        now = Time.now.utc
+        write_attribute('created_at', now) if new?
+        write_attribute('updated_at', now)
+      end
+      
+      def clear_custom_id_flag
+        @using_custom_id = nil
+      end
+    end
+  end # Document
+end # MongoMapper

data/lib/mongo_mapper/dynamic_finder.rb

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

data/lib/mongo_mapper/embedded_document.rb

@@ -0,0 +1,355 @@
+require 'observer'
+
+module MongoMapper
+  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
+
+        extend Validations::Macros
+
+        key :_id, String
+        attr_accessor :_root_document
+      end
+    end
+
+    module ClassMethods
+      def logger
+        MongoMapper.logger
+      end
+      
+      def inherited(subclass)
+        unless subclass.embeddable?
+          subclass.set_collection_name(collection_name)
+        end
+
+        (@subclasses ||= []) << subclass
+      end
+
+      def subclasses
+        @subclasses
+      end
+
+      def keys
+        @keys ||= if parent = parent_model
+          parent.keys.dup
+        else
+          HashWithIndifferentAccess.new
+        end
+      end
+
+      def key(*args)
+        key = Key.new(*args)
+
+        if keys[key.name].blank?
+          keys[key.name] = key
+
+          create_accessors_for(key)
+          create_key_in_subclasses(*args)
+          create_validations_for(key)
+          
+          key
+        end
+        
+        key
+      end
+
+      def embeddable?
+        !self.ancestors.include?(Document)
+      end
+
+      def parent_model
+        (ancestors - [self,EmbeddedDocument]).find do |parent_class|
+          parent_class.ancestors.include?(EmbeddedDocument)
+        end
+      end
+      
+      def to_mongo(instance)
+        return nil if instance.nil?
+        instance.to_mongo
+      end
+      
+      def from_mongo(instance_or_hash)
+        return nil if instance_or_hash.nil?
+        
+        if instance_or_hash.is_a?(self)
+          instance_or_hash
+        else
+          new(instance_or_hash)
+        end
+      end
+      
+    private
+      def accessors_module
+        if const_defined?('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_key_in_subclasses(*args)
+        return if subclasses.blank?
+
+        subclasses.each do |subclass|
+          subclass.key(*args)
+        end
+      end
+
+      def create_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
+            {:minimum => 0, :maximum => key.options[:length]}
+          when Range
+            {:within => key.options[:length]}
+          when Hash
+            key.options[:length]
+          end
+          validates_length_of(attribute, length_options)
+        end
+      end
+    end
+
+    module InstanceMethods
+      def logger
+        self.class.logger
+      end
+      
+      def initialize(attrs={})
+        unless attrs.nil?
+          self.class.associations.each_pair do |name, association|
+            if collection = attrs.delete(name)
+              if association.many? && association.klass.embeddable?
+                root_document = attrs[:_root_document] || self
+                collection.each do |doc|
+                  doc[:_root_document] = root_document
+                end
+              end
+              send("#{association.name}=", collection)
+            end
+          end
+
+          self.attributes = attrs
+          
+          if respond_to?(:_type=) && self['_type'].blank?
+            self._type = self.class.name
+          end
+        end
+
+        if self.class.embeddable? 
+          if read_attribute(:_id).blank?
+            write_attribute :_id, Mongo::ObjectID.new.to_s
+            @new_document = true
+          else
+            @new_document = false
+          end
+        end
+      end
+      
+      def new?
+        !!@new_document
+      end
+
+      def attributes=(attrs)
+        return if attrs.blank?
+        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
+        attrs = HashWithIndifferentAccess.new
+        
+        embedded_keys.each do |key|
+          puts key.inspect
+          attrs[key.name] = read_attribute(key.name).try(:attributes)
+        end
+        
+        non_embedded_keys.each do |key|
+          attrs[key.name] = read_attribute(key.name)
+        end
+        
+        embedded_associations.each do |association|
+          documents = instance_variable_get(association.ivar)
+          next if documents.nil?
+          attrs[association.name] = documents.collect { |doc| doc.attributes }
+        end
+        
+        attrs
+      end
+      
+      def to_mongo
+        attrs = HashWithIndifferentAccess.new
+        
+        _keys.each_pair do |name, key|
+          value = key.set(read_attribute(key.name))
+          attrs[name] = value unless value.nil?
+        end
+        
+        embedded_associations.each do |association|
+          if documents = instance_variable_get(association.ivar)
+            attrs[association.name] = documents.map { |document| document.to_mongo }
+          end
+        end
+        
+        attrs
+      end
+
+      def clone
+        clone_attributes = self.attributes
+        clone_attributes.delete("_id")
+        self.class.new(clone_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
+        read_attribute(:_id)
+      end
+
+      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 = key_names.collect do |name|
+          "#{name}: #{read_attribute(name).inspect}"
+        end.join(", ")
+        "#<#{self.class} #{attributes_as_nice_string}>"
+      end
+
+      def save
+        if _root_document
+          _root_document.save
+        end
+      end
+      
+      def save!
+        if _root_document
+          _root_document.save!
+        end
+      end
+
+      def update_attributes(attrs={})
+        self.attributes = attrs
+        save
+      end
+
+      private
+        def _keys
+          self.class.keys
+        end
+        
+        def key_names
+          _keys.keys
+        end
+        
+        def non_embedded_keys
+          _keys.values.select { |key| !key.embeddable? }
+        end
+        
+        def embedded_keys
+          _keys.values.select { |key| key.embeddable? }
+        end
+        
+        def ensure_key_exists(name)
+          self.class.key(name) unless respond_to?("#{name}=")
+        end
+
+        def read_attribute(name)
+          value = _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)
+          key = _keys[name]
+          instance_variable_set "@#{name}_before_typecast", value
+          instance_variable_set "@#{name}", key.set(value)          
+        end
+        
+        def embedded_associations
+          self.class.associations.select do |name, association|
+            association.embeddable?
+          end.map do |name, association|
+            association
+          end
+        end
+    end # InstanceMethods
+  end # EmbeddedDocument
+end # MongoMapper