jmongo 1.0.3 → 1.1.0

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+gemspec
+
+gem 'rake'
+gem 'shoulda'
+gem 'mocha'
+
+

data/Gemfile.lock

@@ -0,0 +1,43 @@
+PATH
+  remote: .
+  specs:
+    jmongo (1.0.3)
+      require_all (~> 1.2)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    awesome_print (0.4.0)
+    diff-lcs (1.1.3)
+    fuubar (0.0.6)
+      rspec (~> 2.0)
+      rspec-instafail (~> 0.1.8)
+      ruby-progressbar (~> 0.0.10)
+    metaclass (0.0.1)
+    mocha (0.10.0)
+      metaclass (~> 0.0.1)
+    rake (0.9.2)
+    require_all (1.2.0)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-instafail (0.1.8)
+    rspec-mocks (2.6.0)
+    ruby-progressbar (0.0.10)
+    shoulda (2.11.3)
+
+PLATFORMS
+  java
+
+DEPENDENCIES
+  awesome_print (~> 0.4)
+  fuubar (~> 0.0)
+  jmongo!
+  mocha
+  rake
+  rspec (~> 2.6)
+  shoulda

data/Rakefile

@@ -116,3 +116,75 @@ task :validate do
     exit!
   end
 end
+
+require 'rake/testtask'
+
+task :test do
+  puts "\nTo test the pure jruby driver: \nrake test:jruby\n\n"
+end
+
+namespace :test do
+
+  desc "Test the driver using pure jruby (no C extension)"
+  task :jruby do
+    ENV['C_EXT'] = nil
+    if ENV['TEST']
+      Rake::Task['test:functional'].invoke
+    else
+      Rake::Task['test:unit'].invoke
+      Rake::Task['test:functional'].invoke
+      Rake::Task['test:bson'].invoke
+      Rake::Task['test:pooled_threading'].invoke
+      Rake::Task['test:drop_databases'].invoke
+    end
+  end
+
+  desc "Run the replica set test suite"
+  Rake::TestTask.new(:rs) do |t|
+    t.test_files = FileList['test/replica_sets/*_test.rb']
+    t.verbose    = true
+    t.ruby_opts << '-w'
+  end
+
+  Rake::TestTask.new(:unit) do |t|
+    t.test_files = FileList['test/unit/*_test.rb']
+    t.verbose    = true
+    t.ruby_opts << '-w'
+  end
+
+  Rake::TestTask.new(:functional) do |t|
+    t.test_files = FileList['test/*_test.rb']
+    t.verbose    = true
+    t.ruby_opts << '-w'
+  end
+
+  Rake::TestTask.new(:pooled_threading) do |t|
+    t.test_files = FileList['test/threading/*_test.rb']
+    t.verbose    = true
+    t.ruby_opts << '-w'
+  end
+
+  Rake::TestTask.new(:auto_reconnect) do |t|
+    t.test_files = FileList['test/auxillary/autoreconnect_test.rb']
+    t.verbose    = true
+    t.ruby_opts << '-w'
+  end
+
+  Rake::TestTask.new(:authentication) do |t|
+    t.test_files = FileList['test/auxillary/authentication_test.rb']
+    t.verbose    = true
+    t.ruby_opts << '-w'
+  end
+
+  Rake::TestTask.new(:new_features) do |t|
+    t.test_files = FileList['test/auxillary/1.4_features.rb']
+    t.verbose    = true
+    t.ruby_opts << '-w'
+  end
+
+  Rake::TestTask.new(:bson) do |t|
+    t.test_files = FileList['test/bson/*_test.rb']
+    t.verbose    = true
+    t.ruby_opts << '-w'
+  end
+end

data/jmongo.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name              = 'jmongo'
-  s.version           = '1.0.3'
-  s.date              = '2011-09-16'
+  s.version           = '1.1.0'
+  s.date              = '2011-10-03'
   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"]
