_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q2800
|
train
|
function (ports) {
var port = ports[0];
var list = '';
for (var i=0; i < ports.length; i++) {
list += (ports[i] + ', ');
delete l_ports[ports[i]];
}
LOG.warn('release ports: ' + list, 'SR.Monitor');
// remove all other ports associated with this port
for (var i in l_ports) {
if (l_ports[i] === port) {
LOG.warn('release port: ' + i, 'SR.Monitor');
delete l_ports[i];
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q2801
|
train
|
function (port, parent_port) {
// check if the port wasn't reported
if (l_ports.hasOwnProperty(port) === false) {
LOG.warn('recording used port [' + port + ']...', 'SR.Monitor');
l_ports[port] = parent_port || port;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q2802
|
train
|
function (size) {
size = size || 1;
LOG.warn('trying to assign ' + size + ' new ports...', 'SR.Monitor');
// find first available port
var port = SR.Settings.PORT_APP_RANGE_START;
var last_port = SR.Settings.PORT_APP_RANGE_END;
// first port found
var first_port = undefined;
var results = [];
while (port <= last_port) {
if (l_ports.hasOwnProperty(port) === false || l_ports[port] === null) {
// found a unique port
if (!first_port)
first_port = port;
// mark the port as assigned
l_ports[port] = first_port;
results.push(port);
LOG.warn('assigning port: ' + port, 'SR.Monitor');
if (--size === 0)
break;
}
port++;
}
// no available ports found, or not enough ports found
if (port > last_port)
return 0;
if (results.length > 1)
return results;
else
return results[0];
}
|
javascript
|
{
"resource": ""
}
|
|
q2803
|
train
|
function () {
var currTime = new Date();
var overtime = (SR.Settings.INTERVAL_STAT_REPORT * 2);
// remove servers no longer reporting
for (var serverID in SR.Report.servers) {
var stat = SR.Report.servers[serverID];
if (!stat || !stat.reportedTime)
continue;
// server considered dead
if (currTime - stat.reportedTime > overtime) {
var ip_port = stat.server.IP + ':' + stat.server.port;
LOG.sys(ip_port + ' overtime: ' + overtime + ' last: ' + stat.reportedTime);
LOG.error('server: ' + ip_port + ' (' + stat.server.type + ') not responding after ' + overtime + ' ms, mark dead...', 'SR.Monitor');
SR.Report.removeStat(serverID);
// recycle port if it's from a local server
if (stat.server.IP === SR.Settings.SERVER_INFO.IP) {
LOG.warn('server is a local server, re-cycle its ports...', 'SR.Monitor');
l_recyclePort(stat.ports);
}
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q2804
|
train
|
function(req) {
return ((req.headers.origin && req.headers.origin !== "null") ? req.headers.origin : "*");
}
|
javascript
|
{
"resource": ""
}
|
|
q2805
|
train
|
function (res_obj, data, conn) {
// check if we should return empty response
if (typeof res_obj === 'undefined') {
SR.REST.reply(res, {});
return true;
}
// check for special case processing (SR_REDIRECT)
if (res_obj[SR.Tags.UPDATE] === 'SR_REDIRECT' && res_obj[SR.Tags.PARA] && res_obj[SR.Tags.PARA].url) {
var url = res_obj[SR.Tags.PARA].url;
LOG.warn('redirecting to: ' + url, l_name);
/*
res.writeHead(302, {
'Location': url
});
res.end();
*/
// redirect by page
// TODO: merge with same code in FB.js
var page =
'<html><body><script>\n' +
'if (navigator.appName.indexOf("Microsoft") != -1)\n' +
' window.top.location.href="' + url + '";\n' +
'else\n' +
' top.location.href="' + url + '";\n' +
'</script></body></html>\n';
res.writeHead(200, {
'Content-Type': 'text/html'
});
res.end(page);
return true;
}
// check for special case processing (SR_HTML)
if (res_obj[SR.Tags.UPDATE] === 'SR_HTML' && res_obj[SR.Tags.PARA].page) {
res.writeHead(200, {
'Content-Type': 'text/html'
});
res.end(res_obj[SR.Tags.PARA].page);
return true;
}
// check for special case processing (SR_DOWNLOAD)
if (res_obj[SR.Tags.UPDATE] === 'SR_DOWNLOAD' && res_obj[SR.Tags.PARA].data && res_obj[SR.Tags.PARA].filename) {
var filename = res_obj[SR.Tags.PARA].filename;
LOG.warn('allow client to download file: ' + filename, l_name);
var data = res_obj[SR.Tags.PARA].data;
res.writeHead(200, {
'Content-Type': 'application/octet-stream',
'Content-Disposition': 'attachment; filename=' + filename,
'Content-Length': data.length
});
res.end(data);
return true;
}
// check for special case processing (SR_RESOURCE)
if (res_obj[SR.Tags.UPDATE] === 'SR_RESOURCE' && res_obj[SR.Tags.PARA].address) {
var file = res_obj[SR.Tags.PARA].address;
// check if resource exists & its states
SR.fs.stat(file, function (err, stats) {
var resHeader = typeof res_obj[SR.Tags.PARA].header === 'object' ? res_obj[SR.Tags.PARA].header : {};
if (err) {
LOG.error(err, l_name);
res.writeHead(404, resHeader);
res.end();
return;
}
var extFilename = file.match(/[\W\w]*\.([\W\w]*)/)[1];
if (typeof extFilename === 'string')
extFilename = extFilename.toLowerCase();
// default to 200 status
var resStatus = 200;
resHeader['Accept-Ranges'] = 'bytes';
resHeader['Cache-Control'] = 'no-cache';
resHeader['Content-Length'] = stats.size;
if (l_extList[extFilename]) {
resHeader['Content-Type'] = l_extList[extFilename];
};
var start = undefined;
var end = undefined;
// check if request range exists (e.g., streaming media such as webm/mp4) to return 206 status
// see: https://delog.wordpress.com/2011/04/25/stream-webm-file-to-chrome-using-node-js/
if (req.headers.range) {
var range = req.headers.range.split(/bytes=([0-9]*)-([0-9]*)/);
resStatus = 206;
start = parseInt(range[1] || 0);
end = parseInt(range[2] || stats.size - 1);
if (start > end) {
LOG.error('stream file start > end. start: ' + start + ' end: ' + end, l_name);
var resHeader = typeof res_obj[SR.Tags.PARA].header === 'object' ? res_obj[SR.Tags.PARA].header : {};
res.writeHead(404, resHeader);
res.end();
return; // abnormal if we've reached here
}
LOG.debug('requesting bytes ' + start + ' to ' + end + ' for file: ' + file, l_name);
resHeader['Connection'] = 'close';
resHeader['Content-Length'] = end - start + 1;
resHeader['Content-Range'] = 'bytes ' + start + '-' + end + '/' + stats.size;
resHeader['Transfer-Encoding'] = 'chunked';
}
// otherwise assume it's a regular file
else if (l_directExt.hasOwnProperty(extFilename)) {
// NOTE: code below will cause the file be downloaded in a "Save As.." format
// (instead of being displayed directly), we only want this behavior for certain file types (such as .zip)
var filename = file.replace(/^.*[\\\/]/, '')
LOG.warn('requesting a file: ' + filename, l_name);
resHeader['Content-Disposition'] = 'attachment; filename=' + filename;
}
LOG.sys('SR_RESOURCE header:', l_name);
LOG.sys(resHeader);
res.writeHead(resStatus, resHeader);
// start streaming
SR.fs.createReadStream(file, {
flags: 'r',
start: start,
end: end
}).pipe(res);
});
return true;
}
var origin = _getOrigin(req);
// send back via res object if hadn't responded yet
if (res.headersSent === false) {
// NOTE: cookie may be undefined;
SR.REST.reply(res, data, {
origin: origin,
cookie: cookie
});
}
else {
LOG.error('HTTP request has already responded (cannot respond twice)', l_name);
LOG.stack();
}
return true;
}
|
javascript
|
{
"resource": ""
}
|
|
q2806
|
train
|
function() {
var origin = _getOrigin(req);
SR.REST.reply(res, res_str, {
origin: origin
});
}
|
javascript
|
{
"resource": ""
}
|
|
q2807
|
train
|
function (clt_name, op, err, onFail, is_exception) {
var msg = 'DB ' + op + ' error for [' + clt_name + ']';
LOG.error(msg, 'SR.DB');
LOG.error(err, 'SR.DB');
if (typeof err.stack !== 'undefined') {
LOG.error(err.stack, 'SR.DB');
msg += ('\n\n' + err.stack);
}
UTIL.safeCall(onFail, err);
if (is_exception) {
return;
}
// notify project admin if it's not code exception
// NOTE: only project admins are notified
UTIL.notifyAdmin(
'[SR DB error: ' + clt_name + ']',
msg
);
}
|
javascript
|
{
"resource": ""
}
|
|
q2808
|
train
|
function (err_toArray, array) {
if (err_toArray) {
return l_notifyError(clt_name, 'getPage.toArray', err_toArray, cb);
}
//LOG.sys('array found succces, length: ' + array.length, 'SR.DB');
// NOTE: probably no need to check
if (array.length === _opts.limit) {
UTIL.safeCall(cb, null, array, array[array.length - 1]);
} else {
UTIL.safeCall(cb, null, array, null);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q2809
|
nameVersionInstallStrategy
|
train
|
function nameVersionInstallStrategy(baseDir) {
return (name, version) => {
if (!version) {
throw Error('hey I need a version!');
}
// todo - should probably instead instantiate the appropriate library repository
// so we get reuse and consistency
return path.join(baseDir, name+'@'+version);
};
}
|
javascript
|
{
"resource": ""
}
|
q2810
|
train
|
function (type, para) {
// avoid flooding if SR_PUBLISH is sending streaming data
SR.Log('[' + type + '] received');
switch (type) {
//
// pubsub related
//
// when a new published message arrives
case 'SR_MSG':
// handle server-published messages
case 'SR_PUBLISH':
if (onChannelMessages.hasOwnProperty(para.channel)) {
if (typeof onChannelMessages[para.channel] !== 'function')
SR.Error('channel [' + para.channel + '] handler is not a function');
else
onChannelMessages[para.channel](para.msg, para.channel);
}
else
SR.Error('cannot find channel [' + para.channel + '] to publish');
return true;
// when a list of messages arrive (in array)
case 'SR_MSGLIST':
var msg_list = para.msgs;
if (msg_list && msg_list.length > 0 && onChannelMessages.hasOwnProperty(para.channel)) {
for (var i=0; i < msg_list.length; i++)
onChannelMessages[para.channel](msg_list[i], para.channel);
}
return true;
// redirect to another webpage
case 'SR_REDIRECT':
window.location.href = para.url;
return true;
case "SR_NOTIFY" :
SR.Warn('SR_NOTIFY para: ');
SR.Warn(para);
console.log(onChannelMessages);
if (onChannelMessages.hasOwnProperty('notify'))
onChannelMessages['notify'](para, 'notify');
return true;
//
// login related
//
case "SR_LOGIN_RESPONSE":
case "SR_LOGOUT_RESPONSE":
replyLogin(para);
return true;
case "SR_MESSAGE":
alert('SR_MESSAGE: ' + para.msg);
return true;
case "SR_WARNING":
alert('SR_WARNING: ' + para.msg);
return true;
case "SR_ERROR":
alert('SR_ERROR: ' + para.msg);
return true;
default:
// check if custom handlers exist and can handle it
if (responseHandlers.hasOwnProperty(type)) {
var callbacks = responseHandlers[type];
// extract rid if available
var rid = undefined;
if (para.hasOwnProperty('_rid') === true) {
rid = para['_rid'];
delete para['_rid'];
}
if (rid) {
callbacks[rid](para, type);
// remove callback once done
if (rid !== 'keep') {
delete callbacks[rid];
}
}
// otherwise ALL registered callbacks will be called
else {
if (Object.keys(callbacks).length > 1)
SR.Warn('[' + type + '] no rid in update, dispatching to first of ' + Object.keys(callbacks).length + ' callbacks');
// call the first in callbacks then remove it
// so only one callback is called unless it's registered via the 'keep_callback' flag
for (var key in callbacks) {
callbacks[key](para, type);
if (key !== 'keep') {
delete callbacks[key];
break;
}
}
}
return true;
}
// still un-handled
console.error('onResponse: unrecongized type: ' + type);
return false;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q2811
|
train
|
function (entry) {
if (typeof entry === 'number' && entry < entryServers.length) {
entryServers.splice(entry, 1);
return true;
}
else if (typeof entry === 'string') {
for (var i=0; i < entryServers.length; i++) {
if (entryServers[i] === entry) {
entryServers.splice(i, 1);
SR.Log('remove entry: ' + entry + '. entries left: ' + entryServers.length);
return true;
}
}
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
|
q2812
|
train
|
function (name) {
return function (args, onDone) {
if (typeof args === 'function') {
onDone = args;
args = {};
}
console.log('calling API [' + name + ']...');
// NOTE: by default callbacks are always kept
SR.sendEvent(name, args, function (result) {
if (result.err) {
console.error(result.err);
return SR.safeCall(onDone, result.err);
}
SR.safeCall(onDone, null, result.result);
}, undefined, true);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q2813
|
train
|
function (root_path, default_prefix) {
var arr = SR.Settings.SR_PATH.split(SR.path.sep);
var prefix = arr[arr.length-1] + '-';
var dirs = UTIL.getDirectoriesSync(root_path);
if (default_prefix)
prefix = default_prefix;
//LOG.warn('default_prefix: ' + default_prefix + ' prefix: ' + prefix + ' paths to check:');
for (var i in dirs) {
//LOG.warn(dirs[i]);
if (dirs[i].startsWith(prefix)) {
SR.Settings.MOD_PATHS.push(SR.path.resolve(root_path, dirs[i]));
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q2814
|
train
|
function (fullpath, publname) {
var curr_time = new Date();
// store script if modified for first time
if (fullpath !== undefined && publname !== undefined) {
if (l_modified_scripts.hasOwnProperty(fullpath) === false) {
LOG.warn('script modified: ' + fullpath, l_name);
l_modified_scripts[fullpath] = {
time: new Date(curr_time.getTime() + l_reloadTime * 1000),
name: publname
};
}
// if already stored, ignore this request
else
return;
}
else {
// check queue for scripts that can be safely reloaded
for (var path in l_modified_scripts) {
// check if wait time has expired
if (curr_time - l_modified_scripts[path].time > 0) {
// get public name
var name = l_modified_scripts[path].name;
var notify_msg = 'reloading [' + name + '] from: ' + path;
LOG.warn(notify_msg, l_name);
// send e-mail notify to project admin (only if specified)
if (SR.Settings.NOTIFY_SCRIPT_RELOAD === true)
UTIL.notifyAdmin('script reloading', notify_msg);
// save current script in cache as backup
var backup_script = require.cache[path];
// NOTE: if 'path' is incorrect, may not delete successfully, and new script won't load
delete require.cache[path];
// NOTE: this will show false
//LOG.warn('after delete, has path: ' + require.cache.hasOwnProperty(path), l_name);
// NOTE: something can go wrong if the script is corrupt
try {
// re-require
if (l_args.hasOwnProperty(path)) {
LOG.warn('args exist..', l_name);
require(path)(l_args[path]);
l_loaded[name] = require.cache[path];
}
else {
l_loaded[name] = require(path);
SR.Handler.add(l_loaded[name]);
}
}
catch (e) {
LOG.error('reload error: ', l_name);
LOG.error(UTIL.dumpError(e), l_name);
LOG.warn('restoring old script...', l_name);
require.cache[path] = backup_script;
l_loaded[name] = require.cache[path];
// this will show 'true'
//LOG.warn('after restore, has path: ' + require.cache.hasOwnProperty(path), l_name);
}
// remove file record
delete l_modified_scripts[path];
}
}
}
// reload myself to check later if there are scripts to be loaded
if (Object.keys(l_modified_scripts).length > 0) {
var timeout = l_reloadTime * 1.5 * 1000;
LOG.sys('automatic reloading after: ' + timeout + ' ms', l_name);
setTimeout(l_loadScript, timeout);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q2815
|
sma
|
train
|
function sma(arr, range, format) {
if (!Array.isArray(arr)) {
throw TypeError('expected first argument to be an array');
}
var fn = typeof format === 'function' ? format : toFixed;
var num = range || arr.length;
var res = [];
var len = arr.length + 1;
var idx = num - 1;
while (++idx < len) {
res.push(fn(avg(arr, idx, num)));
}
return res;
}
|
javascript
|
{
"resource": ""
}
|
q2816
|
avg
|
train
|
function avg(arr, idx, range) {
return sum(arr.slice(idx - range, idx)) / range;
}
|
javascript
|
{
"resource": ""
}
|
q2817
|
sum
|
train
|
function sum(arr) {
var len = arr.length;
var num = 0;
while (len--) num += Number(arr[len]);
return num;
}
|
javascript
|
{
"resource": ""
}
|
q2818
|
isSpecial
|
train
|
function isSpecial(key) {
if (key.length > 1) {
return !!exports.specialKeys.filter(function (specialKey) {
var pattern = new RegExp("^(" + specialKey + ")(:(\\d+(\\.\\d+)?))?$", 'g');
return pattern.test(key);
}).length;
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
q2819
|
keyboardCapsLockLayout
|
train
|
function keyboardCapsLockLayout(layout, caps) {
return layout.map(function (row) {
return row.map(function (key) {
return isSpecial(key) ? key : (caps ? key.toUpperCase() : key.toLowerCase());
});
});
}
|
javascript
|
{
"resource": ""
}
|
q2820
|
TransactionTask
|
train
|
function TransactionTask(readOnly, txnCallback, errorCallback, successCallback) {
this.readOnly = readOnly;
this.txnCallback = txnCallback;
this.errorCallback = errorCallback;
this.successCallback = successCallback;
}
|
javascript
|
{
"resource": ""
}
|
q2821
|
renameKey
|
train
|
function renameKey(obj, prevKey, nextKey) {
return mapKeys(obj, (_, key) => (key === prevKey ? nextKey : key))
}
|
javascript
|
{
"resource": ""
}
|
q2822
|
openModal
|
train
|
function openModal(src, width) {
if ( !width ) width = 680;
//var elementId = 'orcodio';
var originalYScroll = window.pageYOffset;
//var modalFrame = $.modal('<iframe id="'+ elementId +'" src="' + src + '" width="' + width + '" onload="centerModal(this,' + originalYScroll + ')" style="border:0">', {
var modalFrame = $.modal('<iframe src="' + src + '" width="' + width + '" onload="centerModal(this,' + originalYScroll + ')" style="border:0">', {
closeHTML:'',
containerCss:{
backgroundColor:"#fff",
borderColor:"#fff",
width:width,
padding:0,
margin:0
},
overlayClose:true,
autoPosition:false,
modal:true,
opacity:70
});
}
|
javascript
|
{
"resource": ""
}
|
q2823
|
selectTab
|
train
|
function selectTab(tab,content) {
//deseleziono tutti i tab
$('#'+tab).parent().children().removeClass('tabButtonSelected');
//seleziono il tab cliccato
$('#'+tab).addClass('tabButtonSelected');
//nascondo tutti i content
$('#'+content).parent().children().fadeOut('fast');
//seleziono il tab cliccato
$('#'+content).delay(200).fadeIn('fast');
}
|
javascript
|
{
"resource": ""
}
|
q2824
|
train
|
function( data ) {
var ret = {
coverage: 0,
hits: 0,
misses: 0,
sloc: 0
};
for (var i = 0; i < data.source.length; i++) {
var line = data.source[i];
var num = i + 1;
if (data[num] === 0) {
ret.misses++;
ret.sloc++;
} else if (data[num] !== undefined) {
ret.hits++;
ret.sloc++;
}
}
ret.coverage = ret.hits / ret.sloc * 100;
return [ret.hits,ret.sloc];
}
|
javascript
|
{
"resource": ""
}
|
|
q2825
|
train
|
function(cov){
cov = window._$blanket;
var sortedFileNames = [];
var totals =[];
for (var filename in cov) {
if (cov.hasOwnProperty(filename)) {
sortedFileNames.push(filename);
}
}
sortedFileNames.sort();
for (var i = 0; i < sortedFileNames.length; i++) {
var thisFile = sortedFileNames[i];
var data = cov[thisFile];
var thisTotal= reportFile( data );
sendMessage("blanket:fileDone", thisTotal, thisFile);
}
sendMessage("blanket:done");
}
|
javascript
|
{
"resource": ""
}
|
|
q2826
|
extractLiterals
|
train
|
function extractLiterals(stats, args) {
if (stats.getType() != null && (stats.getType() === "installed" || stats.getType() === "builtin")) {
extractLiteralFromInstalled(stats, args);
}
if (stats.getType() != null && stats.getType() === "def") {
extractLiteralFromDef(stats, args[0]);
}
if (stats.getType() != null && (stats.getType() === "main" || stats.getType() === "remap")) {
extractLiteralFromMain(stats, args[0]);
}
}
|
javascript
|
{
"resource": ""
}
|
q2827
|
train
|
function () {
if(this.is_focused()) { return; }
var f = $.jstree._focused();
if(f) { f.unset_focus(); }
this.get_container().addClass("jstree-focused");
focused_instance = this.get_index();
this.__callback();
}
|
javascript
|
{
"resource": ""
}
|
|
q2828
|
triggerEvent
|
train
|
function triggerEvent(el, type, options) {
if (isString(el)) {
options = type;
type = el;
el = document;
}
var e = createEvent(type, options);
el.dispatchEvent
? el.dispatchEvent(e)
: el.fireEvent('on' + type, e);
}
|
javascript
|
{
"resource": ""
}
|
q2829
|
WrapperError
|
train
|
function WrapperError(message, innerError) {
// supports instantiating the object without the new keyword
if (!(this instanceof WrapperError)) {
return new WrapperError(message, innerError);
}
Error.call(this);
Error.captureStackTrace(this, WrapperError);
this.message = message;
this.innerError = innerError;
}
|
javascript
|
{
"resource": ""
}
|
q2830
|
formatError
|
train
|
function formatError(error, stack) {
if (origPrepareStackTrace) {
return origPrepareStackTrace(error, stack);
}
return [
error.toString(),
stack
.map(function (frame) {
return 'at ' + frame.toString();
})
.map(padLeft)
.join('\n')
].join('\n');
}
|
javascript
|
{
"resource": ""
}
|
q2831
|
isQuantifierNext
|
train
|
function isQuantifierNext(pattern, pos, flags) {
return nativ.test.call(
flags.indexOf('x') > -1 ?
// Ignore any leading whitespace, line comments, and inline comments
/^(?:\s+|#.*|\(\?#[^)]*\))*(?:[?*+]|{\d+(?:,\d*)?})/ :
// Ignore any leading inline comments
/^(?:\(\?#[^)]*\))*(?:[?*+]|{\d+(?:,\d*)?})/,
pattern.slice(pos)
);
}
|
javascript
|
{
"resource": ""
}
|
q2832
|
prepareOptions
|
train
|
function prepareOptions(value) {
var options = {};
if (isType(value, 'String')) {
XRegExp.forEach(value, /[^\s,]+/, function(match) {
options[match] = true;
});
return options;
}
return value;
}
|
javascript
|
{
"resource": ""
}
|
q2833
|
parser
|
train
|
function parser (inputs, output, plugins, cb) {
var data = {
charset: 'UTF-8',
headers: DEFAULT_HEADERS,
translations: {
context: {}
}
}
var defaultContext = data.translations.context
var headers = data.headers
headers['plural-forms'] = headers['plural-forms'] || DEFAULT_HEADERS['plural-forms']
headers['content-type'] = headers['content-type'] || DEFAULT_HEADERS['content-type']
var nplurals = /nplurals ?= ?(\d)/.exec(headers['plural-forms'])[1]
inputs
.forEach(function (file) {
var resolvedFilePath = path.join(process.cwd(), file)
var src = fs.readFileSync(resolvedFilePath, 'utf8')
try {
var ast = babelParser.parse(src, {
sourceType: 'module',
plugins: ['jsx'].concat(plugins)
})
} catch (e) {
console.error(`SyntaxError in ${file} (line: ${e.loc.line}, column: ${e.loc.column})`)
process.exit(1)
}
walk.simple(ast.program, {
CallExpression: function (node) {
if (functionNames.hasOwnProperty(node.callee.name) ||
node.callee.property && functionNames.hasOwnProperty(node.callee.property.name)) {
var functionName = functionNames[node.callee.name] || functionNames[node.callee.property.name]
var translate = {}
var args = node.arguments
for (var i = 0, l = args.length; i < l; i++) {
var name = functionName[i]
if (name && name !== 'count' && name !== 'domain') {
var arg = args[i]
var value = arg.value
if (value) {
var line = node.loc.start.line
translate[name] = value
translate['comments'] = {
reference: file + ':' + line
}
}
if (name === 'msgid_plural') {
translate.msgstr = []
for (var p = 0; p < nplurals; p++) {
translate.msgstr[p] = ''
}
}
}
}
var context = defaultContext
var msgctxt = translate.msgctxt
if (msgctxt) {
data.translations[msgctxt] = data.translations[msgctxt] || {}
context = data.translations[msgctxt]
}
context[translate.msgid] = translate
}
}
})
})
fs.writeFile(output, gettextParser.po.compile(data), function (err) {
if (err) {
cb(err)
}
cb(null)
})
}
|
javascript
|
{
"resource": ""
}
|
q2834
|
Storage
|
train
|
function Storage(mongoURI, mongoOptions, storageOptions) {
if (!(this instanceof Storage)) {
return new Storage(mongoURI, mongoOptions, storageOptions);
}
assert(typeof mongoOptions === 'object', 'Invalid mongo options supplied');
this._uri = mongoURI;
this._options = mongoOptions;
const defaultLogger = {
info: console.log,
debug: console.log,
error: console.error,
warn: console.warn
};
this._log = defaultLogger;
if (storageOptions && storageOptions.logger) {
this._log = storageOptions.logger;
}
// connect to the database
this._connect();
}
|
javascript
|
{
"resource": ""
}
|
q2835
|
addPointToDomain
|
train
|
function addPointToDomain( point, x, y, domainId ){
var domain = domains[ domainId ];
var newPoint = {
value: point,
x: x,
y: y,
identifier: domain.identifier,
domainId: domainId
};
pointsHash[ x + '_' + y ] = {
value: point,
identifier: domain.identifier,
domainId: domainId
};
domain.points.push( newPoint );
}
|
javascript
|
{
"resource": ""
}
|
q2836
|
train
|
function(dir) {
var results = [];
var list = fs.readdirSync(dir);
list.forEach(function(file) {
// Check for every given pattern, regardless of whether it is an array or a string
var matchesSomeExclude = [].concat(options.exclude).some(function(regexp) {
return file.match(regexp) != null;
});
if(!matchesSomeExclude) {
var matchesSomePattern = [].concat(options.match).some(function(regexp) {
return file.match(regexp) != null;
});
file = path.resolve(dir, file);
var stat = fs.statSync(file);
if (stat && stat.isDirectory()) {
if(matchesSomePattern) {
results = results.concat(file);
}
results = results.concat(walk(file));
}
}
});
return results;
}
|
javascript
|
{
"resource": ""
}
|
|
q2837
|
die
|
train
|
function die(reason = "", error = null, exitCode = 0){
reason = (reason || "").trim();
// ANSI escape sequences (disabled if output is redirected)
const [reset,, underline,, noUnderline, red] = process.stderr.isTTY
? [0, 1, 4, 22, 24, [31, 9, 38]].map(s => `\x1B[${ Array.isArray(s) ? s.join(";") : s}m`)
: Array.of("", 40);
if(error){
const {inspect} = require("util");
process.stderr.write(red + inspect(error) + reset + "\n\n");
}
// Underline all occurrences of target-file's name
const target = underline + file + noUnderline;
// "Not found" -> "package.json not found"
if(reason && !reason.match(file))
reason = (file + " ")
+ reason[0].toLowerCase()
+ reason.substr(1);
// Pedantic polishes
reason = reason
.replace(/(?:\r\n|\s)+/g, " ")
.replace(/^\s+|[.!]*\s*$/g, "")
.replace(/^(?!\.$)/, ": ")
.replace(file, target);
const output = `${red}Unable to finish installing Atom-Mocha${reason}${reset}
The following field must be added to your project's ${target} file:
"${key}": "${value}"
See ${underline}README.md${reset} for setup instructions.
`.replace(/^\t/gm, "");
process.stderr.write(output);
process.exit(exitCode);
}
|
javascript
|
{
"resource": ""
}
|
q2838
|
read
|
train
|
function read(filePath, options){
return new Promise((resolve, reject) => {
fs.readFile(filePath, options, (error, data) => {
error
? reject(error)
: resolve(data.toString());
});
});
}
|
javascript
|
{
"resource": ""
}
|
q2839
|
write
|
train
|
function write(filePath, fileData, options){
return new Promise((resolve, reject) => {
fs.writeFile(filePath, fileData, options, error => {
error
? reject(error)
: resolve(fileData);
});
});
}
|
javascript
|
{
"resource": ""
}
|
q2840
|
combineErrors
|
train
|
function combineErrors(errPrev, errNew) {
if (!errPrev) {
return errNew;
}
let errCombined;
if (errPrev instanceof AggregateError) {
errCombined = errPrev;
} else {
errCombined = new AggregateError();
errCombined.push(errPrev);
}
errCombined.push(errNew);
return errCombined;
}
|
javascript
|
{
"resource": ""
}
|
q2841
|
addToChai
|
train
|
function addToChai(names, fn){
for(const name of names)
Chai.Assertion.addMethod(name, fn);
}
|
javascript
|
{
"resource": ""
}
|
q2842
|
FieldReference
|
train
|
function FieldReference(typeFunction, fieldOptions = {}) {
return function (target, key) {
let fieldType = Reflect.getMetadata("design:type", target, key);
let schema = MongoSchemaRegistry_1.MongoSchemaRegistry.getSchema(target.constructor.name);
if (!schema) {
schema = new MongoSchema_1.MongoSchema(target.constructor);
MongoSchemaRegistry_1.MongoSchemaRegistry.register(target.constructor.name, schema);
}
if (!typeFunction) {
typeFunction = type => {
return fieldOptions.type || Reflect.getMetadata("design:type", target, key).name;
};
}
fieldOptions.foreignField = fieldOptions.foreignField || "_id";
if (!fieldType || fieldType.name != "Array") {
fieldOptions.relationType = MongoSchema_1.ERelationType.SingleObjectId;
}
if (fieldType && fieldType.name == "Array") {
fieldOptions.relationType = MongoSchema_1.ERelationType.ArrayObjectId;
}
schema.addField(key, typeFunction, fieldOptions);
};
}
|
javascript
|
{
"resource": ""
}
|
q2843
|
getNumTargets
|
train
|
function getNumTargets() {
if (numTargets) {
return numTargets
}
var targets = grunt.config('npmcopy')
if (targets) {
delete targets.options
numTargets = Object.keys(targets).length
}
return numTargets
}
|
javascript
|
{
"resource": ""
}
|
q2844
|
convert
|
train
|
function convert(files) {
var converted = []
files.forEach(function(file) {
// We need originals as the destinations may not yet exist
file = file.orig
var dest = file.dest
// Use destination for source if no source is available
if (!file.src.length) {
converted.push({
src: dest,
dest: dest
})
return
}
file.src.forEach(function(source) {
converted.push({
src: source,
dest: dest
})
})
})
return converted
}
|
javascript
|
{
"resource": ""
}
|
q2845
|
filterRepresented
|
train
|
function filterRepresented(modules, files, options) {
return _.filter(modules, function(module) {
return !_.some(files, function(file) {
// Look for the module name somewhere in the source path
return (
path
.join(sep, options.srcPrefix, file.src.replace(rmain, '$1'), sep)
.indexOf(sep + module + sep) > -1
)
})
})
}
|
javascript
|
{
"resource": ""
}
|
q2846
|
ensure
|
train
|
function ensure(files, options) {
// Update the global array of represented modules
unused = filterRepresented(unused, files, options)
verbose.writeln('Unrepresented modules list currently at ', unused)
// Only print message when all targets have been run
if (++numRuns === getNumTargets()) {
if (unused.length) {
if (options.report) {
log.writeln('\nPackages left out:')
log.writeln(unused.join('\n'))
}
} else if (options.report) {
log.ok('All modules have something copied.')
}
}
}
|
javascript
|
{
"resource": ""
}
|
q2847
|
convertMatches
|
train
|
function convertMatches(files, options, dest) {
return files.map(function(source) {
return {
src: source,
dest: path.join(
// Build a destination from the new source if no dest
// was specified
dest != null ? dest : path.dirname(source).replace(options.srcPrefix + sep, ''),
path.basename(source)
)
}
})
}
|
javascript
|
{
"resource": ""
}
|
q2848
|
getMain
|
train
|
function getMain(src, options, dest) {
var meta = grunt.file.readJSON(path.join(src, 'package.json'))
if (!meta.main) {
fail.fatal(
'No main property specified by ' + path.normalize(src.replace(options.srcPrefix, ''))
)
}
var files = typeof meta.main === 'string' ? [meta.main] : meta.main
return files.map(function(source) {
return {
src: path.join(src, source),
dest: dest
}
})
}
|
javascript
|
{
"resource": ""
}
|
q2849
|
readStrucPerm
|
train
|
function readStrucPerm(on, req, res, next) {
//console.log('readStrucPerm: req.session.user_id = ' + req.session.user_id);
//solo nel caso di favicon.ico non ha le session impostate, non so perchè,
//quindi bypasso il controllo, perchè su favicon non ho nessuna restrizione
if ( !req.session )
{
next();
}
else
{
//azzero i permessi
req.session.loggedIn = false;
req.session.canCreate = false;
req.session.canModify = false;
req.session.canModifyMyself = false; //questo è un permesso che vale solo per l'elemento "users"
//controllo se sono loggato
if (req.session.user_id) {
//l'utente risulta loggato
//controllo se i suoi dati di login sono validi
//(questo controllo va fatto ogni volta, perchè se dall'ultimo conrollo l'utente fosse stato cancellato, non me ne accorgerei senza controllo
req.app.jsl.sess.checkValidUser(req, function(result, user_id) {
if ( result )
{
//i dati di login sono validi
req.session.loggedIn = true;
if ( user_id == 'superadmin' )
{
//se sono super admin, ho sempre permesso di modify su tutti i contenuti, ma non ho il create (a parte sugli users)
//questo perchè quando si crea un contenuto, questo è strettamente legato all'utente che lo crea, e il superadmin
//non è un utente vero è proprio (non è presente nel db, non ha id). il super admin serve solo per poter vedere e modificare tutto, ma non può creare nulla
req.session.canModify = true;
req.session.canModifyMyself = true; //questo serve per permettere al super admin di modificare gli utenti (il form di modifica lo richiede)
//solo nel caso degli users, il superadmin ha il create, anche se usersCanRegister = false
if ( on == 'user' )
{
req.session.canCreate = true;
}
//la request puo essere processata
next();
}
else
{
//non sono superadmin
//siccome si tratta di permessi su elementi della struttura, chiunque (loggato) ha sempre il permesso di create nuovi elementi
//(tranne per il caso degli "user" in cui si creano altri utenti con il bottone "registrati", che però non prevede di essere loggati)
if ( on != 'user' )
{
req.session.canCreate = true;
}
//differenzio i permessi di modify in base all'oggetto trattato
switch (on)
{
case 'user':
//user è un elemento della struttura particolare, perchè, a differenza di tutti gli altri elementi di struttura, ogni utente può solo modificare
//se stesso. inoltre user non ha un "author" poichè un utente è creato da se stesso tramite il bottone "register"
//nel caso di modifica di users, ho modify solo per modificare me stesso
if ( req.params.id == req.session.user_id ) //controllo se l'id dell'utente da modificare è quello dell'utente loggato, cioè se modifico me stesso
{
//lo user id nella route richiesta corrisponde al mio, quindi posso modificare me stesso (il mio profilo)
req.session.canModifyMyself = true;
}
break;
default:
//ora come ora per tutti gli altri elementi della struttura chiunque ha permesso di modify, ma solo sui propri elementi
req.session.canModify = true;
break;
}
//continuo
next();
}
}
else
{
//i dati di login non sono validi
//console.log('readStrucPerm: login NON valido');
//forzo un logout (potrebbe verificarsi il caso in cui un utente è loggato, e viene cancellato dal db. in quel caso deve avvenire anche il suo logout)
setSignedOut(req);
//vengo mandato in home
res.redirect('/');
}
});
} else {
//console.log('readStrucPerm: utente non loggato');
//non sono loggato. l'unica cosa che posso fare è di registrarmi, ovvero creare un nuovo user
//ma solo se è stato previsto nel config
if ( on == 'user' && req.app.jsl.config.usersCanRegister )
{
req.session.canCreate = true;
}
//non ho nessun permesso, continuo
next();
}
}
}
|
javascript
|
{
"resource": ""
}
|
q2850
|
getFileDetails
|
train
|
function getFileDetails(db, fileSelectionCriteria, fileOptions, cb) {
defaultLogger.debug("In getFileDetails ");
var selectionQuery = undefined;
if (fileSelectionCriteria.groupId) {
selectionQuery= {"metadata.groupId": fileSelectionCriteria.groupId};
} else if (fileSelectionCriteria.hash) {
selectionQuery= {"md5": fileSelectionCriteria.hash};
}
var gridStore = new GridStore(db, null, "r", {"root": constants.ROOT_COLLECTION});
var fileOfInterest = undefined;
gridStore.collection(function(err, collection) {
collection.find(selectionQuery, { "sort": {"metadata.version":-1}}, function(err, files) {
if (err) {
defaultLogger.error(err); return cb(err);
}
files.toArray(function(err, filesArray) {
if (err) {
defaultLogger.error(err); return cb(err);
}
if (!(filesArray && Array.isArray(filesArray) && filesArray.length > 0)) {
return cb(new Error("No files exist for groupId " + fileSelectionCriteria.groupId));
}
//If the file details are needed for all files in the groupId, then an array containing all of the file details is returned.
if (fileOptions.allMatchingFiles == true) { // eslint-disable-line eqeqeq
fileOfInterest = filesArray;
} else {// Just want the details of a single file.
//If there is no version, get the latest version
//If no version is found or we have a hash query, just want the first entry of the array.
if (!fileSelectionCriteria.version || fileSelectionCriteria.hash) {
fileOfInterest = filesArray[0];
} else {
fileOfInterest = filesArray.filter(function(file) {
return file.metadata.version === fileSelectionCriteria.version;
});
if (fileOfInterest.length === 1) {
fileOfInterest = fileOfInterest[0];
} else {
return cb(new Error("Unexpected number of files returned for groupId " + fileSelectionCriteria.groupId, fileOfInterest.length));
}
}
}
if (!Array.isArray(fileOfInterest)) {
//Actually want the thumbnail for the file, return the details for that file instead.
if (fileOptions.thumbnail) {
if (fileOfInterest.metadata.thumbnail) {
getThumbnailFileDetails(db, fileOfInterest.metadata.thumbnail, function(err, thumbFileDetails) {
if (err) {
defaultLogger.error(err); return cb(err);
}
fileOfInterest = thumbFileDetails;
gridStore.close(function(err) {
return cb(err, fileOfInterest);
});
});
} else {
return cb(new Error("Thumbnail for file " + JSON.stringify(fileSelectionCriteria) + " does not exist."));
}
} else {
gridStore.close(function(err) {
return cb(err, fileOfInterest);
});
}
} else {
gridStore.close(function(err) {
return cb(err, fileOfInterest);
});
}
});
});
});
}
|
javascript
|
{
"resource": ""
}
|
q2851
|
updateExistingFile
|
train
|
function updateExistingFile(db, fileName, fileReadStream, options, cb) {
defaultLogger.debug("In updateExistingFile");
getFileDetails(db, {"groupId": options.groupId}, {}, function(err, fileInfo) {
if (err) {
defaultLogger.error(err); return cb(err);
}
var latestFileVersion = fileInfo.metadata.version;
incrementFileVersion(latestFileVersion, function(newFileVersion) {
if (!newFileVersion) {
return cb(new Error("File version was not incremented for file " + fileName));
}
defaultLogger.debug("New File Version ", newFileVersion);
createFileWithVersion(db, fileName, fileReadStream, newFileVersion, options, cb);
});
});
}
|
javascript
|
{
"resource": ""
}
|
q2852
|
createNewFile
|
train
|
function createNewFile(db, fileName, fileReadStream, options, cb) {
defaultLogger.debug("In createNewFile");
createFileWithVersion(db, fileName, fileReadStream, constants.LOWEST_VERSION, options, cb);
}
|
javascript
|
{
"resource": ""
}
|
q2853
|
errorSerializer
|
train
|
function errorSerializer (err) {
if (!err || !err.stack) return err
const obj = {
message: err.message,
name: err.name,
code: err.code,
stack: getErrorStack(err)
}
return obj
}
|
javascript
|
{
"resource": ""
}
|
q2854
|
getCleanUrl
|
train
|
function getCleanUrl (url) {
try {
const parsed = new URL(url)
return parsed.pathname || url
} catch (err) {
return url
}
}
|
javascript
|
{
"resource": ""
}
|
q2855
|
train
|
function(str, index) {
// replace {{ xxx }}
var obj = this
str = str.replace(interpolateReg, function(match, interpolate) {
try {
/*jslint evil: true */
var funcNames = ['','index'].concat(fakerFuncNames).concat(['return ' + interpolate + ';']),
func = new (Function.prototype.bind.apply(Function, funcNames)),
funcs = [function(){return index}].concat(fakerFuncs);
return func.apply(obj, funcs);
} catch(e) {
return e.message;
}
});
// if result is true or false, parse it to boolean
if(/^(true|false)$/.test(str)) {
str = str === 'true';
}
// if result is digit, parse it to float
if(/^[-+]?\d*\.?\d+$/.test(str)) {
str = parseFloat(str);
}
return str;
}
|
javascript
|
{
"resource": ""
}
|
|
q2856
|
train
|
function(obj, index) {
var funcKey = [];
for(var key in obj) {
if(obj.hasOwnProperty(key)) {
// If this is a function, generate it later.
if(typeof obj[key] === 'function') {
funcKey.push(key);
continue;
}
obj[key] = generate.call(obj, obj[key], index);
}
}
// parse function
funcKey.forEach(function(key) {
obj[key] = generate.call(obj, obj[key], index);
});
return obj;
}
|
javascript
|
{
"resource": ""
}
|
|
q2857
|
save
|
train
|
function save(template, distpath) {
var data = generate(template);
var dir = path.dirname(distpath);
mkdirp(dir, function(err) {
if(err) {
console.log(err.message);
return;
}
fs.writeFile(distpath, JSON.stringify(data, null, 2), function(err) {
if(err) {
console.log(err.message);
return;
}
});
});
}
|
javascript
|
{
"resource": ""
}
|
q2858
|
setConversationEtagHeader
|
train
|
function setConversationEtagHeader(res, conversationInfo) {
var copy = JSON.parse(JSON.stringify(conversationInfo));
delete copy.participants;
delete copy.createdOn;
delete copy.updatedOn;
setEtagHeader(res, copy);
}
|
javascript
|
{
"resource": ""
}
|
q2859
|
translate
|
train
|
function translate(singular, plural) {
if (!locales[currentLocale]) {
read(currentLocale);
}
if (plural) {
if (!locales[currentLocale][singular]) {
locales[currentLocale][singular] = {
'one': singular,
'other': plural
};
write(currentLocale);
}
}
if (!locales[currentLocale][singular]) {
locales[currentLocale][singular] = singular;
write(currentLocale);
}
return locales[currentLocale][singular];
}
|
javascript
|
{
"resource": ""
}
|
q2860
|
read
|
train
|
function read(myLocale) {
locales[myLocale] = {};
try {
locales[myLocale] = JSON.parse(fs.readFileSync(locate(myLocale)));
} catch(e) {
console.log('initializing ' + locate(myLocale));
write(myLocale);
}
}
|
javascript
|
{
"resource": ""
}
|
q2861
|
write
|
train
|
function write(myLocale) {
try {
stats = fs.lstatSync(directory);
} catch(e) {
fs.mkdirSync(directory, 0755);
}
fs.writeFile(locate(myLocale), JSON.stringify(locales[myLocale], null, "\t"));
}
|
javascript
|
{
"resource": ""
}
|
q2862
|
guessLanguage
|
train
|
function guessLanguage(request){
//console.log("guessLanguage");
if(typeof request === 'object'){
var language_header = request.headers['accept-language'],
languages = [];
regions = [];
request.languages = [currentLocale];
/*
for (x in request.languages)
{
console.log(request.languages[x] + x);
}
*/
request.regions = [currentLocale];
request.language = currentLocale;
request.region = currentLocale;
if (language_header) {
language_header.split(',').forEach(function(l) {
header = l.split(';', 1)[0];
lr = header.split('-', 2);
if (lr[0]) {
languages.push(lr[0].toLowerCase());
}
if (lr[1]) {
regions.push(lr[1].toLowerCase());
}
});
if (languages.length > 0) {
request.languages = languages;
request.language = languages[0];
}
if (regions.length > 0) {
request.regions = regions;
request.region = regions[0];
}
}
i18n.setLocale(request.language);
}
}
|
javascript
|
{
"resource": ""
}
|
q2863
|
train
|
function(connect, options) {
return [
require('connect-livereload')(),
// Default middlewares
// Serve static files.
connect.static(options.base),
// Make empty directories browsable.
connect.directory(options.base)
];
}
|
javascript
|
{
"resource": ""
}
|
|
q2864
|
fireCallback
|
train
|
function fireCallback(callbackName) {
var data = [], len = arguments.length - 1;
while ( len-- > 0 ) data[ len ] = arguments[ len + 1 ];
/*
Callbacks:
beforeCreate (options),
beforeOpen (xhr, options),
beforeSend (xhr, options),
error (xhr, status),
complete (xhr, stautus),
success (response, status, xhr),
statusCode ()
*/
var globalCallbackValue;
var optionCallbackValue;
if (globals[callbackName]) {
globalCallbackValue = globals[callbackName].apply(globals, data);
}
if (options[callbackName]) {
optionCallbackValue = options[callbackName].apply(options, data);
}
if (typeof globalCallbackValue !== 'boolean') { globalCallbackValue = true; }
if (typeof optionCallbackValue !== 'boolean') { optionCallbackValue = true; }
return (globalCallbackValue && optionCallbackValue);
}
|
javascript
|
{
"resource": ""
}
|
q2865
|
onTabLoaded
|
train
|
function onTabLoaded(contentEl) {
// Remove theme elements
router.removeThemeElements($newTabEl);
var tabEventTarget = $newTabEl;
if (typeof contentEl !== 'string') { tabEventTarget = $(contentEl); }
tabEventTarget.trigger('tab:init tab:mounted', tabRoute);
router.emit('tabInit tabMounted', $newTabEl[0], tabRoute);
if ($oldTabEl && $oldTabEl.length) {
if (animated) {
onTabsChanged(function () {
router.emit('routeChanged', router.currentRoute, router.previousRoute, router);
if (router.params.unloadTabContent) {
router.tabRemove($oldTabEl, $newTabEl, tabRoute);
}
});
} else {
router.emit('routeChanged', router.currentRoute, router.previousRoute, router);
if (router.params.unloadTabContent) {
router.tabRemove($oldTabEl, $newTabEl, tabRoute);
}
}
}
}
|
javascript
|
{
"resource": ""
}
|
q2866
|
loadTab
|
train
|
function loadTab(loadTabParams, loadTabOptions) {
// Load Tab Props
var url = loadTabParams.url;
var content = loadTabParams.content;
var el = loadTabParams.el;
var template = loadTabParams.template;
var templateUrl = loadTabParams.templateUrl;
var component = loadTabParams.component;
var componentUrl = loadTabParams.componentUrl;
// Component/Template Callbacks
function resolve(contentEl) {
router.allowPageChange = true;
if (!contentEl) { return; }
if (typeof contentEl === 'string') {
$newTabEl.html(contentEl);
} else {
$newTabEl.html('');
if (contentEl.f7Component) {
contentEl.f7Component.$mount(function (componentEl) {
$newTabEl.append(componentEl);
});
} else {
$newTabEl.append(contentEl);
}
}
$newTabEl[0].f7RouterTabLoaded = true;
onTabLoaded(contentEl);
}
function reject() {
router.allowPageChange = true;
return router;
}
if (content) {
resolve(content);
} else if (template || templateUrl) {
try {
router.tabTemplateLoader(template, templateUrl, loadTabOptions, resolve, reject);
} catch (err) {
router.allowPageChange = true;
throw err;
}
} else if (el) {
resolve(el);
} else if (component || componentUrl) {
// Load from component (F7/Vue/React/...)
try {
router.tabComponentLoader($newTabEl[0], component, componentUrl, loadTabOptions, resolve, reject);
} catch (err) {
router.allowPageChange = true;
throw err;
}
} else if (url) {
// Load using XHR
if (router.xhr) {
router.xhr.abort();
router.xhr = false;
}
router.xhrRequest(url, loadTabOptions)
.then(function (tabContent) {
resolve(tabContent);
})
.catch(function () {
router.allowPageChange = true;
});
}
}
|
javascript
|
{
"resource": ""
}
|
q2867
|
loadModal
|
train
|
function loadModal(loadModalParams, loadModalOptions) {
// Load Modal Props
var url = loadModalParams.url;
var content = loadModalParams.content;
var template = loadModalParams.template;
var templateUrl = loadModalParams.templateUrl;
var component = loadModalParams.component;
var componentUrl = loadModalParams.componentUrl;
// Component/Template Callbacks
function resolve(contentEl) {
if (contentEl) {
if (typeof contentEl === 'string') {
modalParams.content = contentEl;
} else if (contentEl.f7Component) {
contentEl.f7Component.$mount(function (componentEl) {
modalParams.el = componentEl;
app.root.append(componentEl);
});
} else {
modalParams.el = contentEl;
}
onModalLoaded();
}
}
function reject() {
router.allowPageChange = true;
return router;
}
if (content) {
resolve(content);
} else if (template || templateUrl) {
try {
router.modalTemplateLoader(template, templateUrl, loadModalOptions, resolve, reject);
} catch (err) {
router.allowPageChange = true;
throw err;
}
} else if (component || componentUrl) {
// Load from component (F7/Vue/React/...)
try {
router.modalComponentLoader(app.root[0], component, componentUrl, loadModalOptions, resolve, reject);
} catch (err) {
router.allowPageChange = true;
throw err;
}
} else if (url) {
// Load using XHR
if (router.xhr) {
router.xhr.abort();
router.xhr = false;
}
router.xhrRequest(url, loadModalOptions)
.then(function (modalContent) {
modalParams.content = modalContent;
onModalLoaded();
})
.catch(function () {
router.allowPageChange = true;
});
} else {
onModalLoaded();
}
}
|
javascript
|
{
"resource": ""
}
|
q2868
|
isEmpty
|
train
|
function isEmpty(value) {
if (value === null) {
return true;
}
var type = typeof(value);
switch (type) {
case 'undefined':
return true;
case 'number':
return isNaN(value);
case 'string':
return value.trim() === '';
case 'object':
var countKeys = Object.keys(value).length;
return countKeys < 1;
case 'function':
case 'boolean':
return false;
default:
console.log('Unknown value type: "' + type + '"', 'isEmpty.js');
return false;
}
}
|
javascript
|
{
"resource": ""
}
|
q2869
|
_encodeBlob
|
train
|
function _encodeBlob(blob) {
return new Promise$1(function (resolve, reject) {
var reader = new FileReader();
reader.onerror = reject;
reader.onloadend = function (e) {
var base64 = btoa(e.target.result || '');
resolve({
__local_forage_encoded_blob: true,
data: base64,
type: blob.type
});
};
reader.readAsBinaryString(blob);
});
}
|
javascript
|
{
"resource": ""
}
|
q2870
|
checkIfLocalStorageThrows
|
train
|
function checkIfLocalStorageThrows() {
var localStorageTestKey = '_localforage_support_test';
try {
localStorage.setItem(localStorageTestKey, true);
localStorage.removeItem(localStorageTestKey);
return false;
} catch (e) {
return true;
}
}
|
javascript
|
{
"resource": ""
}
|
q2871
|
uniqueArray
|
train
|
function uniqueArray(arr) {
var result = [];
for (var i = 0; i < arr.length; i++) {
if (result.indexOf(arr[i]) === -1) {
result.push(arr[i]);
}
}
return result;
}
|
javascript
|
{
"resource": ""
}
|
q2872
|
warnOnce
|
train
|
function warnOnce(message) {
if (!(previousWarnOnceMessages.indexOf(message) !== -1)) {
previousWarnOnceMessages.push(message);
warn(message);
}
}
|
javascript
|
{
"resource": ""
}
|
q2873
|
adaptInputValidator
|
train
|
function adaptInputValidator(legacyValidator) {
return function adaptedInputValidator(inputValue, extraParams) {
return legacyValidator.call(this, inputValue, extraParams).then(function () {
return undefined;
}, function (validationMessage) {
return validationMessage;
});
};
}
|
javascript
|
{
"resource": ""
}
|
q2874
|
showWarningsForParams
|
train
|
function showWarningsForParams(params) {
for (var param in params) {
if (!isValidParameter(param)) {
warn("Unknown parameter \"".concat(param, "\""));
}
if (params.toast && toastIncompatibleParams.indexOf(param) !== -1) {
warn("The parameter \"".concat(param, "\" is incompatible with toasts"));
}
if (isDeprecatedParameter(param)) {
warnOnce("The parameter \"".concat(param, "\" is deprecated and will be removed in the next major release."));
}
}
}
|
javascript
|
{
"resource": ""
}
|
q2875
|
mixin
|
train
|
function mixin(mixinParams) {
return withNoNewKeyword(
/*#__PURE__*/
function (_this) {
_inherits(MixinSwal, _this);
function MixinSwal() {
_classCallCheck(this, MixinSwal);
return _possibleConstructorReturn(this, _getPrototypeOf(MixinSwal).apply(this, arguments));
}
_createClass(MixinSwal, [{
key: "_main",
value: function _main(params) {
return _get(_getPrototypeOf(MixinSwal.prototype), "_main", this).call(this, _extends({}, mixinParams, params));
}
}]);
return MixinSwal;
}(this));
}
|
javascript
|
{
"resource": ""
}
|
q2876
|
showLoading
|
train
|
function showLoading() {
var popup = getPopup();
if (!popup) {
Swal('');
}
popup = getPopup();
var actions = getActions();
var confirmButton = getConfirmButton();
var cancelButton = getCancelButton();
show(actions);
show(confirmButton);
addClass([popup, actions], swalClasses.loading);
confirmButton.disabled = true;
cancelButton.disabled = true;
popup.setAttribute('data-loading', true);
popup.setAttribute('aria-busy', true);
popup.focus();
}
|
javascript
|
{
"resource": ""
}
|
q2877
|
hideLoading
|
train
|
function hideLoading() {
var innerParams = privateProps.innerParams.get(this);
var domCache = privateProps.domCache.get(this);
if (!innerParams.showConfirmButton) {
hide(domCache.confirmButton);
if (!innerParams.showCancelButton) {
hide(domCache.actions);
}
}
removeClass([domCache.popup, domCache.actions], swalClasses.loading);
domCache.popup.removeAttribute('aria-busy');
domCache.popup.removeAttribute('data-loading');
domCache.confirmButton.disabled = false;
domCache.cancelButton.disabled = false;
}
|
javascript
|
{
"resource": ""
}
|
q2878
|
resetValidationMessage
|
train
|
function resetValidationMessage() {
var domCache = privateProps.domCache.get(this);
if (domCache.validationMessage) {
hide(domCache.validationMessage);
}
var input = this.getInput();
if (input) {
input.removeAttribute('aria-invalid');
input.removeAttribute('aria-describedBy');
removeClass(input, swalClasses.inputerror);
}
}
|
javascript
|
{
"resource": ""
}
|
q2879
|
openPopup
|
train
|
function openPopup(params) {
var container = getContainer();
var popup = getPopup();
if (params.onBeforeOpen !== null && typeof params.onBeforeOpen === 'function') {
params.onBeforeOpen(popup);
}
if (params.animation) {
addClass(popup, swalClasses.show);
addClass(container, swalClasses.fade);
removeClass(popup, swalClasses.hide);
} else {
removeClass(popup, swalClasses.fade);
}
show(popup); // scrolling is 'hidden' until animation is done, after that 'auto'
container.style.overflowY = 'hidden';
if (animationEndEvent && !hasClass(popup, swalClasses.noanimation)) {
popup.addEventListener(animationEndEvent, function swalCloseEventFinished() {
popup.removeEventListener(animationEndEvent, swalCloseEventFinished);
container.style.overflowY = 'auto';
});
} else {
container.style.overflowY = 'auto';
}
addClass([document.documentElement, document.body, container], swalClasses.shown);
if (params.heightAuto && params.backdrop && !params.toast) {
addClass([document.documentElement, document.body], swalClasses['height-auto']);
}
if (isModal()) {
fixScrollbar();
iOSfix();
IEfix();
setAriaHidden(); // sweetalert2/issues/1247
setTimeout(function () {
container.scrollTop = 0;
});
}
if (!isToast() && !globalState.previousActiveElement) {
globalState.previousActiveElement = document.activeElement;
}
if (params.onOpen !== null && typeof params.onOpen === 'function') {
setTimeout(function () {
params.onOpen(popup);
});
}
}
|
javascript
|
{
"resource": ""
}
|
q2880
|
getInputValue
|
train
|
function getInputValue() {
var input = _this.getInput();
if (!input) {
return null;
}
switch (innerParams.input) {
case 'checkbox':
return input.checked ? 1 : 0;
case 'radio':
return input.checked ? input.value : null;
case 'file':
return input.files.length ? input.files[0] : null;
default:
return innerParams.inputAutoTrim ? input.value.trim() : input.value;
}
}
|
javascript
|
{
"resource": ""
}
|
q2881
|
train
|
function (runner, url, browser) {
this.id = null;
this.taskId = null;
this.user = runner.user;
this.key = runner.key;
this.framework = runner.framework;
this.pollInterval = runner.pollInterval;
this.statusCheckAttempts = runner.statusCheckAttempts;
this.url = url;
this.platform = _.isArray(browser) ? browser : [browser.platform || '', browser.browserName || '', browser.version || ''];
this.build = runner.build;
this.public = browser.public || runner.public || "team";
this.tags = browser.tags || runner.tags;
this.testName = browser.name || runner.testName;
this.sauceConfig = runner.sauceConfig;
this.tunneled = runner.tunneled;
this.tunnelId = runner.tunnelId;
}
|
javascript
|
{
"resource": ""
}
|
|
q2882
|
AggregateError
|
train
|
function AggregateError(message) {
if (!(this instanceof AggregateError)) {
return new AggregateError(message);
}
Error.captureStackTrace(this, AggregateError);
// Like http://www.ecma-international.org/ecma-262/6.0/#sec-error-message
if (message !== undefined) {
Object.defineProperty(this, 'message', {
value: String(message),
configurable: true,
writable: true
});
}
}
|
javascript
|
{
"resource": ""
}
|
q2883
|
split
|
train
|
function split (data, w, h) {
var colors = {};
var pos = 0;
for (var y = 0; y < h; ++y) {
for (var x = 0; x < w; ++x) {
pos = (y * w + x) * 4;
if (data[pos + 3] > 0) {
set(x, y, data[pos], data[pos + 1], data[pos + 2]);
}
}
}
return {
w: w,
h: h,
colors: colors
};
function set (x, y, r, g, b) {
var hex = "#" + [r, g, b].map(hexaze).join("");
if (!colors[hex]) {
colors[hex] = new Array(h);
for (var i = 0; i < h; ++i) {
colors[hex][i] = new Uint8Array(w);
}
}
colors[hex][y][x] = 1;
}
}
|
javascript
|
{
"resource": ""
}
|
q2884
|
handleError
|
train
|
function handleError(error) {
console.log(`${options.entry} failed.`);
console.trace(error);
setTimeout(() => {
throw error;
});
}
|
javascript
|
{
"resource": ""
}
|
q2885
|
getArguments
|
train
|
function getArguments(node) {
if (node && node.arguments && node.arguments.length > 0) {
return node.arguments;
}
return [];
}
|
javascript
|
{
"resource": ""
}
|
q2886
|
extractLiteralFromInstalled
|
train
|
function extractLiteralFromInstalled(stats, element) {
if (element.length === 0) return stats;
let value = "";
if (validLiteral(element[0])) {
value = element[0].value;
// let array = value.split('$');
// if (array.length == 0) {
// stats.setPackageName(value);
// } else {
// stats.setPackageName(array[0]);
// stats.setPackageVersion(array[1]);
// }
stats.setPackageName(value);
}
if (validLiteral(element[1])) {
value = element[1].value;
stats.setFileName(value);
}
if (validLiteral(element[2])) {
value = element[2].value;
stats.setVersion(value);
}
return stats;
}
|
javascript
|
{
"resource": ""
}
|
q2887
|
extractLiteralFromDef
|
train
|
function extractLiteralFromDef(stats, element) {
if (validLiteral(element)) {
stats.setPath(element.value);
let arrayLiteral = element.value.split('/');
let length = arrayLiteral.length;
if (length > 0) {
const index = validIndex(arrayLiteral);
stats.setPackageName(arrayLiteral[index].split("$")[0]);
stats.setVersion(arrayLiteral[index].split("$")[1] || '');
stats.setFileName(arrayLiteral.splice(index + 1, length).join('/'));
}
}
return stats;
}
|
javascript
|
{
"resource": ""
}
|
q2888
|
isFunctionExpression
|
train
|
function isFunctionExpression(node) {
if (node && node.callee && node.callee.type === 'FunctionExpression') {
return true;
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
q2889
|
publish
|
train
|
function publish(target, data, done) {
if(data.enabled !== true)
return grunt.fail.fatal('publishing is disabled; set "publish.enabled" to true to enable');
if(!data.path)
return grunt.fail.fatal('the "publish.path" attribute must be provided for the publish task');
if(!data.message)
return grunt.fail.fatal('the "publish.message" attribute must be provided for the publish task');
/**
* provide the defaults for the git commands. by default, we are assuming the markdown repo is stored
* in a separate directory, so our git commands need to support that...provide the git-dir and work-tree
* paths. the standard publish process is:
*
* git add .
* git commit -m <configured commit message>
* git push <remoteName> <remoteBranch> (defaults to upstream master)
*
*/
_.defaults(data, {
addCmd: ['--git-dir='+ data.path +'/.git', '--work-tree='+ data.path, 'add', '.'],
commitCmd: ['--git-dir='+ data.path +'/.git', '--work-tree='+ data.path, 'commit', '-m', data.message],
pushCmd: ['--git-dir='+ data.path +'/.git', '--work-tree='+ data.path, 'push', data.remoteName || 'upstream', data.remoteBranch || 'master']
});
//run the git commands, using promises to handle when complete
function cmd(args) {
var def = Q.defer();
grunt.util.spawn({ cmd: 'git', args: args }, def.resolve);
return def.promise;
}
//add, commit, and publish the doc repository
cmd(data.addCmd)
.then(cmd.bind(this, data.commitCmd))
.then(cmd.bind(this, data.pushCmd))
.then(done);
}
|
javascript
|
{
"resource": ""
}
|
q2890
|
cmd
|
train
|
function cmd(args) {
var def = Q.defer();
grunt.util.spawn({ cmd: 'git', args: args }, def.resolve);
return def.promise;
}
|
javascript
|
{
"resource": ""
}
|
q2891
|
getArguments
|
train
|
function getArguments(req) {
const result = req.body || {};
for (let i in req.query) {
result[i] = req.query[i];
}
return result;
}
|
javascript
|
{
"resource": ""
}
|
q2892
|
isAutostartEnabled
|
train
|
function isAutostartEnabled(key, callback) {
if (arguments.length < 1) {
throw new Error('Not enough arguments passed to isAutostartEnabled()');
} else if (typeof key !== 'string') {
throw new TypeError('Passed "key" to disableAutostart() is not a string.');
}
if (typeof callback !== 'function') {
return new Promise((resolve, reject) => {
autostart.isAutostartEnabled(key, (error, isEnabled) => {
if (error) {
reject(error);
} else {
resolve(isEnabled);
}
});
});
}
autostart.isAutostartEnabled(key, (error, isEnabled) => {
callback(error, isEnabled);
});
}
|
javascript
|
{
"resource": ""
}
|
q2893
|
iPadTouchStart
|
train
|
function iPadTouchStart(event) {
var touches = event.changedTouches,
first = touches[0],
type = "mouseover",
simulatedEvent = document.createEvent("MouseEvent");
//
// Mouse over first - I have live events attached on mouse over
//
simulatedEvent.initMouseEvent(type, true, true, window, 1, first.screenX, first.screenY, first.clientX, first.clientY,
false, false, false, false, 0, null);
first.target.dispatchEvent(simulatedEvent);
type = "mousedown";
simulatedEvent = document.createEvent("MouseEvent");
simulatedEvent.initMouseEvent(type, true, true, window, 1, first.screenX, first.screenY, first.clientX, first.clientY,
false, false, false, false, 0, null);
first.target.dispatchEvent(simulatedEvent);
if (!tapValid) {
lastTap = first.target;
tapValid = true;
tapTimeout = window.setTimeout("cancelTap();", 600);
startHold(event);
}
else {
window.clearTimeout(tapTimeout);
//
// If a double tap is still a possibility and the elements are the same
// Then perform a double click
//
if (first.target == lastTap) {
lastTap = null;
tapValid = false;
type = "click";
simulatedEvent = document.createEvent("MouseEvent");
simulatedEvent.initMouseEvent(type, true, true, window, 1, first.screenX, first.screenY, first.clientX, first.clientY,
false, false, false, false, 0/*left*/, null);
first.target.dispatchEvent(simulatedEvent);
type = "dblclick";
simulatedEvent = document.createEvent("MouseEvent");
simulatedEvent.initMouseEvent(type, true, true, window, 1, first.screenX, first.screenY, first.clientX, first.clientY,
false, false, false, false, 0/*left*/, null);
first.target.dispatchEvent(simulatedEvent);
}
else {
lastTap = first.target;
tapValid = true;
tapTimeout = window.setTimeout("cancelTap();", 600);
startHold(event);
}
}
}
|
javascript
|
{
"resource": ""
}
|
q2894
|
parseResponse
|
train
|
function parseResponse(cb) {
return function parse(err, response, body) {
// TODO Handel the errors
cb(err, JSON.parse(body))
}
}
|
javascript
|
{
"resource": ""
}
|
q2895
|
query
|
train
|
function query(base, q, callback) {
// Added unescape to fix URI errors resulting from hexadecimal escape sequences
var url = util.format("%s?%s", base, querystring.unescape(querystring.stringify(q)));
request(url, function (err, response) {
if (err) return callback(err);
callback(null, response.body);
});
}
|
javascript
|
{
"resource": ""
}
|
q2896
|
queryRxNormApproximate
|
train
|
function queryRxNormApproximate(medname, maxEntries, callback) {
// maxEntries is optional
if (!callback) {
callback = maxEntries;
maxEntries = 5;
}
query("http://rxnav.nlm.nih.gov/REST/approximateTerm.json", {
term: medname,
maxEntries: maxEntries
}, callback);
}
|
javascript
|
{
"resource": ""
}
|
q2897
|
train
|
function (cb) {
fs.readFile(path.resolve(__dirname, "dose_form_groups.txt"), "UTF-8", function (err, doseForms) {
if (err) return cb(err);
// each group is a new line in the file
doseFormGroups = doseForms.toString().split("\n").filter(function (form) {
// ignore empty lines
return form.length > 0;
});
cb();
});
}
|
javascript
|
{
"resource": ""
}
|
|
q2898
|
queryRxNormGroup
|
train
|
function queryRxNormGroup(medname, callback) {
query("http://rxnav.nlm.nih.gov/REST/drugs.json", {
name: medname
}, function (err, body) {
if (err) return callback(err);
drugFormList(JSON.parse(body), callback);
});
}
|
javascript
|
{
"resource": ""
}
|
q2899
|
minRunLength
|
train
|
function minRunLength(n) {
let r = 0;
while (n >= DEFAULT_MIN_MERGE) {
r |= (n & 1);
n >>= 1;
}
return n + r;
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.