Bump version for future development
Chain interceptors to support builder style configuration

Before:

```javascipt
var client = pathPrefix(errorCode(mime(), { code: 500 }), { prefix: 'http://example.com' });
```

-- or --

```javascript
var client = mime();
client = errorCode(client, { code: 500 });
client = pathPrefix(client, { prefix: 'http://example.com' });
```

Now:

```javascript
var client = rest.chain(mime)
	.chain(errorCode, { code: 500 })
	.chain(pathPrefix, { prefix: 'http://example.com' });
```

Each of these three example configurations are semantically equivalent.
The new style is more clear than the first example, as the config is
closer to the type of the interceptor. It is also more concise than the
second version, while also eliminating the mutation of the 'client' var.

Each of these three styles will still work, this change does not affect
backwards compatibility.

Thanks to Kris De Volder for the sugestion.
Convert code example to Common JS style modules

Node and UMD users will find the example much more approachable. AMD
purists will figure it out.
Default request interceptor

An interceptor that is able to provide default values for any part of the
standard request api:
- method
- path
- params
- headers
- entity

If a value is not defined in the request, this interceptor will provide the
configured default value. For headers and params, the values are mixed
together. This interceptor will not overwrite a value specfied by a request.
typoes
Cross browser testing with Sauce Labs

Sauce Labs now provides free test time for open source projects, yay!

Test results can be viewed at:
https://saucelabs.com/u/s2js-probes

This commit provides a primative test runner that utilizes Travis CI to
drive Buster tests on Sauce for major browsers (and then some). While a
bit hacky in places, it's stable enough to start using. Converting into a
configuratble/resuable Grunt task would be ideal.
Provide a shared context for request and reply interceptor phases

'this' is now provided to the request and reply callbacks for an
interceptor. The context is shared between the request and reply for the
specific interceptor and request/reply pair. Particularaly useful for
state created in the request phase that should be cleaned up in the
response phase.
RestStore without dojo

Introduce SimpleRestStore that contains the core logic from RestStore
wihout a dependency on Dojo. RestStore in turn depends on SimpleRestStore,
appling the Dojo provided behavior.

Issue: #18
Fix integration tests

Disable old IE tests until we work arround the false positives.
Improve async test reliability

Exceptions thrown in promise callbacks were being missed. We now 'fail'
the test after the initial promise has resolved, if the subsecquent
promise is rejceted.

For errorbacks, we need to wrap the function in a try-catch in order
handle exceptions as the promise chain would already be rejected.
Clean up cross browser tests

Particularly older Firefox and IE. Reenabled IE 6 and 7 tests.

Issue: #19
Configuration DSL for wire.js

In it's basic form, the array of interceptors is processed in order, chaining off the parent client.

```javascript
client: {
    rest: {
        parent: { $ref: 'baseClient' },
        interceptors: [
            { module: 'rest/interceptor/mime', config: { mime: 'application/json' } },
            { module: 'rest/interceptor/location' },
            { module: 'rest/interceptor/entity' },
            { module: 'rest/interceptor/hateoas', config: { target: '' } }
        ]
    }
},
baseClient: { module: 'rest' },
plugins: [{ module: 'rest/wire' }]
```

If parent is not defined, or is not a function, the default client is used as the parent.  In that case, the interceptors array can replace the whole facotry object

```javascript
client: {
    rest: [
        { module: 'rest/interceptor/mime', config: { mime: 'application/json' } },
        { module: 'rest/interceptor/location' },
        { module: 'rest/interceptor/entity' },
        { module: 'rest/interceptor/hateoas', config: { target: '' } }
    ]
},
plugins: [{ module: 'rest/wire' }]
```

If a configuration element isn't needed, a string can be provided to represent the module

```javascript
client: {
    rest: [
        { module: 'rest/interceptor/mime', config: { mime: 'application/json' } },
        'rest/interceptor/location',
        'rest/interceptor/entity',
        { module: 'rest/interceptor/hateoas', config: { target: '' } }
    ]
},
plugins: [{ module: 'rest/wire' }]
```

An individual interceptors array entry can use any facility available within wire, including $ref.

```javascript
client: {
    rest: [
        { $ref: 'mime', config: { mime: 'application/json' } },
        'rest/interceptor/location',
        'rest/interceptor/entity',
        { $ref: 'hateoas', config: { target: '' } }
    ]
},
mime: { module: 'rest/interceptor/mime' },
hateoas: { module: 'rest/interceptor/hateoas' },
plugins: [{ module: 'rest/wire' }]
```

Each of these sample configurations are functionally identical.

Known limitations:
- the config object is currently static, and not wired
- tested with wire 0.8.x and 0.9.x, will need a small patch for wire.next

Issue: #20
Avoid timing issues by using fake timers
Remove linguring console.log
Cleanup handling of complex requests

Most interceptors with a request phase just need to manipulate the
request object. Occasionally, an interceptor needs to be more invasive
during the request phase. The request handler can now return a
ComplexRequest object that contains the canonical request object along
with any extras.

In addition to the request object, a ComplexRequest may also contain an
abort promise or a custom client to override the client chain.

interceptor = require('rest/interceptor');
return interceptor({
    request: function (request, config) {
        var abortTrigger = when.defer();
        ...
        return new interceptor.ComplexRequest({
            request: request,
            abort: abortTrigger.promise
        });
    }
});
Fixing issues newly discovered by jshint 1.0
Use Buffer.concat instead of string concat
Ensure reponse.entity is always a string
abort sauce tests for pull request builds
Add XHR fall back interceptor for older IE

Older versions of IE do not support the native XMLHttpRequest. To date, we've
assumed the user would apply something like poly to polyfill the
window.XMLHttpRequest. Instead, users can now apply the
`rest/interceptor/ie/xhrFallback` intercerceptor.