/*global Y: false, Buffer: false, clearInterval: false, clearTimeout: false, console: false, exports: false, global: false, module: false, process: false, querystring: false, require: false, setInterval: false, setTimeout: false, __filename: false, __dirname: false */
                                /**
                                * Node.js override for IO, methods are mixed into `Y.IO`
                                * @module io-nodejs
                                * @main io-nodejs
                                */
                                /**
                                * Passthru to the NodeJS <a href="https://github.com/mikeal/request">request</a> module.
                                * This method is return of `require('request')` so you can use it inside NodeJS without
                                * the IO abstraction.
                                * @method request
                                * @static
                                * @for IO
                                */
                                if (!Y.IO.request) {
                                    // Default Request's cookie jar to `false`. This way cookies will not be
                                    // maintained across requests.
                                    Y.IO.request = require('request').defaults({jar: false});
                                }
                            
                                var codes = require('http').STATUS_CODES;
                            
                                /**
                                Flatten headers object
                                @method flatten
                                @protected
                                @for IO
                                @param {Object} o The headers object
                                @return {String} The flattened headers object
                                */
                                var flatten = function(o) {
                                    var str = [];
                                    Object.keys(o).forEach(function(name) {
                                        str.push(name + ': ' + o[name]);
                                    });
                                    return str.join('\n');
                                };
                            
                                Y.log('Loading NodeJS Request Transport', 'info', 'io');
                            
                                /**
                                NodeJS IO transport, uses the NodeJS <a href="https://github.com/mikeal/request">request</a>
                                module under the hood to perform all network IO.
                                @method transports.nodejs
                                @for IO
                                @static
                                @return {Object} This object contains only a `send` method that accepts a
                                `transaction object`, `uri` and the `config object`.
                                @example
                            
                                    Y.io('https://somedomain.com/url', {
                                        method: 'PUT',
                                        data: '?foo=bar',
                                        //Extra request module config options.
                                        request: {
                                            maxRedirects: 100,
                                            strictSSL: true,
                                            multipart: [
                                                {
                                                    'content-type': 'application/json',
                                                    body: JSON.stringify({
                                                        foo: 'bar',
                                                        _attachments: {
                                                            'message.txt': {
                                                                follows: true,
                                                                length: 18,
                                                                'content_type': 'text/plain'
                                                            }
                                                        }
                                                    })
                                                },
                                                {
                                                    body: 'I am an attachment'
                                                }
                                            ]
                                        },
                                        on: {
                                            success: function(id, e) {
                                                Y.log(e.responseText);
                                            }
                                        }
                                    });
                                */
                            
                                Y.IO.transports.nodejs = function() {
                                    return {
                                        send: function (transaction, uri, config) {
                            
                                            Y.log('Starting Request Transaction', 'info', 'io');
                                            config.notify('start', transaction, config);
                                            config.method = config.method || 'GET';
                                            config.method = config.method.toUpperCase();
                            
                                            var rconf = {
                                                method: config.method,
                                                uri: uri
                                            };
                            
                                            if (config.data) {
                                                if (Y.Lang.isString(config.data)) {
                                                    rconf.body = config.data;
                                                }
                                                if (rconf.body && rconf.method === 'GET') {
                                                    rconf.uri += (rconf.uri.indexOf('?') > -1 ? '&' : '?') + rconf.body;
                                                    rconf.body = '';
                                                }
                                            }
                                            if (config.headers) {
                                                rconf.headers = config.headers;
                                            }
                                            if (config.timeout) {
                                                rconf.timeout = config.timeout;
                                            }
                                            if (config.request) {
                                                Y.mix(rconf, config.request);
                                            }
                                            Y.log('Initiating ' + rconf.method + ' request to: ' + rconf.uri, 'info', 'io');
                                            Y.IO.request(rconf, function(err, data) {
                                                Y.log('Request Transaction Complete', 'info', 'io');
                            
                                                if (err) {
                                                    Y.log('An IO error occurred', 'warn', 'io');
                                                    transaction.c = err;
                                                    config.notify(((err.code === 'ETIMEDOUT') ? 'timeout' : 'failure'), transaction, config);
                                                    return;
                                                }
                                                if (data) {
                                                    transaction.c = {
                                                        status: data.statusCode,
                                                        statusCode: data.statusCode,
                                                        statusText: codes[data.statusCode],
                                                        headers: data.headers,
                                                        responseText: data.body || '',
                                                        responseXML: null,
                                                        getResponseHeader: function(name) {
                                                            return this.headers[name];
                                                        },
                                                        getAllResponseHeaders: function() {
                                                            return flatten(this.headers);
                                                        }
                                                    };
                                                }
                                                Y.log('Request Transaction Complete', 'info', 'io');
                            
                                                config.notify('complete', transaction, config);
                                                config.notify(((data && (data.statusCode >= 200 && data.statusCode <= 299)) ? 'success' : 'failure'), transaction, config);
                                            });
                            
                                            var ret = {
                                                io: transaction
                                            };
                                            return ret;
                                        }
                                    };
                                };
                            
                                Y.IO.defaultTransport('nodejs');