mongo 1.1.1 → 1.1.2

data/Rakefile

@@ -169,7 +169,7 @@ task :ydoc do
   require File.join(File.dirname(__FILE__), 'lib', 'mongo')
   out = File.join('ydoc', Mongo::VERSION)
   FileUtils.rm_rf('ydoc')
-  system "yardoc lib/**/*.rb lib/mongo/**/*.rb lib/bson/**/*.rb -e docs/yard_ext.rb -p docs/templates -o #{out} --title MongoRuby-#{Mongo::VERSION}"
+  system "yardoc lib/**/*.rb lib/mongo/**/*.rb lib/bson/**/*.rb -e yard/yard_ext.rb -p yard/templates -o #{out} --title MongoRuby-#{Mongo::VERSION} --files docs/TUTORIAL.md,docs/HISTORY.md,docs/CREDITS.md,docs/1.0_UPGRADE.md"
 end
 
 namespace :gem do
@@ -177,22 +177,35 @@ namespace :gem do
   desc "Install the gem locally"
   task :install do
     sh "gem build bson.gemspec"
-    sh "gem install bson-*.gem"
+    sh "gem install --no-rdoc --no-ri bson-*.gem"
+
     sh "gem build mongo.gemspec"
-    sh "gem install mongo-*.gem"
+    sh "gem install --no-rdoc --no-ri mongo-*.gem"
+
     sh "rm mongo-*.gem"
     sh "rm bson-*.gem"
   end
 
   desc "Install the optional c extensions"
   task :install_extensions do
+    sh "gem uninstall -x -a -I bson_ext"
     sh "gem build bson_ext.gemspec"
-    sh "gem install bson_ext-*.gem"
+    sh "gem install --no-rdoc --no-ri bson_ext-*.gem"
     sh "rm bson_ext-*.gem"
   end
 
 end
 
+namespace :ci do
+  namespace :test do
+    task :c do
+      Rake::Task['gem:install'].invoke
+      Rake::Task['gem:install_extensions'].invoke
+      Rake::Task['test:c'].invoke
+    end
+  end
+end
+
 task :default => :list
 
 task :list do

data/docs/1.0_UPGRADE.md

@@ -0,0 +1,21 @@
+You can upgrade freely from v0.20 to v1.0.
+
+However, if you're running a version < 0.20, upgrade to 0.20
+before upgrading to 1.0.
+
+The upgrade to 0.20 requires some minor code upgrades.
+
+1. Note the exception changes in HISTORY. Certain exceptions are now scoped under the BSON
+module; if you're catching these, you will need to modify your code.
+
+2. The BSON types are now scoped under the BSON module.
+
+3. Note that mongo_ext no longer exists. The new gems are bson and bson_ext.
+
+4. Indexes on GridFS chunks collections should be unique. If you have existing GridFS
+collections, you should drop the current index and replace with a unique one. Before you do this,
+make sure that index doesn't exist; no need to go through process unnecessarily.
+If you do need to create the index, once you have the chunks collection, here are the commands you can run:
+
+    @chunks.drop_index('files_id_1_n_1')
+    @chunks.create_index([['files_id', Mongo::ASCENDING], ['n', Mongo::ASCENDING]], :unique => true)

data/docs/CREDITS.md

