mongodoc 0.2.1 → 0.2.2

data/lib/mongodoc/associations/hash_proxy.rb

@@ -0,0 +1,96 @@
+module MongoDoc
+  class InvalidEmbeddedHashKey < RuntimeError; end
+
+  module Associations
+    class HashProxy < ProxyBase
+      HASH_METHODS = (Hash.instance_methods - Object.instance_methods).map { |n| n.to_s }
+
+      MUST_DEFINE = %w[to_a inspect to_bson ==]
+
+      DO_NOT_DEFINE = %w[merge! replace store update]
+
+      (HASH_METHODS + MUST_DEFINE - DO_NOT_DEFINE).uniq.each do |method|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{method}(*args, &block)            # def each(*args, &block)
+            hash.send(:#{method}, *args, &block)  #   hash.send(:each, *args, &block)
+          end                                     # end
+        RUBY
+      end
+
+      attr_reader :hash
+
+      def _root=(root)
+        @_root = root
+        hash.each do |key, value|
+          value._root = root if is_document?(value)
+        end
+      end
+
+      def initialize(options)
+        super
+        @hash = {}
+      end
+
+      alias put []=
+      def []=(key, value)
+        raise InvalidEmbeddedHashKey.new("Key name [#{key}] must be a valid element name, see http://www.mongodb.org/display/DOCS/BSON#BSON-noteonelementname") unless valid_key?(key)
+        attach(value)
+        put(key, value)
+      end
+      alias store []=
+
+      def build(key, attrs)
+        item = assoc_class.new(attrs)
+        store(key, item)
+      end
+
+      # Lie about our class. Borrowed from Rake::FileList
+      # Note: Does not work for case equality (<tt>===</tt>)
+      def is_a?(klass)
+        klass == Hash || super(klass)
+      end
+      alias kind_of? is_a?
+
+      def merge!(other)
+        other.each_pair do |key, value|
+          self[key] = if block_given?
+            yield key, [key], value
+          else
+            value
+          end
+        end
+      end
+      alias update merge!
+
+      def replace(other)
+        clear
+        merge!(other)
+      end
+
+      def valid?
+        values.all? do |child|
+          if is_document?(child)
+            child.valid?
+          else
+            true
+          end
+        end
+      end
+
+      protected
+
+      def annotated_keys(src, attrs)
+        assoc_path = "#{assoc_name}.#{index(src)}"
+        annotated = {}
+        attrs.each do |(key, value)|
+          annotated["#{assoc_path}.#{key}"] = value
+        end
+        annotated
+      end
+
+      def valid_key?(key)
+        (String === key or Symbol === key) and key.to_s !~ /(_id|query|\$.*|.*\..*)/
+      end
+    end
+  end
+end

data/lib/mongodoc/associations/proxy_base.rb

@@ -0,0 +1,51 @@
+module MongoDoc
+  module Associations
+    class ProxyBase
+      undef_method :id, :to_bson
+
+      attr_reader :assoc_name, :assoc_class, :_parent, :_root
+
+      def _parent=(parent)
+        @_parent = parent
+      end
+
+      def _path_to_root(src, attrs)
+        _parent._path_to_root(src, annotated_keys(src, attrs))
+      end
+
+      def _root=(root)
+        @_root = root
+      end
+
+      def initialize(options)
+        @assoc_name = options[:assoc_name]
+        @assoc_class = options[:assoc_class]
+        @_root = options[:root]
+        @_parent = options[:parent]
+      end
+
+      def attach(item)
+        if is_document?(item)
+          item._parent = self
+          item._root = _root
+          _root.send(:register_save_observer, item)
+        end
+        item
+      end
+
+      protected
+
+      def annotated_keys(src, hash)
+        annotated = {}
+        hash.each do |(key, value)|
+          annotated["#{assoc_name}.#{key}"] = value
+        end
+        annotated
+      end
+
+      def is_document?(object)
+        object.respond_to?(:_parent)
+      end
+    end
+  end
+end

data/lib/mongodoc/attributes.rb

@@ -1,5 +1,7 @@
-require 'mongodoc/proxy'
-require 'mongodoc/parent_proxy'
+require 'mongodoc/associations/proxy_base'
+require 'mongodoc/associations/collection_proxy'
+require 'mongodoc/associations/document_proxy'
+require 'mongodoc/associations/hash_proxy'
 
 module MongoDoc
   module Attributes
@@ -34,11 +36,6 @@ module MongoDoc
       _parent._path_to_root(self, attrs)
     end
 
-    def _selector_path_to_root(selector)
-      return selector unless _parent
-      _parent._selector_path_to_root(selector)
-    end
-
     module ClassMethods
       def _attributes
         _keys + _associations
@@ -52,27 +49,32 @@ module MongoDoc
       end
 
       def has_one(*args)
+        options = args.extract_options!
+        assoc_class = if class_name = options.delete(:class_name)
+          type_name_with_module(class_name).constantize
+        end
+
         args.each do |name|
           _associations << name unless _associations.include?(name)
+
           attr_reader name
 
           define_method("#{name}=") do |value|
-            if value
-              raise NotADocumentError unless Document === value
-              value._parent = ParentProxy.new(self, name)
-              value._root = _root || self
-              value._root.register_save_observer(value)
+            association = instance_variable_get("@#{name}")
+            unless association
+              association = Associations::DocumentProxy.new(:root => _root || self, :parent => self, :assoc_name => name, :assoc_class => assoc_class || self.class.class_from_name(name))
+              instance_variable_set("@#{name}", association)
             end
-            instance_variable_set("@#{name}", value)
+            association.document = value
           end
 
-          validates_associated name
+          validates_embedded name, :if => Proc.new { !send(name).nil? }
         end
       end
 
       def has_many(*args)
         options = args.extract_options!
-        collection_class = if class_name = options.delete(:class_name)
+        assoc_class = if class_name = options.delete(:class_name)
           type_name_with_module(class_name).constantize
         end
 
@@ -82,13 +84,13 @@ module MongoDoc
           define_method("#{name}") do
             association = instance_variable_get("@#{name}")
             unless association
-              association = Proxy.new(:root => _root || self, :parent => self, :assoc_name => name, :collection_class => collection_class || self.class.type_name_with_module(name.to_s.classify).constantize)
+              association = Associations::CollectionProxy.new(:root => _root || self, :parent => self, :assoc_name => name, :assoc_class => assoc_class || self.class.type_name_with_module(name.to_s.classify).constantize)
               instance_variable_set("@#{name}", association)
             end
             association
           end
 
-          validates_associated name
+          validates_embedded name
 
           define_method("#{name}=") do |arrayish|
             proxy = send("#{name}")
@@ -100,6 +102,36 @@ module MongoDoc
         end
       end
 
+      def has_hash(*args)
+        options = args.extract_options!
+        assoc_class = if class_name = options.delete(:class_name)
+          type_name_with_module(class_name).constantize
+        end
+
+        args.each do |name|
+          _associations << name unless _associations.include?(name)
+
+          define_method("#{name}") do
+            association = instance_variable_get("@#{name}")
+            unless association
+              association = Associations::HashProxy.new(:root => _root || self, :parent => self, :assoc_name => name, :assoc_class => assoc_class || self.class.type_name_with_module(name.to_s.classify).constantize)
+              instance_variable_set("@#{name}", association)
+            end
+            association
+          end
+
+          validates_embedded name
+
+          define_method("#{name}=") do |hash|
+            send("#{name}").replace(hash)
+          end
+        end
+      end
+
+      def class_from_name(name)
+        type_name_with_module(name.to_s.classify).constantize rescue nil
+      end
+
       def type_name_with_module(type_name)
         (/^::/ =~ type_name) ? type_name : "#{parents}::#{type_name}"
       end

data/lib/mongodoc/collection.rb

@@ -3,14 +3,15 @@ require 'mongodoc/cursor'
 module MongoDoc
   class Collection
     attr_accessor :_collection
-    delegate :[], :clear, :count, :create_index, :db, :drop, :drop_index, :drop_indexes, :group, :hint, :index_information, :name, :options, :remove, :rename, :size, :to => :_collection
+
+    delegate :[], :clear, :count, :create_index, :db, :distinct, :drop, :drop_index, :drop_indexes, :group, :hint, :index_information, :map_reduce, :mapreduce, :name, :options, :pk_factory, :remove, :rename, :size, :to => :_collection
 
     def initialize(name)
       self._collection = self.class.mongo_collection(name)
     end
 
     def find(query = {}, options = {})
-      cursor = MongoDoc::Cursor.new(_collection.find(query, options))
+      cursor = wrapped_cursor(query, options)
       if block_given?
         yield cursor
         cursor.close
@@ -34,12 +35,21 @@ module MongoDoc
 
     def update(spec, doc, options = {})
       _collection.update(spec, doc.to_bson, options)
-      result = MongoDoc.database.command({'getlasterror' => 1})
-      (result and result.has_key?('updatedExisting')) ? result['updatedExisting'] : false
+      (last_error || {})['updatedExisting'] || false
+    end
+
+    protected
+
+    def last_error
+      MongoDoc::Connection.database.command({'getlasterror' => 1})
+    end
+
+    def wrapped_cursor(query = {}, options = {})
+      MongoDoc::Cursor.new(self, _collection.find(query, options))
     end
 
     def self.mongo_collection(name)
-      MongoDoc.database.collection(name)
+      MongoDoc::Connection.database.collection(name)
     end
   end
 end

data/lib/mongodoc/connection.rb

@@ -1,25 +1,88 @@
 module MongoDoc
-  mattr_accessor :config, :config_path, :connection, :database
-  self.config_path = './mongodb.yml'
-
-  def self.connect_to_database(name = nil, host = nil, port = nil, options = nil, force_connect = false)
-    name ||= configuration['name']
-    self.database = ((!force_connect && connection)|| connect(host, port, options)).db(name)
-    raise NoDatabaseError unless database
-    database
-  end
+  class NoConnectionError < RuntimeError; end
+  class UnsupportedServerVersionError < RuntimeError; end
 
-  def self.connect(*args)
-    opts = args.extract_options!
-    host = args[0] || configuration['host'] || configuration['host_pairs']
-    port = args[1] || configuration['port']
-    options = opts.empty? ? configuration['options'] || {} : opts
-    self.connection = Mongo::Connection.new(host, port, options)
-    raise NoConnectionError unless connection
-    connection
-  end
+  module Connection
+
+    extend self
+
+    attr_writer :config_path, :env, :host, :name, :options, :port, :strict
+
+    def config_path
+      @config_path || default_path
+    end
+
+    def configuration
+      @configuration ||= File.exists?(config_path) ? YAML.load_file(config_path)[env] : {}
+    end
+
+    def connection
+      @connection ||= connect
+    end
+
+    def database
+      @database ||= connection.db(name, :strict => strict)
+    end
+
+    def env
+      if rails?
+        Rails.env
+      else
+        @env ||= 'development'
+      end
+    end
+
+    def host
+      @host ||= configuration['host']
+    end
+
+    def name
+      @name ||= configuration['name'] || default_name
+    end
+
+    def options
+      @options ||= configuration['options'] || {}
+    end
+
+    def port
+      @port ||= configuration['port']
+    end
+
+    def strict
+      @strict ||= configuration['strict'] || false
+    end
+
+    private
+
+    def connect
+      connection = Mongo::Connection.new(host, port, options)
+      raise NoConnectionError unless connection
+      verify_server_version(connection)
+      connection
+    end
+
+    def default_name
+      if rails?
+        "#{Rails.root.basename}_#{Rails.env}"
+      else
+        "mongodoc"
+      end
+    end
+
+    def default_path
+      if rails?
+        Rails.root + 'config/mongodb.yml'
+      else
+        './mongodb.yml'
+      end
+    end
+
+    def rails?
+      Object.const_defined?("Rails")
+    end
 
-  def self.configuration
-    self.config ||= File.exists?(config_path || '') ? YAML.load_file(config_path) : {}
+    def verify_server_version(connection)
+      raise UnsupportedServerVersionError.new('MongoDoc requires at least mongoDB version 1.3.2') unless connection.server_version >= "1.3.2"
+    end
   end
 end

data/lib/mongodoc/criteria.rb

@@ -101,11 +101,12 @@ module MongoDoc #:nodoc:
     def each(&block)
       @collection ||= execute
       if block_given?
-        @collection = collection.inject([]) do |container, item|
+        container = []
+        collection.each do |item|
           container << item
           yield item
-          container
         end
+        @collection = container
       end
       self
     end
@@ -166,9 +167,10 @@ module MongoDoc #:nodoc:
     #
     # Returns <tt>self</tt>
     def criteria(criteria_conditions = {})
-      criteria_conditions.inject(self) do |criteria, (key, value)|
-        criteria.send(key, value)
+      criteria_conditions.each do |(key, value)|
+        send(key, value)
       end
+      self
     end
 
     # Adds a criterion to the +Criteria+ that specifies values that must all
@@ -242,6 +244,9 @@ module MongoDoc #:nodoc:
     #
     # Returns: <tt>self</tt>
     def id(id_or_object_id)
+      if id_or_object_id.kind_of?(String)
+        id_or_object_id = Mongo::ObjectID.from_string(id_or_object_id)
+      end
       selector[:_id] = id_or_object_id; self
     end