geocode: function ( loc, cbk, opts ) {
if ( ! loc ) {
return cbk( new Error( "Geocoder.geocode requires a location.") );
}
var options = Hash.merge({sensor: false, address: loc}, opts || {});
var params;
if (socksAgent){
params = {
host: 'maps.googleapis.com',
port: 80,
path: '/maps/api/geocode/json?' + querystring.stringify(options),
headers: {},
agent: socksAgent
};
} else {
params = {
host: 'maps.googleapis.com',
port: 80,
path: '/maps/api/geocode/json?' + querystring.stringify(options),
headers: {}
};
}
return request( params, cbk );
},
function checkUsage(f) {
var _process = process;
process = Hash.copy(process);
var exit = false;
process.exit = function () {
exit = true
};
process.env = Hash.merge(process.env, { _: 'node' });
process.argv = [ './usage' ];
var errors = [];
var logs = [];
console._error = console.error;
console.error = function (msg) {
errors.push(msg)
};
console._log = console.log;
console.log = function (msg) {
logs.push(msg)
};
var result = f();
process = _process;
console.error = console._error;
console.log = console._log;
return {
errors: errors,
logs: logs,
exit: exit,
result: result,
};
};
exports.checkOutput = function (f, argv) {
var exit = false,
_exit = process.exit,
_env = process.env,
_argv = process.argv,
_error = console.error,
_log = console.log
process.exit = function () { exit = true }
process.env = Hash.merge(process.env, { _: 'node' })
process.argv = argv || [ './usage' ]
var errors = []
var logs = []
console.error = function (msg) { errors.push(msg) }
console.log = function (msg) { logs.push(msg) }
var result = f()
process.exit = _exit
process.env = _env
process.argv = _argv
console.error = _error
console.log = _log
return {
errors: errors,
logs: logs,
exit: exit,
result: result
}
}
.map(function (file) {
fileWatch(file, opts);
var libname = unext(file.slice(base.length + 1));
if (!libname.match(/^\.\//)) libname = './' + libname;
var p4 = packageFor(file);
var p = Hash.merge({
filename : file,
main : paramFor(file, 'main') || main,
base : paramFor(file, 'base'),
name : opts.name || paramFor(file, 'name'),
}, p4);
if (p.base && !p.base.match(/^\//)) {
p.base = path.resolve(base, p.base);
}
if (p.main && !p.main.match(/^\//)) {
p.main = path.resolve(base, p.main);
}
if (opts.name && (p4 === pkg || p4 === packages[base])) {
p.name = opts.name;
}
var pkgname = main && (
unext(main) === unext(file) || unext(main) === libname
) ? '.' : path.resolve(base, libname).replace(p.base, '.');
return exports.wrap(pkgname, p).source;
})
exports.checkOutput = function (f, argv, cb) {
var exit = false
var _exit = process.exit
var _emit = process.emit
var _env = process.env
var _argv = process.argv
var _error = console.error
var _log = console.log
process.exit = function () { exit = true }
process.env = Hash.merge(process.env, { _: 'node' })
process.argv = argv || [ './usage' ]
var errors = []
var logs = []
console.error = function (msg) { errors.push(msg) }
console.log = function (msg) { logs.push(msg) }
var result
if (typeof cb === 'function') {
process.exit = function () {
exit = true
cb(null, done())
}
process.emit = function (ev, value) {
if (ev === 'uncaughtException') {
done()
cb(value)
return true
}
return _emit.apply(this, arguments)
}
f()
} else {
result = f()
return done()
}
function done () {
process.exit = _exit
process.emit = _emit
process.env = _env
process.argv = _argv
console.error = _error
console.log = _log
return {
errors: errors,
logs: logs,
exit: exit,
result: result
}
}
}
build: function(model, data, callback) {
if (typeof(data) == 'function'){
callback = data;
data = {}
}
if (data === undefined) {
data = {}
}
var attributes = this.patterns[model].attributes
var values = Hash.merge(attributes, data);
// no callback given so use direct style
if (callback === undefined){
values = Hash.map(values, function(value, key){
if (typeof(value) == 'function'){
if (value.length > 0){
throw('you need to pass a callback to the build function - setter for attribute "' + key + '" is asynchronous');
} else {
return value.call();
}
} else {
return value;
}
});
var obj = new(this.patterns[model].class)(values);
return obj;
} else {
// callback given, convert everything to function style
var callbacks = []
Hash.forEach(values, function(value, key){
if (typeof(value) == 'function'){
if (value.length == 0){
callbacks.push({key: key, cbk: function(cbk){
return cbk(null, value.call());
}});
} else {
callbacks.push({key: key, cbk: value});
}
} else {
callbacks.push({key: key, cbk: function(cbk){
return cbk(null, value);
}});
}
});
Seq(callbacks)
.parEach(function(value){
value.cbk(this.into(value.key));
})
.seq(function(){
var obj = new(module.exports.patterns[model].class)(this.vars);
callback(null, obj);
})
.catch(function(err){
callback(err);
});
}
},
function packageFor (file) {
var parts = path.dirname(file).split('/');
while (parts.length) {
var ps = parts.join('/');
parts.shift();
if (packages[ps]) {
var p = packages[ps].browserify || packages[ps] || {};
if (!p.base) {
p.base = ps;
}
else if (p.base.match(/^\./)) {
p.base = (ps + p.base.slice(1)).replace(/\/\.\//g, '/');
}
if (p.main && p.main.match(/^\./)) {
p.main = (ps + p.main.slice(1)).replace(/\/\.\//g, '/');
}
return p;
}
}
var res = Hash.merge(pkg || {}, pkg.browserify || {});
if (Array.isArray(res.base)) {
var subBase = res.base.filter(function (b) {
var r = path.resolve(base, b)
return file.slice(0, r.length) === r;
})[0] || base;
res = Hash.merge(res, { base : subBase });
}
else if (typeof res.base === 'object') {
var subBase = Hash.filter(res.base, function (b) {
var r = path.resolve(base, b)
return file.slice(0, r.length) === r;
});
if (subBase) {
var sb = Object.keys(subBase)[0];
res = Hash.merge(res, { base : subBase[sb] });
res.name = (res.name ? res.name + '/' : '') + sb;
}
}
return res;
}
exports.merge = function () {
var ref = { a : 1, b : 2 };
var items = Hash(ref).merge({ b : 3, c : 3.14 }).items;
var hash = Hash.merge(ref, { b : 3, c : 3.14 });
assert.deepEqual(ref, { a : 1, b : 2 });
assert.deepEqual(items, { a : 1, b : 3, c : 3.14 });
assert.deepEqual(hash, { a : 1, b : 3, c : 3.14 });
};
reverseGeocode: function ( lat, lng, cbk, opts ) {
if ( !lat || !lng ) {
return cbk( new Error( "Geocoder.reverseGeocode requires a latitude and longitude." ) );
}
var options = Hash.merge({sensor: false, latlng: lat + ',' + lng}, opts || {});
var params = {
host: 'maps.googleapis.com',
port: 80,
path: '/maps/api/geocode/json?' + querystring.stringify(options),
headers: {}
};
return request( params, cbk );
},
Airbrake.prototype.trackDeployment = function(params, cb) {
if (typeof params === 'function') {
cb = params;
params = {};
}
params = hashish.merge({
key: this.key,
env: this.env,
user: process.env.USER,
rev: '',
repo: '',
}, params);
var body = this.deploymentPostData(params);
var options = {
method: 'POST',
url: this.url('/deploys.txt'),
body: body,
timeout: this.timeout,
headers: {
'Content-Length': body.length,
'Content-Type': 'application/x-www-form-urlencoded',
},
};
var callback = this._callback(cb);
request(options, function(err, res, body) {
if (err) {
return callback(err);
}
if (res.statusCode >= 300) {
var status = HTTP_STATUS_CODES[res.statusCode];
return callback(new Error(
'Deployment failed: ' + res.statusCode + ' ' + status + ': ' + body
));
}
callback(null, params);
});
};
define: function(key, model, def) {
var _model, _def;
if (typeof(model) == 'string') {
// If 'model' is a string, interpret it as the name of a model that has
// already been defined. Try to inherit from that model.
if (!(model in this.patterns)) {
throw('No parent model with the key "'+model+'" has been defined.');
} else {
_model = this.patterns[model].class;
_def = Hash.merge(this.patterns[model].attributes, def);
}
} else {
_model = model;
_def = def;
}
this.patterns[key] = {
class: _model,
attributes: _def
};
},
function checkUsage (f) {
var exit = false;
process._exit = process.exit;
process._env = process.env;
process._argv = process.argv;
process.stdout._write = process.stdout.write;
process.exit = function () { exit = true };
process.env = Hash.merge(process.env, { _ : 'node' });
process.argv = [ './usage' ];
process.stdout.write = function (msg) { logs.push(msg) };
var errors = [];
var logs = [];
console._error = console.error;
console.error = function (msg) { errors.push(msg) };
console._log = console.log;
console.log = function (msg) { logs.push(msg) };
var result = f();
process.exit = process._exit;
process.env = process._env;
process.argv = process._argv;
process.stdout.write = process.stdout._write;
console.error = console._error;
console.log = console._log;
return {
errors : errors,
logs : logs,
exit : exit,
result : result
};
};
Hash(opts.base).forEach(function (base, name) {
src += exports.wrapDir(base, Hash.merge(opts, {
base : base,
name : name,
}));
});
opts.base.forEach(function (base) {
src += exports.wrapDir(base, Hash.merge(opts, { base : base }));
});
exports.bundle = function (opts) {
if (typeof opts === 'string') {
opts = { base : opts };
var opts_ = arguments[1];
if (typeof opts_ === 'object') {
Object.keys(opts_).forEach(function (key) {
opts[key] = opts_[key];
});
}
}
if (opts.main && opts.main.match(/^\//) && !opts.filename) {
opts.filename = opts.main;
}
var shim = 'shim' in opts ? opts.shim : true;
var req = opts.require || [];
if (!Array.isArray(req)) req = [req];
var src = fs.readFileSync(__dirname + '/wrappers/prelude.js', 'utf8')
+ fs.readFileSync(__dirname + '/wrappers/node_compat.js', 'utf8')
+ (shim ? source.modules('es5-shim')['es5-shim'] : '')
+ builtins
+ (req.length
? exports.wrap(
req, Hash.merge(opts, { base : undefined })
).source
: ''
)
;
if (Array.isArray(opts.base)) {
opts.base.forEach(function (base) {
src += exports.wrapDir(base, Hash.merge(opts, { base : base }));
});
}
else if (typeof opts.base === 'object') {
Hash(opts.base).forEach(function (base, name) {
src += exports.wrapDir(base, Hash.merge(opts, {
base : base,
name : name,
}));
});
}
else if (typeof opts.base === 'string') {
src += exports.wrapDir(opts.base, opts);
}
else if (!opts.base && opts.main) {
var opts_ = Hash.copy(opts);
opts_.base = path.dirname(opts.main);
src += exports.wrap('./' + path.basename(opts.main), opts).source;
}
if (opts.entry) {
if (!Array.isArray(opts.entry)) {
opts.entry = [ opts.entry ];
}
var entryBody = fs.readFileSync(
__dirname + '/wrappers/entry.js', 'utf8'
);
opts.entry.forEach(function (entry) {
fileWatch(entry, opts);
src += entryBody
.replace(/\$aliases/g, function () {
return JSON.stringify([]);
})
.replace(/\$__filename/g, function () {
return JSON.stringify('./' + path.basename(entry))
})
.replace(/\$__dirname/g, function () {
return JSON.stringify('.')
})
.replace('$body', function () {
return fs.readFileSync(entry, 'utf8')
})
;
});
}
return opts.filter ? opts.filter(src) : src;
};
export function checkOutput(func, argv, callback) {
/* eslint-disable func-names */
let exitCode = null;
const _exit = process.exit;
const _emit = process.emit;
const _env = process.env;
const _argv = process.argv;
var _error = console.error; // eslint-disable-line
var _log = console.log; // eslint-disable-line
var _warn = console.warn; // eslint-disable-line
process.exit = function(code) {
exitCode = code;
};
process.env = Hash.merge(process.env, { _: 'node' });
process.argv = argv || ['./usage'];
const errors = [];
const logs = [];
const warnings = [];
console.error = function(msg) {
errors.push(msg);
}; // eslint-disable-line
console.log = function(msg) {
logs.push(msg);
}; // eslint-disable-line
console.warn = function(msg) {
warnings.push(msg);
}; // eslint-disable-line
let result;
function reset() {
process.exit = _exit;
process.emit = _emit;
process.env = _env;
process.argv = _argv;
console.error = _error; // eslint-disable-line
console.log = _log; // eslint-disable-line
console.warn = _warn; // eslint-disable-line
}
function done() {
reset();
return {
errors,
logs,
warnings,
exitCode,
result,
};
}
if (typeof cb === 'function') {
process.exit = function(code) {
exitCode = code;
callback(null, done());
};
process.emit = function(ev, value) {
if (ev === 'uncaughtException') {
done();
callback(value);
return true;
}
// eslint-disable-next-line prefer-rest-params
return _emit.apply(this, arguments);
};
func();
} else {
try {
result = func();
} finally {
reset();
}
return done();
}
}