_id stringlengths 2 6 | title stringlengths 0 58 | partition stringclasses 3 values | text stringlengths 52 373k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q32400 | train | function(zCriticalValue) {
var baselineValue = this.baseline.pEstimate(zCriticalValue).value;
var ratio = this.differenceEstimate(zCriticalValue).value / baselineValue;
var error = this.differenceEstimate(zCriticalValue).error / baselineValue;
return new Abba.ValueWithError(ratio, error);
} | javascript | {
"resource": ""
} | |
q32401 | callInstanceMethod | train | function callInstanceMethod(methodName, req, res, next) {
res.__apiMethod = 'instanceMethod';
res.__apiInstanceMethod = methodName;
const self = this;
const id = req.params.id;
const methodOptions = this.apiOptions.expose[methodName];
const wrapper = (methodOptions.exec instanceof Function) ?
methodOptions.exec :
null;
let filter = this.option(methodName, 'filter');
if (filter instanceof Function) {
filter = filter.call(this, req);
}
const query = Object.assign({}, filter, { _id: id });
const params = (methodOptions.method !== 'get') ?
req.body :
req.query;
this.model.findById(query, function (err, obj) {
if (err) return next(err);
if (!obj) {
return next(new ModelAPIError(
404, `The ${self.nameSingle} was not found by ${id}`
));
};
const mFunc = wrapper || obj[methodName];
mFunc.call(obj, params, function(err, result) {
if (err) return next(err);
res.json(result);
});
});
} | javascript | {
"resource": ""
} |
q32402 | fetchView | train | function fetchView( data, id ) {
data.backgroundColor = randomCol();
data.fontColour = data.backgroundImage? '' : getContrastYIQ( data.backgroundColor );
let wrapper = document.createElement('div');
wrapper.className = 'section hidden';
wrapper.innerHTML = SimpleViewTemplate( data );
wrapper.dataset.id = id;
container.appendChild( wrapper );
return wrapper;
} | javascript | {
"resource": ""
} |
q32403 | disabled | train | function disabled(val) {
// return whether the first element in the set
// is hidden
if(val === undefined) {
return this.hasClass(className);
// hide on truthy
}else if(val) {
this.addClass(className);
// show on falsey
}else{
this.removeClass(className);
}
return this;
} | javascript | {
"resource": ""
} |
q32404 | write | train | function write(ws, source) {
return new Promise(function ($return, $error) {
if (!(ws instanceof Writable)) {
return $error(new Error('Writable stream expected'));
}
if (source instanceof Readable) {
if (!source.readable) {
return $error(new Error('Stream is not readable'));
}
return Promise.resolve(new Promise(function (resolve, reject) {
ws.on('finish', resolve);
ws.on('error', reject);
source.on('error', reject);
source.pipe(ws);
})).then(function ($await_2) {
try {
return $return(ws);
} catch ($boundEx) {
return $error($boundEx);
}
}.bind(this), $error);
}
return Promise.resolve(makePromise(ws.end.bind(ws), source)).then(function ($await_3) {
try {
return $return(ws);
} catch ($boundEx) {
return $error($boundEx);
}
}.bind(this), $error);
}.bind(this));
} | javascript | {
"resource": ""
} |
q32405 | init | train | function init() { // {{{2
/**
* Class constructor
*
* @method constructor
* @internal
*/
O.inherited(this)();
this.setMaxListeners(Consts.coreListeners);
this.subjectState = this.SUBJECT_STATE.INIT;
this.peers = {};
this.shards = {};
} | javascript | {
"resource": ""
} |
q32406 | newSelector | train | function newSelector($block, multiple, type){
var selector = new jqCronSelector(_self, $block, multiple, type);
selector.$.bind('selector:open', function(){
// we close all opened selectors of all other jqCron
for(var n = jqCronInstances.length; n--; ){
if(jqCronInstances[n] != _self) {
jqCronInstances[n].closeSelectors();
}
else {
// we close all other opened selectors of this jqCron
for(var o = _selectors.length; o--; ){
if(_selectors[o] != selector) {
_selectors[o].close();
}
}
}
}
});
selector.$.bind('selector:change', function(){
var boundChanged = false;
// don't propagate if not initialized
if(!_initialized) return;
// bind data between two minute selectors (only if they have the same multiple settings)
if(settings.multiple_mins == settings.multiple_time_minutes) {
if(selector == _selectorMins) {
boundChanged = _selectorTimeM.setValue(_selectorMins.getValue());
}
else if(selector == _selectorTimeM) {
boundChanged = _selectorMins.setValue(_selectorTimeM.getValue());
}
}
// we propagate the change event to the main object
boundChanged || _$obj.trigger('cron:change', _self.getCron());
});
_selectors.push(selector);
return selector;
} | javascript | {
"resource": ""
} |
q32407 | array_unique | train | function array_unique(l){
var i=0,n=l.length,k={},a=[];
while(i<n) {
k[l[i]] || (k[l[i]] = 1 && a.push(l[i]));
i++;
}
return a;
} | javascript | {
"resource": ""
} |
q32408 | RainyDay | train | function RainyDay(options) {
this.img = document.getElementById(options.element);
this.opacity = options.opacity || 1;
this.blurRadius = options.blur || 10;
this.w = this.img.clientWidth;
this.h = this.img.clientHeight;
this.drops = [];
// prepare canvas elements
this.canvas = this.prepareCanvas(this.img);
this.prepareBackground(this.w, this.h);
this.prepareGlass();
// assume defaults
this.reflection = this.REFLECTION_MINIATURE;
this.trail = this.TRAIL_DROPS;
this.gravity = this.GRAVITY_NON_LINEAR;
this.collision = this.COLLISION_SIMPLE;
this.VARIABLE_GRAVITY_THRESHOLD = 3;
this.VARIABLE_GRAVITY_ANGLE = Math.PI / 2;
this.VARIABLE_GRAVITY_ANGLE_VARIANCE = 0;
this.VARIABLE_FPS = options.fps;
this.VARIABLE_FILL_STYLE = '#8ED6FF';
this.VARIABLE_COLLISIONS = true;
this.REFLECTION_SCALEDOWN_FACTOR = 5;
this.REFLECTION_DROP_MAPPING_WIDTH = 200;
this.REFLECTION_DROP_MAPPING_HEIGHT = 200;
} | javascript | {
"resource": ""
} |
q32409 | Drop | train | function Drop(rainyday, centerX, centerY, min, base) {
this.x = Math.floor(centerX);
this.y = Math.floor(centerY);
this.r = (Math.random() * base) + min;
this.rainyday = rainyday;
this.context = rainyday.context;
this.reflection = rainyday.reflected;
} | javascript | {
"resource": ""
} |
q32410 | CollisionMatrix | train | function CollisionMatrix(x, y, r) {
this.resolution = r;
this.xc = x;
this.yc = y;
this.matrix = new Array(x);
for (var i = 0; i <= (x + 5); i++) {
this.matrix[i] = new Array(y);
for (var j = 0; j <= (y + 5); ++j) {
this.matrix[i][j] = new DropItem(null);
}
}
} | javascript | {
"resource": ""
} |
q32411 | _transitionViews | train | function _transitionViews( transitionObj )
{
if( !transitionObj ){ return TransitionController.error('transition is not defined'); }
const transitionModule = _options.transitions[ transitionObj.transitionType ];
if( transitionModule ) {
const deferred = Deferred(),
views = transitionObj.views,
currentViewRef = transitionObj.currentViewID,
nextViewRef = transitionObj.nextViewID;
/* individual transition completed */
deferred.promise.then( () => {
transitionComplete.dispatch( transitionObj );
TransitionController.log( transitionObj.transitionType +' -- completed');
});
if( transitionModule.initialize ){
transitionModule.initialize( views, transitionObj.data, deferred, currentViewRef, nextViewRef );
}
transitionStarted.dispatch( transitionObj );
TransitionController.log( transitionObj.transitionType +' -- started');
transitionModule.animate( views, transitionObj.data, deferred, currentViewRef, nextViewRef );
return deferred.promise;
}
else {
TransitionController.error(transitionObj.transitionType + ' does NOT exist' );
}
} | javascript | {
"resource": ""
} |
q32412 | template | train | function template(source, target) {
source = source || {};
target = target || {};
for(var z in source) {
target[z] = $.partial(source[z]);
}
return target;
} | javascript | {
"resource": ""
} |
q32413 | swap | train | function swap(source, target) {
// wrap to allow string selectors, arrays etc.
source = $(source);
target = $(target);
source.each(function(el, index) {
var content = target.get(index);
if(el.parentNode && content) {
// deep clone template partial
content = content.cloneNode(true);
// replace sourc element with cloned target element
el.parentNode.replaceChild(content, el);
}
})
} | javascript | {
"resource": ""
} |
q32414 | createUploadPromise | train | function createUploadPromise(filepath, destination, options) {
return function () {
// get the name of the file and construct the url for uploading it
var filename = getFilename(filepath),
dropboxPath = destination + (options.version_name ? ("/" + options.version_name + "/") : "/") + filepath,
// read the file and start the upload, decrementing the in-flight count when complete
// Use encoding = null to keep the file as a Buffer
reqOptions = {
access_token: options.access_token,
dropboxPath: dropboxPath,
fileBuffer: grunt.file.read(filepath, { encoding : null })
};
grunt.log.writeln("Uploading " + filepath + " to " + dropboxPath + "...");
// return the upload promise
return dropboxClient.upload(reqOptions);
};
} | javascript | {
"resource": ""
} |
q32415 | process | train | function process(sources, options) {
sources = explodeall(sources);
if (!grunt.fail.errorcount) {
var content = extract(sources, options);
return enclose(content.join(SPACER));
}
} | javascript | {
"resource": ""
} |
q32416 | extract | train | function extract(sources, options) {
return sources
.map(function(src) {
return [src, grunt.file.read(src)];
})
.filter(function(list) {
return syntax.valid(grunt, list[0], list[1]);
})
.map(function(list) {
return extras(list[0], list[1], options);
});
} | javascript | {
"resource": ""
} |
q32417 | writefile | train | function writefile(filepath, filetext, options) {
var version = '-1.0.0';
var packag = filename('package.json', options);
var banner = filename('BANNER.txt', options);
if (grunt.file.exists(banner)) {
filetext = grunt.file.read(banner) + '\n' + filetext;
}
if (grunt.file.exists(packag)) {
var json = grunt.file.readJSON(packag);
version = json.version;
}
grunt.file.write(
filepath,
grunt.template.process(filetext, {
data: {
version: version
}
})
);
grunt.log.writeln('File "' + chalk.cyan(filepath) + '" created.');
} | javascript | {
"resource": ""
} |
q32418 | uglyfile | train | function uglyfile(prettyfile, sourcecode, options) {
var mintarget = prettyfile.replace('.js', '.min.js');
var maptarget = prettyfile.replace('.js', '.js.map');
var uglycodes = uglify(options.max ? prettyfile : sourcecode);
writefile(mintarget, uglycodes.code, options);
if (options.map) {
writefile(maptarget, uglycodes.map, options);
}
} | javascript | {
"resource": ""
} |
q32419 | uglify | train | function uglify(prettyfile, sourcecode) {
console.warn(
'Not quite getting the right path to source in the map :/'
);
return ugli.minify(sourcecode || prettyfile, {
fromString: sourcecode !== undefined,
outSourceMap: path.basename(prettyfile) + '.map',
compress: {
warnings: false
}
});
} | javascript | {
"resource": ""
} |
q32420 | train | function (obj, meta, status = 200, errorCode = -1, devMsg = null, usrMsg = null, moreInfo = null) {
if (res.finished) {
// request ended
return
}
// ref.: https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html
if (status < 300) {
// OK
// respond client and close request
let body
switch (typeof obj) {
case 'object':
// expected
if (meta) {
res.setHeader('X-Metadata', 'true')
body = JSON.stringify({ 'meta': meta, 'result': obj })
} else {
body = JSON.stringify(obj)
}
break
case 'string':
case 'number':
// maybe an ID returned after modification request
body = JSON.stringify({ 'result': obj })
break
default:
// return null JSON object
body = '{}'
}
if (verb === 'GET') {
// ETag to verify browser cache validation
// have to be set here, web servers will not etag proxy requests
// Cloudflare keep only weak ETags
res.setHeader('ETag', etag(body, { 'weak': true }))
}
res.writeHead(status)
res.end(body)
} else if (status < 400 && typeof obj === 'string') {
// redirect
// expect obj to be the redirect URL
// return object with previous and next (after redirect) URL
let response = {
'status': status,
'requested_url': req.url,
'endpoint': obj
}
// explain type of redirect in message
if (status === 301) {
response.message = 'Moved permanently, please re-send this request to the specified endpoint'
} else {
response.message = 'Temporary redirect, re-send this request to the specified temporary endpoint, ' +
'continue to use the original request endpoint for future requests'
}
res.writeHead(status, { 'Location': obj })
res.end(JSON.stringify(response))
} else if (typeof obj === 'object' && obj !== null && Object.keys(obj).length > 0) {
// custom error object
res.writeHead(status)
res.end(JSON.stringify(obj))
} else {
// client and/or server error
httpErrorHandling(res, status, errorCode, devMsg, usrMsg, moreInfo)
}
} | javascript | {
"resource": ""
} | |
q32421 | without | train | function without(componentIDs) {
const context = this.readContext(this);
context.pushOp(WITHOUT);
// the preceeding command is used as the first argument
context.pushVal(componentIDs, true);
return context;
} | javascript | {
"resource": ""
} |
q32422 | dualDiff | train | function dualDiff(a1, a2) {
var o1={}, o2={}, diff1=[], diff2=[], i, len, k;
for (i=0, len=a1.length; i<len; i++) { o1[a1[i]] = true; }
for (i=0, len=a2.length; i<len; i++) { o2[a2[i]] = true; }
for (k in o1) { if (!(k in o2)) { diff1.push(k); } }
for (k in o2) { if (!(k in o1)) { diff2.push(k); } }
return [diff1, diff2];
} | javascript | {
"resource": ""
} |
q32423 | generateHmac | train | function generateHmac(data, key, encoding) {
var hmac = crypto.createHmac(HMAC_SHA256_ALGORITHM, key);
hmac.update(data);
return hmac.digest(encoding);
} | javascript | {
"resource": ""
} |
q32424 | css | train | function css(key, val) {
var style, props;
if(!this.length) {
return this;
}
if(key && typeof key === 'object') {
props = key;
}else if(key && val) {
props = {};
props[key] = val;
}
// get style object
if(key === undefined) {
style = window.getComputedStyle(this.dom[0], null);
// TODO: convert to plain object map?
// for the moment return CSSStyleDeclaration
return style;
// get single style property value
}else if(typeof key === 'string' && !val) {
style = window.getComputedStyle(this.dom[0], null);
return style.getPropertyValue(key);
}
// set inline styles
this.each(function(el) {
el.style = el.style;
for(var z in props) {
el.style[z] = '' + props[z];
}
});
return this;
} | javascript | {
"resource": ""
} |
q32425 | _filesInDirectory | train | async function _filesInDirectory(dirPath, options) {
const basedir = options.basedir || getCallingDir();
const resolvedDirPath = basedir?path.resolve(basedir, dirPath):dirPath;
let xExt = _getExtensionRegEx(options.extension || settings.get('extensions'));
try {
const files = (await readDir(resolvedDirPath));
if (options.rescursive) {
const dirs = chain(await Promise.all(chain(files)
.map(fileName=>path.resolve(resolvedDirPath, fileName))
.map(async (file)=>{
const stat = await lstat(file);
if (stat.isDirectory()) return file;
})
.value())).filter(file=>file);
if (dirs.value().length) files.push(...(await Promise.all(
dirs.map(dirPath=>_filesInDirectory(dirPath, options)).value()
)));
}
return chain(files)
.flattenDeep()
.filter(fileName=>xExt.test(fileName))
.map(fileName=>path.resolve(resolvedDirPath, fileName))
.value();
} catch (err) {
return [];
}
} | javascript | {
"resource": ""
} |
q32426 | filesInDirectories | train | async function filesInDirectories(dirPaths, options) {
let files = await Promise.all(makeArray(dirPaths).map(dirPath=>_filesInDirectory(dirPath, options)));
return flattenDeep(files);
} | javascript | {
"resource": ""
} |
q32427 | _getExtensionRegEx | train | function _getExtensionRegEx(ext=settings.get('extensions')) {
let _ext = '(?:' + makeArray(ext).join('|') + ')';
return new RegExp(_ext + '$');
} | javascript | {
"resource": ""
} |
q32428 | _canImport | train | function _canImport(fileName, callingFileName, options) {
if (callingFileName && (fileName === callingFileName)) return false;
let _fileName = _getFileTests(fileName, options);
if (options.includes) return (intersection(options.includes, _fileName).length > 0);
if (options.excludes) return (intersection(options.includes, _fileName).length === 0);
return true;
} | javascript | {
"resource": ""
} |
q32429 | _importDirectoryOptionsParser | train | function _importDirectoryOptionsParser(options={}) {
const _options = Object.assign({
imports: {},
onload: options.callback,
extension: makeArray(options.extensions || settings.get('extensions')),
useSyncRequire: settings.get('useSyncRequire'),
merge: settings.get('mergeImports'),
rescursive: false
}, options, {
squashErrors: !!options.retry
});
if (_options.extensions) delete _options.extensions;
if (options.callback) console.warn(`The options.callback method is deprecated, please use options.onload() instead. This being used in ${getCallingFileName()}`);
return _options;
} | javascript | {
"resource": ""
} |
q32430 | importDirectory | train | function importDirectory(dirPath, options, callback) {
if (!callback) return _importDirectory(dirPath, options);
_importDirectory(dirPath, options).then(
imports=>setImmediate(()=>callback(null, imports)),
err=>setImmediate(()=>callback(err, undefined))
);
} | javascript | {
"resource": ""
} |
q32431 | captureStackTrace | train | function captureStackTrace(error, constructor) {
if (Error.captureStackTrace) {
Error.captureStackTrace(error, constructor);
} else {
error.stack = new Error().stack;
}
} | javascript | {
"resource": ""
} |
q32432 | createFile | train | function createFile(tree, name, prop, options) {
var opts = utils.extend({}, options);
var str = create(tree[name], {label: 'cwd'});
var file = new utils.File({path: `${prop}-${name}.txt`, contents: new Buffer(str)});
if (typeof opts.treename === 'function') {
opts.treename(file);
}
file.writeFile = true;
file.render = false;
file.layout = null;
file.isTree = true;
utils.contents.sync(file);
return file;
} | javascript | {
"resource": ""
} |
q32433 | sortObject | train | function sortObject(object) {
var keys = Object.keys(object);
var sorted = {};
var options = {
sensitivity: 'base'
};
function compare(a, b) {
return a.localeCompare(b, options);
}
keys.sort(compare);
for (var index in keys) {
if (keys[index]) {
var key = keys[index];
if (Array.isArray(object[key])) {
sorted[key] = object[key].sort(compare);
} else if (typeof object[key] === 'object') {
sorted[key] = sortObject(object[key]);
} else {
sorted[key] = object[key];
}
}
}
return sorted;
} | javascript | {
"resource": ""
} |
q32434 | isValidES2015VarName | train | function isValidES2015VarName(name) {
// In ES2015-compatible code, these are reserved words.
if (name === 'await') { return false; }
if (name === 'enum') { return false; }
return validateVarName(allowedCharactersES2015, name, exports.strict);
} | javascript | {
"resource": ""
} |
q32435 | validateVarName | train | function validateVarName(regex, name, strict) {
if (strict) {
// These are only an issue in strict mode.
if (name === 'eval') { return false; }
if (name === 'arguments') { return false; }
}
var result = regex.test(name);
result = result && validateCommonReservedWords(name);
return result;
} | javascript | {
"resource": ""
} |
q32436 | train | function(s) {
//TODO: validate array length
//TODO: return unwanted subset as new Px object
var counts = this.valCounts(),
multipliers = [];
_.each(s, function(d, i) {
if (d[0] === '*') {
s[i] = _.range(0, counts[i] - 1);
}
});
for (var i = 0, l = counts.length; i < l - 1; i++) {
multipliers[i] = _.reduce(counts.slice(i+1), function(a, b) { return a * b; });
}
multipliers.push(1);
for (var j = 0, k = s.length; j < k; j++) {
// drop the values
this.metadata.VALUES[this.variables()[j]] =
_.filter(this.metadata.VALUES[this.variables()[j]], function(e, m) {
return _.indexOf(s[j], m) !== -1;
});
}
var keepIdxs = [];
var pattern = function pattern(c,m,w,p) {
if (c.length > 1) {
p = typeof p !== 'undefined' ? p : 1;
var count = c.pop(),
multiple = m.pop(),
want = w.pop();
var patt = _.flatten(_.map(_.range(0, count), function(d) {
return _.include(want, d) ? p : _arrayOfZeroes(multiple);
}));
pattern(c, m, w, patt);
}
keepIdxs.push(_.flatten(p));
};
pattern(counts,multipliers,s);
keepIdxs = keepIdxs[0];
var indices = [];
_.each(s[0], function(d) {
var start = d * multipliers[0];
var end = start + multipliers[0];
indices.push(_.filter(_.range(start, end), function(d, i) {return keepIdxs[i] === 1;}));
});
indices = _.flatten(indices);
this.data = _.filter(this.data, function(d, i) {return _.indexOf(indices, i) !== -1;});
} | javascript | {
"resource": ""
} | |
q32437 | deploy | train | function deploy(params, cb) {
params.resourcePath = config.addURIParams(constants.SERVICES_BASE_PATH + "/:guid/deploy", params);
params.method = "POST";
params.data = params.service;
mbaasRequest.admin(params, cb);
} | javascript | {
"resource": ""
} |
q32438 | qinu | train | function qinu (options, args) {
const { dict, length, template, args: optArgs, random } =
this instanceof Qinu ? options : normalizeOptions(options)
if (!(args instanceof Array)) {
args = Array.prototype.slice.call(arguments, 1)
}
if (optArgs instanceof Array) {
args = optArgs.concat(args)
}
const key = !random && this instanceof Qinu
? this.next(dict, length) : generateKey(dict, length)
return applyTemplate(template, key, args)
} | javascript | {
"resource": ""
} |
q32439 | brequire | train | function brequire(module) {
var basepath = process.env.SRC_base ? path.resolve(process.env.SRC_base)
: path.join(__dirname, '..');
if (module.charAt(0) == '.')
return require(path.join(basepath, module));
else //by calling require() from this location we ensure base's copy of the module will get priority
return require(module);
} | javascript | {
"resource": ""
} |
q32440 | returnRankedIntents | train | function returnRankedIntents(input, intents) {
return new Promise((resolve, reject) => {
let lowerCase = input.toLowerCase();
let totalScore = 0;
//loop through all loaded intents
intents.forEach((intent) => {
intent.score = 0;
intent.utterences.forEach((utterence) => {
let words = utterence.toLowerCase().split(" ");
let utterenceMatch = 0;
let ppw = 100 / words.length;
//how many words in input match intent samples
words.forEach((word) => {
if (lowerCase.includes(word)) {
utterenceMatch = utterenceMatch + ppw;
}
});
if (intent.score < utterenceMatch) {
intent.score = utterenceMatch
}
});
//each intent keyword in the input multiplies the intent score by 2
intent.keywords.forEach((keyword) => {
if (input.includes(keyword.toLowerCase())) {
intent.score = intent.score * 2
}
});
//add intent score to totalscore
totalScore = totalScore + intent.score;
});
//work out confident by deviding each intents score by the total
intents.forEach((intent) => {
intent.confidence = intent.score / totalScore
});
//Sort intents
let sorted = intents.sort((a, b) => {
return b.confidence - a.confidence
});
//sent back the classified intents
resolve(sorted);
}
)
} | javascript | {
"resource": ""
} |
q32441 | operate | train | function operate(input, direct, method) {
var node = input[0],
state = /er/.test(method) ? _indeterminate : /bl/.test(method) ? _disabled : _checked,
active = method == _update ? {
checked: node[_checked],
disabled: node[_disabled],
indeterminate: input.attr(_indeterminate) == 'true' || input.attr(_determinate) == 'false'
} : node[state];
// Check, disable or indeterminate
if (/^(ch|di|in)/.test(method) && !active) {
on(input, state);
// Uncheck, enable or determinate
} else if (/^(un|en|de)/.test(method) && active) {
off(input, state);
// Update
} else if (method == _update) {
// Handle states
for (var state in active) {
if (active[state]) {
on(input, state, true);
} else {
off(input, state, true);
};
};
} else if (!direct || method == 'toggle') {
// Helper or label was clicked
if (!direct) {
input[_callback]('ifClicked');
};
// Toggle checked state
if (active) {
if (node[_type] !== _radio) {
off(input, state);
};
} else {
on(input, state);
};
};
} | javascript | {
"resource": ""
} |
q32442 | on | train | function on(input, state, keep) {
var node = input[0],
parent = input.parent(),
checked = state == _checked,
indeterminate = state == _indeterminate,
disabled = state == _disabled,
callback = indeterminate ? _determinate : checked ? _unchecked : 'enabled',
regular = option(input, callback + capitalize(node[_type])),
specific = option(input, state + capitalize(node[_type]));
// Prevent unnecessary actions
if (node[state] !== true) {
// Toggle assigned radio buttons
if (!keep && state == _checked && node[_type] == _radio && node.name) {
var form = input.closest('form'),
inputs = 'input[name="' + node.name + '"]';
inputs = form.length ? form.find(inputs) : $(inputs);
inputs.each(function() {
if (this !== node && $(this).data(_iCheck)) {
off($(this), state);
};
});
};
// Indeterminate state
if (indeterminate) {
// Add indeterminate state
node[state] = true;
// Remove checked state
if (node[_checked]) {
off(input, _checked, 'force');
};
// Checked or disabled state
} else {
// Add checked or disabled state
if (!keep) {
node[state] = true;
};
// Remove indeterminate state
if (checked && node[_indeterminate]) {
off(input, _indeterminate, false);
};
};
// Trigger callbacks
callbacks(input, checked, state, keep);
};
// Add proper cursor
if (node[_disabled] && !!option(input, _cursor, true)) {
parent.find('.' + _iCheckHelper).css(_cursor, 'default');
};
// Add state class
parent[_add](specific || option(input, state) || '');
// Set ARIA attribute
disabled ? parent.attr('aria-disabled', 'true') : parent.attr('aria-checked', indeterminate ? 'mixed' : 'true');
// Remove regular state class
parent[_remove](regular || option(input, callback) || '');
} | javascript | {
"resource": ""
} |
q32443 | off | train | function off(input, state, keep) {
var node = input[0],
parent = input.parent(),
checked = state == _checked,
indeterminate = state == _indeterminate,
disabled = state == _disabled,
callback = indeterminate ? _determinate : checked ? _unchecked : 'enabled',
regular = option(input, callback + capitalize(node[_type])),
specific = option(input, state + capitalize(node[_type]));
// Prevent unnecessary actions
if (node[state] !== false) {
// Toggle state
if (indeterminate || !keep || keep == 'force') {
node[state] = false;
};
// Trigger callbacks
callbacks(input, checked, callback, keep);
};
// Add proper cursor
if (!node[_disabled] && !!option(input, _cursor, true)) {
parent.find('.' + _iCheckHelper).css(_cursor, 'pointer');
};
// Remove state class
parent[_remove](specific || option(input, state) || '');
// Set ARIA attribute
disabled ? parent.attr('aria-disabled', 'false') : parent.attr('aria-checked', 'false');
// Add regular state class
parent[_add](regular || option(input, callback) || '');
} | javascript | {
"resource": ""
} |
q32444 | tidy | train | function tidy(input, callback) {
if (input.data(_iCheck)) {
// Remove everything except input
input.parent().html(input.attr('style', input.data(_iCheck).s || ''));
// Callback
if (callback) {
input[_callback](callback);
};
// Unbind events
input.off('.i').unwrap();
$(_label + '[for="' + input[0].id + '"]').add(input.closest(_label)).off('.i');
};
} | javascript | {
"resource": ""
} |
q32445 | option | train | function option(input, state, regular) {
if (input.data(_iCheck)) {
return input.data(_iCheck).o[state + (regular ? '' : 'Class')];
};
} | javascript | {
"resource": ""
} |
q32446 | ajaxCallback | train | function ajaxCallback(data, textStatus) {
//responses should be a list of successful responses
//if any request failed it *may or may not* be an http-level error
//depending on server-side implementation
// konsole.log("datarequest", data, textStatus, 'dbdata.'+txnId, comment);
if (textStatus == 'success') {
data.getErrors = function() {
if (this.error) return [this.error];
var errors = [];
for (var i=0; i < this.length; i++) {
if (this[i].error)
errors.push(this[i].error);
}
return errors;
};
data.hasErrors = function() { return this.getErrors().length > 0;}
if (false !== $(elem).triggerHandler('dbdata-'+txnId, [data, request, comment])) {
$(elem).trigger('dbdata', [data, request, comment]);
}
} else {
//when textStatus != 'success', data param will be a XMLHttpRequest obj
var errorObj = {"jsonrpc": "2.0", "id": null,
"error": {"code": -32000,
"message": data.statusText || textStatus,
'data' : data.responseText
},
hasErrors: function() { return true;},
getErrors: function() { return [this.error];}
};
if (false !== $(elem).triggerHandler('dbdata-'+txnId, [errorObj, request, comment])) {
$(elem).trigger('dbdata', [errorObj, request, comment]);
}
}
} | javascript | {
"resource": ""
} |
q32447 | train | function( obj ) {
var accessor = this._getAccessor( obj );
var seen = {};
for( var i = 0; i < this.form.elements.length; i++) {
this.serializeField( this.form.elements[i], accessor, seen);
}
return accessor.target;
} | javascript | {
"resource": ""
} | |
q32448 | train | function( obj ) { //set form html
var accessor = this._getAccessor( obj );
for( var i = 0; i < this.form.elements.length; i++) {
this.deserializeField( this.form.elements[i], accessor );
}
return accessor.target;
} | javascript | {
"resource": ""
} | |
q32449 | train | function( element, obj ) {
var accessor = this._getAccessor( obj );
var value = accessor.get( element.name || '');
value = this._format( element.name, value, element );
if( element.type == "radio" || element.type == "checkbox" ) {
element.checked = this._isSelected( element.value, value );
} else if ( element.type == "select-one" || element.type == "select-multiple" ) {
for( var j = 0; j < element.options.length; j++ ) {
element.options[j].selected = this._isSelected( element.options[j].value, value );
}
} else {
element.value = value || "";
// reset defaultValue if we only want to serialize changed fields
if (this.changedOnly) {
element.defaultValue = value;
}
}
} | javascript | {
"resource": ""
} | |
q32450 | uploadSubmissionFile | train | function uploadSubmissionFile(params, cb) {
var resourcePath = config.addURIParams("/appforms/submissions/:id/fields/:fieldId/files/:fileId", params);
var method = "POST";
var data = params.fileDetails;
params.resourcePath = resourcePath;
params.method = method;
params.data = data;
//Flagging This Request As A File Request
params.fileRequest = true;
params.fileUploadRequest = true;
mbaasRequest.app(params, cb);
} | javascript | {
"resource": ""
} |
q32451 | getSubmissionStatus | train | function getSubmissionStatus(params, cb) {
var resourcePath = config.addURIParams("/appforms/submissions/:id/status", params);
var method = "GET";
var data = {};
params.resourcePath = resourcePath;
params.method = method;
params.data = data;
//Flagging This Request As A File Request
params.fileRequest = true;
mbaasRequest.app(params, cb);
} | javascript | {
"resource": ""
} |
q32452 | exportCSV | train | function exportCSV(params, cb) {
var resourcePath = config.addURIParams("/appforms/submissions/export", params);
var method = "POST";
var data = params.queryParams;
params.resourcePath = resourcePath;
params.method = method;
params.data = data;
params.fileRequest = true;
mbaasRequest.app(params, cb);
} | javascript | {
"resource": ""
} |
q32453 | validate | train | function validate(candidate) {
if (candidate.doc_type) {
var schema = schemasDeepCopy()[candidate.doc_type];
validator.validate(candidate, schema);
var errors = validator.getLastErrors();
return errors;
}
return [{
dataModel: 'the object to be validated is missing a `doc_type` property'
}];
} | javascript | {
"resource": ""
} |
q32454 | generate | train | function generate(model, count) {
count = count || 1;
var registry = {};
var models = [];
if (model) {
models = typeof model === 'string' ? [model] : model;
} else {
models = Object.keys(schemas);
}
function build(model) {
var instance = jsf(schemas[model]);
var invalid = validate(instance);
if (invalid) {
var errors = JSON.stringify(invalid, null, 2);
throw new Error('Invalid "' + model + '" instance:\n' + errors);
}
return instance;
}
function factory(model) {
var instances = [];
for (var i = 0, len = count; i < len; i++) {
var instance = build(model);
instances.push(instance);
}
registry[model] = instances;
}
models.forEach(factory);
return registry;
} | javascript | {
"resource": ""
} |
q32455 | serverClose | train | function serverClose (signal, done) {
_logger.info('Process received ' + signal + ', exiting ....')
if (done === undefined) {
done = function () {
process.exit(0)
}
}
if (server) {
server.close(done)
} else {
done()
}
} | javascript | {
"resource": ""
} |
q32456 | scroll | train | function scroll(e) {
var attr = e.element.attributes;
if (!(attr || attr.href)) return;
var target = $(attr.href.value).plain(0);
if (!target) return;
e.preventDefault();
//
// Store the current window top Y and difference.
//
this.y = document.body.scrollTop;
this.target = target.offsetTop;
this.direction = this.target > this.y ? 1 : -1;
this.delta = Math.abs(this.y - this.target);
//
// Start the animation.
//
this.animated = setInterval(this.animate.bind(this), 10);
} | javascript | {
"resource": ""
} |
q32457 | animate | train | function animate() {
var diff = this.speed;
//
// If we're getting close to the endpoint stop at 0.
//
if (this.delta < diff) {
clearInterval(this.animated);
diff = this.delta;
}
//
// Keep track of how much is scrolled.
//
this.delta = this.delta - diff;
this.y = this.y + diff * this.direction;
//
// Animate the scroll position.
//
window.scrollTo(0, this.y);
} | javascript | {
"resource": ""
} |
q32458 | arrayHasAdjacent | train | function arrayHasAdjacent(values, array) {
error_if_not_array_1.errorIfNotArray(values);
if (is_empty_not_empty_1.isEmpty(values))
return false;
var indexes = array_get_indexes_1.getIndexesOf(values[0], array);
var i = -1;
while (++i < indexes.length) {
if (indexes[i] + values.length > array.length)
return false;
var adjacentItems = array_get_adjacent_at_1.getAdjacentAt(indexes[i], values.length, array);
if (arrays_match_1.arraysMatch(values, adjacentItems))
return true;
}
return false;
} | javascript | {
"resource": ""
} |
q32459 | restartAppFromWatching | train | function restartAppFromWatching(err) {
updateWatcherCount()
if (err) self.emit('error', err)
if (dashboard.state !== 'stop') {
log('Restarting ' + conf.name + ' due to file watch trigger')
appLink.afterThat('restart')
} else log('Watcher restart ignored in stop state')
} | javascript | {
"resource": ""
} |
q32460 | renderTemplate | train | function renderTemplate(fragment, templateName) {
if (templateName === 'none') return fragment._txt;
var t = generator.template$[templateName];
if (!t) {
log('Unknown template %s for %s, using default.', templateName, fragment._href);
t = generator.template$.default;
}
var out;
try { out = t(fragment); }
catch(err) {
var msg = u.format('Error rendering %s\n\ntemplate: %s\n',
fragment._href, templateName, err.stack || err);
log(msg);
out = opts.production ? '' : '<pre>' + esc(msg) + '</pre>';
}
return out;
} | javascript | {
"resource": ""
} |
q32461 | renderPage | train | function renderPage(page) {
var template = pageTemplate(page);
var html = renderTemplate(page, template);
return '<div data-render-page="' + esc(template) + '">' + html + '</div>';
} | javascript | {
"resource": ""
} |
q32462 | docTemplate | train | function docTemplate(page) {
return page.doclayout ||
(page.notemplate && 'none') ||
(page.nolayout && page.template) ||
(generator.template$['doc-layout'] && 'doc-layout') ||
layoutTemplate(page);
} | javascript | {
"resource": ""
} |
q32463 | rewriteLink | train | function rewriteLink(href, renderOpts) {
var imgRoute = renderOpts.fqImages && (renderOpts.fqImages.route || '/images/');
var imgPrefix = renderOpts.fqImages && renderOpts.fqImages.url;
var linkPrefix = renderOpts.fqLinks || renderOpts.relPath;
if (imgPrefix && u.startsWith(href, imgRoute)) { href = imgPrefix + href; }
else if (linkPrefix && /^\/([^/]|$)/.test(href)) { href = linkPrefix + href; }
return href;
} | javascript | {
"resource": ""
} |
q32464 | inventory | train | function inventory() {
var images = generator.images = {};
var currentPage;
var baseRenderImage = generator.renderer.image;
generator.renderer.image = function(href, title, text) {
if (!images[href]) { images[href] = []; }
images[href].push(currentPage._href);
return baseRenderImage(href, title, text);
};
u.each(generator.pages, function(pg) {
currentPage=pg;
renderDoc(pg);
});
generator.renderer.image = baseRenderImage;
} | javascript | {
"resource": ""
} |
q32465 | createSession | train | function createSession(){
// can also check if any ealier session can be used
if (!currentSession){
const createNewSession = _setSessionReferrer();
const currentSessionCookie = utils.getCookie(constants.sessionCookieName);
if (currentSessionCookie && !createNewSession){
const currentSessionSplit = currentSessionCookie.split('__');
currentSession = new session(currentSessionSplit[0],
parseInt(currentSessionSplit[1]), {});
logger.debug('Found existing session', currentSessionSplit[0],
currentSessionSplit[1]);
} else{
currentSession = new session(null, null, {});
setSessionCookie();
logger.debug('Creating new session', currentSession.getSessionToken(),
currentSession.getSessionUnixTime());
}
// associate session referrer with the session
if (sessionReferrer){
currentSession.setExtra('referrer', sessionReferrer);
}
}
return currentSession;
} | javascript | {
"resource": ""
} |
q32466 | train | function(subscription_id) {
var params = {
client_id: this._credentials.client_id,
client_secret: this._credentials.client_secret
};
if (subscription_id==='users') {
params.object = 'user';
} else if (subscription_id==='all') {
params.object = 'all';
} else {
params.id = subscription_id;
}
return params;
} | javascript | {
"resource": ""
} | |
q32467 | train | function() {
this.subscribe('user', function(error, response) {
if (!error && response) {
logger.info('instagram -', 'users', 'subscription confirmed');
Subscriber.prototype.subscriptions['users'] = response.id;
}
});
} | javascript | {
"resource": ""
} | |
q32468 | createAnnotation | train | function createAnnotation(desc) {
utils.check(['type', 'hasTarget', 'annotatedBy'], desc);
var anno = { type: desc.type, hasTarget: desc.hasTarget, annotatedAt : desc.annotatedAt || new Date().toISOString(), annotatedBy : desc.annotatedBy, state: desc.state || utils.states.annotations.unvalidated};
// used to create a hierarchical position
// FIXME reconcile roots / position
var position = desc.roots || [], flattened = desc.type + unitSep;
anno.roots = desc.roots || [];
if (desc.type === 'quote') {
utils.check(['ranges', 'quote'], desc);
if (!desc.ranges || desc.ranges.length < 1) {
utils.checkError(desc, 'missing ranges');
}
anno.quote = desc.quote;
anno.ranges = desc.ranges;
position.push(anno.quote);
flattened += position.join(unitSep);
} else if (desc.type === 'category') {
utils.check(['category'], desc);
anno.category = Array.isArray(desc.category) ? desc.category : [desc.category];
position = position.concat(anno.category);
flattened += position.join(unitSep);
} else if (desc.type === 'value' || desc.type === 'valueQuote') {
utils.check(['key', 'value'], desc);
if (desc.type === 'valueQuote') {
utils.check(['ranges'], desc);
anno.ranges = desc.ranges;
}
anno.key = desc.key;
anno.value = desc.value;
position.push(desc.key);
flattened += position.join(unitSep) + unitSep + desc.value;
// add data types
if (desc.isA) {
try {
anno.isA = desc.isA;
anno.typed = {};
anno.typed[desc.isA] = dataTypes[desc.isA](desc.value);
} catch (e) {
anno.typed.failure = e;
GLOBAL.warn('isA failed', e, desc);
}
}
} else {
throw new Error('unknown type ' + desc.type);
}
anno.position = position;
anno.flattened = flattened;
if (anno.attributes) {
anno.attributes = desc.attributes; // additional attributes
}
return anno;
} | javascript | {
"resource": ""
} |
q32469 | createRange | train | function createRange(desc) {
var fields = ['exact', 'offset', 'selector'];
utils.check(fields, desc);
return { exact: desc.exact, offset: desc.offset, selector: desc.selector};
} | javascript | {
"resource": ""
} |
q32470 | createInstance | train | function createInstance(desc) {
var fields = ['exact', 'instance', 'selector'];
utils.check(fields, desc);
return { exact: desc.exact, instance: desc.instance, selector: desc.selector};
} | javascript | {
"resource": ""
} |
q32471 | diffTable | train | function diffTable(results) {
var curRefs = $('.references-list li').text().toString().split('\n').map(function(r) { return r.trim(); });
$('#sbResults').html('<table><thead><tr><th>Title</th><th>Created</th><th>Source</th></tr></thead><tbody></tbody></table>');
console.log('diffResults', results);
if (results && results.hits.total > 0) {
var t, created;
t += '<tr><th colspan="4">Included</th></tr>';
_.pluck(results.hits.hits, '_source').forEach(function(r) {
created = false;
// included annos
r.annotations.forEach(function(a) {
if (a.key === 'DateCreated' && new Date(a.typed.Date) < new Date(2013, 4)) {
if (curRefs.indexOf(r.title) > -1) {
created = a.typed.Date;
}
}
});
if (created) {
r.created = created;
t += _.template('<tr><td><a href="<%= uri %>"><%= title %></a></td><td><%= created %></td><td><div class="ui tiny buttons"><div class="ui basic tiny button">PubMed</div></td></tr>', r);
}
$('#sbResults table').append(t);
});
t += '<tr><th colspan="4">Not included</th></tr>';
_.pluck(results.hits.hits, '_source').forEach(function(r) {
created = false;
// included annos
r.annotations.forEach(function(a) {
if (a.key === 'DateCreated' && new Date(a.typed.Date) < new Date(2013, 4)) {
if (curRefs.indexOf(r.title) < 0) {
created = a.typed.Date;
}
}
});
if (created) {
r.created = created;
t += _.template('<tr><td><a href="<%= uri %>"><%= title %></a></td><td><%= created %></td><td><div class="ui tiny buttons"><div class="ui basic tiny button">PubMed</div></td></tr>', r);
}
$('#sbResults tbody').append(t);
});
t += '<tr><th colspan="4">New</th></tr>';
_.pluck(results.hits.hits, '_source').forEach(function(r) {
created = false;
// included annos
r.annotations.forEach(function(a) {
if (a.key === 'DateCreated' && new Date(a.typed.Date) > new Date(2013, 3)) {
created = a.typed.Date;
}
});
if (created) {
r.created = created;
t += _.template('<tr><td><a href="<%= uri %>"><%= title %></a></td><td><%= created %></td><td><div class="ui tiny buttons"><div class="ui basic tiny button">PubMed</div></td></tr>', r);
}
$('#sbResults table').html(t);
});
}
} | javascript | {
"resource": ""
} |
q32472 | findInstanceOffset | train | function findInstanceOffset(anno, text) {
var re = new RegExp('\\b'+anno.exact+'\\b', 'g'), cur = 1, match;
while ((match = re.exec(text)) !== null) {
if (cur === anno.instance) {
return match.index;
}
cur++;
}
} | javascript | {
"resource": ""
} |
q32473 | displayAllAnnos | train | function displayAllAnnos(treeItems) {
var items = [], selector, newHTML, i;
// two passes; first assign offsets and add to array with the same selector
for (i in treeItems.map) {
var anno = treeItems.map[i];
console.log(anno);
if (anno.selector === 'body') {
anno.selector = '#SBEnclosure';
}
if (anno.instance && (!selector || selector === anno.selector)) {
if (!newHTML) {
selector = anno.selector;
newHTML = $(selector, doc).html();
}
anno.offset = findInstanceOffset(anno, newHTML);
items.push(anno);
}
}
console.log(items.length, 'eligible in', selector, 'out of', i);
// second pass, sort and display annotations, later first.
var latest = 1, item;
while (latest > -1) {
latest = -1;
for (i = 0; i < items.length; i++) {
item = items[i];
if (item && item.offset > latest) {
latest = i;
}
}
if (latest > -1) {
newHTML = insertAnno(items[latest], newHTML);
delete items[latest];
}
}
try {
$(selector, doc).html(newHTML);
} catch (e) {
console.log('failed for', selector, newHTML.length);
console.log(e);
}
} | javascript | {
"resource": ""
} |
q32474 | insertAnno | train | function insertAnno(anno, newHTML) {
var annoID = 'SB-anno-' + anno.__id;
var startTag = '<span id="' + annoID + '" class="sbAnnotation sbAnnotation-b">', endTag = '</span>';
anno.offset = findInstanceOffset(anno, newHTML);
return newHTML.substring(0, anno.offset) + startTag + anno.exact + endTag + newHTML.substring(anno.offset + anno.exact.length);
} | javascript | {
"resource": ""
} |
q32475 | _getParent | train | function _getParent(config) {
if (config.hasOwnProperty('parent')) {
if (!isString(config.parent)) return config.parent;
if (cache.has(config.parent)) return cache.get(config.parent);
}
return settings.get('parent').parent || settings.get('parent');
} | javascript | {
"resource": ""
} |
q32476 | _getRequire | train | function _getRequire(config) {
if (!config.syncRequire && !config.resolveModulePath) return requireLike(config.filename);
const _requireResolver = {
basedir:config.basedir||path.dirname(config.filename),
parent:config.filename,
scope:config.scope,
useSandbox:config.useSandbox,
squashErrors:!!((config.resolver ||{}).squashErrors || config.squashErrors)
};
const requireX = require('./index');
const _mergeResolver = resolver=>Object.assign({}, _requireResolver, resolver);
const _getResolver = (params, resolverId=0)=>{
if (isString(params[resolverId]) || Array.isArray(params[resolverId])) return _requireResolver;
return _mergeResolver(params.shift());
};
return Object.assign(function(...params) {
return config.syncRequire(_getResolver(params), ...params);
}, requireX, {
resolve: (...params)=>config.resolveModulePathSync(_getResolver(params), ...params),
resolveAsync: (...params)=>config.resolveModulePath(_getResolver(params), ...params),
async: (...params)=>requireX(_getResolver(params), ...params),
native: moduleId=>requireLike(config.filename)(moduleId),
import: (dirPath, options, callback)=>requireX.import(dirPath, _mergeResolver(options), callback)
});
} | javascript | {
"resource": ""
} |
q32477 | createId | train | function createId (coll) {
var _ = this
var idProperty = _.__id()
if (_.isEmpty(coll)) {
return 1
} else {
var id = _.maxBy(coll, function (doc) {
return doc[idProperty]
})[idProperty]
if (_.isFinite(id)) {
// Increment integer id
return ++id
} else {
// Generate string id
return uuid()
}
}
} | javascript | {
"resource": ""
} |
q32478 | hasClass | train | function hasClass(className) {
var i, val;
for(i = 0;i < this.length;i++) {
val = this.get(i).getAttribute(attr);
val = val ? val.split(/\s+/) : [];
if(~val.indexOf(className)) {
return true;
}
}
return false;
} | javascript | {
"resource": ""
} |
q32479 | removeClass | train | function removeClass(className) {
if(!className) {
// remove all classes from all matched elements
this.each(function(el) {
el.removeAttribute(attr);
});
return this;
}
var classes = className.split(/\s+/);
this.each(function(el) {
var val = el.getAttribute(attr);
// no class attribute - nothing to remove
if(!val) {
return;
}
var names = val.split(/\s+/);
names = names.filter(function(nm) {
return ~classes.indexOf(nm) ? false : nm;
});
el.setAttribute(attr, names.join(' '));
});
return this;
} | javascript | {
"resource": ""
} |
q32480 | toggleClass | train | function toggleClass(className) {
var classes = className.split(/\s+/)
, name
, i;
for(i = 0;i < classes.length;i++) {
name = classes[i];
if(this.hasClass(name)) {
this.removeClass(name)
}else{
this.addClass(name)
}
}
} | javascript | {
"resource": ""
} |
q32481 | delById | train | function delById(req, res, next) {
res.__apiMethod = 'delete';
var self = this;
var id = req.params.id;
var filter = this.option('delete', 'filter');
if (filter instanceof Function) filter = filter.call(this, req);
var query = extend({_id: id}, filter);
this.model.remove(query).exec(function(err, affected) {
if (err) return next(err);
if (affected.result.n == 0) {
return next(new ModelAPIError(
404, `The ${self.nameSingle} was not found by ${id}`
));
}
res.status(200);
return res.json({});
});
} | javascript | {
"resource": ""
} |
q32482 | labelFragment | train | function labelFragment(fragment, func, source) {
// use 'in' to handle case where delim is set to ''
var leftDelim = 'leftDelim' in source ? source.leftDelim : '----';
var rightDelim = 'rightDelim' in source ? source.rightDelim : '----';
var headerDelim = 'headerDelim' in source ? source.headerDelim : '';
if (fragment._hdr) {
var lines = fragment._hdr.split('\n');
var fl = lines[0];
// sanity check - make sure this fragments does not have a (func) label already
var lbl = parseLabel(fl.slice(leftDelim.length, fl.length - rightDelim.length), false, source.slugify);
if (lbl.func) return false;
lines[0] = fl.slice(0, fl.length - rightDelim.length) + ' (' + func + ') ' + rightDelim;
fragment._hdr = lines.join('\n');
}
else {
fragment._hdr = leftDelim + ' (' + func + ') ' + rightDelim
+ '\n' + headerDelim + '\n';
}
return true;
} | javascript | {
"resource": ""
} |
q32483 | clientSave | train | function clientSave() {
u.each(sources, function(source) {
var dirtyFiles = u.filter(source.files, function(file) {
if (file._dirty) { // 1 means unsaved, 2 means saving
file._dirty = 2; // side effect of filter
return true;
}
return false;
});
if (dirtyFiles.length) {
var files = u.map(dirtyFiles, generator.serializeFile);
debug('clientSave %s files, %s...', files.length, files[0].text.slice(0,200));
// static save from browser directly to source
if (opts.staticHost && source.staticSrc && source.src) {
// NOTE: subtle difference in data compared to httpClient.put()
source.src.put(files, function(err, savedFiles) {
if (err || (u.size(savedFiles) !== u.size(dirtyFiles))) {
// notify user on save errors
return notify('error saving files, please check your internet connection');
}
u.each(dirtyFiles, function(file) {
// no collision detection support with static saves (for now)
file._oldtext = file.text;
// only mark as clean if unchanged while waiting for save
if (file._dirty === 2) { delete file._dirty; }
});
return source.verbose && notify(u.size(savedFiles) + ' file(s) saved');
});
}
// normal (non-static) save from browser to pub-server
else {
httpClient.put({ source:source.name, files:files }, function(err, savedFiles) {
if (err || (u.size(savedFiles) !== u.size(dirtyFiles))) {
if (err) { log(err); }
// notify user on save errors
return notify('error saving files, please check your internet connection');
}
u.each(dirtyFiles, function(file, idx) {
var savedFile = savedFiles[idx];
if (typeof savedFile !== 'object') {
// most likely a collision - must notify user
return notify('error saving file: ' + savedFile);
}
// preserve for next update
file._oldtext = savedFile.text;
// only mark as clean if unchanged while waiting for save
if (file._dirty === 2) { delete file._dirty; }
});
return source.verbose && notify(u.size(savedFiles) + ' file(s) saved');
});
}
}
});
} | javascript | {
"resource": ""
} |
q32484 | reloadSources | train | function reloadSources(names) {
names = u.isArray(names) ? names :
names ? [names] :
u.keys(opts.source$);
var results = [];
u.each(names, function(name) {
var source = opts.source$[name];
if (source) {
source._reloadFromSource = true;
results.push(name);
} else {
results.push(log('reloadSources unknown source ' + name));
}
});
generator.reload(); // throttled
return results;
} | javascript | {
"resource": ""
} |
q32485 | Alcatraz | train | function Alcatraz(method, source, domain) {
if (!(this instanceof Alcatraz)) return new Alcatraz(method, source);
this.domain = domain || ('undefined' !== typeof document ? document.domain : '');
this.method = 'if ('+method+') '+ method;
this.source = source;
this.compiled = null;
} | javascript | {
"resource": ""
} |
q32486 | polyconsole | train | function polyconsole(method) {
var attach = { debug: 1, error: 1, log: 1, warn: 1 };
//
// Ensure that this host environment always has working console.
//
global.console[method] = function polyfilled() {
var args = Array.prototype.slice.call(arguments, 0);
//
// If the host supports this given method natively, execute it.
//
if (method in fconsole) fconsole[method].apply(fconsole, args);
//
// Proxy messages to the container.
//
this._alcatraz_method_({
attach: method in attach,
type: 'console',
scope: method,
args: args
});
};
} | javascript | {
"resource": ""
} |
q32487 | getDate | train | function getDate(ymValue) {
checkNumber(ymValue)
var utcFullYear = Math.floor(ymValue / monthsPerYear) + zeroUtcFullYear
var utcMonth = modFix(Math.floor(ymValue), monthsPerYear) + zeroUtcMonth
return new Date(Date.UTC(utcFullYear, utcMonth))
} | javascript | {
"resource": ""
} |
q32488 | encodeDate | train | function encodeDate(date) {
if (!(date instanceof Date)) throw new Error('Value not Date: ' + date)
return (date.getUTCFullYear() * monthsPerYear + date.getUTCMonth()) - yearMonthZero
} | javascript | {
"resource": ""
} |
q32489 | handleIt | train | function handleIt(cb) {
callbacks = cb;
broadcast = callbacks.broadcast;
let msg = {
cmd: MessageType.RockPaperScissors,
handlerId: id
};
broadcast("action", msg);
// Return a promise for the result
deferred = q.defer();
return deferred.promise;
} | javascript | {
"resource": ""
} |
q32490 | beginCountdown | train | function beginCountdown() {
let msg = {
cmd: MessageType.RpsCountdown
};
broadcast("action", msg);
q.delay(COUNTDOWN_DELAY).done(determineWinner);
} | javascript | {
"resource": ""
} |
q32491 | restartGame | train | function restartGame(players) {
// Replace the current instance with a new instance
let newGame = new RockPaperScissors(game, players, winCounter, id);
proxy.swap(newGame);
q.delay(RESULTS_DELAY)
.done(function() {
deferred.resolve(newGame.handleIt(callbacks));
});
} | javascript | {
"resource": ""
} |
q32492 | containsPath | train | function containsPath(self, dirname) {
return self.__paths__.some(function(p) {
return p === dirname.substr(0, p.length);
});
} | javascript | {
"resource": ""
} |
q32493 | sortMatches | train | function sortMatches(self, matches, basename) {
var weights = {};
var ext_name = path.extname(basename);
var aliases = has(self.__aliases__, ext_name) ? self.__aliases__[ext_name] : [];
matches.forEach(function(match) {
// XXX: this doesn't work well with aliases
// i.e. entry=index.php, extnames=index.html
var extnames = match.replace(basename, '').split('.');
weights[match] = extnames.reduce(function(sum, ext) {
if (!ext) {
return sum;
}
ext = '.' + ext;
if (self.__extensions__.indexOf(ext) >= 0) {
return sum + self.__extensions__.indexOf(ext) + 1;
}
if (aliases.indexOf(ext) >= 0) {
return sum + aliases.indexOf(ext) + 11;
}
return sum;
}, 0);
});
return matches.sort(function(a, b) {
return weights[a] > weights[b] ? 1 : -1;
});
} | javascript | {
"resource": ""
} |
q32494 | match | train | function match(self, dirname, basename, callback) {
var pathname, stats, pattern, matches;
pattern = patternFor(self, basename);
matches = self.entries(dirname).filter(function(m) { return pattern.test(m); });
matches = sortMatches(self, matches, basename);
while (matches.length) {
pathname = path.join(dirname, matches.shift());
stats = self.stat(pathname);
if (stats && stats.isFile() && callback(pathname)) {
return pathname;
}
}
} | javascript | {
"resource": ""
} |
q32495 | setPositionCallback | train | function setPositionCallback(positionFunction){
if (typeof(positionFunction) == 'function'){
orientationCollector.setPositionCallback(positionFunction);
callbacks.positionCallback = positionFunction;
}
else
logger.warn('Trying to set a non function object as position callback');
} | javascript | {
"resource": ""
} |
q32496 | configureEventCollection | train | function configureEventCollection(eventType, collectionStatus, timePeriod){
if (eventType in dataConfig){
// check that collection status is present as true or false
collectionStatus = collectionStatus == false ? false : true;
dataConfig[eventType].status = collectionStatus;
if(!isNaN(timePeriod)){
timePeriod = parseInt(timePeriod);
if(timePeriod > 0){
dataConfig[eventType].timePeriod = timePeriod;
}else{
dataConfig[eventType].status = false;
}
}
}
} | javascript | {
"resource": ""
} |
q32497 | tick | train | function tick(){
performanceCollector.tick();
const useMedia = dataManager.getMediaState();
const playTimeSinceStart = timeManager.getPlayTimeSinceStart();
for (let key in dataConfig){
const infoDict = dataConfig[key];
if (infoDict.status &&
playTimeSinceStart - infoDict.lastFetchTime > infoDict.timePeriod){
const timeDifferene = playTimeSinceStart - infoDict.lastFetchTime;
if (useMedia)
_setEvents(infoDict.calculator.getMediaEvents(timeDifferene));
// always collecting default events
_setEvents(infoDict.calculator.getEvents(timeDifferene));
infoDict.lastFetchTime = playTimeSinceStart;
}
}
} | javascript | {
"resource": ""
} |
q32498 | _setEvents | train | function _setEvents(eventsArray){
for (let i = 0; i < eventsArray.length; i++){
let event = eventsArray[i];
dataManager.registerEvent(event[0], event[1], event[2]);
}
} | javascript | {
"resource": ""
} |
q32499 | train | function(propertyName, value)
{
if (this[propertyName] === value)
{
return this;
}
// Ensure numbers are returned as Number not String
if (value && conbo.isString(value) && !isNaN(value))
{
value = parseFloat(value);
if (isNaN(value)) value = '';
}
this[propertyName] = value;
return this;
} | javascript | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.