jmongo 1.0.3 → 1.1.0

data/lib/jmongo/exceptions.rb

@@ -2,4 +2,43 @@ module Mongo
   MongoDBException = Java::ComMongodb::MongoException
   NetworkException = Java::ComMongodb::MongoException::Network
   DuplicateKeyException = Java::ComMongodb::MongoException::DuplicateKey
+
+    # Generic Mongo Ruby Driver exception class.
+  class MongoRubyError < StandardError; end
+
+  # Raised when MongoDB itself has returned an error.
+  class MongoDBError < RuntimeError; end
+
+  # Raised when invalid arguments are sent to Mongo Ruby methods.
+  class MongoArgumentError < MongoRubyError; end
+
+  # Raised on failures in connection to the database server.
+  class ConnectionError < MongoRubyError; end
+
+  # Raised on failures in connection to the database server.
+  class ReplicaSetConnectionError < ConnectionError; end
+
+  # Raised on failures in connection to the database server.
+  class ConnectionTimeoutError < MongoRubyError; end
+
+  # Raised when a connection operation fails.
+  class ConnectionFailure < MongoDBError; end
+
+  # Raised when authentication fails.
+  class AuthenticationError < MongoDBError; end
+
+  # Raised when a database operation fails.
+  class OperationFailure < MongoDBError; end
+
+  # Raised when a socket read operation times out.
+  class OperationTimeout < MongoDBError; end
+
+  # Raised when a client attempts to perform an invalid operation.
+  class InvalidOperation < MongoDBError; end
+
+  # Raised when an invalid collection or database name is used (invalid namespace name).
+  class InvalidNSName < RuntimeError; end
+
+  # Raised when the client supplies an invalid value to sort by.
+  class InvalidSortValueError < MongoRubyError; end
 end

data/lib/jmongo/mongo/bson.rb

@@ -0,0 +1,130 @@
+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
+
+  OrderedHash = Java::ComMongodb::BasicDBObject
+  BsonCode = Java::OrgBsonTypes::CodeWScope
+
+  class ObjectId
+    def self.from_string(str)
+      v = is_valid?(str.to_s)
+      raise BSON::InvalidObjectId, "illegal ObjectID format" unless v
+      new(str.to_s)
+    end
+
+    def self.create_pk(doc)
+      doc.has_key?(:_id) || doc.has_key?('_id') ? doc : doc.merge!(:_id => self.new)
+    end
+
+    def self.from_time(time, opts={})
+      unique = opts.fetch(:unique, false)
+      if unique
+        self.new(time)
+      else
+        self.new([time.to_i,0,0].pack("NNN").to_java_bytes)
+      end
+    end
+
+    #"data=", "decode64", "encode64", "decode_b", "b64encode" - shout out if these methods are needed
+
+    def data
+      self.to_byte_array.to_a.map{|x| x & 0xFF}
+    end
+
+    def clone
+      self.class.new(self.to_byte_array)
+    end
+
+    def inspect
+      "BSON::ObjectID('#{self.to_s}')"
+    end
+
+    def generation_time
+      Time.at(self.get_time/1000).utc
+    end
+  end
+
+  class MaxKey
+    def ==(obj)
+      obj.class == self.class
+    end
+  end
+
+  class MinKey
+    def ==(obj)
+      obj.class == self.class
+    end
+  end
+
+  class Code
+    # Wrap code to be evaluated by MongoDB.
+    #
+    # @param [String] code the JavaScript code.
+    # @param [Hash] a document mapping identifiers to values, which
+    #   represent the scope in which the code is to be executed.
+    def initialize(code, scope={})
+      unless code.is_a?(String)
+        raise ArgumentError, "BSON::Code must be in the form of a String; #{code.class} is not accepted."
+      end
+      @bson_code  = BsonCode.new(code, scope.to_bson)
+    end
+
+    def code
+      @bson_code.code
+    end
+
+    def scope
+      @bson_code.scope
+    end
+
+    def length
+      code.length
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        code == other.code && scope == other.scope
+    end
+
+    def inspect
+      "<BSON::Code:#{object_id} @code=\"#{code}\" @scope=\"#{scope.inspect}\">"
+    end
+
+    def to_s
+      code.to_s
+    end
+
+    def to_bson
+      @bson_code
+    end
+    alias :to_bson_code :to_bson
+  end
+
+  # Generic Mongo Ruby Driver exception class.
+  class MongoRubyError < StandardError; end
+
+  # Raised when MongoDB itself has returned an error.
+  class MongoDBError < RuntimeError; end
+
+  # This will replace MongoDBError.
+  class BSONError < MongoDBError; end
+
+  # Raised when given a string is not valid utf-8 (Ruby 1.8 only).
+  class InvalidStringEncoding < BSONError; end
+
+  # Raised when attempting to initialize an invalid ObjectId.
+  class InvalidObjectId < BSONError; end
+  class InvalidObjectID < BSONError; end
+
+  # Raised when trying to insert a document that exceeds the 4MB limit or
+  # when the document contains objects that can't be serialized as BSON.
+  class InvalidDocument < BSONError; end
+
+  # Raised when an invalid name is used.
+  class InvalidKeyName < BSONError; end
+end

