Browse files

Update dependencies

  • Loading branch information...
1 parent 5187e23 commit a129b982fbe98356a8e3726bc0f06ab235bf222b @pvorb committed Mar 3, 2012
View
9 node_modules/.bin/express
@@ -0,0 +1,9 @@
+#!/bin/sh
+if [ -x "`dirname "$0"`/node" ]; then
+ "`dirname "$0"`/node" "`dirname "$0"`/../express/bin/express" "$@"
+ ret=$?
+else
+ node "`dirname "$0"`/../express/bin/express" "$@"
+ ret=$?
+fi
+exit $ret
View
9 node_modules/async/.gitmodules
@@ -0,0 +1,9 @@
+[submodule "deps/nodeunit"]
+ path = deps/nodeunit
+ url = git://github.com/caolan/nodeunit.git
+[submodule "deps/UglifyJS"]
+ path = deps/UglifyJS
+ url = https://github.com/mishoo/UglifyJS.git
+[submodule "deps/nodelint"]
+ path = deps/nodelint
+ url = https://github.com/tav/nodelint.git
View
4 node_modules/async/.npmignore
@@ -0,0 +1,4 @@
+deps
+dist
+test
+nodelint.cfg
View
19 node_modules/async/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2010 Caolan McMahon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
View
25 node_modules/async/Makefile
@@ -0,0 +1,25 @@
+PACKAGE = asyncjs
+NODEJS = $(if $(shell test -f /usr/bin/nodejs && echo "true"),nodejs,node)
+CWD := $(shell pwd)
+NODEUNIT = $(CWD)/node_modules/nodeunit/bin/nodeunit
+UGLIFY = $(CWD)/node_modules/uglify-js/bin/uglifyjs
+NODELINT = $(CWD)/node_modules/nodelint/nodelint
+
+BUILDDIR = dist
+
+all: clean test build
+
+build: $(wildcard lib/*.js)
+ mkdir -p $(BUILDDIR)
+ $(UGLIFY) lib/async.js > $(BUILDDIR)/async.min.js
+
+test:
+ $(NODEUNIT) test
+
+clean:
+ rm -rf $(BUILDDIR)
+
+lint:
+ $(NODELINT) --config nodelint.cfg lib/async.js
+
+.PHONY: test build all
View
1,022 node_modules/async/README.md
@@ -0,0 +1,1022 @@
+# Async.js
+
+Async is a utility module which provides straight-forward, powerful functions
+for working with asynchronous JavaScript. Although originally designed for
+use with [node.js](http://nodejs.org), it can also be used directly in the
+browser.
+
+Async provides around 20 functions that include the usual 'functional'
+suspects (map, reduce, filter, forEach…) as well as some common patterns
+for asynchronous control flow (parallel, series, waterfall…). All these
+functions assume you follow the node.js convention of providing a single
+callback as the last argument of your async function.
+
+
+## Quick Examples
+
+ async.map(['file1','file2','file3'], fs.stat, function(err, results){
+ // results is now an array of stats for each file
+ });
+
+ async.filter(['file1','file2','file3'], path.exists, function(results){
+ // results now equals an array of the existing files
+ });
+
+ async.parallel([
+ function(){ ... },
+ function(){ ... }
+ ], callback);
+
+ async.series([
+ function(){ ... },
+ function(){ ... }
+ ]);
+
+There are many more functions available so take a look at the docs below for a
+full list. This module aims to be comprehensive, so if you feel anything is
+missing please create a GitHub issue for it.
+
+
+## Download
+
+Releases are available for download from
+[GitHub](http://github.com/caolan/async/downloads).
+Alternatively, you can install using Node Package Manager (npm):
+
+ npm install async
+
+
+__Development:__ [async.js](https://github.com/caolan/async/raw/master/lib/async.js) - 17.5kb Uncompressed
+
+__Production:__ [async.min.js](https://github.com/caolan/async/raw/master/dist/async.min.js) - 1.7kb Packed and Gzipped
+
+
+## In the Browser
+
+So far its been tested in IE6, IE7, IE8, FF3.6 and Chrome 5. Usage:
+
+ <script type="text/javascript" src="async.js"></script>
+ <script type="text/javascript">
+
+ async.map(data, asyncProcess, function(err, results){
+ alert(results);
+ });
+
+ </script>
+
+
+## Documentation
+
+### Collections
+
+* [forEach](#forEach)
+* [map](#map)
+* [filter](#filter)
+* [reject](#reject)
+* [reduce](#reduce)
+* [detect](#detect)
+* [sortBy](#sortBy)
+* [some](#some)
+* [every](#every)
+* [concat](#concat)
+
+### Control Flow
+
+* [series](#series)
+* [parallel](#parallel)
+* [whilst](#whilst)
+* [until](#until)
+* [waterfall](#waterfall)
+* [queue](#queue)
+* [auto](#auto)
+* [iterator](#iterator)
+* [apply](#apply)
+* [nextTick](#nextTick)
+
+### Utils
+
+* [memoize](#memoize)
+* [unmemoize](#unmemoize)
+* [log](#log)
+* [dir](#dir)
+* [noConflict](#noConflict)
+
+
+## Collections
+
+<a name="forEach" />
+### forEach(arr, iterator, callback)
+
+Applies an iterator function to each item in an array, in parallel.
+The iterator is called with an item from the list and a callback for when it
+has finished. If the iterator passes an error to this callback, the main
+callback for the forEach function is immediately called with the error.
+
+Note, that since this function applies the iterator to each item in parallel
+there is no guarantee that the iterator functions will complete in order.
+
+__Arguments__
+
+* arr - An array to iterate over.
+* iterator(item, callback) - A function to apply to each item in the array.
+ The iterator is passed a callback which must be called once it has completed.
+* callback(err) - A callback which is called after all the iterator functions
+ have finished, or an error has occurred.
+
+__Example__
+
+ // assuming openFiles is an array of file names and saveFile is a function
+ // to save the modified contents of that file:
+
+ async.forEach(openFiles, saveFile, function(err){
+ // if any of the saves produced an error, err would equal that error
+ });
+
+---------------------------------------
+
+<a name="forEachSeries" />
+### forEachSeries(arr, iterator, callback)
+
+The same as forEach only the iterator is applied to each item in the array in
+series. The next iterator is only called once the current one has completed
+processing. This means the iterator functions will complete in order.
+
+
+---------------------------------------
+
+<a name="forEachLimit" />
+### forEachLimit(arr, limit, iterator, callback)
+
+The same as forEach only the iterator is applied to batches of items in the
+array, in series. The next batch of iterators is only called once the current
+one has completed processing.
+
+__Arguments__
+
+* arr - An array to iterate over.
+* limit - How many items should be in each batch.
+* iterator(item, callback) - A function to apply to each item in the array.
+ The iterator is passed a callback which must be called once it has completed.
+* callback(err) - A callback which is called after all the iterator functions
+ have finished, or an error has occurred.
+
+__Example__
+
+ // Assume documents is an array of JSON objects and requestApi is a
+ // function that interacts with a rate-limited REST api.
+
+ async.forEachLimit(documents, 20, requestApi, function(err){
+ // if any of the saves produced an error, err would equal that error
+ });
+---------------------------------------
+
+<a name="map" />
+### map(arr, iterator, callback)
+
+Produces a new array of values by mapping each value in the given array through
+the iterator function. The iterator is called with an item from the array and a
+callback for when it has finished processing. The callback takes 2 arguments,
+an error and the transformed item from the array. If the iterator passes an
+error to this callback, the main callback for the map function is immediately
+called with the error.
+
+Note, that since this function applies the iterator to each item in parallel
+there is no guarantee that the iterator functions will complete in order, however
+the results array will be in the same order as the original array.
+
+__Arguments__
+
+* arr - An array to iterate over.
+* iterator(item, callback) - A function to apply to each item in the array.
+ The iterator is passed a callback which must be called once it has completed
+ with an error (which can be null) and a transformed item.
+* callback(err, results) - A callback which is called after all the iterator
+ functions have finished, or an error has occurred. Results is an array of the
+ transformed items from the original array.
+
+__Example__
+
+ async.map(['file1','file2','file3'], fs.stat, function(err, results){
+ // results is now an array of stats for each file
+ });
+
+---------------------------------------
+
+<a name="mapSeries" />
+### mapSeries(arr, iterator, callback)
+
+The same as map only the iterator is applied to each item in the array in
+series. The next iterator is only called once the current one has completed
+processing. The results array will be in the same order as the original.
+
+
+---------------------------------------
+
+<a name="filter" />
+### filter(arr, iterator, callback)
+
+__Alias:__ select
+
+Returns a new array of all the values which pass an async truth test.
+_The callback for each iterator call only accepts a single argument of true or
+false, it does not accept an error argument first!_ This is in-line with the
+way node libraries work with truth tests like path.exists. This operation is
+performed in parallel, but the results array will be in the same order as the
+original.
+
+__Arguments__
+
+* arr - An array to iterate over.
+* iterator(item, callback) - A truth test to apply to each item in the array.
+ The iterator is passed a callback which must be called once it has completed.
+* callback(results) - A callback which is called after all the iterator
+ functions have finished.
+
+__Example__
+
+ async.filter(['file1','file2','file3'], path.exists, function(results){
+ // results now equals an array of the existing files
+ });
+
+---------------------------------------
+
+<a name="filterSeries" />
+### filterSeries(arr, iterator, callback)
+
+__alias:__ selectSeries
+
+The same as filter only the iterator is applied to each item in the array in
+series. The next iterator is only called once the current one has completed
+processing. The results array will be in the same order as the original.
+
+---------------------------------------
+
+<a name="reject" />
+### reject(arr, iterator, callback)
+
+The opposite of filter. Removes values that pass an async truth test.
+
+---------------------------------------
+
+<a name="rejectSeries" />
+### rejectSeries(arr, iterator, callback)
+
+The same as filter, only the iterator is applied to each item in the array
+in series.
+
+
+---------------------------------------
+
+<a name="reduce" />
+### reduce(arr, memo, iterator, callback)
+
+__aliases:__ inject, foldl
+
+Reduces a list of values into a single value using an async iterator to return
+each successive step. Memo is the initial state of the reduction. This
+function only operates in series. For performance reasons, it may make sense to
+split a call to this function into a parallel map, then use the normal
+Array.prototype.reduce on the results. This function is for situations where
+each step in the reduction needs to be async, if you can get the data before
+reducing it then its probably a good idea to do so.
+
+__Arguments__
+
+* arr - An array to iterate over.
+* memo - The initial state of the reduction.
+* iterator(memo, item, callback) - A function applied to each item in the
+ array to produce the next step in the reduction. The iterator is passed a
+ callback which accepts an optional error as its first argument, and the state
+ of the reduction as the second. If an error is passed to the callback, the
+ reduction is stopped and the main callback is immediately called with the
+ error.
+* callback(err, result) - A callback which is called after all the iterator
+ functions have finished. Result is the reduced value.
+
+__Example__
+
+ async.reduce([1,2,3], 0, function(memo, item, callback){
+ // pointless async:
+ process.nextTick(function(){
+ callback(null, memo + item)
+ });
+ }, function(err, result){
+ // result is now equal to the last value of memo, which is 6
+ });
+
+---------------------------------------
+
+<a name="reduceRight" />
+### reduceRight(arr, memo, iterator, callback)
+
+__Alias:__ foldr
+
+Same as reduce, only operates on the items in the array in reverse order.
+
+
+---------------------------------------
+
+<a name="detect" />
+### detect(arr, iterator, callback)
+
+Returns the first value in a list that passes an async truth test. The
+iterator is applied in parallel, meaning the first iterator to return true will
+fire the detect callback with that result. That means the result might not be
+the first item in the original array (in terms of order) that passes the test.
+
+If order within the original array is important then look at detectSeries.
+
+__Arguments__
+
+* arr - An array to iterate over.
+* iterator(item, callback) - A truth test to apply to each item in the array.
+ The iterator is passed a callback which must be called once it has completed.
+* callback(result) - A callback which is called as soon as any iterator returns
+ true, or after all the iterator functions have finished. Result will be
+ the first item in the array that passes the truth test (iterator) or the
+ value undefined if none passed.
+
+__Example__
+
+ async.detect(['file1','file2','file3'], path.exists, function(result){
+ // result now equals the first file in the list that exists
+ });
+
+---------------------------------------
+
+<a name="detectSeries" />
+### detectSeries(arr, iterator, callback)
+
+The same as detect, only the iterator is applied to each item in the array
+in series. This means the result is always the first in the original array (in
+terms of array order) that passes the truth test.
+
+
+---------------------------------------
+
+<a name="sortBy" />
+### sortBy(arr, iterator, callback)
+
+Sorts a list by the results of running each value through an async iterator.
+
+__Arguments__
+
+* arr - An array to iterate over.
+* iterator(item, callback) - A function to apply to each item in the array.
+ The iterator is passed a callback which must be called once it has completed
+ with an error (which can be null) and a value to use as the sort criteria.
+* callback(err, results) - A callback which is called after all the iterator
+ functions have finished, or an error has occurred. Results is the items from
+ the original array sorted by the values returned by the iterator calls.
+
+__Example__
+
+ async.sortBy(['file1','file2','file3'], function(file, callback){
+ fs.stat(file, function(err, stats){
+ callback(err, stats.mtime);
+ });
+ }, function(err, results){
+ // results is now the original array of files sorted by
+ // modified date
+ });
+
+
+---------------------------------------
+
+<a name="some" />
+### some(arr, iterator, callback)
+
+__Alias:__ any
+
+Returns true if at least one element in the array satisfies an async test.
+_The callback for each iterator call only accepts a single argument of true or
+false, it does not accept an error argument first!_ This is in-line with the
+way node libraries work with truth tests like path.exists. Once any iterator
+call returns true, the main callback is immediately called.
+
+__Arguments__
+
+* arr - An array to iterate over.
+* iterator(item, callback) - A truth test to apply to each item in the array.
+ The iterator is passed a callback which must be called once it has completed.
+* callback(result) - A callback which is called as soon as any iterator returns
+ true, or after all the iterator functions have finished. Result will be
+ either true or false depending on the values of the async tests.
+
+__Example__
+
+ async.some(['file1','file2','file3'], path.exists, function(result){
+ // if result is true then at least one of the files exists
+ });
+
+---------------------------------------
+
+<a name="every" />
+### every(arr, iterator, callback)
+
+__Alias:__ all
+
+Returns true if every element in the array satisfies an async test.
+_The callback for each iterator call only accepts a single argument of true or
+false, it does not accept an error argument first!_ This is in-line with the
+way node libraries work with truth tests like path.exists.
+
+__Arguments__
+
+* arr - An array to iterate over.
+* iterator(item, callback) - A truth test to apply to each item in the array.
+ The iterator is passed a callback which must be called once it has completed.
+* callback(result) - A callback which is called after all the iterator
+ functions have finished. Result will be either true or false depending on
+ the values of the async tests.
+
+__Example__
+
+ async.every(['file1','file2','file3'], path.exists, function(result){
+ // if result is true then every file exists
+ });
+
+---------------------------------------
+
+<a name="concat" />
+### concat(arr, iterator, callback)
+
+Applies an iterator to each item in a list, concatenating the results. Returns the
+concatenated list. The iterators are called in parallel, and the results are
+concatenated as they return. There is no guarantee that the results array will
+be returned in the original order of the arguments passed to the iterator function.
+
+__Arguments__
+
+* arr - An array to iterate over
+* iterator(item, callback) - A function to apply to each item in the array.
+ The iterator is passed a callback which must be called once it has completed
+ with an error (which can be null) and an array of results.
+* callback(err, results) - A callback which is called after all the iterator
+ functions have finished, or an error has occurred. Results is an array containing
+ the concatenated results of the iterator function.
+
+__Example__
+
+ async.concat(['dir1','dir2','dir3'], fs.readdir, function(err, files){
+ // files is now a list of filenames that exist in the 3 directories
+ });
+
+---------------------------------------
+
+<a name="concatSeries" />
+### concatSeries(arr, iterator, callback)
+
+Same as async.concat, but executes in series instead of parallel.
+
+
+## Control Flow
+
+<a name="series" />
+### series(tasks, [callback])
+
+Run an array of functions in series, each one running once the previous
+function has completed. If any functions in the series pass an error to its
+callback, no more functions are run and the callback for the series is
+immediately called with the value of the error. Once the tasks have completed,
+the results are passed to the final callback as an array.
+
+It is also possible to use an object instead of an array. Each property will be
+run as a function and the results will be passed to the final callback as an object
+instead of an array. This can be a more readable way of handling results from
+async.series.
+
+
+__Arguments__
+
+* tasks - An array or object containing functions to run, each function is passed
+ a callback it must call on completion.
+* callback(err, results) - An optional callback to run once all the functions
+ have completed. This function gets an array of all the arguments passed to
+ the callbacks used in the array.
+
+__Example__
+
+ async.series([
+ function(callback){
+ // do some stuff ...
+ callback(null, 'one');
+ },
+ function(callback){
+ // do some more stuff ...
+ callback(null, 'two');
+ },
+ ],
+ // optional callback
+ function(err, results){
+ // results is now equal to ['one', 'two']
+ });
+
+
+ // an example using an object instead of an array
+ async.series({
+ one: function(callback){
+ setTimeout(function(){
+ callback(null, 1);
+ }, 200);
+ },
+ two: function(callback){
+ setTimeout(function(){
+ callback(null, 2);
+ }, 100);
+ },
+ },
+ function(err, results) {
+ // results is now equal to: {one: 1, two: 2}
+ });
+
+
+---------------------------------------
+
+<a name="parallel" />
+### parallel(tasks, [callback])
+
+Run an array of functions in parallel, without waiting until the previous
+function has completed. If any of the functions pass an error to its
+callback, the main callback is immediately called with the value of the error.
+Once the tasks have completed, the results are passed to the final callback as an
+array.
+
+It is also possible to use an object instead of an array. Each property will be
+run as a function and the results will be passed to the final callback as an object
+instead of an array. This can be a more readable way of handling results from
+async.parallel.
+
+
+__Arguments__
+
+* tasks - An array or object containing functions to run, each function is passed a
+ callback it must call on completion.
+* callback(err, results) - An optional callback to run once all the functions
+ have completed. This function gets an array of all the arguments passed to
+ the callbacks used in the array.
+
+__Example__
+
+ async.parallel([
+ function(callback){
+ setTimeout(function(){
+ callback(null, 'one');
+ }, 200);
+ },
+ function(callback){
+ setTimeout(function(){
+ callback(null, 'two');
+ }, 100);
+ },
+ ],
+ // optional callback
+ function(err, results){
+ // in this case, the results array will equal ['two','one']
+ // because the functions were run in parallel and the second
+ // function had a shorter timeout before calling the callback.
+ });
+
+
+ // an example using an object instead of an array
+ async.parallel({
+ one: function(callback){
+ setTimeout(function(){
+ callback(null, 1);
+ }, 200);
+ },
+ two: function(callback){
+ setTimeout(function(){
+ callback(null, 2);
+ }, 100);
+ },
+ },
+ function(err, results) {
+ // results is now equals to: {one: 1, two: 2}
+ });
+
+
+---------------------------------------
+
+<a name="whilst" />
+### whilst(test, fn, callback)
+
+Repeatedly call fn, while test returns true. Calls the callback when stopped,
+or an error occurs.
+
+__Arguments__
+
+* test() - synchronous truth test to perform before each execution of fn.
+* fn(callback) - A function to call each time the test passes. The function is
+ passed a callback which must be called once it has completed with an optional
+ error as the first argument.
+* callback(err) - A callback which is called after the test fails and repeated
+ execution of fn has stopped.
+
+__Example__
+
+ var count = 0;
+
+ async.whilst(
+ function () { return count < 5; },
+ function (callback) {
+ count++;
+ setTimeout(callback, 1000);
+ },
+ function (err) {
+ // 5 seconds have passed
+ }
+ );
+
+
+---------------------------------------
+
+<a name="until" />
+### until(test, fn, callback)
+
+Repeatedly call fn, until test returns true. Calls the callback when stopped,
+or an error occurs.
+
+The inverse of async.whilst.
+
+
+---------------------------------------
+
+<a name="waterfall" />
+### waterfall(tasks, [callback])
+
+Runs an array of functions in series, each passing their results to the next in
+the array. However, if any of the functions pass an error to the callback, the
+next function is not executed and the main callback is immediately called with
+the error.
+
+__Arguments__
+
+* tasks - An array of functions to run, each function is passed a callback it
+ must call on completion.
+* callback(err, [results]) - An optional callback to run once all the functions
+ have completed. This will be passed the results of the last task's callback.
+
+
+
+__Example__
+
+ async.waterfall([
+ function(callback){
+ callback(null, 'one', 'two');
+ },
+ function(arg1, arg2, callback){
+ callback(null, 'three');
+ },
+ function(arg1, callback){
+ // arg1 now equals 'three'
+ callback(null, 'done');
+ }
+ ], function (err, result) {
+ // result now equals 'done'
+ });
+
+
+---------------------------------------
+
+<a name="queue" />
+### queue(worker, concurrency)
+
+Creates a queue object with the specified concurrency. Tasks added to the
+queue will be processed in parallel (up to the concurrency limit). If all
+workers are in progress, the task is queued until one is available. Once
+a worker has completed a task, the task's callback is called.
+
+__Arguments__
+
+* worker(task, callback) - An asynchronous function for processing a queued
+ task.
+* concurrency - An integer for determining how many worker functions should be
+ run in parallel.
+
+__Queue objects__
+
+The queue object returned by this function has the following properties and
+methods:
+
+* length() - a function returning the number of items waiting to be processed.
+* concurrency - an integer for determining how many worker functions should be
+ run in parallel. This property can be changed after a queue is created to
+ alter the concurrency on-the-fly.
+* push(task, [callback]) - add a new task to the queue, the callback is called
+ once the worker has finished processing the task.
+ instead of a single task, an array of tasks can be submitted. the respective callback is used for every task in the list.
+* saturated - a callback that is called when the queue length hits the concurrency and further tasks will be queued
+* empty - a callback that is called when the last item from the queue is given to a worker
+* drain - a callback that is called when the last item from the queue has returned from the worker
+
+__Example__
+
+ // create a queue object with concurrency 2
+
+ var q = async.queue(function (task, callback) {
+ console.log('hello ' + task.name);
+ callback();
+ }, 2);
+
+
+ // assign a callback
+ q.drain = function() {
+ console.log('all items have been processed');
+ }
+
+ // add some items to the queue
+
+ q.push({name: 'foo'}, function (err) {
+ console.log('finished processing foo');
+ });
+ q.push({name: 'bar'}, function (err) {
+ console.log('finished processing bar');
+ });
+
+ // add some items to the queue (batch-wise)
+
+ q.push([{name: 'baz'},{name: 'bay'},{name: 'bax'}], function (err) {
+ console.log('finished processing bar');
+ });
+
+
+---------------------------------------
+
+<a name="auto" />
+### auto(tasks, [callback])
+
+Determines the best order for running functions based on their requirements.
+Each function can optionally depend on other functions being completed first,
+and each function is run as soon as its requirements are satisfied. If any of
+the functions pass an error to their callback, that function will not complete
+(so any other functions depending on it will not run) and the main callback
+will be called immediately with the error. Functions also receive an object
+containing the results of functions which have completed so far.
+
+__Arguments__
+
+* tasks - An object literal containing named functions or an array of
+ requirements, with the function itself the last item in the array. The key
+ used for each function or array is used when specifying requirements. The
+ syntax is easier to understand by looking at the example.
+* callback(err, results) - An optional callback which is called when all the
+ tasks have been completed. The callback will receive an error as an argument
+ if any tasks pass an error to their callback. If all tasks complete
+ successfully, it will receive an object containing their results.
+
+__Example__
+
+ async.auto({
+ get_data: function(callback){
+ // async code to get some data
+ },
+ make_folder: function(callback){
+ // async code to create a directory to store a file in
+ // this is run at the same time as getting the data
+ },
+ write_file: ['get_data', 'make_folder', function(callback){
+ // once there is some data and the directory exists,
+ // write the data to a file in the directory
+ callback(null, filename);
+ }],
+ email_link: ['write_file', function(callback, results){
+ // once the file is written let's email a link to it...
+ // results.write_file contains the filename returned by write_file.
+ }]
+ });
+
+This is a fairly trivial example, but to do this using the basic parallel and
+series functions would look like this:
+
+ async.parallel([
+ function(callback){
+ // async code to get some data
+ },
+ function(callback){
+ // async code to create a directory to store a file in
+ // this is run at the same time as getting the data
+ }
+ ],
+ function(results){
+ async.series([
+ function(callback){
+ // once there is some data and the directory exists,
+ // write the data to a file in the directory
+ },
+ email_link: function(callback){
+ // once the file is written let's email a link to it...
+ }
+ ]);
+ });
+
+For a complicated series of async tasks using the auto function makes adding
+new tasks much easier and makes the code more readable.
+
+
+---------------------------------------
+
+<a name="iterator" />
+### iterator(tasks)
+
+Creates an iterator function which calls the next function in the array,
+returning a continuation to call the next one after that. Its also possible to
+'peek' the next iterator by doing iterator.next().
+
+This function is used internally by the async module but can be useful when
+you want to manually control the flow of functions in series.
+
+__Arguments__
+
+* tasks - An array of functions to run, each function is passed a callback it
+ must call on completion.
+
+__Example__
+
+ var iterator = async.iterator([
+ function(){ sys.p('one'); },
+ function(){ sys.p('two'); },
+ function(){ sys.p('three'); }
+ ]);
+
+ node> var iterator2 = iterator();
+ 'one'
+ node> var iterator3 = iterator2();
+ 'two'
+ node> iterator3();
+ 'three'
+ node> var nextfn = iterator2.next();
+ node> nextfn();
+ 'three'
+
+
+---------------------------------------
+
+<a name="apply" />
+### apply(function, arguments..)
+
+Creates a continuation function with some arguments already applied, a useful
+shorthand when combined with other control flow functions. Any arguments
+passed to the returned function are added to the arguments originally passed
+to apply.
+
+__Arguments__
+
+* function - The function you want to eventually apply all arguments to.
+* arguments... - Any number of arguments to automatically apply when the
+ continuation is called.
+
+__Example__
+
+ // using apply
+
+ async.parallel([
+ async.apply(fs.writeFile, 'testfile1', 'test1'),
+ async.apply(fs.writeFile, 'testfile2', 'test2'),
+ ]);
+
+
+ // the same process without using apply
+
+ async.parallel([
+ function(callback){
+ fs.writeFile('testfile1', 'test1', callback);
+ },
+ function(callback){
+ fs.writeFile('testfile2', 'test2', callback);
+ },
+ ]);
+
+It's possible to pass any number of additional arguments when calling the
+continuation:
+
+ node> var fn = async.apply(sys.puts, 'one');
+ node> fn('two', 'three');
+ one
+ two
+ three
+
+---------------------------------------
+
+<a name="nextTick" />
+### nextTick(callback)
+
+Calls the callback on a later loop around the event loop. In node.js this just
+calls process.nextTick, in the browser it falls back to setTimeout(callback, 0),
+which means other higher priority events may precede the execution of the callback.
+
+This is used internally for browser-compatibility purposes.
+
+__Arguments__
+
+* callback - The function to call on a later loop around the event loop.
+
+__Example__
+
+ var call_order = [];
+ async.nextTick(function(){
+ call_order.push('two');
+ // call_order now equals ['one','two]
+ });
+ call_order.push('one')
+
+
+## Utils
+
+<a name="memoize" />
+### memoize(fn, [hasher])
+
+Caches the results of an async function. When creating a hash to store function
+results against, the callback is omitted from the hash and an optional hash
+function can be used.
+
+__Arguments__
+
+* fn - the function you to proxy and cache results from.
+* hasher - an optional function for generating a custom hash for storing
+ results, it has all the arguments applied to it apart from the callback, and
+ must be synchronous.
+
+__Example__
+
+ var slow_fn = function (name, callback) {
+ // do something
+ callback(null, result);
+ };
+ var fn = async.memoize(slow_fn);
+
+ // fn can now be used as if it were slow_fn
+ fn('some name', function () {
+ // callback
+ });
+
+<a name="unmemoize" />
+### unmemoize(fn)
+
+Undoes a memoized function, reverting it to the original, unmemoized
+form. Comes handy in tests.
+
+__Arguments__
+
+* fn - the memoized function
+
+<a name="log" />
+### log(function, arguments)
+
+Logs the result of an async function to the console. Only works in node.js or
+in browsers that support console.log and console.error (such as FF and Chrome).
+If multiple arguments are returned from the async function, console.log is
+called on each argument in order.
+
+__Arguments__
+
+* function - The function you want to eventually apply all arguments to.
+* arguments... - Any number of arguments to apply to the function.
+
+__Example__
+
+ var hello = function(name, callback){
+ setTimeout(function(){
+ callback(null, 'hello ' + name);
+ }, 1000);
+ };
+
+ node> async.log(hello, 'world');
+ 'hello world'
+
+
+---------------------------------------
+
+<a name="dir" />
+### dir(function, arguments)
+
+Logs the result of an async function to the console using console.dir to
+display the properties of the resulting object. Only works in node.js or
+in browsers that support console.dir and console.error (such as FF and Chrome).
+If multiple arguments are returned from the async function, console.dir is
+called on each argument in order.
+
+__Arguments__
+
+* function - The function you want to eventually apply all arguments to.
+* arguments... - Any number of arguments to apply to the function.
+
+__Example__
+
+ var hello = function(name, callback){
+ setTimeout(function(){
+ callback(null, {hello: name});
+ }, 1000);
+ };
+
+ node> async.dir(hello, 'world');
+ {hello: 'world'}
+
+
+---------------------------------------
+
+<a name="noConflict" />
+### noConflict()
+
+Changes the value of async back to its original value, returning a reference to the
+async object.
View
3 node_modules/async/index.js
@@ -0,0 +1,3 @@
+// This file is just added for convenience so this repository can be
+// directly checked out into a project's deps folder
+module.exports = require('./lib/async');
View
692 node_modules/async/lib/async.js
@@ -0,0 +1,692 @@
+/*global setTimeout: false, console: false */
+(function () {
+
+ var async = {};
+
+ // global on the server, window in the browser
+ var root = this,
+ previous_async = root.async;
+
+ if (typeof module !== 'undefined' && module.exports) {
+ module.exports = async;
+ }
+ else {
+ root.async = async;
+ }
+
+ async.noConflict = function () {
+ root.async = previous_async;
+ return async;
+ };
+
+ //// cross-browser compatiblity functions ////
+
+ var _forEach = function (arr, iterator) {
+ if (arr.forEach) {
+ return arr.forEach(iterator);
+ }
+ for (var i = 0; i < arr.length; i += 1) {
+ iterator(arr[i], i, arr);
+ }
+ };
+
+ var _map = function (arr, iterator) {
+ if (arr.map) {
+ return arr.map(iterator);
+ }
+ var results = [];
+ _forEach(arr, function (x, i, a) {
+ results.push(iterator(x, i, a));
+ });
+ return results;
+ };
+
+ var _reduce = function (arr, iterator, memo) {
+ if (arr.reduce) {
+ return arr.reduce(iterator, memo);
+ }
+ _forEach(arr, function (x, i, a) {
+ memo = iterator(memo, x, i, a);
+ });
+ return memo;
+ };
+
+ var _keys = function (obj) {
+ if (Object.keys) {
+ return Object.keys(obj);
+ }
+ var keys = [];
+ for (var k in obj) {
+ if (obj.hasOwnProperty(k)) {
+ keys.push(k);
+ }
+ }
+ return keys;
+ };
+
+ //// exported async module functions ////
+
+ //// nextTick implementation with browser-compatible fallback ////
+ if (typeof process === 'undefined' || !(process.nextTick)) {
+ async.nextTick = function (fn) {
+ setTimeout(fn, 0);
+ };
+ }
+ else {
+ async.nextTick = process.nextTick;
+ }
+
+ async.forEach = function (arr, iterator, callback) {
+ callback = callback || function () {};
+ if (!arr.length) {
+ return callback();
+ }
+ var completed = 0;
+ _forEach(arr, function (x) {
+ iterator(x, function (err) {
+ if (err) {
+ callback(err);
+ callback = function () {};
+ }
+ else {
+ completed += 1;
+ if (completed === arr.length) {
+ callback();
+ }
+ }
+ });
+ });
+ };
+
+ async.forEachSeries = function (arr, iterator, callback) {
+ callback = callback || function () {};
+ if (!arr.length) {
+ return callback();
+ }
+ var completed = 0;
+ var iterate = function () {
+ iterator(arr[completed], function (err) {
+ if (err) {
+ callback(err);
+ callback = function () {};
+ }
+ else {
+ completed += 1;
+ if (completed === arr.length) {
+ callback();
+ }
+ else {
+ iterate();
+ }
+ }
+ });
+ };
+ iterate();
+ };
+
+ async.forEachLimit = function (arr, limit, iterator, callback) {
+ callback = callback || function () {};
+ if (!arr.length || limit <= 0) {
+ return callback();
+ }
+ var completed = 0;
+ var started = 0;
+ var running = 0;
+
+ (function replenish () {
+ if (completed === arr.length) {
+ return callback();
+ }
+
+ while (running < limit && started < arr.length) {
+ iterator(arr[started], function (err) {
+ if (err) {
+ callback(err);
+ callback = function () {};
+ }
+ else {
+ completed += 1;
+ running -= 1;
+ if (completed === arr.length) {
+ callback();
+ }
+ else {
+ replenish();
+ }
+ }
+ });
+ started += 1;
+ running += 1;
+ }
+ })();
+ };
+
+
+ var doParallel = function (fn) {
+ return function () {
+ var args = Array.prototype.slice.call(arguments);
+ return fn.apply(null, [async.forEach].concat(args));
+ };
+ };
+ var doSeries = function (fn) {
+ return function () {
+ var args = Array.prototype.slice.call(arguments);
+ return fn.apply(null, [async.forEachSeries].concat(args));
+ };
+ };
+
+
+ var _asyncMap = function (eachfn, arr, iterator, callback) {
+ var results = [];
+ arr = _map(arr, function (x, i) {
+ return {index: i, value: x};
+ });
+ eachfn(arr, function (x, callback) {
+ iterator(x.value, function (err, v) {
+ results[x.index] = v;
+ callback(err);
+ });
+ }, function (err) {
+ callback(err, results);
+ });
+ };
+ async.map = doParallel(_asyncMap);
+ async.mapSeries = doSeries(_asyncMap);
+
+
+ // reduce only has a series version, as doing reduce in parallel won't
+ // work in many situations.
+ async.reduce = function (arr, memo, iterator, callback) {
+ async.forEachSeries(arr, function (x, callback) {
+ iterator(memo, x, function (err, v) {
+ memo = v;
+ callback(err);
+ });
+ }, function (err) {
+ callback(err, memo);
+ });
+ };
+ // inject alias
+ async.inject = async.reduce;
+ // foldl alias
+ async.foldl = async.reduce;
+
+ async.reduceRight = function (arr, memo, iterator, callback) {
+ var reversed = _map(arr, function (x) {
+ return x;
+ }).reverse();
+ async.reduce(reversed, memo, iterator, callback);
+ };
+ // foldr alias
+ async.foldr = async.reduceRight;
+
+ var _filter = function (eachfn, arr, iterator, callback) {
+ var results = [];
+ arr = _map(arr, function (x, i) {
+ return {index: i, value: x};
+ });
+ eachfn(arr, function (x, callback) {
+ iterator(x.value, function (v) {
+ if (v) {
+ results.push(x);
+ }
+ callback();
+ });
+ }, function (err) {
+ callback(_map(results.sort(function (a, b) {
+ return a.index - b.index;
+ }), function (x) {
+ return x.value;
+ }));
+ });
+ };
+ async.filter = doParallel(_filter);
+ async.filterSeries = doSeries(_filter);
+ // select alias
+ async.select = async.filter;
+ async.selectSeries = async.filterSeries;
+
+ var _reject = function (eachfn, arr, iterator, callback) {
+ var results = [];
+ arr = _map(arr, function (x, i) {
+ return {index: i, value: x};
+ });
+ eachfn(arr, function (x, callback) {
+ iterator(x.value, function (v) {
+ if (!v) {
+ results.push(x);
+ }
+ callback();
+ });
+ }, function (err) {
+ callback(_map(results.sort(function (a, b) {
+ return a.index - b.index;
+ }), function (x) {
+ return x.value;
+ }));
+ });
+ };
+ async.reject = doParallel(_reject);
+ async.rejectSeries = doSeries(_reject);
+
+ var _detect = function (eachfn, arr, iterator, main_callback) {
+ eachfn(arr, function (x, callback) {
+ iterator(x, function (result) {
+ if (result) {
+ main_callback(x);
+ main_callback = function () {};
+ }
+ else {
+ callback();
+ }
+ });
+ }, function (err) {
+ main_callback();
+ });
+ };
+ async.detect = doParallel(_detect);
+ async.detectSeries = doSeries(_detect);
+
+ async.some = function (arr, iterator, main_callback) {
+ async.forEach(arr, function (x, callback) {
+ iterator(x, function (v) {
+ if (v) {
+ main_callback(true);
+ main_callback = function () {};
+ }
+ callback();
+ });
+ }, function (err) {
+ main_callback(false);
+ });
+ };
+ // any alias
+ async.any = async.some;
+
+ async.every = function (arr, iterator, main_callback) {
+ async.forEach(arr, function (x, callback) {
+ iterator(x, function (v) {
+ if (!v) {
+ main_callback(false);
+ main_callback = function () {};
+ }
+ callback();
+ });
+ }, function (err) {
+ main_callback(true);
+ });
+ };
+ // all alias
+ async.all = async.every;
+
+ async.sortBy = function (arr, iterator, callback) {
+ async.map(arr, function (x, callback) {
+ iterator(x, function (err, criteria) {
+ if (err) {
+ callback(err);
+ }
+ else {
+ callback(null, {value: x, criteria: criteria});
+ }
+ });
+ }, function (err, results) {
+ if (err) {
+ return callback(err);
+ }
+ else {
+ var fn = function (left, right) {
+ var a = left.criteria, b = right.criteria;
+ return a < b ? -1 : a > b ? 1 : 0;
+ };
+ callback(null, _map(results.sort(fn), function (x) {
+ return x.value;
+ }));
+ }
+ });
+ };
+
+ async.auto = function (tasks, callback) {
+ callback = callback || function () {};
+ var keys = _keys(tasks);
+ if (!keys.length) {
+ return callback(null);
+ }
+
+ var results = {};
+
+ var listeners = [];
+ var addListener = function (fn) {
+ listeners.unshift(fn);
+ };
+ var removeListener = function (fn) {
+ for (var i = 0; i < listeners.length; i += 1) {
+ if (listeners[i] === fn) {
+ listeners.splice(i, 1);
+ return;
+ }
+ }
+ };
+ var taskComplete = function () {
+ _forEach(listeners.slice(0), function (fn) {
+ fn();
+ });
+ };
+
+ addListener(function () {
+ if (_keys(results).length === keys.length) {
+ callback(null, results);
+ callback = function () {};
+ }
+ });
+
+ _forEach(keys, function (k) {
+ var task = (tasks[k] instanceof Function) ? [tasks[k]]: tasks[k];
+ var taskCallback = function (err) {
+ if (err) {
+ callback(err);
+ // stop subsequent errors hitting callback multiple times
+ callback = function () {};
+ }
+ else {
+ var args = Array.prototype.slice.call(arguments, 1);
+ if (args.length <= 1) {
+ args = args[0];
+ }
+ results[k] = args;
+ taskComplete();
+ }
+ };
+ var requires = task.slice(0, Math.abs(task.length - 1)) || [];
+ var ready = function () {
+ return _reduce(requires, function (a, x) {
+ return (a && results.hasOwnProperty(x));
+ }, true);
+ };
+ if (ready()) {
+ task[task.length - 1](taskCallback, results);
+ }
+ else {
+ var listener = function () {
+ if (ready()) {
+ removeListener(listener);
+ task[task.length - 1](taskCallback, results);
+ }
+ };
+ addListener(listener);
+ }
+ });
+ };
+
+ async.waterfall = function (tasks, callback) {
+ callback = callback || function () {};
+ if (!tasks.length) {
+ return callback();
+ }
+ var wrapIterator = function (iterator) {
+ return function (err) {
+ if (err) {
+ callback(err);
+ callback = function () {};
+ }
+ else {
+ var args = Array.prototype.slice.call(arguments, 1);
+ var next = iterator.next();
+ if (next) {
+ args.push(wrapIterator(next));
+ }
+ else {
+ args.push(callback);
+ }
+ async.nextTick(function () {
+ iterator.apply(null, args);
+ });
+ }
+ };
+ };
+ wrapIterator(async.iterator(tasks))();
+ };
+
+ async.parallel = function (tasks, callback) {
+ callback = callback || function () {};
+ if (tasks.constructor === Array) {
+ async.map(tasks, function (fn, callback) {
+ if (fn) {
+ fn(function (err) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ if (args.length <= 1) {
+ args = args[0];
+ }
+ callback.call(null, err, args);
+ });
+ }
+ }, callback);
+ }
+ else {
+ var results = {};
+ async.forEach(_keys(tasks), function (k, callback) {
+ tasks[k](function (err) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ if (args.length <= 1) {
+ args = args[0];
+ }
+ results[k] = args;
+ callback(err);
+ });
+ }, function (err) {
+ callback(err, results);
+ });
+ }
+ };
+
+ async.series = function (tasks, callback) {
+ callback = callback || function () {};
+ if (tasks.constructor === Array) {
+ async.mapSeries(tasks, function (fn, callback) {
+ if (fn) {
+ fn(function (err) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ if (args.length <= 1) {
+ args = args[0];
+ }
+ callback.call(null, err, args);
+ });
+ }
+ }, callback);
+ }
+ else {
+ var results = {};
+ async.forEachSeries(_keys(tasks), function (k, callback) {
+ tasks[k](function (err) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ if (args.length <= 1) {
+ args = args[0];
+ }
+ results[k] = args;
+ callback(err);
+ });
+ }, function (err) {
+ callback(err, results);
+ });
+ }
+ };
+
+ async.iterator = function (tasks) {
+ var makeCallback = function (index) {
+ var fn = function () {
+ if (tasks.length) {
+ tasks[index].apply(null, arguments);
+ }
+ return fn.next();
+ };
+ fn.next = function () {
+ return (index < tasks.length - 1) ? makeCallback(index + 1): null;
+ };
+ return fn;
+ };
+ return makeCallback(0);
+ };
+
+ async.apply = function (fn) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ return function () {
+ return fn.apply(
+ null, args.concat(Array.prototype.slice.call(arguments))
+ );
+ };
+ };
+
+ var _concat = function (eachfn, arr, fn, callback) {
+ var r = [];
+ eachfn(arr, function (x, cb) {
+ fn(x, function (err, y) {
+ r = r.concat(y || []);
+ cb(err);
+ });
+ }, function (err) {
+ callback(err, r);
+ });
+ };
+ async.concat = doParallel(_concat);
+ async.concatSeries = doSeries(_concat);
+
+ async.whilst = function (test, iterator, callback) {
+ if (test()) {
+ iterator(function (err) {
+ if (err) {
+ return callback(err);
+ }
+ async.whilst(test, iterator, callback);
+ });
+ }
+ else {
+ callback();
+ }
+ };
+
+ async.until = function (test, iterator, callback) {
+ if (!test()) {
+ iterator(function (err) {
+ if (err) {
+ return callback(err);
+ }
+ async.until(test, iterator, callback);
+ });
+ }
+ else {
+ callback();
+ }
+ };
+
+ async.queue = function (worker, concurrency) {
+ var workers = 0;
+ var q = {
+ tasks: [],
+ concurrency: concurrency,
+ saturated: null,
+ empty: null,
+ drain: null,
+ push: function (data, callback) {
+ if(data.constructor !== Array) {
+ data = [data];
+ }
+ _forEach(data, function(task) {
+ q.tasks.push({
+ data: task,
+ callback: typeof callback === 'function' ? callback : null
+ });
+ if (q.saturated && q.tasks.length == concurrency) {
+ q.saturated();
+ }
+ async.nextTick(q.process);
+ });
+ },
+ process: function () {
+ if (workers < q.concurrency && q.tasks.length) {
+ var task = q.tasks.shift();
+ if(q.empty && q.tasks.length == 0) q.empty();
+ workers += 1;
+ worker(task.data, function () {
+ workers -= 1;
+ if (task.callback) {
+ task.callback.apply(task, arguments);
+ }
+ if(q.drain && q.tasks.length + workers == 0) q.drain();
+ q.process();
+ });
+ }
+ },
+ length: function () {
+ return q.tasks.length;
+ },
+ running: function () {
+ return workers;
+ }
+ };
+ return q;
+ };
+
+ var _console_fn = function (name) {
+ return function (fn) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ fn.apply(null, args.concat([function (err) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ if (typeof console !== 'undefined') {
+ if (err) {
+ if (console.error) {
+ console.error(err);
+ }
+ }
+ else if (console[name]) {
+ _forEach(args, function (x) {
+ console[name](x);
+ });
+ }
+ }
+ }]));
+ };
+ };
+ async.log = _console_fn('log');
+ async.dir = _console_fn('dir');
+ /*async.info = _console_fn('info');
+ async.warn = _console_fn('warn');
+ async.error = _console_fn('error');*/
+
+ async.memoize = function (fn, hasher) {
+ var memo = {};
+ var queues = {};
+ hasher = hasher || function (x) {
+ return x;
+ };
+ var memoized = function () {
+ var args = Array.prototype.slice.call(arguments);
+ var callback = args.pop();
+ var key = hasher.apply(null, args);
+ if (key in memo) {
+ callback.apply(null, memo[key]);
+ }
+ else if (key in queues) {
+ queues[key].push(callback);
+ }
+ else {
+ queues[key] = [callback];
+ fn.apply(null, args.concat([function () {
+ memo[key] = arguments;
+ var q = queues[key];
+ delete queues[key];
+ for (var i = 0, l = q.length; i < l; i++) {
+ q[i].apply(null, arguments);
+ }
+ }]));
+ }
+ };
+ memoized.unmemoized = fn;
+ return memoized;
+ };
+
+ async.unmemoize = function (fn) {
+ return function () {
+ return (fn.unmemoized || fn).apply(null, arguments);
+ }
+ };
+
+}());
View
21 node_modules/async/package.json
@@ -0,0 +1,21 @@
+{ "name": "async"
+, "description": "Higher-order functions and common patterns for asynchronous code"
+, "main": "./index"
+, "author": "Caolan McMahon"
+, "version": "0.1.18"
+, "repository" :
+ { "type" : "git"
+ , "url" : "http://github.com/caolan/async.git"
+ }
+, "bugs" : { "url" : "http://github.com/caolan/async/issues" }
+, "licenses" :
+ [ { "type" : "MIT"
+ , "url" : "http://github.com/caolan/async/raw/master/LICENSE"
+ }
+ ]
+, "devDependencies":
+ { "nodeunit": ">0.0.0"
+ , "uglify-js": "1.2.x"
+ , "nodelint": ">0.0.0"
+ }
+}
View
12 node_modules/mongodb/.npmignore
@@ -1,12 +0,0 @@
-.git*
-.buildinfo
-.mongodb
-docs/
-docs/sphinx-docs
-data/
-dev/
-examples/
-test/
-.DS_Store
-
-
View
408 node_modules/mongodb/HISTORY
@@ -1,408 +0,0 @@
-0.9.9.2 2012-02-17
-------------------
-* Improved detection of Buffers using Buffer.isBuffer instead of instanceof.
-* Added wrap error around db.dropDatabase to catch all errors (Issue #512)
-* Added aggregate helper to collection, only for MongoDB >= 2.1
-
-0.9.9.1 2012-02-15
-------------------
-* Better handling of safe when using some commands such as createIndex, ensureIndex, addUser, removeUser, createCollection.
-* Mapreduce now throws error if out parameter is not specified.
-
-0.9.9 2012-02-13
-----------------
-* Added createFromTime method on ObjectID to allow for queries against _id more easily using the timestamp.
-* Db.close(true) now makes connection unusable as it's been force closed by app.
-* Fixed mapReduce and group functions to correctly send slaveOk on queries.
-* Fixes for find method to correctly work with find(query, fields, callback) (Issue #506).
-* A fix for connection error handling when using the SSL on MongoDB.
-
-0.9.8-7 2012-02-06
-------------------
-* Simplified findOne to use the find command instead of the custom code (Issue #498).
-* BSON JS parser not also checks for _bsonType variable in case BSON object is in weird scope (Issue #495).
-
-0.9.8-6 2012-02-04
-------------------
-* Removed the check for replicaset change code as it will never work with node.js.
-
-0.9.8-5 2012-02-02
-------------------
-* Added geoNear command to Collection.
-* Added geoHaystackSearch command to Collection.
-* Added indexes command to collection to retrieve the indexes on a Collection.
-* Added stats command to collection to retrieve the statistics on a Collection.
-* Added listDatabases command to admin object to allow retrieval of all available dbs.
-* Changed createCreateIndexCommand to work better with options.
-* Fixed dereference method on Db class to correctly dereference Db reference objects.
-* Moved connect object onto Db class(Db.connect) as well as keeping backward compatibility.
-* Removed writeBuffer method from gridstore, write handles switching automatically now.
-* Changed readBuffer to read on Gridstore, Gridstore now only supports Binary Buffers no Strings anymore.
-* Moved Long class to bson directory.
-
-0.9.8-4 2012-01-28
-------------------
-* Added reIndex command to collection and db level.
-* Added support for $returnKey, $maxScan, $min, $max, $showDiskLoc, $comment to cursor and find/findOne methods.
-* Added dropDups and v option to createIndex and ensureIndex.
-* Added isCapped method to Collection.
-* Added indexExists method to Collection.
-* Added findAndRemove method to Collection.
-* Fixed bug for replicaset connection when no active servers in the set.
-* Fixed bug for replicaset connections when errors occur during connection.
-* Merged in patch for BSON Number handling from Lee Salzman, did some small fixes and added test coverage.
-
-0.9.8-3 2012-01-21
-------------------
-* Workaround for issue with Object.defineProperty (Issue #484)
-* ObjectID generation with date does not set rest of fields to zero (Issue #482)
-
-0.9.8-2 2012-01-20
-------------------
-* Fixed a missing this in the ReplSetServers constructor.
-
-0.9.8-1 2012-01-17
-------------------
-* FindAndModify bug fix for duplicate errors (Issue #481)
-
-0.9.8 2012-01-17
-----------------
-* Replicasets now correctly adjusts to live changes in the replicaset configuration on the servers, reconnecting correctly.
- - Set the interval for checking for changes setting the replicaSetCheckInterval property when creating the ReplSetServers instance or on db.serverConfig.replicaSetCheckInterval. (default 1000 miliseconds)
-* Fixes formattedOrderClause in collection.js to accept a plain hash as a parameter (Issue #469) https://github.com/tedeh
-* Removed duplicate code for formattedOrderClause and moved to utils module
-* Pass in poolSize for ReplSetServers to set default poolSize for new replicaset members
-* Bug fix for BSON JS deserializer. Isolating the eval functions in separate functions to avoid V8 deoptimizations
-* Correct handling of illegal BSON messages during deserialization
-* Fixed Infinite loop when reading GridFs file with no chunks (Issue #471)
-* Correctly update existing user password when using addUser (Issue #470)
-
-0.9.7.3-5 2012-01-04
---------------------
-* Fix for RegExp serialization for 0.4.X where typeof /regexp/ == 'function' vs in 0.6.X typeof /regexp/ == 'object'
-* Don't allow keepAlive and setNoDelay for 0.4.X as it throws errors
-
-0.9.7.3-4 2012-01-04
---------------------
-* Chased down potential memory leak on findAndModify, Issue #467 (node.js removeAllListeners leaves the key in the _events object, node.js bug on eventlistener?, leads to extremely slow memory leak on listener object)
-* Sanity checks for GridFS performance with benchmark added
-
-0.9.7.3-3 2012-01-04
---------------------
-* Bug fixes for performance issues going form 0.9.6.X to 0.9.7.X on linux
-* BSON bug fixes for performance
-
-0.9.7.3-2 2012-01-02
---------------------
-* Fixed up documentation to reflect the preferred way of instantiating bson types
-* GC bug fix for JS bson parser to avoid stop-and-go GC collection
-
-0.9.7.3-1 2012-01-02
---------------------
-* Fix to make db.bson_serializer and db.bson_deserializer work as it did previously
-
-0.9.7.3 2011-12-30
---------------------
-* Moved BSON_BINARY_SUBTYPE_DEFAULT from BSON object to Binary object and removed the BSON_BINARY_ prefixes
-* Removed Native BSON types, C++ parser uses JS types (faster due to cost of crossing the JS-C++ barrier for each call)
-* Added build fix for 0.4.X branch of Node.js where GetOwnPropertyNames is not defined in v8
-* Fix for wire protocol parser for corner situation where the message is larger than the maximum socket buffer in node.js (Issue #464, #461, #447)
-* Connection pool status set to connected on poolReady, isConnected returns false on anything but connected status (Issue #455)
-
-0.9.7.2-5 2011-12-22
---------------------
-* Brand spanking new Streaming Cursor support Issue #458 (https://github.com/christkv/node-mongodb-native/pull/458) thanks to Mr Aaron Heckmann
-
-0.9.7.2-4 2011-12-21
---------------------
-* Refactoring of callback code to work around performance regression on linux
-* Fixed group function to correctly use the command mode as default
-
-0.9.7.2-3 2011-12-18
---------------------
-* Fixed error handling for findAndModify while still working for mongodb 1.8.6 (Issue #450).
-* Allow for force send query to primary, pass option (read:'primary') on find command.
- * ``find({a:1}, {read:'primary'}).toArray(function(err, items) {});``
-
-0.9.7.2-2 2011-12-16
---------------------
-* Fixes infinite streamRecords QueryFailure fix when using Mongos (Issue #442)
-
-0.9.7.2-1 2011-12-16
---------------------
-* ~10% perf improvement for ObjectId#toHexString (Issue #448, https://github.com/aheckmann)
-* Only using process.nextTick on errors emitted on callbacks not on all parsing, reduces number of ticks in the driver
-* Changed parsing off bson messages to use process.nextTick to do bson parsing in batches if the message is over 10K as to yield more time to the event look increasing concurrency on big mongoreply messages with multiple documents
-
-0.9.7.2 2011-12-15
-------------------
-* Added SSL support for future version of mongodb (VERY VERY EXPERIMENTAL)
- * pass in the ssl:true option to the server or replicaset server config to enable
- * a bug either in mongodb or node.js does not allow for more than 1 connection pr db instance (poolSize:1).
-* Added getTimestamp() method to objectID that returns a date object
-* Added finalize function to collection.group
- * function group (keys, condition, initial, reduce, finalize, command, callback)
-* Reaper no longer using setTimeout to handle reaping. Triggering is done in the general flow leading to predictable behavior.
- * reaperInterval, set interval for reaper (default 10000 miliseconds)
- * reaperTimeout, set timeout for calls (default 30000 miliseconds)
- * reaper, enable/disable reaper (default false)
-* Work around for issues with findAndModify during high concurrency load, insure that the behavior is the same across the 1.8.X branch and 2.X branch of MongoDb
-* Reworked multiple db's sharing same connection pool to behave correctly on error, timeout and close
-* EnsureIndex command can be executed without a callback (Issue #438)
-* Eval function no accepts options including nolock (Issue #432)
- * eval(code, parameters, options, callback) (where options = {nolock:true})
-
-0.9.7.1-4 2011-11-27
---------------------
-* Replaced install.sh with install.js to install correctly on all supported os's
-
-0.9.7.1-3 2011-11-27
---------------------
-* Fixes incorrect scope for ensureIndex error wrapping (Issue #419) https://github.com/ritch
-
-0.9.7.1-2 2011-11-27
---------------------
-* Set statistical selection strategy as default for secondary choice.
-
-0.9.7.1-1 2011-11-27
---------------------
-* Better handling of single server reconnect (fixes some bugs)
-* Better test coverage of single server failure
-* Correct handling of callbacks on replicaset servers when firewall dropping packets, correct reconnect
-
-0.9.7.1 2011-11-24
-------------------
-* Better handling of dead server for single server instances
-* FindOne and find treats selector == null as {}, Issue #403
-* Possible to pass in a strategy for the replicaset to pick secondary reader node
- * parameter strategy
- * ping (default), pings the servers and picks the one with the lowest ping time
- * statistical, measures each request and pick the one with the lowest mean and std deviation
-* Set replicaset read preference replicaset.setReadPreference()
- * Server.READ_PRIMARY (use primary server for reads)
- * Server.READ_SECONDARY (from a secondary server (uses the strategy set))
- * tags, {object of tags}
-* Added replay of commands issued to a closed connection when the connection is re-established
-* Fix isConnected and close on unopened connections. Issue #409, fix by (https://github.com/sethml)
-* Moved reaper to db.open instead of constructor (Issue #406)
-* Allows passing through of socket connection settings to Server or ReplSetServer under the option socketOptions
- * timeout = set seconds before connection times out (default 0)
- * noDelay = Disables the Nagle algorithm (default true)
- * keepAlive = Set if keepAlive is used (default 0, which means no keepAlive, set higher than 0 for keepAlive)
- * encoding = ['ascii', 'utf8', or 'base64'] (default null)
-* Fixes for handling of errors during shutdown off a socket connection
-* Correctly applies socket options including timeout
-* Cleanup of test management code to close connections correctly
-* Handle parser errors better, closing down the connection and emitting an error
-* Correctly emit errors from server.js only wrapping errors that are strings
-
-0.9.7 2011-11-10
-----------------
-* Added priority setting to replicaset manager
-* Added correct handling of passive servers in replicaset
-* Reworked socket code for simpler clearer handling
-* Correct handling of connections in test helpers
-* Added control of retries on failure
- * control with parameters retryMiliSeconds and numberOfRetries when creating a db instance
-* Added reaper that will timeout and cleanup queries that never return
- * control with parameters reaperInterval and reaperTimeout when creating a db instance
-* Refactored test helper classes for replicaset tests
-* Allows raw (no bson parser mode for insert, update, remove, find and findOne)
- * control raw mode passing in option raw:true on the commands
- * will return buffers with the binary bson objects
-* Fixed memory leak in cursor.toArray
-* Fixed bug in command creation for mongodb server with wrong scope of call
-* Added db(dbName) method to db.js to allow for reuse of connections against other databases
-* Serialization of functions in an object is off by default, override with parameter
- * serializeFunctions [true/false] on db level, collection level or individual insert/update/findAndModify
-* Added Long.fromString to c++ class and fixed minor bug in the code (Test case for $gt operator on 64-bit integers, Issue #394)
-* FindOne and find now share same code execution and will work in the same manner, Issue #399
-* Fix for tailable cursors, Issue #384
-* Fix for Cursor rewind broken, Issue #389
-* Allow Gridstore.exist to query using regexp, Issue #387, fix by (https://github.com/kaij)
-* Updated documentation on https://github.com/christkv/node-mongodb-native
-* Fixed toJSON methods across all objects for BSON, Binary return Base64 Encoded data
-
-0.9.6-22 2011-10-15
--------------------
-* Fixed bug in js bson parser that could cause wrong object size on serialization, Issue #370
-* Fixed bug in findAndModify that did not throw error on replicaset timeout, Issue #373
-
-0.9.6-21 2011-10-05
--------------------
-* Reworked reconnect code to work correctly
-* Handling errors in different parts of the code to ensure that it does not lock the connection
-* Consistent error handling for Object.createFromHexString for JS and C++
-
-0.9.6-20 2011-10-04
--------------------
-* Reworked bson.js parser to get rid off Array.shift() due to it allocating new memory for each call. Speedup varies between 5-15% depending on doc
-* Reworked bson.cc to throw error when trying to serialize js bson types
-* Added MinKey, MaxKey and Double support for JS and C++ parser
-* Reworked socket handling code to emit errors on unparsable messages
-* Added logger option for Db class, lets you pass in a function in the shape
- {
- log : function(message, object) {},
- error : function(errorMessage, errorObject) {},
- debug : function(debugMessage, object) {},
- }
-
- Usage is new Db(new Server(..), {logger: loggerInstance})
-
-0.9.6-19 2011-09-29
--------------------
-* Fixing compatibility issues between C++ bson parser and js parser
-* Added Symbol support to C++ parser
-* Fixed socket handling bug for seldom misaligned message from mongodb
-* Correctly handles serialization of functions using the C++ bson parser
-
-0.9.6-18 2011-09-22
--------------------
-* Fixed bug in waitForConnection that would lead to 100% cpu usage, Issue #352
-
-0.9.6-17 2011-09-21
--------------------
-* Fixed broken exception test causing bamboo to hang
-* Handling correctly command+lastError when both return results as in findAndModify, Issue #351
-
-0.9.6-16 2011-09-14
--------------------
-* Fixing a bunch of issues with compatibility with MongoDB 2.0.X branch. Some fairly big changes in behavior from 1.8.X to 2.0.X on the server.
-* Error Connection MongoDB V2.0.0 with Auth=true, Issue #348
-
-0.9.6-15 2011-09-09
--------------------
-* Fixed issue where pools would not be correctly cleaned up after an error, Issue #345
-* Fixed authentication issue with secondary servers in Replicaset, Issue #334
-* Duplicate replica-set servers when omitting port, Issue #341
-* Fixing findAndModify to correctly work with Replicasets ensuring proper error handling, Issue #336
-* Merged in code from (https://github.com/aheckmann) that checks for global variable leaks
-
-0.9.6-14 2011-09-05
--------------------
-* Minor fixes for error handling in cursor streaming (https://github.com/sethml), Issue #332
-* Minor doc fixes
-* Some more cursor sort tests added, Issue #333
-* Fixes to work with 0.5.X branch
-* Fix Db not removing reconnect listener from serverConfig, (https://github.com/sbrekken), Issue #337
-* Removed node_events.h includes (https://github.com/jannehietamaki), Issue #339
-* Implement correct safe/strict mode for findAndModify.
-
-0.9.6-13 2011-08-24
--------------------
-* Db names correctly error checked for illegal characters
-
-0.9.6-12 2011-08-24
--------------------
-* Nasty bug in GridFS if you changed the default chunk size
-* Fixed error handling bug in findOne
-
-0.9.6-11 2011-08-23
--------------------
-* Timeout option not correctly making it to the cursor, Issue #320, Fix from (https://github.com/year2013)
-* Fixes for memory leaks when using buffers and C++ parser
-* Fixes to make tests pass on 0.5.X
-* Cleanup of bson.js to remove duplicated code paths
-* Fix for errors occurring in ensureIndex, Issue #326
-* Removing require.paths to make tests work with the 0.5.X branch
-
-0.9.6-10 2011-08-11
--------------------
-* Specific type Double for capped collections (https://github.com/mbostock), Issue #312
-* Decorating Errors with all all object info from Mongo (https://github.com/laurie71), Issue #308
-* Implementing fixes for mongodb 1.9.1 and higher to make tests pass
-* Admin validateCollection now takes an options argument for you to pass in full option
-* Implemented keepGoing parameter for mongodb 1.9.1 or higher, Issue #310
-* Added test for read_secondary count issue, merged in fix from (https://github.com/year2013), Issue #317
-
-0.9.6-9
--------
-* Bug fix for bson parsing the key '':'' correctly without crashing
-
-0.9.6-8
--------
-* Changed to using node.js crypto library MD5 digest
-* Connect method support documented mongodb: syntax by (https://github.com/sethml)
-* Support Symbol type for BSON, serializes to it's own type Symbol, Issue #302, #288
-* Code object without scope serializing to correct BSON type
-* Lot's of fixes to avoid double callbacks (https://github.com/aheckmann) Issue #304
-* Long deserializes as Number for values in the range -2^53 to 2^53, Issue #305 (https://github.com/sethml)
-* Fixed C++ parser to reflect JS parser handling of long deserialization
-* Bson small optimizations
-
-0.9.6-7 2011-07-13
-------------------
-* JS Bson deserialization bug #287
-
-0.9.6-6 2011-07-12
-------------------
-* FindAndModify not returning error message as other methods Issue #277
-* Added test coverage for $push, $pushAll and $inc atomic operations
-* Correct Error handling for non 12/24 bit ids on Pure JS ObjectID class Issue #276
-* Fixed terrible deserialization bug in js bson code #285
-* Fix by andrewjstone to avoid throwing errors when this.primary not defined
-
-0.9.6-5 2011-07-06
-------------------
-* Rewritten BSON js parser now faster than the C parser on my core2duo laptop
-* Added option full to indexInformation to get all index info Issue #265
-* Passing in ObjectID for new Gridstore works correctly Issue #272
-
-0.9.6-4 2011-07-01
-------------------
-* Added test and bug fix for insert/update/remove without callback supplied
-
-0.9.6-3 2011-07-01
-------------------
-* Added simple grid class called Grid with put, get, delete methods
-* Fixed writeBuffer/readBuffer methods on GridStore so they work correctly
-* Automatic handling of buffers when using write method on GridStore
-* GridStore now accepts a ObjectID instead of file name for write and read methods
-* GridStore.list accepts id option to return of file ids instead of filenames
-* GridStore close method returns document for the file allowing user to reference _id field
-
-0.9.6-2 2011-06-30
-------------------
-* Fixes for reconnect logic for server object (replays auth correctly)
-* More testcases for auth
-* Fixes in error handling for replicaset
-* Fixed bug with safe parameter that would fail to execute safe when passing w or wtimeout
-* Fixed slaveOk bug for findOne method
-* Implemented auth support for replicaset and test cases
-* Fixed error when not passing in rs_name
-
-0.9.6-1 2011-06-25
-------------------
-* Fixes for test to run properly using c++ bson parser
-* Fixes for dbref in native parser (correctly handles ref without db component)
-* Connection fixes for replicasets to avoid runtime conditions in cygwin (https://github.com/vincentcr)
-* Fixes for timestamp in js bson parser (distinct timestamp type now)
-
-0.9.6 2011-06-21
-----------------
-* Worked around npm version handling bug
-* Race condition fix for cygwin (https://github.com/vincentcr)
-
-0.9.5-1 2011-06-21
-------------------
-* Extracted Timestamp as separate class for bson js parser to avoid instanceof problems
-* Fixed driver strict mode issue
-
-0.9.5 2011-06-20
-----------------
-* Replicaset support (failover and reading from secondary servers)
-* Removed ServerPair and ServerCluster
-* Added connection pool functionality
-* Fixed serious bug in C++ bson parser where bytes > 127 would generate 2 byte sequences
-* Allows for forcing the server to assign ObjectID's using the option {forceServerObjectId: true}
-
-0.6.8
------
-* Removed multiple message concept from bson
-* Changed db.open(db) to be db.open(err, db)
-
-0.1 2010-01-30
---------------
-* Initial release support of driver using native node.js interface
-* Supports gridfs specification
-* Supports admin functionality
View
408 node_modules/mongodb/Readme.md
@@ -1,408 +0,0 @@
-Install
-========
-
-To install the most recent release from npm, run:
-
- npm install mongodb
-
-That may give you a warning telling you that bugs['web'] should be bugs['url'], it would be safe to ignore it (this has been fixed in the development version)
-
-To install from the latest from the repository, run::
-
- npm install path/to/node-mongodb-native
-
-Community
-========
-Check out the google group [node-mongodb-native](http://groups.google.com/group/node-mongodb-native) for questions/answers from users of the driver.
-
-Introduction
-========
-
-This is a node.js driver for MongoDB. It's a port (or close to a port) of the library for ruby at http://github.com/mongodb/mongo-ruby-driver/.
-
-A simple example of inserting a document.
-
- var client = new Db('test', new Server("127.0.0.1", 27017, {})),
- test = function (err, collection) {
- collection.insert({a:2}, function(err, docs) {
-
- collection.count(function(err, count) {
- test.assertEquals(1, count);
- });
-
- // Locate all the entries using find
- collection.find().toArray(function(err, results) {
- test.assertEquals(1, results.length);
- test.assertTrue(results.a === 2);
-
- // Let's close the db
- client.close();
- });
- });
- };
-
- client.open(function(err, p_client) {
- client.collection('test_insert', test);
- });
-
-Data types
-========
-
-To store and retrieve the non-JSON MongoDb primitives ([ObjectID](http://www.mongodb.org/display/DOCS/Object+IDs), Long, Binary, [Timestamp](http://www.mongodb.org/display/DOCS/Timestamp+data+type), [DBRef](http://www.mongodb.org/display/DOCS/Database+References#DatabaseReferences-DBRef), Code).
-
-In particular, every document has a unique `_id` which can be almost any type, and by default a 12-byte ObjectID is created. ObjectIDs can be represented as 24-digit hexadecimal strings, but you must convert the string back into an ObjectID before you can use it in the database. For example:
-
- // Get the objectID type
- var ObjectID = require('mongodb').ObjectID;
-
- var idString = '4e4e1638c85e808431000003';
- collection.findOne({_id: new ObjectID(idString)}, console.log) // ok
- collection.findOne({_id: idString}, console.log) // wrong! callback gets undefined
-
-Here are the constructors the non-Javascript BSON primitive types:
-
- // Fetch the library
- var mongo = require('mongodb');
- // Create new instances of BSON types
- new mongo.Long(numberString)
- new mongo.ObjectID(hexString)
- new mongo.Timestamp() // the actual unique number is generated on insert.
- new mongo.DBRef(collectionName, id, dbName)
- new mongo.Binary(buffer) // takes a string or Buffer
- new mongo.Code(code, [context])
- new mongo.Symbol(string)
- new mongo.MinKey()
- new mongo.MaxKey()
- new mongo.Double(number) // Force double storage
-
-The C/C++ bson parser/serializer
---------
-
-From V0.8.0 to V0.9.6.9, the Javascript bson parser was slower than an optional C/C++ bson parser. As of V0.9.6.9+, due to performance improvements in the Javascript parser, the C/C++ parser is deprecated and is not installed by default anymore.
-
-If you are running a version of this library has the C/C++ parser compiled, to enable the driver to use the C/C++ bson parser pass it the option native_parser:true like below
-
- // using Deprecated native_parser:
- var client = new Db('integration_tests_20',
- new Server("127.0.0.1", 27017),
- {native_parser:true});
-
-The C++ parser uses the js objects both for serialization and deserialization.
-
-GitHub information
-========
-
-The source code is available at http://github.com/christkv/node-mongodb-native.
-You can either clone the repository or download a tarball of the latest release.
-
-Once you have the source you can test the driver by running
-
- $ make test
-
-in the main directory. You will need to have a mongo instance running on localhost for the integration tests to pass.
-
-Examples
-========
-
-For examples look in the examples/ directory. You can execute the examples using node.
-
- $ cd examples
- $ node queries.js
-
-GridStore
-=========
-
-The GridStore class allows for storage of binary files in mongoDB using the mongoDB defined files and chunks collection definition.
-
-For more information have a look at [Gridstore](https://github.com/christkv/node-mongodb-native/blob/master/docs/gridfs.md)
-
-Replicasets
-===========
-For more information about how to connect to a replicaset have a look at [Replicasets](https://github.com/christkv/node-mongodb-native/blob/master/docs/replicaset.md)
-
-Primary Key Factories
---------
-
-Defining your own primary key factory allows you to generate your own series of id's
-(this could f.ex be to use something like ISBN numbers). The generated the id needs to be a 12 byte long "string".
-
-Simple example below
-
- // Custom factory (need to provide a 12 byte array);
- CustomPKFactory = function() {}
- CustomPKFactory.prototype = new Object();
- CustomPKFactory.createPk = function() {
- return new ObjectID("aaaaaaaaaaaa");
- }
-
- var p_client = new Db('integration_tests_20', new Server("127.0.0.1", 27017, {}), {'pk':CustomPKFactory});
- p_client.open(function(err, p_client) {
- p_client.dropDatabase(function(err, done) {
- p_client.createCollection('test_custom_key', function(err, collection) {
- collection.insert({'a':1}, function(err, docs) {
- collection.find({'_id':new ObjectID("aaaaaaaaaaaa")}, function(err, cursor) {
- cursor.toArray(function(err, items) {
- test.assertEquals(1, items.length);
-
- // Let's close the db
- p_client.close();
- });
- });
- });
- });
- });
- });
-
-Strict mode
---------
-
-Each database has an optional strict mode. If it is set then asking for a collection
-that does not exist will return an Error object in the callback. Similarly if you
-attempt to create a collection that already exists. Strict is provided for convenience.
-
- var error_client = new Db('integration_tests_', new Server("127.0.0.1", 27017, {auto_reconnect: false}), {strict:true});
- test.assertEquals(true, error_client.strict);
-
- error_client.open(function(err, error_client) {
- error_client.collection('does-not-exist', function(err, collection) {
- test.assertTrue(err instanceof Error);
- test.assertEquals("Collection does-not-exist does not exist. Currently in strict mode.", err.message);
- });
-
- error_client.createCollection('test_strict_access_collection', function(err, collection) {
- error_client.collection('test_strict_access_collection', function(err, collection) {
- test.assertTrue(collection instanceof Collection);
- // Let's close the db
- error_client.close();
- });
- });
- });
-
-Documentation
-========
-
-If this document doesn't answer your questions, see the source of
-[Collection](https://github.com/christkv/node-mongodb-native/blob/master/lib/mongodb/collection.js)
-or [Cursor](https://github.com/christkv/node-mongodb-native/blob/master/lib/mongodb/cursor.js),
-or the documentation at MongoDB for query and update formats.
-
-Find
---------
-
-The find method is actually a factory method to create
-Cursor objects. A Cursor lazily uses the connection the first time
-you call `nextObject`, `each`, or `toArray`.
-
-The basic operation on a cursor is the `nextObject` method
-that fetches the next matching document from the database. The convenience
-methods `each` and `toArray` call `nextObject` until the cursor is exhausted.
-
-Signatures:
-
- var cursor = collection.find(query, [fields], options);
- cursor.sort(fields).limit(n).skip(m).
-
- cursor.nextObject(function(err, doc) {});
- cursor.each(function(err, doc) {});
- cursor.toArray(function(err, docs) {});
-
- cursor.rewind() // reset the cursor to its initial state.
-
-Useful chainable methods of cursor. These can optionally be options of `find` instead of method calls:
-
-* `.limit(n).skip(m)` to control paging.
-* `.sort(fields)` Order by the given fields. There are several equivalent syntaxes:
- * `.sort({field1: -1, field2: 1})` descending by field1, then ascending by field2.
- * `.sort([['field1', 'desc'], ['field2', 'asc']])` same as above
- * `.sort([['field1', 'desc'], 'field2'])` same as above
- * `.sort('field1')` ascending by field1
-
-Other options of `find`:
-
-* `fields` the fields to fetch (to avoid transferring the entire document)
-* `tailable` if true, makes the cursor [tailable](http://www.mongodb.org/display/DOCS/Tailable+Cursors).
-* `batchSize` The number of the subset of results to request the database
-to return for every request. This should initially be greater than 1 otherwise
-the database will automatically close the cursor. The batch size can be set to 1
-with `batchSize(n, function(err){})` after performing the initial query to the database.
-* `hint` See [Optimization: hint](http://www.mongodb.org/display/DOCS/Optimization#Optimization-Hint).
-* `explain` turns this into an explain query. You can also call
-`explain()` on any cursor to fetch the explanation.
-* `snapshot` prevents documents that are updated while the query is active
-from being returned multiple times. See more
-[details about query snapshots](http://www.mongodb.org/display/DOCS/How+to+do+Snapshotted+Queries+in+the+Mongo+Database).
-* `timeout` if false, asks MongoDb not to time out this cursor after an
-inactivity period.
-
-
-For information on how to create queries, see the
-[MongoDB section on querying](http://www.mongodb.org/display/DOCS/Querying).
-
- var mongodb = require('mongodb');
- var server = new mongodb.Server("127.0.0.1", 27017, {});
- new mongodb.Db('test', server, {}).open(function (error, client) {
- if (error) throw error;
- var collection = new mongodb.Collection(client, 'test_collection');
- collection.find({}, {limit:10}).toArray(function(err, docs) {
- console.dir(docs);
- });
- });
-
-Insert
---------
-
-Signature:
-
- collection.insert(docs, options, [callback]);
-
-where `docs` can be a single document or an array of documents.
-
-Useful options:
-
-* `safe:true` Should always set if you have a callback.
-
-See also: [MongoDB docs for insert](http://www.mongodb.org/display/DOCS/Inserting).
-
- var mongodb = require('mongodb');
- var server = new mongodb.Server("127.0.0.1", 27017, {});
- new mongodb.Db('test', server, {}).open(function (error, client) {
- if (error) throw error;
- var collection = new mongodb.Collection(client, 'test_collection');
- collection.insert({hello: 'world'}, {safe:true},
- function(err, objects) {
- if (err) console.warn(err.message);
- if (err && err.message.indexOf('E11000 ') !== -1) {
- // this _id was already inserted in the database
- }
- });
- });
-
-Note that there's no reason to pass a callback to the insert or update commands
-unless you use the `safe:true` option. If you don't specify `safe:true`, then
-your callback will be called immediately.
-
-Update; update and insert (upsert)
---------
-
-The update operation will update the first document that matches your query
-(or all documents that match if you use `multi:true`).
-If `safe:true`, `upsert` is not set, and no documents match, your callback
-will be given an error.
-
-See the [MongoDB docs](http://www.mongodb.org/display/DOCS/Updating) for
-the modifier (`$inc`, `$set`, `$push`, etc.) formats.
-
-Signature:
-
- collection.update(criteria, objNew, options, [callback]);
-
-Useful options:
-
-* `safe:true` Should always set if you have a callback.
-* `multi:true