@@ -0,0 +1,119 @@
+# Credits
+
+Adrian Madrid, aemadrid@gmail.com
+
+* bin/mongo_console
+* examples/benchmarks.rb
+* examples/irb.rb
+* Modifications to examples/simple.rb
+* Found plenty of bugs and missing features.
+* Ruby 1.9 support.
+* Gem support.
+* Many other code suggestions and improvements.
+
+Aman Gupta, aman@tmm1.net
+
+* Collection#save
+* Noted bug in returning query batch size.
+
+Jon Crosby, jon@joncrosby.me
+
+* Some code clean-up
+
+John Nunemaker, http://railstips.org
+
+* Collection#create_index takes symbols as well as strings
+* Fix for Collection#save
+* Add logger convenience methods to connection and database
+
+David James, djames@sunlightfoundation.com
+
+* Fix dates to return as UTC
+
+Paul Dlug, paul.dlug@gmail.com
+
+* Generate _id on the client side if not provided
+* Collection#insert and Collection#save return _id
+
+Durran Jordan, durran@gmail.com
+
+* DB#collections
+* Support for specifying sort order as array of [key, direction] pairs
+* OrderedHash#update aliases to merge!
+
+Cyril Mougel, cyril.mougel@gmail.com
+
+* Initial logging support
+* Test case
+
+Jack Chen, chendo on github
+
+* Test case + fix for deserializing pre-epoch Time instances
+
+Michael Bernstein, mrb on github
+
+* Cursor#sort
+
+Paulo Ahahgon, pahagon on github
+
+* removed hard limit
+
+Les Hill, leshill on github
+
+* OrderedHash#each returns self
+
+Sean Cribbs, seancribbs on github
+
+* Modified standard_benchmark to allow profiling
+* C ext for faster ObjectID creation
+
+Sunny Hirai
+
+* Suggested hashcode fix for Mongo::ObjectID
+* Noted index ordering bug.
+* GridFS performance boost
+
+Christos Trochalakis
+
+* Added map/reduce helper
+
+Blythe Dunham
+
+* Added finalize option to map/reduce
+
+Matt Powell (fauxparse)
+
+* Added GridStore#mv
+
+Patrick Collison
+
+* Added safe mode for Collection#remove
+
+Chuck Remes
+
+* Extraction of BSON into separate gems
+* Extensions compile on Rubinius
+* Performance improvements for INT in C extensions
+* Performance improvements for JRuby BSON encoder and callback classes
+
+Dmitrii Golub (Houdini) and Jacques Crocker (railsjedi)
+
+* Support open to exclude fields on query
+
+dfitzgibbon
+
+* patch for ensuring bson_ext compatibility with early release of Ruby 1.8.5
+
+Matt Taylor
+
+* Noticed excessive calls to ObjectId#to_s. As a result, stopped creating
+log messages when no logger was passed to Mongo::Connection. Resulted in a significant
+performance improvement.
+
+Hongli Lai (Phusion)
+
+* Significant performance improvements. See commits.
+
+Mislav Marohnić
+
+* Replaced returning with each_with_object

data/docs/HISTORY.md

