mongo 1.2.rc1 → 1.2.rc2

data/lib/mongo.rb

@@ -3,7 +3,7 @@
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
 module Mongo
-  VERSION = "1.2.rc1"
+  VERSION = "1.2.rc2"
 end
 
 module Mongo

data/lib/mongo/collection.rb

@@ -556,17 +556,28 @@ module Mongo
 
     # 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)
+    # @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(key, condition={}, initial={}, reduce=nil, finalize=nil)
+      if key.is_a?(Hash)
+        return new_group(key)
+      else
+        warn "Collection#group no longer take a list of paramters. This usage is deprecated." +
+             "Check out the new API at http://api.mongodb.org/ruby/current/Mongo/Collection.html#group-instance_method"
+      end
+
       reduce = BSON::Code.new(reduce) unless reduce.is_a?(BSON::Code)
 
       group_command = {
@@ -578,6 +589,11 @@ module Mongo
         }
       }
 
+      if key.is_a?(Symbol)
+        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
+
       unless key.nil?
         if key.is_a? Array
           key_type = "key"
@@ -605,6 +621,48 @@ module Mongo
       end
     end
 
+    private
+
+    def new_group(opts={})
+      reduce   =  opts[:reduce]
+      finalize =  opts[:finalize]
+      cond     =  opts.fetch(:cond, {})
+      initial  =  opts[:initial]
+
+      if !(reduce && initial)
+        raise MongoArgumentError, "Group requires at minimum values for initial and reduce."
+      end
+
+      cmd = {
+        "group" => {
+          "ns"      => @name,
+          "$reduce" => reduce.to_bson_code,
+          "cond"    => cond,
+          "initial" => initial
+        }
+      }
+
+      if finalize
+        cmd['group']['finalize'] = finalize.to_bson_code
+      end
+
+      if key = opts[:key]
+        if key.is_a?(String) || key.is_a?(Symbol)
+          key = [key]
+        end
+        key_value = {}
+        key.each { |k| key_value[k] = 1 }
+        cmd["group"]["key"] = key_value
+      elsif keyf = opts[:keyf]
+        cmd["group"]["$keyf"] = keyf.to_bson_code
+      end
+
+      result = @db.command(cmd)
+      result["retval"]
+    end
+
+    public
+
     # Return a list of distinct values for +key+ across all
     # documents in the collection. The key may use dot notation
     # to reach into an embedded object.

data/lib/mongo/util/core_ext.rb

@@ -48,3 +48,13 @@ class Hash
   end
 
 end
+
+#:nodoc:
+class String
+
+  #:nodoc:
+  def to_bson_code
+    BSON::Code.new(self)
+  end
+
+end

data/test/bson/bson_test.rb

@@ -150,6 +150,12 @@ class BSONTest < Test::Unit::TestCase
     assert_doc_pass(doc)
   end
 
+  def test_code_with_symbol
+    assert_raise_error ArgumentError, "BSON::Code must be in the form of a String" do
+      Code.new(:fubar)
+    end
+  end
+
   def test_code_with_scope
     doc = {'$where' => Code.new('this.a.b < this.b', {'foo' => 1})}
     assert_doc_pass(doc)

data/test/collection_test.rb

@@ -626,15 +626,25 @@ class TestCollection < Test::Unit::TestCase
       @reduce_function = "function (obj, prev) { prev.count += inc_value; }"
     end
 
+    should "fail if missing required options" do
+      assert_raise MongoArgumentError do
+        @@test.group(:initial => {})
+      end
+
+      assert_raise MongoArgumentError do
+        @@test.group(:reduce => "foo")
+      end
+    end
+
     should "group results using eval form" do
-      assert_equal 1, @@test.group([], {}, @initial, Code.new(@reduce_function, {"inc_value" => 0.5}))[0]["count"]
-      assert_equal 2, @@test.group([], {}, @initial, Code.new(@reduce_function, {"inc_value" => 1}))[0]["count"]
-      assert_equal 4, @@test.group([], {}, @initial, Code.new(@reduce_function, {"inc_value" => 2}))[0]["count"]
+      assert_equal 1, @@test.group(:initial => @initial, :reduce => Code.new(@reduce_function, {"inc_value" => 0.5}))[0]["count"]
+      assert_equal 2, @@test.group(:initial => @initial, :reduce => Code.new(@reduce_function, {"inc_value" => 1}))[0]["count"]
+      assert_equal 4, @@test.group(:initial => @initial, :reduce => Code.new(@reduce_function, {"inc_value" => 2}))[0]["count"]
     end
 
     should "finalize grouped results" do
       @finalize = "function(doc) {doc.f = doc.count + 200; }"
-      assert_equal 202, @@test.group([], {}, @initial, Code.new(@reduce_function, {"inc_value" => 1}), @finalize)[0]["f"]
+      assert_equal 202, @@test.group(:initial => @initial, :reduce => Code.new(@reduce_function, {"inc_value" => 1}), :finalize => @finalize)[0]["f"]
     end
   end
 
@@ -650,7 +660,7 @@ class TestCollection < Test::Unit::TestCase
     end
 
     should "group" do
-      result = @@test.group([:a], {}, @initial, @reduce_function, nil)
+      result = @@test.group(:key => :a, :initial => @initial, :reduce => @reduce_function)
       assert result.all? { |r| r['count'] == 200 }
     end
   end