data/lib/jmongo/mongo/collection.rb

@@ -0,0 +1,185 @@
+# Copyright (C) 2010 Guy Boertje
+
+module Mongo
+  module JavaImpl
+    module Collection_
+
+      private
+
+      def name_from opts
+        return unless (opts[:name] || opts['name'])
+        name = opts.delete(:name) || opts.delete('name')
+        name ? name.to_s : nil
+      end
+
+      def _drop_index(spec)
+        name = generate_index_name(spec.is_a?(String) || spec.is_a?(Symbol) ? spec : parse_index_spec(spec))
+        idx = @db.index_information(@name).values.select do |entry|
+          entry['name'] == name || name == generate_index_name(entry['key'])
+        end
+        if idx.nil? || idx.empty?
+          raise MongoDBError, "Error with drop_index command for: #{name}"
+        end
+        @j_collection.dropIndexes(idx.first['name'].to_s)
+      end
+
+      def _create_indexes(obj,opts = {})
+        name = name_from(opts)
+        field_spec = parse_index_spec(obj)
+        opts[:dropDups] = opts[:drop_dups] if opts[:drop_dups]
+        if obj.is_a?(String) || obj.is_a?(Symbol)
+          name = obj.to_s unless name
+        end
+        name = generate_index_name(field_spec) unless name
+        opts['name'] = name
+        begin
+          @j_collection.ensureIndex(to_dbobject(field_spec),to_dbobject(opts))
+        rescue => e
+          if opts[:dropDups] && e.message =~ /E11000/
+            # NOP. If the user is intentionally dropping dups, we can ignore duplicate key errors.
+          else
+            msg = "Failed to create index #{field_spec.inspect} with the following error: #{e.message}"
+            raise Mongo::OperationFailure, msg
+          end
+        end
+        name
+      end
+
+      def generate_index_name(spec)
+        return spec.to_s if spec.is_a?(String) || spec.is_a?(Symbol)
+        indexes = []
+        spec.each_pair do |field, direction|
+          dir = sort_value(field,direction)
+          indexes.push("#{field}_#{dir}")
+        end
+        indexes.join("_")
+      end
+
+      def parse_index_spec(spec)
+        field_spec = Hash.new
+        if spec.is_a?(String) || spec.is_a?(Symbol)
+          field_spec[spec.to_s] = 1
+        elsif spec.is_a?(Array) && spec.all? {|field| field.is_a?(Array) }
+          spec.each do |f|
+            if [Mongo::ASCENDING, Mongo::DESCENDING, Mongo::GEO2D].include?(f[1])
+              field_spec[f[0].to_s] = f[1]
+            else
+              raise MongoArgumentError, "Invalid index field #{f[1].inspect}; " +
+                "should be one of Mongo::ASCENDING (1), Mongo::DESCENDING (-1) or Mongo::GEO2D ('2d')."
+            end
+          end
+        else
+          raise MongoArgumentError, "Invalid index specification #{spec.inspect}; " +
+            "should be either a string, symbol, or an array of arrays."
+        end
+        field_spec
+      end
+
+      def remove_documents(obj, safe=nil)
+        concern = write_concern(safe)
+        wr = @j_collection.remove(to_dbobject(obj), concern)
+        return from_dbobject(wr.last_error(concern)) if concern.call_get_last_error
+        true
+      end
+
+      ## Note: refactor when java driver fully supports continue_on_error
+      def insert_documents(obj, safe=nil, continue_on_error=false)
+        to_do = [obj].flatten
+        concern = write_concern(safe)
+        if continue_on_error
+          out = []
+          to_do.each do |doc|
+            res = _insert_one(doc, concern)
+            out << res if res
+          end
+          if to_do.size != out.size
+            msg = "Failed to insert document #{obj.inspect}, duplicate key"
+            raise(Mongo::OperationFailure, msg)
+          end
+        else
+          begin
+            @j_collection.insert( to_dbobject(to_do), concern )
+          rescue => ex
+            if ex.message =~ /E11000/
+              msg = "Failed to insert document #{obj.inspect}, duplicate key, E11000"
+              raise(Mongo::OperationFailure, msg)
+            else
+              msg = "Failed to insert document #{obj.inspect} db error: #{ex.message}"
+              raise Mongo::MongoDBError, msg
+            end
+          end
+        end
+        to_do
+      end
+
+      def _insert_one(obj, concern)
+        one_obj = [obj].flatten.first
+        dbo = to_dbobject(one_obj)
+        begin
+          jres = @j_collection.insert( dbo, concern )
+          result = from_dbobject(jres.get_last_error(concern))
+        rescue => ex
+          if ex.message =~ /E11000/ #noop duplicate key
+            result = {'err'=>ex.message}
+          else
+            msg = "Failed to insert document #{obj.inspect} db error: #{ex.message}"
+            raise Mongo::MongoDBError, msg
+          end
+        end
+        doc = from_dbobject(dbo)
+        result["err"] =~ /E11000/ ? nil : doc
+      end
+
+      def find_and_modify_document(query,fields,sort,remove,update,new_,upsert)
+        from_dbobject @j_collection.find_and_modify(to_dbobject(query),to_dbobject(fields),to_dbobject(sort),remove,to_dbobject(update),new_,upsert)
+      end
+
+      def find_one_document(spec, opts = {})
+        opts[:skip] = 0
+        opts[:batch_size] = -1
+        opts[:limit] = 0
+        doc = nil
+        self.find(spec, opts) { |c| doc = c.next }
+        doc
+      end
+
+      def update_documents(selector, document, upsert=false, multi=false, safe=nil)
+        begin
+          @j_collection.update(to_dbobject(selector),to_dbobject(document), upsert, multi, write_concern(safe))
+        rescue => ex
+          if ex.message =~ /E11001/
+            msg = "Failed to update document #{document.inspect}, duplicate key"
+            raise(Mongo::OperationFailure, msg)
+          else
+            msg = "Failed to update document #{document.inspect} db error: #{ex.message}"
+            raise Mongo::MongoDBError, msg
+          end
+        end
+      end
+
+      def save_document(obj, safe=nil)
+        @pk_factory.create_pk(obj)
+        db_obj = to_dbobject(obj)
+        concern = write_concern(safe)
+        begin
+          @j_collection.save( db_obj, concern )
+        rescue => ex
+          if ex.message =~ /E11000/
+            msg = "Failed to insert document #{obj.inspect}, duplicate key"
+            raise(Mongo::OperationFailure, msg)
+          else
+            msg = "Failed to insert document #{obj.inspect} db error: #{ex.message}"
+            raise Mongo::MongoDBError, msg
+          end
+        end
+        db_obj['_id']
+      end
+
+      # def id_nil?(obj)
+      #   return true if obj.has_key?(:_id) && obj[:_id].nil?
+      #   return true if obj.has_key?('_id') && obj['_id'].nil?
+      #   false
+      # end
+    end
+  end
+end

