vulcan 0.1.6 → 0.2.0

data/server/node_modules/node-uuid/uuid.js

@@ -1,80 +1,249 @@
+//     node-uuid/uuid.js
+//
+//     Copyright (c) 2010 Robert Kieffer
+//     Dual licensed under the MIT and GPL licenses.
+//     Documentation and details at https://github.com/broofa/node-uuid
 (function() {
-  /*
-  * Generate a RFC4122(v4) UUID
-  *
-  * Documentation at https://github.com/broofa/node-uuid
-  */
+  var _global = this;
 
-  // Use node.js Buffer class if available, otherwise use the Array class
-  var BufferClass = typeof(Buffer) == 'function' ? Buffer : Array;
+  // Unique ID creation requires a high quality random # generator, but
+  // Math.random() does not guarantee "cryptographic quality".  So we feature
+  // detect for more robust APIs, normalizing each method to return 128-bits
+  // (16 bytes) of random data.
+  var mathRNG, nodeRNG, whatwgRNG;
+
+  // Math.random()-based RNG.  All platforms, very fast, unknown quality
+  var _rndBytes = new Array(16);
+  mathRNG = function() {
+    var r, b = _rndBytes, i = 0;
+
+    for (var i = 0, r; i < 16; i++) {
+      if ((i & 0x03) == 0) r = Math.random() * 0x100000000;
+      b[i] = r >>> ((i & 0x03) << 3) & 0xff;
+    }
+
+    return b;
+  }
+
+  // WHATWG crypto-based RNG - http://wiki.whatwg.org/wiki/Crypto
+  // WebKit only (currently), moderately fast, high quality
+  if (_global.crypto && crypto.getRandomValues) {
+    var _rnds = new Uint32Array(4);
+    whatwgRNG = function() {
+      crypto.getRandomValues(_rnds);
 
-  // Buffer used for generating string uuids
-  var _buf = new BufferClass(16);
+      for (var c = 0 ; c < 16; c++) {
+        _rndBytes[c] = _rnds[c >> 2] >>> ((c & 0x03) * 8) & 0xff;
+      }
+      return _rndBytes;
+    }
+  }
+
+  // Node.js crypto-based RNG - http://nodejs.org/docs/v0.6.2/api/crypto.html
+  // Node.js only, moderately fast, high quality
+  try {
+    var _rb = require('crypto').randomBytes;
+    nodeRNG = _rb && function() {
+      return _rb(16);
+    };
+  } catch (e) {}
+
+  // Select RNG with best quality
+  var _rng = nodeRNG || whatwgRNG || mathRNG;
 
-  // Cache number <-> hex string for octet values
-  var toString = [];
-  var toNumber = {};
+  // Buffer class to use
+  var BufferClass = typeof(Buffer) == 'function' ? Buffer : Array;
+
+  // Maps for number <-> hex string conversion
+  var _byteToHex = [];
+  var _hexToByte = {};
   for (var i = 0; i < 256; i++) {
-    toString[i] = (i + 0x100).toString(16).substr(1);
-    toNumber[toString[i]] = i;
+    _byteToHex[i] = (i + 0x100).toString(16).substr(1);
+    _hexToByte[_byteToHex[i]] = i;
   }
 
-  function parse(s) {
-    var buf = new BufferClass(16);
-    var i = 0, ton = toNumber;
-    s.toLowerCase().replace(/[0-9a-f][0-9a-f]/g, function(octet) {
-      buf[i++] = toNumber[octet];
+  // **`parse()` - Parse a UUID into it's component bytes**
+  function parse(s, buf, offset) {
+    var i = (buf && offset) || 0, ii = 0;
+
+    buf = buf || [];
+    s.toLowerCase().replace(/[0-9a-f]{2}/g, function(byte) {
+      if (ii < 16) { // Don't overflow!
+        buf[i + ii++] = _hexToByte[byte];
+      }
     });
+
+    // Zero out remaining bytes if string was short
+    while (ii < 16) {
+      buf[i + ii++] = 0;
+    }
+
     return buf;
   }
 
-  function unparse(buf) {
-    var tos = toString, b = buf;
-    return tos[b[0]] + tos[b[1]] + tos[b[2]] + tos[b[3]] + '-' +
-           tos[b[4]] + tos[b[5]] + '-' +
-           tos[b[6]] + tos[b[7]] + '-' +
-           tos[b[8]] + tos[b[9]] + '-' +
-           tos[b[10]] + tos[b[11]] + tos[b[12]] +
-           tos[b[13]] + tos[b[14]] + tos[b[15]];
+  // **`unparse()` - Convert UUID byte array (ala parse()) into a string**
+  function unparse(buf, offset) {
+    var i = offset || 0, bth = _byteToHex;
+    return  bth[buf[i++]] + bth[buf[i++]] +
+            bth[buf[i++]] + bth[buf[i++]] + '-' +
+            bth[buf[i++]] + bth[buf[i++]] + '-' +
+            bth[buf[i++]] + bth[buf[i++]] + '-' +
+            bth[buf[i++]] + bth[buf[i++]] + '-' +
+            bth[buf[i++]] + bth[buf[i++]] +
+            bth[buf[i++]] + bth[buf[i++]] +
+            bth[buf[i++]] + bth[buf[i++]];
   }
 
-  var b32 = 0x100000000, ff = 0xff;
-  function uuid(fmt, buf, offset) {
-    var b = fmt != 'binary' ? _buf : (buf ? buf : new BufferClass(16));
+  // **`v1()` - Generate time-based UUID**
+  //
+  // Inspired by https://github.com/LiosK/UUID.js
+  // and http://docs.python.org/library/uuid.html
+
+  // random #'s we need to init node and clockseq
+  var _seedBytes = _rng();
+
+  // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)
+  var _nodeId = [
+    _seedBytes[0] | 0x01,
+    _seedBytes[1], _seedBytes[2], _seedBytes[3], _seedBytes[4], _seedBytes[5]
+  ];
+
+  // Per 4.2.2, randomize (14 bit) clockseq
+  var _clockseq = (_seedBytes[6] << 8 | _seedBytes[7]) & 0x3fff;
+
+  // Previous uuid creation time
+  var _lastMSecs = 0, _lastNSecs = 0;
+
+  // See https://github.com/broofa/node-uuid for API details
+  function v1(options, buf, offset) {
     var i = buf && offset || 0;
+    var b = buf || [];
+
+    options = options || {};
+
+    var clockseq = options.clockseq != null ? options.clockseq : _clockseq;
+
+    // UUID timestamps are 100 nano-second units since the Gregorian epoch,
+    // (1582-10-15 00:00).  JSNumbers aren't precise enough for this, so
+    // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'
+    // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.
+    var msecs = options.msecs != null ? options.msecs : new Date().getTime();
+
+    // Per 4.2.1.2, use count of uuid's generated during the current clock
+    // cycle to simulate higher resolution clock
+    var nsecs = options.nsecs != null ? options.nsecs : _lastNSecs + 1;
+
+    // Time since last uuid creation (in msecs)
+    var dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs)/10000;
 
-    var r = Math.random()*b32;
-    b[i++] = r & ff;
-    b[i++] = r>>>8 & ff;
-    b[i++] = r>>>16 & ff;
-    b[i++] = r>>>24 & ff;
-    r = Math.random()*b32;
-    b[i++] = r & ff;
-    b[i++] = r>>>8 & ff;
-    b[i++] = r>>>16 & 0x0f | 0x40; // See RFC4122 sect. 4.1.3
-    b[i++] = r>>>24 & ff;
-    r = Math.random()*b32;
-    b[i++] = r & 0x3f | 0x80; // See RFC4122 sect. 4.4
-    b[i++] = r>>>8 & ff;
-    b[i++] = r>>>16 & ff;
-    b[i++] = r>>>24 & ff;
-    r = Math.random()*b32;
-    b[i++] = r & ff;
-    b[i++] = r>>>8 & ff;
-    b[i++] = r>>>16 & ff;
-    b[i++] = r>>>24 & ff;
-
-    return fmt === undefined ? unparse(b) : b;
-  };
+    // Per 4.2.1.2, Bump clockseq on clock regression
+    if (dt < 0 && options.clockseq == null) {
+      clockseq = clockseq + 1 & 0x3fff;
+    }
 
+    // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new
+    // time interval
+    if ((dt < 0 || msecs > _lastMSecs) && options.nsecs == null) {
+      nsecs = 0;
+    }
+
+    // Per 4.2.1.2 Throw error if too many uuids are requested
+    if (nsecs >= 10000) {
+      throw new Error('uuid.v1(): Can\'t create more than 10M uuids/sec');
+    }
+
+    _lastMSecs = msecs;
+    _lastNSecs = nsecs;
+    _clockseq = clockseq;
+
+    // Per 4.1.4 - Convert from unix epoch to Gregorian epoch
+    msecs += 12219292800000;
+
+    // `time_low`
+    var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
+    b[i++] = tl >>> 24 & 0xff;
+    b[i++] = tl >>> 16 & 0xff;
+    b[i++] = tl >>> 8 & 0xff;
+    b[i++] = tl & 0xff;
+
+    // `time_mid`
+    var tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;
+    b[i++] = tmh >>> 8 & 0xff;
+    b[i++] = tmh & 0xff;
+
+    // `time_high_and_version`
+    b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
+    b[i++] = tmh >>> 16 & 0xff;
+
+    // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
+    b[i++] = clockseq >>> 8 | 0x80;
+
+    // `clock_seq_low`
+    b[i++] = clockseq & 0xff;
+
+    // `node`
+    var node = options.node || _nodeId;
+    for (var n = 0; n < 6; n++) {
+      b[i + n] = node[n];
+    }
+
+    return buf ? buf : unparse(b);
+  }
+
+  // **`v4()` - Generate random UUID**
+
+  // See https://github.com/broofa/node-uuid for API details
+  function v4(options, buf, offset) {
+    // Deprecated - 'format' argument, as supported in v1.2
+    var i = buf && offset || 0;
+
+    if (typeof(options) == 'string') {
+      buf = options == 'binary' ? new BufferClass(16) : null;
+      options = null;
+    }
+    options = options || {};
+
+    var rnds = options.random || (options.rng || _rng)();
+
+    // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+    rnds[6] = (rnds[6] & 0x0f) | 0x40;
+    rnds[8] = (rnds[8] & 0x3f) | 0x80;
+
+    // Copy bytes to buffer, if provided
+    if (buf) {
+      for (var ii = 0; ii < 16; ii++) {
+        buf[i + ii] = rnds[ii];
+      }
+    }
+
+    return buf || unparse(rnds);
+  }
+
+  // Export public API
+  var uuid = v4;
+  uuid.v1 = v1;
+  uuid.v4 = v4;
   uuid.parse = parse;
   uuid.unparse = unparse;
   uuid.BufferClass = BufferClass;
 
+  // Export RNG options
+  uuid.mathRNG = mathRNG;
+  uuid.nodeRNG = nodeRNG;
+  uuid.whatwgRNG = whatwgRNG;
+
   if (typeof(module) != 'undefined') {
+    // Play nice with node.js
     module.exports = uuid;
   } else {
-    // In browser? Set as top-level function
-    this.uuid = uuid;
+    // Play nice with browsers
+    var _previousRoot = _global.uuid;
+
+    // **`noConflict()` - (browser only) to reset global 'uuid' var**
+    uuid.noConflict = function() {
+      _global.uuid = _previousRoot;
+      return uuid;
+    }
+    _global.uuid = uuid;
   }
-})();
+}());

data/server/node_modules/restler/README.md

@@ -1,10 +1,12 @@
-Restler 0.2.0
+Restler 0.2.4
 ===========
 
 (C) Dan Webb (dan@danwebb.net/@danwrong) 2011, Licensed under the MIT-LICENSE
 
 An HTTP client library for node.js (0.3 and up).  Hides most of the complexity of creating and using http.Client. Very early days yet.
 
+See [Version History](https://github.com/danwrong/restler/wiki/Version-History) for changes
+
 
 Features
 --------
@@ -19,8 +21,9 @@ Features
 * Transparently handle SSL (just specify https in the URL)
 * Deals with basic auth for you, just provide username and password options
 * Simple service wrapper that allows you to easily put together REST API libraries
-    
-    
+* Transparently handle content-encoded responses (gzip, deflate)
+
+
 API
 ---
 
@@ -68,9 +71,12 @@ All of these attempt to turn the response into a JavaScript object. In order to
 
 * _method_ Request method, can be get, post, put, del
 * _query_ Query string variables as a javascript object, will override the querystring in the URL
-* _data_ The data to be added to the body of the request.  Can be a string or any object
+* _data_ The data to be added to the body of the request.  Can be a string or any object. 
+Note that if you want your request body to be JSON with the Content-Type `application/json`, you need to 
+JSON.stringify your object first. Otherwise, it will be sent as `application/x-www-form-urlencoded` and encoded accordingly.
 * _parser_ A function that will be called on the returned data.  try parsers.auto, parsers.json etc
 * _encoding_ The encoding of the request body.  defaults to utf8
+* _decoding_ The encoding of the response body. For a list of supported values see [Buffers](http://nodejs.org/docs/latest/api/buffers.html#buffers). Additionally accepts `"buffer"` - returns response as `Buffer`. Defaults to `utf8`.
 * _headers_ a hash of HTTP headers to be sent
 * _username_ Basic auth username
 * _password_ Basic auth password
@@ -82,7 +88,7 @@ All of these attempt to turn the response into a JavaScript object. In order to
 Example usage
 -------------
 
-    var sys = require('sys'),
+    var sys = require('util'),
         rest = require('./restler');
 
     rest.get('http://google.com').on('complete', function(data) {
@@ -112,7 +118,7 @@ Example usage
       password: 'wouldntyouliketoknow',
       data: {
         'sound[message]': 'hello from restler!',
-        'sound[file]': rest.file('doug-e-fresh_the-show.mp3', 'audio/mpeg')
+        'sound[file]': rest.file('doug-e-fresh_the-show.mp3', null, null, null, 'audio/mpeg')
       }
     }).on('complete', function(data) {
       sys.puts(data.audio_url);
@@ -135,6 +141,13 @@ Example usage
       sys.p(data);
     });
 
+    // the JSON post
+    rest.post('http://example.com/action', {
+      data: JSON.stringify({ id: 334 }),
+    }).on('complete', function(data, response) {
+      // you can get at the raw response like this...
+    });
+
     
 Running the tests
 -----------------
@@ -144,4 +157,4 @@ Running the tests
 TODO
 ----
 * Deal with no utf-8 response bodies
-* What do you need? Let me know or fork.
+* What do you need? Let me know or fork.

data/server/node_modules/restler/bin/restler

@@ -2,7 +2,7 @@
 
 require.paths.push(process.cwd());
 
-var sys  = require('sys'),
+var sys  = require('util'),
     rest = require('../lib/restler'),
     repl = require('repl');
   

data/server/node_modules/restler/lib/multipartform.js

@@ -1,5 +1,5 @@
 var fs = require('fs');
-var sys = require("sys")
+var sys = require('util')
 exports.defaultBoundary = '48940923NODERESLTER3890457293';
 
 
@@ -109,7 +109,7 @@ Part.prototype = {
   	  fs.open(this.value.path, "r", 0666, function (err, fd) { 
     	  if (err) throw err; 
     	  
-  		  position = 0;
+  		  var position = 0;
   		  
   	    (function reader () {
   	      fs.read(fd, 1024 * 4, position, "binary", function (er, chunk) {
@@ -142,12 +142,13 @@ function MultiPartRequest(data, boundary) {
 
 MultiPartRequest.prototype = {
   _partNames: function() {
-	  partNames = []
-      for (var name in this.data) {
-  		partNames.push(name)
+    var partNames = [];
+    for (var name in this.data) {
+      partNames.push(name)
   	}
   	return partNames;
   },
+  
   write: function(stream, callback) {
     var partCount = 0, self = this;
     
@@ -157,8 +158,8 @@ MultiPartRequest.prototype = {
   	
   	// Let each part write itself out to the stream
   	(function writePart() {
-  	  partName = this.partNames[partCount];
-  	  part = new Part(partName, self.data[partName], self.boundary);
+  	  var partName = self.partNames[partCount];
+  	  var part = new Part(partName, self.data[partName], self.boundary);
   	  part.write(stream, function (err) {
   		  if (err) {
     			callback(err);
@@ -199,4 +200,4 @@ var exportMethods = {
 
 Object.keys(exportMethods).forEach(function(exportMethod) {
   exports[exportMethod] = exportMethods[exportMethod]
-})
+})

data/server/node_modules/restler/lib/restler.js

@@ -1,9 +1,10 @@
-var sys       = require('sys'),
+var sys       = require('util'),
     http      = require('http'),
     https     = require('https'),
     url       = require('url'),
     qs        = require('querystring'),
-    multipart = require('./multipartform');
+    multipart = require('./multipartform'),
+    zlib      = require('zlib');
     
 function mixin(target, source) {
   Object.keys(source).forEach(function(key) {
@@ -20,7 +21,7 @@ function Request(uri, options) {
     'Accept': '*/*',
     'User-Agent': 'Restler for node.js',
     'Host': this.url.host
-  }
+  };
   
   mixin(this.headers, options.headers || {});
   
@@ -46,6 +47,11 @@ function Request(uri, options) {
       this.headers['Content-Type'] = 'application/x-www-form-urlencoded';
       this.headers['Content-Length'] = this.options.data.length;
     }
+    if(typeof this.options.data == 'string') {
+      var buffer = new Buffer(this.options.data, this.options.encoding || 'utf8');
+      this.options.data = buffer;
+      this.headers['Content-Length'] = buffer.length;
+    }
   }
   
   var proto = (this.url.protocol == 'https:') ? https : http;
@@ -62,9 +68,10 @@ function Request(uri, options) {
 }
 
 Request.prototype = new process.EventEmitter();
+
 mixin(Request.prototype, {
   _isRedirect: function(response) {
-    return ([301, 302].indexOf(response.statusCode) >= 0);
+    return ([301, 302, 303].indexOf(response.statusCode) >= 0);
   },
   _fullPath: function() {
     var path = this.url.pathname || '/';
@@ -101,25 +108,46 @@ mixin(Request.prototype, {
     } else {
       var body = '';
       
-      // TODO Handle different encodings
-      response.setEncoding('utf8');
+      response.setEncoding('binary');
       
       response.on('data', function(chunk) {
         body += chunk;
       });
       
       response.on('end', function() {
-         if (self.options.parser) {
-           self.options.parser.call(response, body, function(parsedData) {
-
-             self._fireEvents(parsedData, response);
-           });
-         } else {
-           self._fireEvents(body, response);
-         }
+        self._decode(new Buffer(body, 'binary'), response, function(err, body) {
+          if (err) {
+            self._respond('error', '', 'Failed to decode response body');
+            return;
+          }
+          self._encode(body, response, function(body) {
+            self._fireEvents(body, response);
+          });
+        });
       });
     }
   },
+  _decode: function(body, response, callback) {
+    var encoder = response.headers['content-encoding'];
+    if (encoder in decoders) {
+      decoders[encoder].call(response, body, callback);
+    } else {
+      callback(null, body);
+    }
+  },
+  _encode: function(body, response, callback) {
+    var self = this;
+    if (self.options.decoding == 'buffer') {
+      callback(body);
+    } else {
+      body = body.toString(self.options.decoding);
+      if (self.options.parser) {
+        self.options.parser.call(response, body, callback);
+      } else {
+        callback(body);
+      }
+    }
+  },
   _respond: function(type, data, response) {
     if (this.options.originalRequest) {
       this.options.originalRequest.emit(type, data, response);
@@ -135,11 +163,11 @@ mixin(Request.prototype, {
     this._respond(response.statusCode.toString(), body, response);
     this._respond('complete', body, response);
   },
-  _makeRequest: function() { 
+  _makeRequest: function() {
     var self = this;
        
     this.request.on('response', function(response) {
-		  self._responseHandler(response);
+  	  self._responseHandler(response);
   	}).on('error', function(err) {
   	  self._respond('error', null, err);
   	});
@@ -155,7 +183,7 @@ mixin(Request.prototype, {
       if (this.options.data) {
         this.request.write(this.options.data.toString(), this.options.encoding || 'utf8');
       }
-		  this.request.end();
+      this.request.end();
     }
     
     return this;
@@ -170,7 +198,9 @@ function shortcutOptions(options, method) {
 }
     
 function request(url, options) {  
-  	return (new Request(url, options)).run();
+  var request = new Request(url, options);
+  request.on('error', function() {}); 
+ 	return request.run();
 }
 
 function get(url, options) {
@@ -207,7 +237,7 @@ var parsers = {
   json: function(data, callback) {
     callback(data && JSON.parse(data));
   }
-}
+};
 
 parsers.auto.matchers = {
   'application/json': parsers.json
@@ -233,15 +263,27 @@ try {
       parser.on('end', function(result) {
           callback(result);
       });
-      
-      parser.parseString(data);
+      try {
+          parser.parseString(data);
+      } catch (e) {
+          callback({error:'Oops, something went wrong.'});
+      }
     } else {
       callback();
     }
   };
   
   parsers.auto.matchers['application/xml'] = parsers.xml;
-} catch(e) {}
+} catch(e) { }
+
+var decoders = {
+  gzip: function(buf, callback) {
+    zlib.gunzip(buf, callback);
+  },
+  deflate: function(buf, callback) {
+    zlib.inflate(buf, callback);
+  }
+};
 
 
 function Service(defaults) {