@@ -669,10 +679,17 @@ class TestCollection < Test::Unit::TestCase
     end
 
     should "group results" do
-      results = @@test.group(@keyf, {}, @initial, @reduce).sort {|a, b| a['count'] <=> b['count']}
+      results = @@test.group(:keyf => @keyf, :initial => @initial, :reduce => @reduce).sort {|a, b| a['count'] <=> b['count']}
       assert results[0]['even'] && results[0]['count'] == 2.0
       assert results[1]['odd'] && results[1]['count'] == 3.0
     end
+
+    should "group filtered results" do
+      results = @@test.group(:keyf => @keyf, :cond => {:a => {'$ne' => 2}},
+        :initial => @initial, :reduce => @reduce).sort {|a, b| a['count'] <=> b['count']}
+      assert results[0]['even'] && results[0]['count'] == 1.0
+      assert results[1]['odd'] && results[1]['count'] == 3.0
+    end
   end
 
   context "A collection with two records" do

data/test/db_api_test.rb

@@ -509,33 +509,37 @@ class DBAPITest < Test::Unit::TestCase
     @@db.drop_collection("test")
     test = @@db.collection("test")
 
-    assert_equal [], test.group([], {}, {"count" => 0}, "function (obj, prev) { prev.count++; }")
-    assert_equal [], test.group([], {}, {"count" => 0}, "function (obj, prev) { prev.count++; }")
+    assert_equal [], test.group(:initial => {"count" => 0}, :reduce => "function (obj, prev) { prev.count++; }")
+    assert_equal [], test.group(:initial => {"count" => 0}, :reduce => "function (obj, prev) { prev.count++; }")
 
     test.insert("a" => 2)
     test.insert("b" => 5)
     test.insert("a" => 1)
 
-    assert_equal 3, test.group([], {}, {"count" => 0}, "function (obj, prev) { prev.count++; }")[0]["count"]
-    assert_equal 3, test.group([], {}, {"count" => 0}, "function (obj, prev) { prev.count++; }")[0]["count"]
-    assert_equal 1, test.group([], {"a" => {"$gt" => 1}}, {"count" => 0}, "function (obj, prev) { prev.count++; }")[0]["count"]
-    assert_equal 1, test.group([], {"a" => {"$gt" => 1}}, {"count" => 0}, "function (obj, prev) { prev.count++; }")[0]["count"]
+    assert_equal 3, test.group(:initial => {"count" => 0},
+                      :reduce => "function (obj, prev) { prev.count++; }")[0]["count"]
+    assert_equal 3, test.group(:initial => {"count" => 0},
+                      :reduce => "function (obj, prev) { prev.count++; }")[0]["count"]
+    assert_equal 1, test.group(:cond => {"a" => {"$gt" => 1}},
+                      :initial => {"count" => 0}, :reduce => "function (obj, prev) { prev.count++; }")[0]["count"]
+    assert_equal 1, test.group(:cond => {"a" => {"$gt" => 1}},
+                      :initial => {"count" => 0}, :reduce => "function (obj, prev) { prev.count++; }")[0]["count"]
 
     finalize = "function (obj) { obj.f = obj.count - 1; }"
-    assert_equal 2, test.group([], {}, {"count" => 0}, "function (obj, prev) { prev.count++; }", finalize)[0]["f"]
+    assert_equal 2, test.group(:initial => {"count" => 0}, 
+                      :reduce => "function (obj, prev) { prev.count++; }", :finalize => finalize)[0]["f"]
 
     test.insert("a" => 2, "b" => 3)
     expected = [{"a" => 2, "count" => 2},
                 {"a" => nil, "count" => 1},
                 {"a" => 1, "count" => 1}]
-    assert_equal expected, test.group(["a"], {}, {"count" => 0}, "function (obj, prev) { prev.count++; }")
-    assert_equal expected, test.group(["a"], {}, {"count" => 0}, "function (obj, prev) { prev.count++; }", true)
+    assert_equal expected, test.group(:key => ["a"], :initial => {"count" => 0},
+                             :reduce => "function (obj, prev) { prev.count++; }")
+    assert_equal expected, test.group(:key => :a, :initial => {"count" => 0},
+                             :reduce => "function (obj, prev) { prev.count++; }")
 
     assert_raise OperationFailure do
-      test.group([], {}, {}, "5 ++ 5")
-    end
-    assert_raise OperationFailure do
-      test.group([], {}, {}, "5 ++ 5", true)
+      test.group(:initial => {}, :reduce => "5 ++ 5")
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: mongo
 version: !ruby/object:Gem::Version 
-  hash: 15424231
+  hash: 15424225
   prerelease: 4
   segments: 
   - 1
   - 2
   - rc
-  - 1
-  version: 1.2.rc1
+  - 2
+  version: 1.2.rc2
 platform: ruby
 authors: 
 - Jim Menard
@@ -18,7 +18,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-05 00:00:00 -05:00
+date: 2011-01-06 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -29,13 +29,13 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 15424231
+        hash: 15424225
         segments: 
         - 1
         - 2
         - rc
-        - 1
-        version: 1.2.rc1
+        - 2
+        version: 1.2.rc2
   type: :runtime
   version_requirements: *id001
 description: A Ruby driver for MongoDB. For more information about Mongo, see http://www.mongodb.org.