@@ -11,6 +11,8 @@ Gem::Specification.new do |s|
 
   # = MANIFEST =
   s.files = %w[
+    Gemfile
+    Gemfile.lock
     History.txt
     LICENSE.txt
     README.txt
@@ -18,18 +20,94 @@ Gem::Specification.new do |s|
     bin/jmongo
     jmongo.gemspec
     lib/jmongo.rb
-    lib/jmongo/ajrb.rb
     lib/jmongo/collection.rb
     lib/jmongo/connection.rb
     lib/jmongo/cursor.rb
     lib/jmongo/db.rb
     lib/jmongo/exceptions.rb
-    lib/jmongo/jmongo_jext.rb
-    lib/jmongo/mongo-2.6.3.jar
-    lib/jmongo/utils.rb
+    lib/jmongo/mongo-2.6.5.gb1.jar
+    lib/jmongo/mongo/bson.rb
+    lib/jmongo/mongo/collection.rb
+    lib/jmongo/mongo/connection.rb
+    lib/jmongo/mongo/db.rb
+    lib/jmongo/mongo/jmongo.rb
+    lib/jmongo/mongo/mongo.rb
+    lib/jmongo/mongo/ruby_ext.rb
+    lib/jmongo/mongo/utils.rb
     lib/jmongo/version.rb
     spec/jmongo_spec.rb
     spec/spec_helper.rb
+    test-results.txt
+    test/auxillary/1.4_features.rb
+    test/auxillary/authentication_test.rb
+    test/auxillary/autoreconnect_test.rb
+    test/auxillary/fork_test.rb
+    test/auxillary/repl_set_auth_test.rb
+    test/auxillary/slave_connection_test.rb
+    test/auxillary/threaded_authentication_test.rb
+    test/bson/binary_test.rb
+    test/bson/bson_test.rb
+    test/bson/byte_buffer_test.rb
+    test/bson/hash_with_indifferent_access_test.rb
+    test/bson/json_test.rb
+    test/bson/object_id_test.rb
+    test/bson/ordered_hash_test.rb
+    test/bson/test_helper.rb
+    test/bson/timestamp_test.rb
+    test/collection_test.rb
+    test/connection_test.rb
+    test/conversions_test.rb
+    test/cursor_fail_test.rb
+    test/cursor_message_test.rb
+    test/cursor_test.rb
+    test/data/empty_data
+    test/data/sample_data
+    test/data/sample_file.pdf
+    test/data/small_data.txt
+    test/db_api_test.rb
+    test/db_connection_test.rb
+    test/db_test.rb
+    test/grid_file_system_test.rb
+    test/grid_io_test.rb
+    test/grid_test.rb
+    test/load/thin/config.ru
+    test/load/thin/config.yml.template
+    test/load/thin/load.rb
+    test/load/unicorn/config.ru
+    test/load/unicorn/load.rb
+    test/load/unicorn/unicorn.rb.template
+    test/replica_sets/connect_test.rb
+    test/replica_sets/connection_string_test.rb
+    test/replica_sets/count_test.rb
+    test/replica_sets/insert_test.rb
+    test/replica_sets/pooled_insert_test.rb
+    test/replica_sets/query_secondaries.rb
+    test/replica_sets/query_test.rb
+    test/replica_sets/read_preference_test.rb
+    test/replica_sets/refresh_test.rb
+    test/replica_sets/replication_ack_test.rb
+    test/replica_sets/rs_test_helper.rb
+    test/safe_test.rb
+    test/support/hash_with_indifferent_access.rb
+    test/support/keys.rb
+    test/support_test.rb
+    test/test_helper.rb
+    test/threading/threading_with_large_pool_test.rb
+    test/threading_test.rb
+    test/tools/auth_repl_set_manager.rb
+    test/tools/keyfile.txt
+    test/tools/repl_set_manager.rb
+    test/unit/collection_test.rb
+    test/unit/connection_test.rb
+    test/unit/cursor_test.rb
+    test/unit/db_test.rb
+    test/unit/grid_test.rb
+    test/unit/node_test.rb
+    test/unit/pool_manager_test.rb
+    test/unit/pool_test.rb
+    test/unit/read_test.rb
+    test/unit/safe_test.rb
+    test/uri_test.rb
   ]
   # = MANIFEST =
 

data/lib/jmongo.rb

@@ -1,7 +1,7 @@
-# Copyright (C) 2010 Chuck Remes
+# Copyright (C) 2010 Chuck Remes, Guy Boertje
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
+# you may not use this file except in coSmpliance with the License.
 # You may obtain a copy of the License at
 #
 #     http://www.apache.org/licenses/LICENSE-2.0
@@ -17,19 +17,11 @@ unless RUBY_PLATFORM =~ /java/
   exit 255
 end
 