data/lib/jmongo/mongo/connection.rb

@@ -0,0 +1,45 @@
+# Copyright (C) 2010 Guy Boertje
+
+module Mongo
+  module JavaImpl
+    module Connection_
+      module InstanceMethods
+
+        private
+
+        def get_db_names
+          @connection.get_database_names
+        end
+
+        def drop_a_db name
+          @connection.drop_database(name)
+        end
+      end
+
+      module ClassMethods
+        URI_RE = /^mongodb:\/\/(([-.\w]+):([^@]+)@)?([-.\w]+)(:([\w]+))?(\/([-\w]+))?/
+        OPTS_KEYS = %W[maxpoolsize waitqueuemultiple waitqueuetimeoutms connecttimeoutms sockettimeoutms
+                       autoconnectretry slaveok safe w wtimeout fsync]
+
+        def _from_uri uri, opts={}
+          optarr = []
+          unless uri =~ URI_RE
+            raise MongoArgumentError, "MongoDB URI incorrect"
+          end
+          pieces = uri.split("//")
+          extra = pieces.last.count('/') == 0 ? "/" : ""
+          opts.each do|k,v|
+            if OPTS_KEYS.include?(k.to_s) && !v.nil?
+              (optarr << "#{k}=#{v}")
+            end
+          end
+          unless optarr.empty?
+            uri << "#{extra}?" << optarr.join("&")
+          end
+          opts[:new_from_uri] = Java::ComMongodb::MongoURI.new(uri)
+          new("",0,opts)
+        end
+      end
+    end
+  end
+end

