vulcan 0.6.1 → 0.7.0

data/server/node_modules/nodemon/nodemonignore.example

@@ -0,0 +1,11 @@
+# .nodemonignore file
+#
+# This is an example of a comment
+#
+# You can list individual files in the ignore list, or they can be
+# file patterns. For example:
+#
+# /vendor/*
+# /public/css/styles.css
+# ./server.js
+# ./.git/*

data/server/node_modules/nodemon/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "nodemon",
+  "homepage": "http://github.com/remy/nodemon",
+  "author": {
+    "name": "Remy Sharp",
+    "url": "http://github.com/remy"
+  },
+  "bin": {
+    "nodemon": "./nodemon.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/remy/nodemon.git"
+  },
+  "description": "Simple monitor script for use during development of a node.js app.",
+  "keywords": [
+    "monitor",
+    "development",
+    "restart",
+    "autoload",
+    "reload",
+    "terminal"
+  ],
+  "version": "0.6.18",
+  "preferGlobal": "true",
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "http://rem.mit-license.org"
+    }
+  ],
+  "main": "./nodemon",
+  "_npmUser": {
+    "name": "ddollar",
+    "email": "ddollar@gmail.com"
+  },
+  "_id": "nodemon@0.6.18",
+  "dependencies": {},
+  "devDependencies": {},
+  "optionalDependencies": {},
+  "engines": {
+    "node": "*"
+  },
+  "_engineSupported": true,
+  "_npmVersion": "1.1.21",
+  "_nodeVersion": "v0.6.17",
+  "_defaultsLoaded": true,
+  "_from": "nodemon@0.6.x"
+}

data/server/node_modules/restler/README.md