+require 'timeout'
+require 'java'
+
 require 'require_all'
 require_rel 'jmongo/*.jar'
 
-# import all of the java packages we'll need into the JMongo namespace
-require 'jmongo/jmongo_jext'
-require_rel 'jmongo/*.rb'
-
-module Mongo
-  ASCENDING  =  1
-  DESCENDING = -1
-  GEO2D      = '2d'
+require_rel 'jmongo/**/*.rb'
 
-  module Constants
-    DEFAULT_BATCH_SIZE = 100
-  end
-end

data/lib/jmongo/collection.rb

@@ -35,30 +35,31 @@ module Mongo
     # @return [Collection]
     #
     # @core collections constructor_details
-    def initialize(db, name, pk_factory=nil)
-      case name
-      when Symbol, String
-      else
-        raise TypeError, "new_name must be a string or symbol"
+    #db, name, options=nil, j_collection=nil
+    def initialize(*args)
+      j_collection = nil
+      @opts = {}
+      if args.size == 4
+        j_collection = args.pop
       end
-
-      name = name.to_s
-
-      if name.empty? or name.include? ".."
-        raise Mongo::InvalidNSName, "collection names cannot be empty"
+      if args.size == 3
+        @opts = args.pop
       end
-      if name.include? "$"
-        raise Mongo::InvalidNSName, "collection names must not contain '$'" unless name =~ /((^\$cmd)|(oplog\.\$main))/
+      if args.size < 2
+        raise ArgumentError.new("Must supply at least name and db parameters")
       end
-      if name.match(/^\./) or name.match(/\.$/)
-        raise Mongo::InvalidNSName, "collection names must not start or end with '.'"
+      if args.first.respond_to?('collection_names')
+        db, name = args
+      else
+        name, db = args
       end
 
-      @db, @j_db, @name  = db, db.j_db, name
+      @name = validate_name(name)
+      @db, @j_db  = db, db.j_db
       @connection = @db.connection
-      @pk_factory = pk_factory || BSON::ObjectId
+      @pk_factory = @opts[:pk] || BSON::ObjectId
       @hint = nil
-      @j_collection = @j_db.getCollection @name
+      @j_collection = j_collection || @j_db.get_collection(@name)
     end
 
     # Return a sub-collection of this collection by name. If 'users' is a collection, then
@@ -73,8 +74,14 @@ module Mongo
     # @return [Collection]
     #   the specified sub-collection
     def [](name)
+      new_name = "#{self.name}.#{name}"
+      validate_name new_name
+      @db.create_collection(new_name, @opts)
     end
 
+    def capped?
+      @j_collection.isCapped
+    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.
@@ -131,29 +138,34 @@ module Mongo
     #
     # @core find find-instance_method
     def find(selector={}, opts={})
-      fields = opts.delete(:fields)
-      fields = ["_id"] if fields && fields.empty?
+      fields = prep_fields(opts.delete(:fields))
       skip   = opts.delete(:skip) || skip || 0
       limit  = opts.delete(:limit) || 0
       sort   = opts.delete(:sort)
       hint   = opts.delete(:hint)
       snapshot = opts.delete(:snapshot)
       batch_size = opts.delete(:batch_size)
-      if opts[:timeout] == false && !block_given?
+      timeout    = (opts.delete(:timeout) == false) ? false : true
+      transformer = opts.delete(:transformer)
+      if timeout == false && !block_given?
         raise ArgumentError, "Timeout can be set to false only when #find is invoked with a block."
       end
-      timeout = block_given? ? (opts.delete(:timeout) || true) : true
+
       if hint
         hint = normalize_hint_fields(hint)
       else
         hint = @hint        # assumed to be normalized already
       end
+
       raise RuntimeError, "Unknown options [#{opts.inspect}]" unless opts.empty?
 
       cursor = Cursor.new(self, :selector => selector, :fields => fields, :skip => skip, :limit => limit,
-                          :order => sort, :hint => hint, :snapshot => snapshot, :timeout => timeout, :batch_size => batch_size)
+                                :order => sort, :hint => hint, :snapshot => snapshot,
+                                :batch_size => batch_size, :timeout => timeout,
+                                :transformer => transformer)
       if block_given?
         yield cursor
+        cursor.close
         nil
       else
         cursor
@@ -186,7 +198,11 @@ module Mongo
              else
                raise TypeError, "spec_or_object_id must be an instance of ObjectId or Hash, or nil"
              end
