First version of the rewritten module

var Promise = require('bluebird'),

    request = require('request'),

    _ = require('lodash'),

    util = require('util');

var defaultOptions = {simple: true, resolveWithFullResponse: false};

function rp(options) {

    var c = _.cloneDeep(defaultOptions), i;

    if (typeof options === 'string') {

        c.uri = options;

        c.method = 'GET';

    }

    if (typeof options === 'object') {

        for (i in options) {

            if (options.hasOwnProperty(i)) {

                c[i] = options[i];

            }

        }

    }

    c.method = c.method || 'GET';

    c.method = c.method.toUpperCase();

    return buildPromise(c);

'use strict';

var request = require('request'),

    Bluebird = require('bluebird'),

    _ = require('lodash');

function ownCallback(err, httpResponse, body) {

    /* jshint validthis:true */

    if (_.isFunction(this._rp_callbackOrig)) {

        try {

            this._rp_callbackOrig.apply(this, arguments);

        } catch (e) { }

    }

function buildPromise (c, requester) {

    var _requester = requester || request;

    return new Promise(function (resolve, reject) {

            _requester(c, function (error, response, body) {

            if (error) {

                reject({

                    error: error,

                    options: c,

                    response: response

    if (err) {

        this._rp_reject({

            error: err,

            options: this._rp_options,

            response: httpResponse

        });

            } else if (c.simple && !(/^2/.test('' + response.statusCode))) {

                reject({

    } else if (this._rp_options.simple && !(/^2/.test('' + httpResponse.statusCode))) {

        this._rp_reject({

            error: body,

                    options: c,

                    response: response,

                    statusCode: response.statusCode

            options: this._rp_options,

            response: httpResponse,

            statusCode: httpResponse.statusCode

        });

    } else {

                if (c.transform && typeof c.transform === 'function') {

                    resolve(c.transform(body));

                } else if (c.resolveWithFullResponse) {

                    resolve(response);

        if (this._rp_options.transform && typeof this._rp_options.transform === 'function') {

            // FIXME: Produces unhandled exception if transform fails.

            this._rp_resolve(this._rp_options.transform(body));

        } else if (this._rp_options.resolveWithFullResponse) {

            this._rp_resolve(httpResponse);

        } else {

                    resolve(body);

            this._rp_resolve(body);

        }

    }

        });

    });

}

var wrapMethods = [

    'post',

    'put',

    'patch',

    'head',

    'del',

    'get'

];

var methodNameLookup = {

    'post'  : 'POST',

    'put'   : 'PUT',

    'patch' : 'PATCH',

    'head'  : 'HEAD',

    'del'   : 'DELETE',

    'get'   : 'GET'

var originalInit = request.Request.prototype.init;

request.Request.prototype.init = function (options) {

    this._rp_callbackOrig = this.callback;

    this.callback = ownCallback;

    this._rp_options = _.cloneDeep(options);

    this._rp_options.simple = options.simple === false ? false : true;

    this._rp_options.resolveWithFullResponse = options.resolveWithFullResponse === true ? true : false;

    return originalInit.apply(this, arguments);

};

Object.keys(request).filter(function(key){

    return typeof(request[key]) === "function" && !wrapMethods.indexOf(key) +1 && key !== 'defaults';

}).forEach(function(key){

    rp[key] = request[key].bind(request);

});

request.Request.prototype.then = function (onFulfilled, onRejected) {

Object.keys(request).filter(function(key){

    return typeof(request[key]) === "function" && wrapMethods.indexOf(key) +1;

}).forEach(function(key){

    rp[key] = defaultHttpMethod(key);

});

    var self = this;

rp.request = request;

    return new Bluebird(function (resolve, reject) {

rp.defaults =  function (options, requester) {

    options.simple = options.simple || defaultOptions.simple;

    options.resolveWithFullResponse = options.resolveWithFullResponse || defaultOptions.resolveWithFullResponse;

        self._rp_resolve = resolve;

        self._rp_reject = reject;

    var def = function (method) {

        var d = function (uri, opts, callback) {

            var params = request.initParams(uri, opts, callback)

            Object.keys(options).forEach(function (key) {

                if (key !== 'headers' && params.options[key] === undefined) {

                    params.options[key] = options[key]

                }

            })

            if (options.headers) {

                var headers = {}

                util._extend(headers, options.headers)

                util._extend(headers, params.options.headers)

                params.options.headers = headers

            }

            if(typeof requester === 'function') {

                if(method === request) {

                    method = requester

                } else {

                    params.options._requester = requester

                }

            }

            return buildPromise(params.options, method);

        }

        return d

    }

    var de = def(request)

    de.get = def(request.get)

    de.patch = def(request.patch)

    de.post = def(request.post)

    de.put = def(request.put)

    de.head = def(request.head)

    de.del = def(request.del)

    de.cookie = def(request.cookie)

    de.jar = request.jar

    return de

}

    }).then(onFulfilled, onRejected);

function defaultHttpMethod(key) {

    return function() {

        var args = Array.prototype.slice.call(arguments, 0);

        var params = request.initParams.apply(request, args);

        params.method = methodNameLookup[key];

        return buildPromise(params);

};

}

module.exports = rp;

module.exports = request;