jmongo 1.0.3 → 1.1.0

data/lib/jmongo/mongo/mongo.rb

@@ -0,0 +1,98 @@
+module Mongo
+  ASCENDING  =  1
+  DESCENDING = -1
+  GEO2D      = '2d'
+
+  DEFAULT_MAX_BSON_SIZE = 1024 * 1024 * 4
+
+  REPLACE  = JMongo::MapReduceCommand::OutputType::REPLACE
+  MERGE    = JMongo::MapReduceCommand::OutputType::MERGE
+  REDUCE   = JMongo::MapReduceCommand::OutputType::REDUCE
+  INLINE   = JMongo::MapReduceCommand::OutputType::INLINE
+
+  MapReduceEnumHash = {:replace => REPLACE, :merge => MERGE, :reduce => REDUCE, :inline => INLINE}
+
+  DEFAULT_BATCH_SIZE = 100
+
+  OP_REPLY        = 1
+  OP_MSG          = 1000
+  OP_UPDATE       = 2001
+  OP_INSERT       = 2002
+  OP_QUERY        = 2004
+  OP_GET_MORE     = 2005
+  OP_DELETE       = 2006
+  OP_KILL_CURSORS = 2007
+
+  OP_QUERY_TAILABLE          = JMongo::Bytes::QUERYOPTION_TAILABLE
+  OP_QUERY_SLAVE_OK          = JMongo::Bytes::QUERYOPTION_SLAVEOK
+  OP_QUERY_OPLOG_REPLAY      = JMongo::Bytes::QUERYOPTION_OPLOGREPLAY
+  OP_QUERY_NO_CURSOR_TIMEOUT = JMongo::Bytes::QUERYOPTION_NOTIMEOUT
+  OP_QUERY_AWAIT_DATA        = JMongo::Bytes::QUERYOPTION_AWAITDATA
+  OP_QUERY_EXHAUST           = JMongo::Bytes::QUERYOPTION_EXHAUST
+
+  REPLY_CURSOR_NOT_FOUND     = JMongo::Bytes::RESULTFLAG_CURSORNOTFOUND
+  REPLY_QUERY_FAILURE        = JMongo::Bytes::RESULTFLAG_ERRSET
+  REPLY_SHARD_CONFIG_STALE   = JMongo::Bytes::RESULTFLAG_SHARDCONFIGSTALE
+  REPLY_AWAIT_CAPABLE        = JMongo::Bytes::RESULTFLAG_AWAITCAPABLE
+
+  def self.logger(logger=nil)
+    logger ? @logger = logger : @logger
+  end
+
+  def self.result_ok?(result)
+    result['ok'] == 1.0 || result['ok'] == true
+  end
+
+  # Simple class for comparing server versions.
+  class ServerVersion
+    include Comparable
+
+    def initialize(version)
+      @version = version
+    end
+
+    # Implements comparable.
+    def <=>(new)
+      local, new  = self.to_a, to_array(new)
+      for n in 0...local.size do
+        break if elements_include_mods?(local[n], new[n])
+        if local[n] < new[n].to_i
+          result = -1
+          break;
+        elsif local[n] > new[n].to_i
+          result = 1
+          break;
+        end
+      end
+      result || 0
+    end
+
+    # Return an array representation of this server version.
+    def to_a
+      to_array(@version)
+    end
+
+    # Return a string representation of this server version.
+    def to_s
+      @version
+    end
+
+    private
+
+    # Returns true if any elements include mod symbols (-, +)
+    def elements_include_mods?(*elements)
+      elements.any? { |n| n =~ /[\-\+]/ }
+    end
+
+    # Converts argument to an array of integers,
+    # appending any mods as the final element.
+    def to_array(version)
+      array = version.split(".").map {|n| (n =~ /^\d+$/) ? n.to_i : n }
+      if array.last =~ /(\d+)([\-\+])/
+        array[array.length-1] = $1.to_i
+        array << $2
+      end
+      array
+    end
+  end
+end