-      find_one_document(spec, opts)
+      begin
+        find_one_document(spec, opts)
+      rescue => ex
+        raise OperationFailure, ex.message
+      end
     end
 
     # Save a document to this collection.
@@ -225,8 +241,9 @@ module Mongo
       doc_or_docs = [doc_or_docs] unless doc_or_docs.kind_of?(Array)
       doc_or_docs.collect! { |doc| @pk_factory.create_pk(doc) }
       safe = (options[:safe] || false)
-      result = insert_documents(doc_or_docs,safe)
-      result.size > 1 ? result : result.first
+      continue = (options[:continue_on_error] || false)
+      docs = insert_documents(doc_or_docs, safe, continue)
+      docs.size == 1 ? docs.first['_id'] : docs.collect{|doc| doc['_id']}
     end
     alias_method :<<, :insert
 
@@ -279,7 +296,7 @@ module Mongo
     def update(selector, document, options={})
       upsert, multi = !!(options[:upsert]), !!(options[:multi])
       safe = (options[:safe] || false)
-      update_documents(selector, document,upsert,multi,safe)
+      update_documents(selector, document, upsert, multi, safe)
     end
 
     # Create a new index.
@@ -325,17 +342,21 @@ module Mongo
     #
     # @core indexes create_index-instance_method
     def create_index(spec, opts={})
-      create_indexes(spec,opts)
+      _create_indexes(spec, opts)
     end
     alias_method :ensure_index, :create_index
 
     # Drop a specified index.
     #
-    # @param [String] name
+    # @param [String, Array] spec
+    #   should be either a single field name or an array of
+    #   [field name, direction] pairs. Directions should be specified
+    #   as Mongo::ASCENDING, Mongo::DESCENDING, or Mongo::GEO2D.
     #
     # @core indexes
-    def drop_index(name)
-      @j_collection.dropIndexes(name)
+    def drop_index(spec)
+      raise MongoArgumentError, "Cannot drop index for nil name" unless name
+      _drop_index(spec)
     end
 
     # Drop all indexes.
@@ -369,12 +390,14 @@ module Mongo
     def find_and_modify(opts={})
       query  = opts[:query] || {}
       fields = opts[:fields] || {}
-      sort   = opts[:sort] || {}
+      sort   = prep_sort(opts[:sort] || [])
       update = opts[:update] || {}
       remove = opts[:remove] || false
       new_    = opts[:new] || false
       upsert = opts[:upsert] || false
-      find_and_modify_document(query, fields, sort, remove, update, new_, upsert)
+      trap_raise(OperationFailure) do
+        find_and_modify_document(query, fields, sort, remove, update, new_, upsert)
+      end
     end
 
     # Perform a map/reduce operation on the current collection.
@@ -399,72 +422,125 @@ module Mongo
     #
     # @core mapreduce map_reduce-instance_method
     def map_reduce(map, reduce, opts={})
-      map    = BSON::Code.new(map) unless map.is_a?(BSON::Code)
-      reduce = BSON::Code.new(reduce) unless reduce.is_a?(BSON::Code)
-
-      hash = OrderedHash.new
-      hash['mapreduce'] = self.name
-      hash['map'] = map
-      hash['reduce'] = reduce
-      hash.merge! opts
-
-      result = @db.command(hash)
-      unless result["ok"] == 1
-        raise Mongo::OperationFailure, "map-reduce failed: #{result['errmsg']}"
+      query = opts.fetch(:query,{})
+      sort = opts.fetch(:sort,[])
+      limit = opts.fetch(:limit,0)
+      finalize = opts[:finalize]
+      out = opts[:out]
+      keeptemp = opts.fetch(:keeptemp,true)
+      verbose = opts.fetch(:verbose,true)
+      raw     = opts.delete(:raw)
+
+      m = map.to_s
+      r = reduce.to_s
+
+      mrc = case out
+          when String
+            JMongo::MapReduceCommand.new(@j_collection, m, r, out, REPLACE, to_dbobject(query))
+          when Hash
+            if out.keys.size != 1
+              raise ArgumentError, "You need to specify one key value pair in the out hash"
+            end
+            out_type = out.keys.first
+            out_val = out[out_type]
+            unless MapReduceEnumHash.keys.include?(out_type)
+              raise ArgumentError, "Your out hash must have one of these keys: #{MapReduceEnumHash.keys}"
+            end
+            out_type_enum = MapReduceEnumHash[out_type]
+            out_dest = out_val.is_a?(String) ? out_val : nil
+            JMongo::MapReduceCommand.new(@j_collection, m, r, out_dest, out_type_enum, to_dbobject(query))
+          else
+            raise ArgumentError, "You need to specify an out parameter in the options hash"
+          end
+
+      mrc.verbose = verbose
+      mrc.sort = prep_sort(sort)
+      mrc.limit = limit
+      mrc.finalize = finalize
+      result =  from_dbobject(@j_db.command(mrc.toDBObject))
+
+      if raw
+        result
+      elsif result["result"]
+        @db[result["result"]]
+      else
+        raise ArgumentError, "Could not instantiate collection from result. If you specified " +
+          "{:out => {:inline => true}}, then you must also specify :raw => true to get the results."
       end
