vulcan 0.0.1 → 0.0.2

data/server/node_modules/knox/test/utils.test.js

@@ -0,0 +1,17 @@
+
+/**
+ * Module dependencies.
+ */
+
+var knox = require('knox')
+  , utils = knox.utils;
+
+module.exports = {
+  'test .base64.encode()': function(assert){
+    assert.equal('aGV5', utils.base64.encode('hey'));
+  },
+  
+  'test .base64.decode()': function(assert){
+    assert.equal('hey', utils.base64.decode('aGV5'));
+  }
+};

data/server/node_modules/node-uuid/LICENSE.md

@@ -0,0 +1,3 @@
+Copyright (c) 2010 Robert Kieffer
+
+Dual licensed under the [MIT](http://en.wikipedia.org/wiki/MIT_License) and [GPL](http://en.wikipedia.org/wiki/GNU_General_Public_License) licenses.

data/server/node_modules/node-uuid/README.md

@@ -0,0 +1,100 @@
+# node-uuid
+
+Simple, fast generation of RFC4122[RFC4122(v4)](http://www.ietf.org/rfc/rfc4122.txt) UUIDS.  It runs in node.js and all major browsers.
+
+## Installation
+
+    npm install node-uuid
+
+### In browser
+
+    <script src="uuid.js"></script>
+
+### In node.js
+
+    var uuid = require('node-uuid');
+
+## Usage
+
+### Generate a String UUID
+
+    var id = uuid(); // -> '92329D39-6F5C-4520-ABFC-AAB64544E172'
+
+### Generate a Binary UUID
+
+    // Simple form - allocates a Buffer/Array for you
+    var buf = uuid('binary');
+    // node.js -> <Buffer 08 50 05 c8 9c b2 4c 07 ac 07 d1 4f b9 f5 04 51>
+    // browser -> [8, 80, 5, 200, 156, 178, 76, 7, 172, 7, 209, 79, 185, 245, 4, 81]
+
+    // Provide your own Buffer or Array
+    var buf = new Array(16);
+    uuid('binary', buf); // -> [8, 80, 5, 200, 156, 178, 76, 7, 172, 7, 209, 79, 185, 245, 4, 81]
+    var buf = new Buffer(16);
+    uuid('binary', buf); // -> <Buffer 08 50 05 c8 9c b2 4c 07 ac 07 d1 4f b9 f5 04 51>
+
+    // Provide your own Buffer/Array, plus specify offset
+    // (e.g. here we fill an array with 3 uuids)
+    var buf = new Buffer(16 \* 3);
+    uuid('binary', id, 0);
+    uuid('binary', id, 16);
+    uuid('binary', id, 32);
+
+## Testing
+
+test/test.js generates performance data (similar to test/benchmark.js). It also verifies the syntax of 100K string UUIDs, and logs the distribution of hex digits found therein.  For example:
+
+    - - - Performance Data - - -
+    uuid(): 1052631 uuids/second
+    uuid('binary'): 680272 uuids/second
+    uuid('binary', buffer): 2702702 uuids/second
+
+    - - - Distribution of Hex Digits (% deviation from ideal) - - -
+    0 |================================| 187705 (0.11%)
+    1 |================================| 187880 (0.2%)
+    2 |================================| 186875 (-0.33%)
+    3 |================================| 186847 (-0.35%)
+    4 |==================================================| 287433 (-0.02%)
+    5 |================================| 187910 (0.22%)
+    6 |================================| 188172 (0.36%)
+    7 |================================| 187350 (-0.08%)
+    8 |====================================| 211994 (-0.24%)
+    9 |====================================| 212664 (0.08%)
+    A |=====================================| 213185 (0.32%)
+    B |=====================================| 212877 (0.18%)
+    C |================================| 187445 (-0.03%)
+    D |================================| 186737 (-0.41%)
+    E |================================| 187155 (-0.18%)
+    F |================================| 187771 (0.14%)
+
+Note that the increased values for 4 and 8-B are expected as part of the RFC4122 syntax (and are accounted for in the deviation calculation). BTW, if someone wants to do the calculation to determine what a statistically significant deviation would be, I'll gladly add that to the test.
+
+### In browser
+
+    Open test/test.html
+
+### In node.js
+
+    > node test/test.js
+
+node.js users can also run the node-uuid .vs. uuid.js benchmark:
+
+    > node test/benchmark.js
+
+## Performance
+
+### In node.js
+
+node-uuid is designed to be fast.  That said, the target platform is node.js, where it is screaming fast.  Here's what I get on my 2.66GHz Macbook Pro for the test/benchmark.js script:
+
+    nodeuuid(): 1126126 uuids/second
+    nodeuuid('binary'): 782472 uuids/second
+    nodeuuid('binary', buffer): 2688172 uuids/second
+    uuidjs(): 620347 uuids/second
+    uuidjs('binary'): 1275510 uuids/second
+
+The uuidjs() entries are for Nikhil Marathe's [uuidjs module](https://bitbucket.org/nikhilm/uuidjs), and are provided for comparison.  uuidjs is a wrapper around the native libuuid library.
+
+### In browser
+
+node-uuid performance varies dramatically across browsers.  For comprehensive test results, please [checkout the JSPerf tests](http://jsperf.com/node-uuid-performance).

data/server/node_modules/node-uuid/package.json

@@ -0,0 +1,12 @@
+{
+  "name"          : "node-uuid",
+  "description"   : "Simple, fast generation of RFC4122(v4) UUIDs.",
+  "url"           : "http://github.com/broofa/node-uuid",
+  "keywords"      : ["uuid", "guid", "rfc4122"],
+  "author"        : "Robert Kieffer <robert@broofa.com>",
+  "contributors"  : [],
+  "dependencies"  : [],
+  "lib"           : ".",
+  "main"          : "./uuid.js",
+  "version"       : "1.2.0"
+}

data/server/node_modules/node-uuid/test/benchmark-native.c

@@ -0,0 +1,34 @@
+/*
+Test performance of native C UUID generation
+
+To Compile: cc -luuid benchmark-native.c -o benchmark-native
+*/
+
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <uuid/uuid.h>
+
+int main() {
+  uuid_t myid;
+  char buf[36+1];
+  int i;
+  struct timeval t;
+  double start, finish;
+
+  gettimeofday(&t, NULL);
+  start = t.tv_sec + t.tv_usec/1e6;
+
+  int n = 2e5;
+  for (i = 0; i < n; i++) {
+    uuid_generate(myid);
+    uuid_unparse(myid, buf);
+  }
+
+  gettimeofday(&t, NULL);
+  finish = t.tv_sec + t.tv_usec/1e6;
+  double dur = finish - start;
+
+  printf("%d uuids/sec", (int)(n/dur));
+  return 0;
+}

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

@@ -0,0 +1,27 @@
+var nodeuuid = require('../uuid'),
+    uuidjs = require('uuid').generate,
+    N = 5e5;
+
+function rate(msg, t) {
+  console.log(msg + ': ' +
+    (N / (Date.now() - t) * 1e3 | 0) +
+    ' uuids/second');
+}
+
+// node-uuid - string form
+for (var i = 0, t = Date.now(); i < N; i++) nodeuuid();
+rate('nodeuuid()', t);
+
+for (var i = 0, t = Date.now(); i < N; i++) nodeuuid('binary');
+rate('nodeuuid(\'binary\')', t);
+
+var buffer = new nodeuuid.BufferClass(16);
+for (var i = 0, t = Date.now(); i < N; i++) nodeuuid('binary', buffer);
+rate('nodeuuid(\'binary\', buffer)', t);
+
+// node-uuid - string form
+for (var i = 0, t = Date.now(); i < N; i++) uuidjs();
+rate('uuidjs()', t);
+
+for (var i = 0, t = Date.now(); i < N; i++) uuidjs('binary');
+rate('uuidjs(\'binary\')', t);

data/server/node_modules/node-uuid/test/test.html

@@ -0,0 +1,14 @@
+<html>
+  <head>
+    <style>
+      div {
+        font-family: monospace;
+        font-size: 8pt;
+      }
+    </style>
+    <script src="../uuid.js"></script>
+  </head>
+  <body>
+    <script src="./test.js"></script>
+  </body>
+</html>

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

@@ -0,0 +1,83 @@
+if (typeof(uuid) == 'undefined') {
+  uuid = require('../uuid');
+}
+
+var UUID_FORMAT = /[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[89a-fAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}/;
+var N = 1e5;
+
+function log(msg) {
+  if (typeof(document) != 'undefined') {
+    document.write('<div>' + msg + '</div>');
+  }
+  if (typeof(console) != 'undefined') {
+    console.log(msg);
+  }
+}
+
+function rate(msg, t) {
+  log(msg + ': ' + (N / (Date.now() - t) * 1e3 | 0) + ' uuids/second');
+}
+
+// Perf tests
+log('- - - Performance Data - - -');
+for (var i = 0, t = Date.now(); i < N; i++) uuid();
+rate('uuid()', t);
+for (var i = 0, t = Date.now(); i < N; i++) uuid('binary');
+rate('uuid(\'binary\')', t);
+var buf = new uuid.BufferClass(16);
+for (var i = 0, t = Date.now(); i < N; i++) uuid('binary', buf);
+rate('uuid(\'binary\', buffer)', t);
+
+var counts = {}, max = 0;
+
+var b  = new uuid.BufferClass(16);
+for (var i = 0; i < N; i++) {
+  id = uuid();
+  if (!UUID_FORMAT.test(id)) {
+    throw Error(id + ' is not a valid UUID string');
+  }
+
+  if (id != uuid.unparse(uuid.parse(id))) {
+    throw Error(id + ' does not parse/unparse');
+  }
+
+  // Count digits for our randomness check
+  var digits = id.replace(/-/g, '').split('');
+  for (var j = digits.length-1; j >= 0; j--) {
+    var c = digits[j];
+    max = Math.max(max, counts[c] = (counts[c] || 0) + 1);
+  }
+}
+
+// Get %'age an actual value differs from the ideal value
+function divergence(actual, ideal) {
+  return Math.round(100*100*(actual - ideal)/ideal)/100;
+}
+
+log('<br />- - - Distribution of Hex Digits (% deviation from ideal) - - -');
+
+// Check randomness
+for (var i = 0; i < 16; i++) {
+  var c = i.toString(16);
+  var bar = '', n = counts[c], p = Math.round(n/max*100|0);
+
+  // 1-3,5-8, and D-F: 1:16 odds over 30 digits
+  var ideal = N*30/16;
+  if (i == 4) {
+    // 4: 1:1 odds on 1 digit, plus 1:16 odds on 30 digits
+    ideal = N*(1 + 30/16);
+  } else if (i >= 8 && i <= 11) {
+    // 8-B: 1:4 odds on 1 digit, plus 1:16 odds on 30 digits
+    ideal = N*(1/4 + 30/16);
+  } else {
+    // Otherwise: 1:16 odds on 30 digits
+    ideal = N*30/16;
+  }
+  var d = divergence(n, ideal);
+
+  // Draw bar using UTF squares (just for grins)
+  var s = n/max*50 | 0;
+  while (s--) bar += '=';
+
+  log(c + ' |' + bar + '| ' + counts[c] + ' (' + d + '%)');
+}

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

@@ -0,0 +1,80 @@
+(function() {
+  /*
+  * Generate a RFC4122(v4) UUID
+  *
+  * Documentation at https://github.com/broofa/node-uuid
+  */
+
+  // Use node.js Buffer class if available, otherwise use the Array class
+  var BufferClass = typeof(Buffer) == 'function' ? Buffer : Array;
+
+  // Buffer used for generating string uuids
+  var _buf = new BufferClass(16);
+
+  // Cache number <-> hex string for octet values
+  var toString = [];
+  var toNumber = {};
+  for (var i = 0; i < 256; i++) {
+    toString[i] = (i + 0x100).toString(16).substr(1);
+    toNumber[toString[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];
+    });
+    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]];
+  }
+
+  var b32 = 0x100000000, ff = 0xff;
+  function uuid(fmt, buf, offset) {
+    var b = fmt != 'binary' ? _buf : (buf ? buf : new BufferClass(16));
+    var i = buf && offset || 0;
+
+    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;
+  };
+
+  uuid.parse = parse;
+  uuid.unparse = unparse;
+  uuid.BufferClass = BufferClass;
+
+  if (typeof(module) != 'undefined') {
+    module.exports = uuid;
+  } else {
+    // In browser? Set as top-level function
+    this.uuid = uuid;
+  }
+})();

data/server/node_modules/restler/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Dan Webb
+
+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.

data/server/node_modules/restler/README.md

@@ -0,0 +1,147 @@
+Restler 0.2.0
+===========
+
+(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.
+
+
+Features
+--------
+
+* Easy interface for common operations via http.request
+* Automatic serialization of post data
+* Automatic serialization of query string data
+* Automatic deserialization of XML, JSON and YAML responses to JavaScript objects (if you have js-yaml and/or xml2js in the require path)
+* Provide your own deserialization functions for other datatypes
+* Automatic following of redirects
+* Send files with multipart requests
+* 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
+    
+    
+API
+---
+
+### request(url, options)
+
+Basic method to make a request of any type.  The function returns a RestRequest object
+that emits events:
+
+* _complete_ emitted when the request has finished whether it was successful or not.  Gets passed the response data and the response as arguments.
+* _success_ emitted when the request was successful.  Gets passed the response data and the response as arguments.
+* _error_ emitted when the request was unsuccessful.  Gets passed the response data and the response as arguments.
+* _2XX, 3XX, 4XX, 5XX etc_ emitted for all requests with response codes in the range.  Eg. 2XX emitted for 200, 201, 203
+* _actual response code_ there is an event emitted for every single response code.  eg.  404, 201, etc.
+
+### get(url, options)
+
+Create a GET request. 
+
+### post(url, options)
+
+Create a POST request.
+
+### put(url, options)
+
+Create a PUT request.
+
+### del(url, options)
+
+Create a DELETE request.
+
+### response parsers
+
+You can give any of these to the parsers option to specify how the response data is deserialized.
+
+#### parsers.auto
+
+Checks the content-type and then uses parsers.xml, parsers.json or parsers.yaml.  
+If the content type isn't recognised it just returns the data untouched.
+
+#### parsers.json, parsers.xml, parsers.yaml
+
+All of these attempt to turn the response into a JavaScript object. In order to use the YAML and XML parsers you must have yaml and/or xml2js installed.
+
+### options hash
+
+* _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
+* _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
+* _headers_ a hash of HTTP headers to be sent
+* _username_ Basic auth username
+* _password_ Basic auth password
+* _multipart_ If set the data passed will be formated as multipart/form-encoded.  See multipart example below.
+* _client_ A http.Client instance if you want to reuse or implement some kind of connection pooling.
+* _followRedirects_ Does what it says on the tin.
+
+
+Example usage
+-------------
+
+    var sys = require('sys'),
+        rest = require('./restler');
+
+    rest.get('http://google.com').on('complete', function(data) {
+      sys.puts(data);
+    });
+
+    rest.get('http://twaud.io/api/v1/users/danwrong.json').on('complete', function(data) {
+      sys.puts(data[0].message); // auto convert to object
+    });
+    
+    rest.get('http://twaud.io/api/v1/users/danwrong.xml').on('complete', function(data) {
+      sys.puts(data[0].sounds[0].sound[0].message); // auto convert to object
+    });
+    
+    rest.post('http://user:pass@service.com/action', {
+      data: { id: 334 },
+    }).on('complete', function(data, response) {
+      if (response.statusCode == 201) {
+        // you can get at the raw response like this...
+      }
+    });
+    
+    // multipart request sending a file and using https
+    rest.post('https://twaud.io/api/v1/upload.json', {
+      multipart: true,
+      username: 'danwrong',
+      password: 'wouldntyouliketoknow',
+      data: {
+        'sound[message]': 'hello from restler!',
+        'sound[file]': rest.file('doug-e-fresh_the-show.mp3', 'audio/mpeg')
+      }
+    }).on('complete', function(data) {
+      sys.puts(data.audio_url);
+    });
+    
+    // create a service constructor for very easy API wrappers a la HTTParty...
+    Twitter = rest.service(function(u, p) {
+      this.defaults.username = u;
+      this.defaults.password = p;
+    }, {
+      baseURL: 'http://twitter.com'
+    }, {
+      update: function(message) {
+        return this.post('/statuses/update.json', { data: { status: message } });
+      }
+    });
+    
+    var client = new Twitter('danwrong', 'password');
+    client.update('Tweeting using a Restler service thingy').on('complete', function(data) {
+      sys.p(data);
+    });
+
+    
+Running the tests
+-----------------
+
+    node test/restler.js 
+    
+TODO
+----
+* Deal with no utf-8 response bodies
+* What do you need? Let me know or fork.