data/lib/jmongo/mongo/db.rb

@@ -0,0 +1,31 @@
+# Copyright (C) 2010 Guy Boertje
+
+module Mongo
+  module JavaImpl
+    module Db_
+      SYSTEM_NAMESPACE_COLLECTION = "system.namespaces"
+      SYSTEM_PROFILE_COLLECTION = "system.profile"
+
+      private
+
+      def exec_command(cmd)
+        cmd_hash = cmd.kind_of?(Hash) ? cmd : {cmd => 1}
+        cmd_res = @j_db.command(to_dbobject(cmd_hash))
+        from_dbobject(cmd_res)
+      end
+
+      def do_eval(string, *args)
+        @j_db.do_eval(string, *args)
+      end
+
+      def has_coll(name)
+        @j_db.collection_exists(name)
+      end
+
+      def get_last_error
+        from_dbobject @j_db.get_last_error
+      end
+
+    end
+  end
+end

data/lib/jmongo/mongo/jmongo.rb

@@ -0,0 +1,44 @@
+module JMongo
+  java_import com.mongodb.BasicDBList
+  java_import com.mongodb.BasicDBObject
+  java_import com.mongodb.Bytes
+  java_import com.mongodb.DB
+  java_import com.mongodb.DBRef
+  java_import com.mongodb.DBCollection
+  java_import com.mongodb.DBCursor
+  java_import com.mongodb.DBObject
+  java_import com.mongodb.Mongo
+  java_import com.mongodb.MongoOptions
+  java_import com.mongodb.ServerAddress
+  java_import com.mongodb.WriteConcern
+  java_import com.mongodb.WriteResult
+  java_import com.mongodb.MongoException
+  java_import com.mongodb.MongoURI
+  java_import com.mongodb.MapReduceCommand
+  java_import com.mongodb.MapReduceOutput
+end
+
+class Java::ComMongodb::BasicDBObject
+  def self.[](*args)
+    Hash[*args]
+  end
+
+  if RUBY_PLATFORM == 'java' && JRUBY_VERSION =~ /(1\.[6-9]|[2-9]\.[0-9])..*/
+    def hashify
+      self.to_map.to_hash
+    end
+  else
+    def hashify
+      Hash[self.key_set.to_a.zip(self.values.to_a)]
+    end
+  end
+  def get(key)
+    self.java_send(:get,key.to_s)
+  end
+end
+
+class Java::ComMongodb::BasicDBList
+  def arrayify
+    self.to_array
+  end
+end