data/lib/jmongo/mongo/ruby_ext.rb

@@ -0,0 +1,38 @@
+
+class String
+  def to_bson_code
+    BSON::Code.new(self)
+  end
+end
+
+class Symbol
+  def to_bson
+    BSON::Symbol.new(self.to_s)
+  end
+end
+
+class Object
+  def to_bson
+    self
+  end
+end
+
+class Hash
+  def to_bson
+    obj = ::JMongo::BasicDBObject.new
+    self.each_pair do |key, val|
+      obj.put( key.to_s, val.to_bson )
+    end
+    obj
+  end
+end
+
+class Array
+  def to_bson
+    list = Array.new #Java::ComMongodb::DBObject[ary.length].new
+    self.each_with_index do |ele, i|
+      list[i] = ele.to_bson
+    end
+    list
+  end
+end

data/lib/jmongo/mongo/utils.rb

@@ -0,0 +1,136 @@
+# Copyright (C) 2010 Guy Boertje
+
+module Mongo
+  module JavaImpl
+
+    module NoImplYetClass
+      def raise_not_implemented
+        raise NoMethodError, "This method hasn't been implemented yet."
+      end
+    end
+
+    module Utils
+      def raise_not_implemented
+        raise NoMethodError, "This method hasn't been implemented yet."
+      end
+
+      def trap_raise(ex_class, msg=nil)
+        begin
+          yield
+        rescue => ex
+          raise ex_class, msg ? "#{msg} - #{ex.message}" : ex.message
+        end
+      end
+
+      def prep_fields(fields)
+        case fields
+        when String, Symbol
+          {fields => 1}
+        when Array
+          fields << "_id" if fields.empty?
+          Hash[fields.zip( [1]*fields.size )]
+        when Hash
+          fields
+        end
+      end
+
+      def prep_sort(key_or_list=nil, direction=nil)
+        return if key_or_list.nil?
+        if !direction.nil?
+          order = [[key_or_list, direction]]
+        elsif key_or_list.is_a?(String) || key_or_list.is_a?(Symbol)
+          order = [[key_or_list.to_s, 1]]
+        else
+          order = [key_or_list]
+        end
+        hord = {}
+        order.flatten.each_slice(2){|k,v| hord[k] = sort_value(k,v)}
+        to_dbobject(hord)
+      end
+
+      def to_dbobject obj
+        if obj.respond_to?('to_bson')
+          obj.to_bson
+        elsif obj.respond_to?(:merge)
+          hash_to_dbobject(obj)
+        elsif obj.respond_to?(:compact)
+          array_to_dblist(obj)
+        else
+          obj
+        end
+      end
+
+      def from_dbobject obj
+        # for better upstream compatibility make the objects into ruby hash or array
+        
+        case obj
+        when Java::ComMongodb::BasicDBObject, Java::ComMongodb::CommandResult
+          h = obj.hashify
+          Hash[h.keys.zip(h.values.map{|v| from_dbobject(v)})]
+        when Java::ComMongodb::BasicDBList
+          obj.arrayify.map{|v| from_dbobject(v)}
+        when Java::JavaUtil::ArrayList
+          obj.map{|v| from_dbobject(v)}
+        when Java::JavaUtil::Date
+          Time.at(obj.get_time/1000.0)
+        when Java::OrgBsonTypes::Symbol
+          obj.toString.to_sym
+        else
+          obj
+        end
+      end
+
+      def sort_value(key, value)
+        val = value.to_s.downcase
+        return val if val == '2d'
+        direction = SortingHash[val]
+        return direction if direction != 0
+        raise InvalidSortValueError.new(
+          "for key: #{key}, #{value} was supplied as a sort direction when acceptable values are: " +
+          "Mongo::ASCENDING, 'ascending', 'asc', :ascending, :asc, 1, Mongo::DESCENDING, " +
+          "'descending', 'desc', :descending, :desc, -1.")
+      end
+
+      SortingHash = Hash.new(0).merge!(
+        "ascending" => 1, "asc" => 1, "1" => 1,
+        "descending" => -1, "desc" => -1, "-1" => -1
+      )
+
+      private
+
+      def hash_to_dbobject doc
+        obj = JMongo::BasicDBObject.new
+        doc.each_pair do |key, value|
+          obj.put(key.to_s, to_dbobject(value))
+        end
+        obj
+      end
+
+      def array_to_dblist ary
+        list = [] #Java::ComMongodb::DBObject[ary.length].new
+        ary.each_with_index do |ele, i|
+          list[i] = to_dbobject(ele)
+        end
+        list
+      end
+
+      #@collection.save({:doc => 'foo'}, :safe => nil)       ---> NONE = new WriteConcern(-1)
+      #@collection.save({:doc => 'foo'}, :safe => true)        ---> NORMAL = new WriteConcern(0)
+      #@collection.save({:doc => 'foo'}, :safe => {:w => 2})   ---> new WriteConcern( 2 , 0 , false)
+      #@collection.save({:doc => 'foo'}, :safe => {:w => 2, :wtimeout => 200})                 ---> new WriteConcern( 2 , 200 , false)
+      #@collection.save({:doc => 'foo'}, :safe => {:w => 2, :wtimeout => 200, :fsync => true}) ---> new WriteConcern( 2 , 0 , true)
+      #@collection.save({:doc => 'foo'}, :safe => {:fsync => true}) ---> FSYNC_SAFE = new WriteConcern( 1 , 0 , true)
+
+      def write_concern(safe)
+        return JMongo::WriteConcern.new(-1) if safe.nil?
+        return JMongo::WriteConcern.new(0) if safe.is_a?(FalseClass)
+        return JMongo::WriteConcern.new(1) if safe.is_a?(TrueClass)
+        return JMongo::WriteConcern.new(0) unless safe.is_a?(Hash)
+        w = safe[:w] || 1
+        t = safe[:wtimeout] || 0
+        f = !!(safe[:fsync] || false)
+        JMongo::WriteConcern.new(w, t, f) #dont laugh!
+      end
+    end
+  end
+end