@@ -0,0 +1,158 @@
+# MongoDB Ruby Driver History
+
+### 1.1.2
+2010-11-4
+
+* Two critical fixes to automated failover and replica sets.
+* Bug passing :timeout to Cursor.
+* Permit safe mode specification on Connection, Collection, and DB levels.
+* Specify replica set name on connect to verify connection to the right set.
+* Misc. reorganization of project and docs.
+
+### 1.1.1
+2010-10-14
+
+* Several critical JRuby bug fixes
+* Fixes for JRuby in 1.9 mode
+* Check keys and move id only when necessary for JRuby encoder
+
+## 1.1
+2010-10-4
+
+* Official JRuby support via Java extensons for BSON (beta)
+* Connection#lock! and Connection#unlock! for easy fsync lock
+* Note: BSON::Code is no longer a subclass of String.
+
+### 1.0.9
+2010-9-20
+
+* Significant performance improvements (with a lot of help from Hongli Lai)
+
+### 1.0.8
+2010-8-27
+
+* Cursor#rewind! and more consistent Cursor Enumberable behavior
+* Deprecated ObjectID for ObjectId
+* Numerous minor bug fixes.
+
+### 1.0.7
+2010-8-4
+
+* A few minor test/doc fixes.
+* Better tests for replica sets and replication acknowledgment.
+* Deprecated DB#error and DB#last_status
+
+### 1.0.6
+2010-7-26
+
+* Replica set support.
+* Collection#map_reduce bug fix.
+
+### 1.0.5 
+2010-7-13
+
+* Fix for bug introduced in 1.0.4.
+
+### 1.0.4
+2010-7-13
+
+* Removed deprecated
+  * Cursor admin option
+  * DB#query
+  * DB#create_index (use Collection#create_index)
+  * DB#command only takes hash options now
+* j2bson executable (neomantra)
+* Fixed bson_ext compilation on Solaris (slyphon)
+* System JS helpers (neovintage)
+* Use one mutex per thread on pooled connections (cremes)
+* Check for CursorNotFound response flag
+* MapReduce can return raw command output using :raw
+* BSON::OrderedHash equality with other Ruby hashes (Ryan Angilly)
+* Fix for broken Socket.send with large payloads (Frédéric De Jaeger)
+* Lots of minor improvements. See commmits.
+
+### 1.0.3
+2010-6-15
+
+* Optimiztion for BSON::OrderedHash
+* Some important fixes.
+
+### 1.0.2
+2010-6-5
+
+This is a minor release for fixing an incompatibility with MongoDB v1.5.2
+
+* Fix for boolean response on commands for core server v1.5.2
+* BSON.read_bson_document and b2json executable (neomantra)
+* BSON::ObjectID() shortcut for BSON::ObjectID.from_string (tmm1)
+* Various bug fixes.
+
+### 1.0.1
+2010-5-7
+
+* set Encoding.default_internal
+* DEPRECATE JavaScript string on Collection#find. You now must specify $where explicitly.
+* Added Grid#exist? and GridFileSystem#exist?
+* Support for replication acknowledgment
+* Support for $slice
+* Namespaced OrderedHash under BSON (sleverbor)
+
+## 1.0
+2010-4-29
+Note: if upgrading from versions prior to 0.20, be sure to upgrade
+to 0.20 before upgrading to 1.0.
+
+* Inspected ObjectID is represented in MongoDB extended json format.
+* Support for tailable cursors.
+* Configurable query response batch size (thx. to Aman Gupta)
+
+* bson_ext installs on early release of Ruby 1.8.5 (dfitzgibbon)
+* Deprecated DB#create_index. Use Collection#create_index index.
+* Removed deprecated Grid#put syntax; no longer requires a filename.
+
+### 0.20.1
+2010-4-7
+
+* Added bson gem dependency.
+
+### 0.20
+2010-4-7
+
+If upgrading from a previous version of the Ruby driver, please read these notes carefully,
+along with the 0.20_UPGRADE doc.
+
+* Support for new commands:
+  * Collection#find_and_modify
+  * Collection#stats
+  * DB#stats
+* Query :fields options allows for values of 0 to exclude fields (houdini, railsjedi).
+* GridFS
+  * Option to delete old versions of GridFileSystem entries.
+  * Filename is now optional for Grid#put.
+  * Option to write arbitrary attributes to a file: @grid.put(@data, :favorite_phrase => "blimey!")
+  * Indexes created on the chunks collection are now unique. If you have an existing chunks collection,
+    you may want to remove 
+* Removed the following deprecated items:
+  * GridStore class
+  * RegexpOfHolding class
+  * Paired connections must now be initialized with Connection.paired
+
+* BSON-related code extracted into two separate gems: bson and bson_ext (thx to Chuck Remes).
+  * mongo_ext no longer exists.
+  * BSON::Binary constructor can now take a string, which will be packed into an array.
+  * Exception class adjustments:
+    * Mongo::InvalidObjectID moved to BSON::InvalidObjectID
+    * Mongo::InvalidDocument moved to BSON::InvalidDocument
+    * Mongo::InvalidStringEncoding moved to BSON::InvalidStringEncoding
+    * Mongo::InvalidName replaced by Mongo::InvalidNSName and BSON::InvalidKeyName
+  * BSON types are now namespaced under the BSON module. These types include:
+    * Binary
+    * ObjectID
+    * Code
+    * DBRef
+    * MinKey and MaxKey
+  * Extensions compile on Rubinius (Chuck Remes).
+
+## Prior to 0.20
+
+See git revisions.

data/docs/TUTORIAL.md