-      @db[result["result"]]
     end
     alias :mapreduce :map_reduce
 
     # Perform a group aggregation.
     #
-    # @param [Array, String, BSON::Code, Nil] :key either 1) an array of fields to group by,
-    #   2) a javascript function to generate the key object, or 3) nil.
-    # @param [Hash] condition an optional document specifying a query to limit the documents over which group is run.
-    # @param [Hash] initial initial value of the aggregation counter object
-    # @param [String, BSON::Code] reduce aggregation function, in JavaScript
-    # @param [String, BSON::Code] finalize :: optional. a JavaScript function that receives and modifies
-    #              each of the resultant grouped objects. Available only when group is run
-    #              with command set to true.
-    #
-    # @return [Array] the grouped items.
-    def group(key, condition, initial, reduce, finalize=nil)
-      reduce = BSON::Code.new(reduce) unless reduce.is_a?(BSON::Code)
+    # @param [Hash] opts the options for this group operation. The minimum required are :initial
+    #   and :reduce.
+    #
+    # @option opts [Array, String, Symbol] :key (nil) Either the name of a field or a list of fields to group by (optional).
+    # @option opts [String, BSON::Code] :keyf (nil) A JavaScript function to be used to generate the grouping keys (optional).
+    # @option opts [String, BSON::Code] :cond ({}) A document specifying a query for filtering the documents over
+    #   which the aggregation is run (optional).
+    # @option opts [Hash] :initial the initial value of the aggregation counter object (required).
+    # @option opts [String, BSON::Code] :reduce (nil) a JavaScript aggregation function (required).
+    # @option opts [String, BSON::Code] :finalize (nil) a JavaScript function that receives and modifies
+    #   each of the resultant grouped objects. Available only when group is run with command
+    #   set to true.
+    #
+    # @return [Array] the command response consisting of grouped items.
+    def group(opts, condition={}, initial={}, reduce=nil, finalize=nil)
+      key = keyf = false
+      if opts.is_a?(Hash)
+        reduce, finalize, initial= opts.values_at(:reduce, :finalize, :initial)
+        key, keyf = opts.values_at(:key, :keyf)
+        condition = opts.fetch(:cond, {})
+        unless key.nil? && keyf.nil?
+          unless key.is_a?(Array) || keyf.is_a?(String) || keyf.is_a?(BSON::Code)
+            raise MongoArgumentError, "Group takes either an array of fields to group by or a JavaScript function" +
+              "in the form of a String or BSON::Code."
+          end
+        end
+      else
+        warn "Collection#group no longer take a list of parameters. This usage is deprecated and will be remove in v2.0." +
+             "Check out the new API at http://api.mongodb.org/ruby/current/Mongo/Collection.html#group-instance_method"
+        case opts
+        when Array
+          key = opts
+        when String, BSON::Code
+          keyf = opts
+        else
+          raise MongoArgumentError, "Group takes either an array of fields to group by or a JavaScript function" +
+          "in the form of a String or BSON::Code."
+        end
+      end
+
+      if !(reduce && initial)
+        raise MongoArgumentError, "Group requires at minimum values for initial and reduce."
+      end
 