data/lib/jmongo/version.rb

@@ -1,3 +1,3 @@
 module Mongo
-  VERSION = '1.0.3'
+  VERSION = '1.1.0'
 end

data/test-results.txt

@@ -0,0 +1,98 @@
+Loaded suite ./test/collection_test
+Started
+"test_map_reduce_with_raw_response"
+"function() { emit(this.user_id, 1); }"
+"function(k,vals) { return 1; }"
+{
+        "result" => "foo",
+    "timeMillis" => 18,
+        "timing" => {
+         "mapTime" => 0,
+        "emitLoop" => 17,
+           "total" => 18
+    },
+        "counts" => {
+         "input" => 3,
+          "emit" => 3,
+        "output" => 3
+    },
+            "ok" => 1.0
+}
+........."test_map_reduce_with_output_collection"
+"function() { emit(this.user_id, 1); }"
+"function(k,vals) { return 1; }"
+{
+        "result" => "test-map-coll",
+    "timeMillis" => 1,
+        "timing" => {
+         "mapTime" => 0,
+        "emitLoop" => 0,
+           "total" => 1
+    },
+        "counts" => {
+         "input" => 3,
+          "emit" => 3,
+        "output" => 3
+    },
+            "ok" => 1.0
+}
+....."test_map_reduce_with_code_objects"
+"function() { emit(this.user_id, 1); }"
+"function(k,vals) { return 1; }"
+{
+        "result" => "foo",
+    "timeMillis" => 1,
+        "timing" => {
+         "mapTime" => 0,
+        "emitLoop" => 0,
+           "total" => 1
+    },
+        "counts" => {
+         "input" => 2,
+          "emit" => 2,
+        "output" => 2
+    },
+            "ok" => 1.0
+}
+..."test_map_reduce_with_options"
+"function() { emit(this.user_id, 1); }"
+"function(k,vals) { return 1; }"
+{
+        "result" => "foo",
+    "timeMillis" => 1,
+        "timing" => {
+         "mapTime" => 0,
+        "emitLoop" => 0,
+           "total" => 1
+    },
+        "counts" => {
+         "input" => 2,
+          "emit" => 2,
+        "output" => 2
+    },
+            "ok" => 1.0
+}
+.."test_map_reduce"
+"function() { emit(this.user_id, 1); }"
+"function(k,vals) { return 1; }"
+{
+        "result" => "foo",
+    "timeMillis" => 1,
+        "timing" => {
+         "mapTime" => 0,
+        "emitLoop" => 0,
+           "total" => 1
+    },
+        "counts" => {
+         "input" => 2,
+          "emit" => 2,
+        "output" => 2
+    },
+            "ok" => 1.0
+}
+..............
+Finished in 0.304000 seconds.
+
+33 tests, 94 assertions, 0 failures, 0 errors, 0 skips
+
+Test run options: --seed 45344