@@ -0,0 +1,247 @@
+# MongoDB Ruby Driver Tutorial
+
+This tutorial gives many common examples of using MongoDB with the Ruby driver. If you're looking for information on data modeling, see [MongoDB Data Modeling and Rails](http://www.mongodb.org/display/DOCS/MongoDB+Data+Modeling+and+Rails). Links to the various object mappers are listed on our [object mappers page](http://www.mongodb.org/display/DOCS/Object+Mappers+for+Ruby+and+MongoDB).
+
+Interested in GridFS? See [GridFS in Ruby](http://www.mongodb.org/display/DOCS/GridFS+in+Ruby).
+
+As always, the [latest source for the Ruby driver](http://github.com/mongodb/mongo-ruby-driver) can be found on [github](http://github.com/mongodb/mongo-ruby-driver/).
+
+## Installation
+
+The mongo-ruby-driver gem is served through Rubygems.org. To install, make sure you have the latest version of rubygems.
+    gem update --system
+Next, install the mongo rubygem:
+    gem install mongo
+
+The required `bson` gem will be installed automatically.
+
+For optimum performance, install the bson_ext gem:
+
+    gem install bson_ext
+
+After installing, you may want to look at the [examples](http://github.com/mongodb/mongo-ruby-driver/tree/master/examples) directory included in the source distribution. These examples walk through some of the basics of using the Ruby driver.
+
+## Getting started
+
+#### Using the gem
+
+All of the code here assumes that you have already executed the following Ruby code:
+
+    require 'rubygems'  # not necessary for Ruby 1.9
+    require 'mongo'
+
+#### Making a Connection
+
+An `Mongo::Connection` instance represents a connection to MongoDB. You use a Connection instance to obtain an Mongo:DB instance, which represents a named database. The database doesn't have to exist - if it doesn't, MongoDB will create it for you.
+
+You can optionally specify the MongoDB server address and port when connecting. The following example shows three ways to connect to the database "mydb" on the local machine:
+
+    db = Mongo::Connection.new.db("mydb")
+    db = Mongo::Connection.new("localhost").db("mydb")
+    db = Mongo::Connection.new("localhost", 27017).db("mydb")
+
+At this point, the `db` object will be a connection to a MongoDB server for the specified database. Each DB instance uses a separate socket connection to the server.
+
+If you're trying to connect to a replica set, see [Replica Sets in Ruby](http://www.mongodb.org/display/DOCS/Replica+Sets+in+Ruby).
+
+#### Listing All Databases
+
+    connection = Mongo::Connection.new # (optional host/port args)
+    connection.database_names.each { |name| puts name }
+    connection.database_info.each { |info| puts info.inspect}
+
+    #### Dropping a Database
+    connection.drop_database('database_name')
+
+MongoDB can be run in a secure mode where access to databases is controlled through name and password authentication.  When run in this mode, any client application must provide a name and password before doing any operations.  In the Ruby driver, you simply do the following with the connected mongo object:
+
+    auth = db.authenticate(my_user_name, my_password)
+
+If the name and password are valid for the database, `auth` will be `true`.  Otherwise, it will be `false`.  You should look at the MongoDB log for further information if available.
+
+#### Getting a List Of Collections
+
+Each database has zero or more collections.  You can retrieve a list of them from the db (and print out any that are there):
+
+    db.collection_names.each { |name| puts name }
+
+and assuming that there are two collections, name and address, in the database, you would see
+
+    name
+    address
+
+as the output.
+
+#### Getting a Collection
+
+You can get a collection to use using the `collection` method:
+    coll = db.collection("testCollection")
+This is aliased to the \[\] method:
+    coll = db["testCollection"]
+
+Once you have this collection object, you can now do things like insert data, query for data, etc.
+
+#### Inserting a Document
+
+Once you have the collection object, you can insert documents into the collection.  For example, lets make a little document that in JSON would be represented as
+
+      {
+         "name" : "MongoDB",
+         "type" : "database",
+         "count" : 1,
+         "info" : {
+                     x : 203,
+                     y : 102
+                   }
+      }
+
+Notice that the above has an "inner" document embedded within it.  To do this, we can use a Hash or the driver's OrderedHash (which preserves key order) to create the document (including the inner document), and then just simply insert it into the collection using the `insert()` method.
+
+    doc = {"name" => "MongoDB", "type" => "database", "count" => 1,
+           "info" => {"x" => 203, "y" => '102'`
+    coll.insert(doc)
+
+#### Updating a Document
+
+We can update the previous document using the `update` method. There are a couple ways to update a document. We can rewrite it:
+
+    doc["name"] = "MongoDB Ruby"
+    coll.update({"_id" => doc["_id"]}, doc)
+
+Or we can use an atomic operator to change a single value:
+
+    coll.update({"_id" => doc["_id"]}, {"$set" => {"name" => "MongoDB Ruby"`)
+
+Read [more about updating documents|Updating].
+
+#### Finding the First Document In a Collection using `find_one()`
+
+To show that the document we inserted in the previous step is there, we can do a simple `find_one()` operation to get the first document in the collection.  This method returns a single document (rather than the `Cursor` that the `find()` operation returns).
+
+    my_doc = coll.find_one()
+    puts my_doc.inspect
+
+and you should see:
+
+    {"_id"=>#<BSON::ObjectID:0x118576c ...>, "name"=>"MongoDB",
+     "info"=>{"x"=>203, "y"=>102}, "type"=>"database", "count"=>1}
+
+Note the `\_id` element has been added automatically by MongoDB to your document.
+
+#### Adding Multiple Documents
+
+To demonstrate some more interesting queries, let's add multiple simple documents to the collection.  These documents will have the following form:
+    {
+       "i" : value
+    }
+
+Here's how to insert them:
+
+    100.times { |i| coll.insert("i" => i) }
+
+Notice that we can insert documents of different "shapes" into the same collection. These records are in the same collection as the complex record we inserted above.  This aspect is what we mean when we say that MongoDB is "schema-free".
+
+#### Counting Documents in a Collection
+
+Now that we've inserted 101 documents (the 100 we did in the loop, plus the first one), we can check to see if we have them all using the `count()` method.
+
+    puts coll.count()
+
+and it should print `101`.
+
+#### Using a Cursor to get all of the Documents
+
+To get all the documents from the collection, we use the `find()` method. `find()` returns a `Cursor` object, which allows us to iterate over the set of documents that matches our query.  The Ruby driver's Cursor implemented Enumerable, which allows us to use `Enumerable#each`, `Enumerable#map}, etc. For instance:
+
+    coll.find().each { |row| puts row.inspect }
+
+and that should print all 101 documents in the collection.
+
+#### Getting a Single Document with a Query
+
+We can create a _query_ hash to pass to the `find()` method to get a subset of the documents in our collection.  For example, if we wanted to find the document for which the value of the "i" field is 71, we would do the following ;
+
+    coll.find("i" => 71).each { |row| puts row.inspect }
+
+and it should just print just one document:
+
+    {"_id"=>#<BSON::ObjectID:0x117de90 ...>, "i"=>71}
+
+#### Getting a Set of Documents With a Query
+
+We can use the query to get a set of documents from our collection.  For example, if we wanted to get all documents where "i" > 50, we could write:
+
+    coll.find("i" => {"$gt" => 50}).each { |row| puts row }
+
+which should print the documents where i > 50.  We could also get a range, say   20 < i <= 30:
+
+    coll.find("i" => {"$gt" => 20, "$lte" => 30}).each { |row| puts row }
+
+#### Selecting a subset of fields for a query
+
+Use the `:fields` option. If you just want fields "a" and "b":
+
+    coll.find("i" => {"$gt" => 50}, :fields => ["a", "b"]).each { |row| puts row }
+
+#### Querying with Regular Expressions
+
+Regular expressions can be used to query MongoDB. To find all names that begin with 'a':
+
+    coll.find({"name" => /^a/})
+
+You can also construct a regular expression dynamically. To match a given search string:
+
+    search_string = params['search']
+
+    # Constructor syntax
+    coll.find({"name" => Regexp.new(search_string)})
+
+    # Literal syntax
+    coll.find({"name" => /#{search_string}/})
+
+Although MongoDB isn't vulnerable to anything like SQL-injection, it may be worth checking the search string for anything malicious.
+
+## Indexing
+
+#### Creating An Index
+
+MongoDB supports indexes, and they are very easy to add on a collection.  To create an index, you specify an index name and an array of field names to be indexed, or a single field name. The following creates an ascending index on the "i" field:
+
+    # create_index assumes ascending order; see method docs
+    # for details
+    coll.create_index("i")
+To specify complex indexes or a descending index you need to use a slightly more complex syntax - the index specifier must be an Array of [field name, direction] pairs. Directions should be specified as Mongo::ASCENDING or Mongo::DESCENDING:
+
+    # Explicit "ascending"
+    coll.create_index([["i", Mongo::ASCENDING]])
+
+#### Creating and querying on a geospatial index
+
+First, create the index on a field containing long-lat values:
+
+    people.create_index([["loc", Mongo::GEO2D]])
+
+Then get a list of the twenty locations nearest to the point 50, 50:
+
+    people.find({"loc" => {"$near" => [50, 50]}}, {:limit => 20}).each do |p|
+      puts p.inspect 
+    end
+
+#### Getting a List of Indexes on a Collection
+
+You can get a list of the indexes on a collection using `coll.index_information()`.
+
+## Database Administration
+
+A database can have one of three profiling levels: off (:off), slow queries only (:slow_only), or all (:all). To see the database level:
+
+    puts db.profiling_level   # => off (the symbol :off printed as a string)
+    db.profiling_level = :slow_only
+
+Validating a collection will return an interesting hash if all is well or raise an exception if there is a problem.
+    p db.validate_collection('coll_name')
+
+## See Also
+
+* [MongoDB Koans](http://github.com/chicagoruby/MongoDB_Koans) A path to MongoDB enlightenment via the Ruby driver.
+* [MongoDB Manual](http://www.mongodb.org/display/DOCS/Developer+Zone)