@@ -1,9 +1,13 @@
-Restler 0.2.4
-===========
+Restler
+=======
 
 (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.
+An HTTP client library for node.js (0.6.x and up).  Hides most of the complexity of creating and using http.Client.
+
+**Release 2.x.x** is dedicated to modifying how errors are handled and emitted. Currently errors are being fired as an on 'error' event but as [@ctavan](https://github.com/ctavan) pointed out on [issue #36](https://github.com/danwrong/restler/pull/36) a better approach (and more commonly in vogue now) would be to pass the error obj to the callback.
+
+Ths change will inevitably affect those using older < 0.2.x versions of restler. Those not ready to upgrade yet are encouraged to stay on the 0.2.x version.
 
 See [Version History](https://github.com/danwrong/restler/wiki/Version-History) for changes
 
@@ -21,7 +25,8 @@ 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)
+* Transparently handle content-encoded responses (gzip, deflate) (requires node 0.6+)
+* Transparently handle different content charsets via [iconv](https://github.com/bnoordhuis/node-iconv) (if available)
 
 
 API
@@ -29,18 +34,28 @@ API
 
 ### request(url, options)
 
-Basic method to make a request of any type.  The function returns a RestRequest object
-that emits events:
+Basic method to make a request of any type. The function returns a RestRequest object that emits events:
+
+#### events
+
+* `complete: function(result, response)` - emitted when the request has finished whether it was successful or not. Gets passed the response result and the response object as arguments. If some error has occurred, `result` is always instance of `Error`, otherwise it contains response data.
+* `success: function(data, response)` - emitted when the request was successful. Gets passed the response data and the response object as arguments.
+* `fail: function(data, response)` - emitted when the request was successful, but 4xx status code returned. Gets passed the response data and the response object as arguments.
+* `error: function(err, response)` - emitted when some errors have occurred (eg. connection aborted, parse, encoding, decoding failed or some other unhandled errors). Gets passed the `Error` object and the response object (when available) as arguments.
+* `abort: function()` - emitted when `request.abort()` is called.
+* `2XX`, `3XX`, `4XX`, `5XX: function(data, response)` - emitted for all requests with response codes in the range (eg. `2XX` emitted for 200, 201, 203).
+* <code><i>actual response code</i>: function(data, response)</code> - emitted for every single response code (eg. 404, 201, etc).
+
+#### members
+
+* `abort([error])` Cancels request. `abort` event is emitted. `request.aborted` is set to `true`. If non-falsy `error` is passed, then `error` will be additionaly emitted (with `error` passed as a param and `error.type` is set to `"abort"`). Otherwise only `complete` event will raise.
+* `retry([timeout])` Re-sends request after `timeout` ms. Pending request is aborted.
+* `aborted` Determines if request was aborted.
 
-* _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. 
+Create a GET request.
 
 ### post(url, options)
 
@@ -54,107 +69,142 @@ Create a PUT request.
 
 Create a DELETE request.
 
-### response parsers
+### head(url, options)
+
+Create a HEAD request.
+
+### json(url, data, options)
+
+Send json `data` via GET method.
+
+### postJson(url, data, options)
+
+Send json `data` via POST method.
+
+
+### Parsers
 
 You can give any of these to the parsers option to specify how the response data is deserialized.
+In case of malformed content, parsers emit `error` event. Original data returned by server is stored in `response.raw`.
 
 #### parsers.auto
 
-Checks the content-type and then uses parsers.xml, parsers.json or parsers.yaml.  
+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. 
-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
-* _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.
+### Options
+
+* `method` Request method, can be get, post, put, del. Defaults to `"get"`.
+* `query` Query string variables as a javascript object, will override the querystring in the URL. Defaults to empty.
+* `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.
+Also you can use `json()` and `postJson()` methods.
+* `parser` A function that will be called on the returned data. Use any of predefined `restler.parsers`. See parsers section below. Defaults to `restler.parsers.auto`.
+* `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. Defaults to `{ 'Accept': '*/*', 'User-Agent': 'Restler for node.js' }`.
+* `username` Basic auth username. Defaults to empty.
+* `password` Basic auth password. Defaults to empty.
+* `multipart` If set the data passed will be formated as `multipart/form-encoded`. See multipart example below. Defaults to `false`.
+* `client` A http.Client instance if you want to reuse or implement some kind of connection pooling. Defaults to empty.
+* `followRedirects` If set will recursively follow redirects. Defaults to `true`.
 
 
 Example usage
 -------------
 
-    var sys = require('util'),
-        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', null, null, null, '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);
-    });
-
-    // 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...
-    });
-
-    
+```javascript
+var sys = require('util'),
+    rest = require('./restler');
+
+rest.get('http://google.com').on('complete', function(result) {
+  if (result instanceof Error) {
+    sys.puts('Error: ' + result.message);
+    this.retry(5000); // try again after 5 sec
+  } else {
+    sys.puts(result);
+  }
+});
+
+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 321567 byte long file 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', null, 321567, null, '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);
+});
+
+// post JSON
+var jsonData = { id: 334 };
+rest.postJson('http://example.com/action', jsonData).on('complete', function(data, response) {
+  // handle response
+});
+
+```
+
 Running the tests
 -----------------