data/test/auxillary/1.4_features.rb

@@ -0,0 +1,166 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'mongo'
+require 'test/unit'
+require './test/test_helper'
+
+# Demonstrate features in MongoDB 1.4
+class Features14Test < Test::Unit::TestCase
+
+  context "MongoDB 1.4" do
+    setup do
+      @con = Mongo::Connection.new
+      @db  = @con['mongo-ruby-test']
+      @col = @db['new-features']
+    end
+
+    teardown do
+      @col.drop
+    end
+
+    context "new query operators: " do
+
+      context "$elemMatch: " do
+        setup do
+          @col.save({:user => 'bob', :updates => [{:date => Time.now.utc, :body => 'skiing', :n => 1},
+                                                  {:date => Time.now.utc, :body => 'biking', :n => 2}]})
+
+          @col.save({:user => 'joe', :updates => [{:date => Time.now.utc, :body => 'skiing', :n => 2},
+                                                  {:date => Time.now.utc, :body => 'biking', :n => 10}]})
+        end
+
+        should "match a document with a matching object element in an array" do
+          doc = @col.find_one({"updates" => {"$elemMatch" => {"body" => "skiing", "n" => 2}}})
+          assert_equal 'joe', doc['user']
+        end
+
+        should "$elemMatch with a conditional operator" do
+          doc1 = @col.find_one({"updates" => {"$elemMatch" => {"body" => "biking", "n" => {"$gt" => 5}}}})
+          assert_equal 'joe', doc1['user']
+        end
+
+        should "note the difference between $elemMatch and a traditional match" do
+          doc = @col.find({"updates.body" => "skiing", "updates.n" => 2}).to_a
+          assert_equal 2, doc.size
+        end
+      end
+
+      context "$all with regexes" do
+        setup do
+          @col.save({:n => 1, :a => 'whale'})
+          @col.save({:n => 2, :a => 'snake'})
+        end
+
+        should "match multiple regexes" do
+          doc = @col.find({:a => {'$all' => [/ha/, /le/]}}).to_a
+          assert_equal 1, doc.size
+          assert_equal 1, doc.first['n']
+        end
+
+        should "not match if not every regex matches" do
+          doc = @col.find({:a => {'$all' => [/ha/, /sn/]}}).to_a
+          assert_equal 0, doc.size
+        end
+      end
+
+      context "the $not operator" do
+        setup do
+          @col.save({:a => ['x']})
+          @col.save({:a => ['x', 'y']})
+          @col.save({:a => ['x', 'y', 'z']})
+        end
+
+        should "negate a standard operator" do
+          results = @col.find({:a => {'$not' => {'$size' => 2}}}).to_a
+          assert_equal 2, results.size
+          results = results.map {|r| r['a']}
+          assert_equal ['x'], results.sort.first
+          assert_equal ['x', 'y', 'z'], results.sort.last
+        end
+      end
+    end
+
+    context "new update operators: " do
+
+      context "$addToSet (pushing a unique value)" do
+        setup do
+          @col.save({:username => 'bob', :interests => ['skiing', 'guitar']})
+        end
+
+        should "add an item to a set uniquely ($addToSet)" do
+          @col.update({:username => 'bob'}, {'$addToSet' => {'interests' => 'skiing'}})
+          @col.update({:username => 'bob'}, {'$addToSet' => {'interests' => 'kayaking'}})
+          document = @col.find_one({:username => 'bob'})
+          assert_equal ['guitar', 'kayaking', 'skiing'], document['interests'].sort
+        end
+
+        should "add an array of items uniquely ($addToSet with $each)" do
+          @col.update({:username => 'bob'}, {'$addToSet' => {'interests' => {'$each' => ['skiing', 'kayaking', 'biking']}}})
+          document = @col.find_one({:username => 'bob'})
+          assert_equal ['biking', 'guitar', 'kayaking', 'skiing'], document['interests'].sort
+        end
+      end
+
+      context "the positional operator ($)" do
+        setup do
+          @id1 = @col.insert({:text => 'hello',
+                             :comments => [{'by'   => 'bob',
+                                            'text' => 'lol!'},
+                                           {'by'   => 'susie',
+                                            'text' => 'bye bye!'}]})
+          @id2 = @col.insert({:text => 'goodbye',
+                            :comments => [{'by'   => 'bob',
+                                           'text' => 'au revoir'},
+                                          {'by'   => 'susie',
+                                           'text' => 'bye bye!'}]})
+        end
+
+        should "update a matching array item" do
+          @col.update({"_id" => @id1, "comments.by" => 'bob'}, {'$set' => {'comments.$.text' => 'lmao!'}}, :multi => true)
+          result = @col.find_one({"_id" => @id1})
+          assert_equal 'lmao!', result['comments'][0]['text']
+        end
+      end
+    end
+
+    context "Geoindexing" do
+      setup do
+        @places = @db['places']
+        @places.create_index([['loc', Mongo::GEO2D]])
+
+        @empire_state = ([40.748371, -73.985031])
+        @jfk = ([40.643711, -73.790009])
+
+        @places.insert({'name' => 'Empire State Building', 'loc' => ([40.748371, -73.985031])})
+        @places.insert({'name' => 'Flatiron Building', 'loc' => ([40.741581, -73.987549])})
+        @places.insert({'name' => 'Grand Central', 'loc' => ([40.751678, -73.976562])})
+        @places.insert({'name' => 'Columbia University', 'loc' => ([40.808922, -73.961617])})
+        @places.insert({'name' => 'NYSE', 'loc' => ([40.71455, -74.007124])})
+        @places.insert({'name' => 'JFK', 'loc' => ([40.643711, -73.790009])})
+      end
+
+      teardown do
+        @places.drop
+      end
+
+      should "find the nearest addresses" do
+        results = @places.find({'loc' => {'$near' => @empire_state}}).limit(2).to_a
+        assert_equal 2, results.size
+        assert_equal 'Empire State Building', results[0]['name']
+        assert_equal 'Flatiron Building', results[1]['name']
+      end
+
+      should "use geoNear command to return distances from a point" do
+        cmd = BSON::OrderedHash.new
+        cmd['geoNear'] = 'places'
+        cmd['near']    = @empire_state
+        cmd['num']     = 6
+        r = @db.command(cmd)
+
+        assert_equal 6, r['results'].length
+        r['results'].each do |result|
+          puts result.inspect
+        end
+      end
+    end
+  end
+end