-      group_command = {
+      cmd = {
         "group" => {
           "ns"      => @name,
-          "$reduce" => reduce,
+          "$reduce" => reduce.to_bson_code,
           "cond"    => condition,
           "initial" => initial
         }
       }
 
-      unless key.nil?
-        if key.is_a? Array
-          key_type = "key"
-          key_value = {}
-          key.each { |k| key_value[k] = 1 }
-        else
-          key_type  = "$keyf"
-          key_value = key.is_a?(BSON::Code) ? key : BSON::Code.new(key)
-        end
-
-        group_command["group"][key_type] = key_value
+      if keyf
+        cmd["group"]["$keyf"] = keyf.to_bson_code
+      elsif key
+        key_hash = Hash[key.zip( [1]*key.size )]
+        cmd["group"]["key"] = key_hash
       end
 
-      finalize = BSON::Code.new(finalize) if finalize.is_a?(String)
-      if finalize.is_a?(BSON::Code)
-        group_command['group']['finalize'] = finalize
+      if finalize
+        cmd['group']['finalize'] = finalize.to_bson_code
       end
 
-      result = @db.command group_command
+      result = from_dbobject(@db.command(cmd))
 
-      if result["ok"] == 1
-        result["retval"]
-      else
-        raise OperationFailure, "group command failed: #{result['errmsg']}"
-      end
+      return result["retval"] if Mongo.result_ok?(result)
+
+      raise OperationFailure, "group command failed: #{result['errmsg']}"
     end
 
     # Return a list of distinct values for +key+ across all
@@ -494,12 +570,11 @@ module Mongo
     # @return [Array] an array of distinct values.
     def distinct(key, query=nil)
       raise MongoArgumentError unless [String, Symbol].include?(key.class)
-      command = OrderedHash.new
-      command[:distinct] = @name
-      command[:key]      = key.to_s
-      command[:query]    = query
-
-      @db.command(command)["values"]
+      if query
+        from_dbobject @j_collection.distinct(key.to_s, to_dbobject(query))
+      else
+        from_dbobject @j_collection.distinct(key.to_s)
+      end
     end
 
     # Rename this collection.
@@ -511,25 +586,14 @@ module Mongo
     #
     # @raise [Mongo::InvalidNSName] if +new_name+ is an invalid collection name.
     def rename(new_name)
-      case new_name
-      when Symbol, String
-      else
-        raise TypeError, "new_name must be a string or symbol"
+      name = validate_name(new_name)
+      begin
+        jcol = @j_collection.rename(name)
+        @name = name
+        @j_collection = jcol
+      rescue => ex
+        raise MongoDBError, "Error renaming collection: #{name}, more: #{ex.message}"
       end
-
-      new_name = new_name.to_s
-
-      if new_name.empty? or new_name.include? ".."
-        raise Mongo::InvalidNSName, "collection names cannot be empty"
-      end
-      if new_name.include? "$"
-        raise Mongo::InvalidNSName, "collection names must not contain '$'"
-      end
-      if new_name.match(/^\./) or new_name.match(/\.$/)
-        raise Mongo::InvalidNSName, "collection names must not start or end with '.'"
-      end
-
-      @db.rename_collection(@name, new_name)
     end
 
     # Get information on the indexes for this collection.
@@ -546,7 +610,9 @@ module Mongo
     #
     # @return [Hash] options that apply to this collection.
     def options
-      @db.collections_info(@name).next_document['options']
+      info = @db.collections_info(@name).to_a
+      ap info
+      info.last['options']
     end
 
     # Return stats on the collection. Uses MongoDB's collstats command.
@@ -559,14 +625,36 @@ module Mongo
     # Get the number of documents in this collection.
     #
     # @return [Integer]
-    def count
-      @j_collection.count()
+    def count(opts={})
+      return @j_collection.count() if opts.empty?
+      query = opts[:query] || opts['query'] || {}
+      fields = opts[:fields] || opts['fields'] || {}
+      limit = opts[:limit] || opts['limit'] || 0
+      skip = opts[:skip] || opts['skip'] || 0
+      @j_collection.get_count(to_dbobject(query), to_dbobject(fields), limit, skip)
     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
@@ -576,16 +664,10 @@ module Mongo
       when nil
         nil
       else
-        h = OrderedHash.new
-        hint.to_a.each { |k| h[k] = 1 }
+        h = BSON::OrderedHash.new
+        hint.to_a.each { |k| h[k.to_s] = 1 }
         h
       end
     end
-
-    private
-
-    def generate_index_name(spec)
-      @j_collection.genIndexName(to_dbobject(spec))
-    end
   end
 end