+install **[nodeunit](https://github.com/caolan/nodeunit)**
+
+```bash
+npm install nodeunit
+```
+
+then
+
+```bash
+node test/all.js
+```
+
+or
+
+```bash
+nodeunit test/restler.js
+```
 
-    node test/restler.js 
-    
 TODO
 ----
-* Deal with no utf-8 response bodies
 * What do you need? Let me know or fork.

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

@@ -87,6 +87,8 @@ Part.prototype = {
   	  valueSize = this.value.fileSize;
   	} else if (this.value.data) {
   	  valueSize = this.value.data.length;
+        } else if (typeof this.value === 'number') {
+          valueSize = this.value.toString().length;
   	} else {
   	  valueSize = this.value.length;
   	}

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

@@ -1,19 +1,29 @@
-var sys       = require('util'),
-    http      = require('http'),
-    https     = require('https'),
-    url       = require('url'),
-    qs        = require('querystring'),
-    multipart = require('./multipartform'),
-    zlib      = require('zlib');
-    
+var sys       = require('util');
+var http      = require('http');
+var https     = require('https');
+var url       = require('url');
+var qs        = require('querystring');
+var multipart = require('./multipartform');
+var zlib      = null;
+var Iconv     = null;
+
+try {
+  zlib = require('zlib');
+} catch (err) {}
+
+try {
+  Iconv = require('iconv').Iconv;
+} catch (err) {}
+
 function mixin(target, source) {
+  source = source || {};
   Object.keys(source).forEach(function(key) {
     target[key] = source[key];
   });
   
   return target;
 }
-    
+
 function Request(uri, options) {
   this.url = url.parse(uri);
   this.options = options;
@@ -22,6 +32,10 @@ function Request(uri, options) {
     'User-Agent': 'Restler for node.js',
     'Host': this.url.host
   };
+
+  if (zlib) {
+    this.headers['Accept-Encoding'] = 'gzip, deflate';
+  }
   
   mixin(this.headers, options.headers || {});
   
@@ -41,6 +55,13 @@ function Request(uri, options) {
   
   if (this.options.multipart) {
     this.headers['Content-Type'] = 'multipart/form-data; boundary=' + multipart.defaultBoundary;
+    var multipart_size = multipart.sizeOf(this.options.data, multipart.defaultBoundary);
+    if (typeof multipart_size === 'number' && multipart_size === multipart_size) {
+        this.headers['Content-Length'] = multipart_size;
+    }
+    else {
+        console.log("Building multipart request without Content-Length header, please specify all file sizes");
+    }
   } else {
     if (typeof this.options.data == 'object') {
       this.options.data = qs.stringify(this.options.data);
@@ -96,14 +117,14 @@ mixin(Request.prototype, {
   _responseHandler: function(response) {
     var self = this;
     
-    if (this._isRedirect(response) && this.options.followRedirects == true) {
+    if (self._isRedirect(response) && self.options.followRedirects) {
       try {
-        var location = url.resolve(this.url, response.headers['location']);
-        this.options.originalRequest = this;
-        
-        request(location, this.options);
-      } catch(e) {
-        self._respond('error', '', 'Failed to follow redirect');
+        self.url = url.parse(url.resolve(self.url.href, response.headers['location']));
+        self._retry();
+        // todo handle somehow infinite redirects
+      } catch(err) {
+        err.message = 'Failed to follow redirect: ' + err.message;
+        self._fireError(err, response);
       }
     } else {
       var body = '';
@@ -115,62 +136,96 @@ mixin(Request.prototype, {
       });
       
       response.on('end', function() {
+        response.rawEncoded = body;
         self._decode(new Buffer(body, 'binary'), response, function(err, body) {
           if (err) {
-            self._respond('error', '', 'Failed to decode response body');
+            self._fireError(err, response);
             return;
           }
-          self._encode(body, response, function(body) {
-            self._fireEvents(body, response);
+          response.raw = body;
+          body = self._iconv(body, response);
+          self._encode(body, response, function(err, body) {
+            if (err) {
+              self._fireError(err, response);
+            } else {
+              self._fireSuccess(body, response);
+            }
           });
         });
       });
     }
   },
   _decode: function(body, response, callback) {
-    var encoder = response.headers['content-encoding'];
-    if (encoder in decoders) {
-      decoders[encoder].call(response, body, callback);
+    var decoder = response.headers['content-encoding'];
+    if (decoder in decoders) {
+      decoders[decoder].call(response, body, callback);
     } else {
       callback(null, body);
     }
   },
+  _iconv: function(body, response) {
+    if (Iconv) {
+      var charset = response.headers['content-type'];
+      if (charset) {
+        charset = /\bcharset=(.+)(?:;|$)/i.exec(charset);
+        if (charset) {
+          charset = charset[1].trim().toUpperCase();
+          if (charset != 'UTF-8') {
+            try {
+              var iconv = new Iconv(charset, 'UTF-8//TRANSLIT//IGNORE');
+              return iconv.convert(body);
+            } catch (err) {}
+          }
+        }
+      }
+    }
+    return body;
+  },
   _encode: function(body, response, callback) {
     var self = this;
     if (self.options.decoding == 'buffer') {
-      callback(body);
+      callback(null, body);
     } else {
       body = body.toString(self.options.decoding);
       if (self.options.parser) {
         self.options.parser.call(response, body, callback);
       } else {
-        callback(body);
+        callback(null, body);
       }
     }
   },
-  _respond: function(type, data, response) {
-    if (this.options.originalRequest) {
-      this.options.originalRequest.emit(type, data, response);
+  _fireError: function(err, response) {
+    this.emit('error', err, response);
+    this.emit('complete', err, response);
+  },
+  _fireSuccess: function(body, response) {
+    if (parseInt(response.statusCode) >= 400) {
+      this.emit('fail', body, response);
     } else {
-      this.emit(type, data, response);
+      this.emit('success', body, response);
     }
-  },
-  _fireEvents: function(body, response) {
-    if (parseInt(response.statusCode) >= 400) this._respond('error', body, response);
-    else this._respond('success', body, response);
-        
-    this._respond(response.statusCode.toString().replace(/\d{2}$/, 'XX'), body, response);
-    this._respond(response.statusCode.toString(), body, response);
-    this._respond('complete', body, response);
+    this.emit(response.statusCode.toString().replace(/\d{2}$/, 'XX'), body, response);
+    this.emit(response.statusCode.toString(), body, response);
+    this.emit('complete', body, response);
   },
   _makeRequest: function() {
     var self = this;
-       
     this.request.on('response', function(response) {
-  	  self._responseHandler(response);
-  	}).on('error', function(err) {
-  	  self._respond('error', null, err);
-  	});
+      self.emit('response', response);
+      self._responseHandler(response);
+    }).on('error', function(err) {
+      if (!self.aborted) {
+        self._fireError(err, null);
+      }
+    });
+  },
+  _retry: function() {
+    this.request.removeAllListeners().on('error', function() {});
+    if (this.request.finished) {
+      this.request.abort();
+    }
+    Request.call(this, this.url.href, this.options); // reusing request object to handle recursive calls and remember listeners
+    this.run();
   },
   run: function() {
     var self = this;
@@ -186,6 +241,44 @@ mixin(Request.prototype, {
       this.request.end();
     }
     
+    return this;
+  },
+  abort: function(err) {
+    var self = this;
+
+    if (err) {
+      if (typeof err == 'string') {
+        err = new Error(err);
+      } else if (!(err instanceof Error)) {
+        err = new Error('AbortError');
+      }
+      err.type = 'abort';
+    } else {
+      err = null;
+    }
+
+    self.request.on('close', function() {
+      if (err) {
+        self._fireError(err, null);
+      } else {
+        self.emit('complete', null, null);
+      }
+    });
+
+    self.aborted = true;
+    self.request.abort();
+    self.emit('abort', err);
+    return this;
+  },
+  retry: function(timeout) {
+    var self = this;
+    timeout = parseInt(timeout);
+    var fn = self._retry.bind(self);
+    if (!isFinite(timeout) || timeout <= 0) {
+      process.nextTick(fn, timeout);
+    } else {
+      setTimeout(fn, timeout);
+    }
     return this;
   }
 });
@@ -199,14 +292,19 @@ function shortcutOptions(options, method) {
     
 function request(url, options) {  
   var request = new Request(url, options);
-  request.on('error', function() {}); 
- 	return request.run();
+  request.on('error', function() {});
+  process.nextTick(request.run.bind(request));
+ 	return request;
 }
 
 function get(url, options) {
  return request(url, shortcutOptions(options, 'GET'));
 }
 
+function patch(url, options) {
+  return request(url, shortcutOptions(options, 'PATCH'));
+}
+
 function post(url, options) {
   return request(url, shortcutOptions(options, 'POST'));
 }
@@ -219,23 +317,66 @@ function del(url, options) {
   return request(url, shortcutOptions(options, 'DELETE'));
 }
 
+function head(url, options) {
+  return request(url, shortcutOptions(options, 'HEAD'));
+}
+
+function json(url, data, options, method) {
+  options = options || {};
+  options.parser = (typeof options.parser !== "undefined") ? options.parser : parsers.auto;
+  options.headers = options.headers || {};
+  options.headers['content-type'] = 'application/json';
+  options.data = JSON.stringify(data);
+  options.method = method || 'GET';
+  return request(url, options);
+}
+
+function postJson(url, data, options) {
+  return json(url, data, options, 'POST');
+}
+
 var parsers = {
   auto: function(data, callback) {
     var contentType = this.headers['content-type'];
-    
+    var contentParser;
     if (contentType) {
-      for (var matcher in parsers.auto.matchers) {
-
-        if (contentType.indexOf(matcher) == 0) {
-          return parsers.auto.matchers[matcher].call(this, data, callback);
+      contentType = contentType.replace(/;.+/, ''); // remove all except mime type (eg. text/html; charset=UTF-8)
+      if (contentType in parsers.auto.matchers) {
+        contentParser = parsers.auto.matchers[contentType];
+      } else {
+        // custom (vendor) mime types
+        var parts = contentType.match(/^([\w-]+)\/vnd((?:\.(?:[\w-]+))+)\+([\w-]+)$/i);
+        if (parts) {
+          var type = parts[1];
+          var vendors = parts[2].substr(1).split('.');
+          var subtype = parts[3];
+          var vendorType;
+          while (vendors.pop() && !(vendorType in parsers.auto.matchers)) {
+            vendorType = vendors.length
+              ? type + '/vnd.' + vendors.join('.') + '+' + subtype
+              : vendorType = type + '/' + subtype;
+          }
+          contentParser = parsers.auto.matchers[vendorType];
         }
       }
     }
-    
-    callback(data);
+    if (typeof contentParser == 'function') {
+      contentParser.call(this, data, callback);
+    } else {
+      callback(null, data);
+    }
   },
   json: function(data, callback) {
-    callback(data && JSON.parse(data));
+    if (data && data.length) {
+      try {
+        callback(null, JSON.parse(data));
+      } catch (err) {
+        err.message = 'Failed to parse JSON body: ' + err.message;
+        callback(err, null);
+      }
+    } else {
+      callback(null, null);
+    }
   }
 };
 
@@ -247,7 +388,16 @@ try {
   var yaml = require('yaml');
   
   parsers.yaml = function(data, callback) {
-    return callback(data && yaml.eval(data));
+    if (data) {
+      try {
+        callback(null, yaml.eval(data));
+      } catch (err) {
+        err.message = 'Failed to parse YAML body: ' + err.message;
+        callback(err, null);
+      }
+    } else {
+      callback(null, null);
+    }
   };
   
   parsers.auto.matchers['application/yaml'] = parsers.yaml;
@@ -259,17 +409,14 @@ try {
   parsers.xml = function(data, callback) {
     if (data) {
       var parser = new xml2js.Parser();
-      
-      parser.on('end', function(result) {
-          callback(result);
+      parser.parseString(data, function(err, data) {
+        if (err) {
+          err.message = 'Failed to parse XML body: ' + err.message;
+        }
+        callback(err, data);
       });
-      try {
-          parser.parseString(data);
-      } catch (e) {
-          callback({error:'Oops, something went wrong.'});
-      }
     } else {
-      callback();
+      callback(null, null);
     }
   };
   
@@ -302,12 +449,18 @@ mixin(Service.prototype, {
   get: function(path, options) {
     return get(this._url(path), this._withDefaults(options));
   },
+  patch: function(path, options) {
+    return patch(this._url(path), this._withDefaults(options));
+  },
   put: function(path, options) {
     return put(this._url(path), this._withDefaults(options));
   },
   post: function(path, options) {
     return post(this._url(path), this._withDefaults(options));
   },
+  json: function(method, path, data, options) {
+    return json(this._url(path), data, this._withDefaults(options), method);
+  },
   del: function(path, options) {
     return del(this._url(path), this._withDefaults(options));
   },
@@ -333,9 +486,13 @@ mixin(exports, {
   request: request,
   service: service,
   get: get,
+  patch: patch,
   post: post,
   put: put,
   del: del,
+  head: head,
+  json: json,
+  postJson: postJson,
   parsers: parsers,
   file: multipart.file,
   data: multipart.data