jmongo 1.1.1 → 1.1.2

data/Rakefile

@@ -36,6 +36,10 @@ def replace_header(head, header_name)
   head.sub!(/(\.#{header_name}\s*= ').*'/) { "#{$1}#{send(header_name)}'"}
 end
 
+def jruby?
+  RUBY_PLATFORM.to_s == 'java'
+end
+
 #############################################################################
 #
 # Custom tasks
@@ -65,7 +69,16 @@ task :release => :build do
   sh "git tag v#{version}"
   sh "git push origin master"
   sh "git push origin v#{version}"
-  sh "gem push pkg/#{name}-#{version}.gem"
+
+  command = "gem push pkg/#{name}-#{version}.gem"
+
+  if jruby?
+    puts "--------------------------------------------------------------------------------------"
+    puts "can't push to rubygems using jruby at the moment, so switch to mri and run: #{command}"
+    puts "--------------------------------------------------------------------------------------"
+  else
+    sh command
+  end
 end
 
 desc "Build #{gem_file} into the pkg directory"

data/jmongo.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name              = 'jmongo'
-  s.version           = '1.1.1'
-  s.date              = '2011-10-06'
+  s.version           = '1.1.2'
+  s.date              = '2011-10-10'
   s.platform          = Gem::Platform::RUBY
   s.authors           = ["Chuck Remes","Guy Boertje", "Lee Henson"]
   s.email             = ["cremes@mac.com", "guyboertje@gmail.com", "lee.m.henson@gmail.com"]

data/lib/jmongo/collection.rb

@@ -19,7 +19,7 @@ module Mongo
     include Mongo::JavaImpl::Collection_
 
     attr_reader :j_collection, :j_db
-    attr_reader :db, :name, :pk_factory, :hint
+    attr_reader :db, :name, :pk_factory
 
     # Initialize a collection object.
     #
@@ -57,9 +57,13 @@ module Mongo
       @name = validate_name(name)
       @db, @j_db  = db, db.j_db
       @connection = @db.connection
-      @pk_factory = @opts[:pk] || BSON::ObjectId
+      @pk_factory = @opts.delete(:pk)|| BSON::ObjectId
       @hint = nil
-      @j_collection = j_collection || @j_db.get_collection(@name)
+      @j_collection = j_collection || @j_db.create_collection(@name, to_dbobject(@opts))
+    end
+
+    def safe
+      !!@opts.fetch(:safe, false)
     end
 
     # Return a sub-collection of this collection by name. If 'users' is a collection, then
@@ -75,13 +79,13 @@ module Mongo
     #   the specified sub-collection
     def [](name)
       new_name = "#{self.name}.#{name}"
-      validate_name new_name
-      @db.create_collection(new_name, @opts)
+      @db.collection(new_name, @opts)
     end
 
     def capped?
-      @j_collection.isCapped
+      @j_collection.capped?
     end
+
     # Set a hint field for query optimizer. Hint may be a single field
     # name, array of field names, or a hash (preferably an [OrderedHash]).
     # If using MongoDB > 1.1, you probably don't ever need to set a hint.
@@ -89,8 +93,13 @@ module Mongo
     # @param [String, Array, OrderedHash] hint a single field, an array of
     #   fields, or a hash specifying fields
     def hint=(hint=nil)
+      @hint = prep_hint(hint)
+      self
     end
 
+    def hint
+      @hint 
+    end
     # Query the database.
     #
     # The +selector+ argument is a prototype document that all results must
@@ -152,7 +161,7 @@ module Mongo
       end
 
       if hint
-        hint = normalize_hint_fields(hint)
+        hint = prep_hint(hint)
       else
         hint = @hint        # assumed to be normalized already
       end
@@ -239,9 +248,13 @@ module Mongo
     # @core insert insert-instance_method
     def insert(doc_or_docs, options={})
       doc_or_docs = [doc_or_docs] unless doc_or_docs.kind_of?(Array)
-      doc_or_docs.collect! { |doc| @pk_factory.create_pk(doc) }
+      doc_or_docs.collect! do |doc|
+        @pk_factory.create_pk(doc)
+        prep_id(doc)
+      end
+      safe = options.fetch(:safe, @opts[:safe])
       continue = (options[:continue_on_error] || false)
-      docs = insert_documents(doc_or_docs, options[:safe], continue)
+      docs = insert_documents(doc_or_docs, safe, continue)
       docs.size == 1 ? docs.first['_id'] : docs.collect{|doc| doc['_id']}
     end
     alias_method :<<, :insert
@@ -293,7 +306,8 @@ module Mongo
     # @core update update-instance_method
     def update(selector, document, options={})
       upsert, multi = !!(options[:upsert]), !!(options[:multi])
-      update_documents(selector, document, upsert, multi, options[:safe])
+      safe = options.fetch(:safe, @opts[:safe])
+      update_documents(selector, document, upsert, multi, safe)
     end
 
     # Create a new index.
@@ -339,10 +353,13 @@ module Mongo
     #
     # @core indexes create_index-instance_method
     def create_index(spec, opts={})
-      _create_indexes(spec, opts)
+      _create_index(spec, opts)
     end
-    alias_method :ensure_index, :create_index
 
+    def ensure_index(spec, opts={})
+      _ensure_index(spec, opts)
+    end
+      
     # Drop a specified index.
     #
     # @param [String, Array] spec
@@ -583,10 +600,10 @@ module Mongo
     #
     # @raise [Mongo::InvalidNSName] if +new_name+ is an invalid collection name.
     def rename(new_name)
-      name = validate_name(new_name)
+      _name = validate_name(new_name)
       begin
-        jcol = @j_collection.rename(name)
-        @name = name
+        jcol = @j_collection.rename(_name)
+        @name = _name
         @j_collection = jcol
       rescue => ex
         raise MongoDBError, "Error renaming collection: #{name}, more: #{ex.message}"
@@ -608,7 +625,6 @@ module Mongo
     # @return [Hash] options that apply to this collection.
     def options
       info = @db.collections_info(@name).to_a
-      ap info
       info.last['options']
     end
 
@@ -632,39 +648,5 @@ module Mongo
     end
 
     alias :size :count
-
-    protected
-
-    def validate_name(new_name)
-      raise TypeError, "new_name must be a string like" unless new_name.respond_to?(:to_s)
-
-      name = new_name.to_s
-
-      if name.empty? || name.include?("..")
-        raise Mongo::InvalidNSName, "collection names cannot be empty"
-      end
-      if name.include? "$"
-        raise Mongo::InvalidNSName, "collection names must not contain '$'" unless name =~ /((^\$cmd)|(oplog\.\$main))/
-      end
-      if name.match(/^\./) || name.match(/\.$/)
-        raise Mongo::InvalidNSName, "collection names must not start or end with '.'"
-      end
-      name
-    end
-
-    def normalize_hint_fields(hint)
-      case hint
-      when String
-        {hint => 1}
-      when Hash
-        hint
-      when nil
-        nil
-      else
-        h = BSON::OrderedHash.new
-        hint.to_a.each { |k| h[k.to_s] = 1 }
-        h
-      end
-    end
   end
 end

data/lib/jmongo/connection.rb

@@ -20,28 +20,40 @@ module Mongo
     include Mongo::JavaImpl::Connection_::InstanceMethods
      extend Mongo::JavaImpl::Connection_::ClassMethods
 
-    attr_reader :connection, :connector, :logger, :auths, :primary
+    attr_reader :connection, :connector, :logger, :auths, :primary, :write_concern
 
     DEFAULT_PORT = 27017
 
     def initialize host = nil, port = nil, opts = {}
+      @logger = opts.delete(:logger)
+      @auths = opts.delete(:auths) || []
       if opts.has_key?(:new_from_uri)
-        @options = opts
         @mongo_uri = opts[:new_from_uri]
+        @options = @mongo_uri.options
+        @write_concern = @options.write_concern
         @connection = JMongo::Mongo.new(@mongo_uri)
       else
-        @logger = opts[:logger]
         @host = host || 'localhost'
         @port = port || 27017
         @server_address = JMongo::ServerAddress.new @host, @port
         @options = JMongo::MongoOptions.new
-        @options.connectionsPerHost = opts[:pool_size] || 1
-        @options.socketTimeout = opts[:timeout].to_i * 1000 || 5000
+        opts.each do |k,v|
+          key = k.to_sym
+          jmo_key = JMongo.options_ruby2java_lu(key)
+          case jmo_key
+          when :safe
+            @write_concern = DB.write_concern(v)
+            @options.w = @write_concern.w
+            @options.wtimeout = @write_concern.wtimeout
+            @options.fsync = @write_concern.fsync
+          else
+            jmo_val = JMongo.options_ruby2java_xf(key, v)
+            @options.send("#{jmo_key}=", jmo_val)
+          end
+        end
         @connection = JMongo::Mongo.new(@server_address, @options)
       end
       @connector = @connection.connector
-      @logger = opts[:logger]
-      @auths = opts.fetch(:auths, [])
       add = @connector.address
       @primary = [add.host, add.port]
     end
@@ -124,7 +136,10 @@ module Mongo
     #
     # @return [Hash]
     def database_info
-      raise_not_implemented
+      doc = self['admin'].command({:listDatabases => 1})
+      doc['databases'].each_with_object({}) do |db, info|
+        info[db['name']] = db['sizeOnDisk'].to_i
+      end
     end
 
     # Return an array of database names.
@@ -143,7 +158,7 @@ module Mongo
     #
     # @core databases db-instance_method
     def db(db_name, options={})
-      DB.new db_name, self, options
+      DB.new db_name, self, options 
     end
 
     # Shortcut for returning a database. Use DB#db to accept options.

data/lib/jmongo/db.rb

@@ -18,19 +18,30 @@ module Mongo
     include Mongo::JavaImpl::Db_
     include Mongo::JavaImpl::Utils
 
-    attr_reader :j_db
-    attr_reader :name
-    attr_reader :connection
+    attr_reader :j_db, :name, :connection, :safe
 
-    attr_writer :strict
+    attr_accessor :strict
 
     ProfileLevel = {:off => 0, :slow_only => 1, :all => 2, 0 => 'off', 1 => 'slow_only', 2 => 'all'}
 
+    def self.write_concern(safe_)
+      return safe_ if safe_.is_a?(JMongo::WriteConcern)
+      return JMongo::WriteConcern.new(0) if safe_.is_a?(FalseClass)
+      return JMongo::WriteConcern.new(true) if safe_.is_a?(TrueClass)
+      return JMongo::WriteConcern.new(safe.to_i) if safe_.is_a?(Numeric)
+      return JMongo::WriteConcern.new(-1) unless safe_.is_a?(Hash)
+      w = safe_.fetch(:w, 0)
+      t = safe_.fetch(:wtimeout, 0)
+      f = !!safe_.fetch(:fsync, false)
+      JMongo::WriteConcern.new(w, t, f) #dont laugh!
+    end
+
     def initialize(db_name, connection, options={})
       @name       = db_name
       @connection = connection
       @j_db = @connection.connection.get_db db_name
       @pk_factory = options[:pk]
+      @safe = options[:safe]
       @strict = options.fetch(:strict, false)
     end
 
@@ -64,39 +75,45 @@ module Mongo
 
     def collections
       collection_names.map do |name|
-        Collection.new(self, name)
+        collection(name)
       end
     end
 
     def collections_info(coll_name=nil)
-      selector = {}
-      selector[:name] = full_collection_name(coll_name) if coll_name
-      coll = self.collection(SYSTEM_NAMESPACE_COLLECTION)
-      coll.find selector
+      _collections_info coll_name
     end
 
     def create_collection(name, options={})
-      if collection_names.include?(name)
-        raise MongoDBError, "Collection #{name} already exists. Currently in strict mode." if @strict
-        collection(name, options)
-      else
-        begin
-          jc = @j_db.create_collection(name, to_dbobject(options))
-          Collection.new self, name, options, jc
-        rescue NativeException => ex
-          raise MongoDBError, "Collection #{name} creation error: " +
-              ex.message
+      validate_name(name)
+      if collection_exists?(name)
+        if strict?
+          raise MongoDBError, "Collection #{name} already exists. Currently in strict mode."
+        else
+          return Collection.new self, name, options, @j_db.get_collection(name)
         end
       end
+      begin
+        Collection.new self, name, options
+      rescue => ex
+        raise MongoDBError, "Collection #{name} creation error: " + ex.message
+      end
     end
 
     def collection(name, options = {})
-      Collection.new self, name, options
+      validate_name(name)
+      if strict? && !collection_exists?(name) 
+        raise MongoDBError, "Collection #{name} does not exists. Currently in strict mode."
+      else
+        Collection.new self, name, options, @j_db.get_collection(name)
+      end
     end
     alias_method :[], :collection
 
     def drop_collection(name)
-      coll = collection(name).j_collection.drop
+      col_name = name.to_s
+      return true unless collection_exists?(col_name)
+
+      ok?(command(:drop => col_name))
     end
 
     def get_last_error
@@ -122,15 +139,13 @@ module Mongo
 
     def dereference(dbref)
       ns = dbref.namespace
-      raise MongoArgumentError, "No namespace for dbref: #{dbref.inspect}"
+      raise MongoArgumentError, "No collection for dbref: #{dbref.inspect}" unless collection_exists?(ns)
       collection(ns).find_one("_id" => dbref.object_id)
     end
 
     def eval(code, *args)
       doc = do_eval(code, *args)
-      return unless doc
-      return doc['retval']['value'] if doc['retval'] && doc['retval']['value']
-      doc['retval']
+      (retval = doc['retval']).is_a?(Hash) && (value = retval['value']) ? value : retval
     end
 
     def rename_collection(from, to)
@@ -143,12 +158,12 @@ module Mongo
     end
 
     def drop_index(collection_name, index_name)
-      self[collection_name].drop_index(index_name)
+      collection(collection_name).drop_index(index_name)
     end
 
     def index_information(collection_name)
       info = {}
-      from_dbobject(@j_db.get_collection(collection_name).get_index_info).each do |index|
+      from_dbobject(@j_db.getCollectionFromString(collection_name).getIndexInfo).each do |index|
         info[index['name']] = index
       end
       info
@@ -258,11 +273,6 @@ module Mongo
       end
       doc
     end
-
-    # additions to the ruby driver
-    def has_collection?(name)
-      has_coll name
-    end
   end # class DB
 
 end # module Mongo

data/lib/jmongo/mongo/bson.rb

@@ -2,7 +2,6 @@ module BSON
   # add missing BSON::ObjectId ruby methods
   java_import Java::OrgBsonTypes::ObjectId
 
-  java_import Java::ComMongodb::DBRef
   java_import Java::OrgBsonTypes::MaxKey
   java_import Java::OrgBsonTypes::MinKey
   java_import Java::OrgBsonTypes::Symbol
@@ -18,7 +17,7 @@ module BSON
     end
 
     def self.create_pk(doc)
-      doc.has_key?(:_id) || doc.has_key?('_id') ? doc : doc.merge!(:_id => self.new)
+      doc.has_key?(:_id) || doc.has_key?('_id') ? doc : doc.merge!('_id' => self.new)
     end
 
     def self.from_time(time, opts={})
@@ -105,6 +104,31 @@ module BSON
     alias :to_bson_code :to_bson
   end
 
+  class DBRef
+
+    attr_reader :namespace, :object_id
+
+    # Create a DBRef. Use this class in conjunction with DB#dereference.
+    #
+    # @param [String] a collection name
+    # @param [ObjectId] an object id
+    #
+    # @core dbrefs constructor_details
+    def initialize(namespace, object_id)
+      @namespace = namespace
+      @object_id = object_id
+    end
+
+    def to_s
+      "ns: #{namespace}, id: #{object_id}"
+    end
+
+    def to_hash
+      {"$ns" => @namespace, "$id" => @object_id }
+    end
+
+  end
+  
   # Generic Mongo Ruby Driver exception class.
   class MongoRubyError < StandardError; end