_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q7500
|
cautiouslyApplyEach
|
train
|
function cautiouslyApplyEach(
array,
fns,
log = true,
keepOldValueOnFalseyReturn = false)
{
let items = Array.from(array);
if (items && Array.isArray(items) && fns && Array.isArray(fns)) {
items.forEach((item, itemIndex, itemArray) => {
let newItem = item;
fns.forEach(fn => {
try {
let bindFunctor = Array.isArray(fn) && fn[1];
let functor = bindFunctor ?
fn[0].bind(newItem) :
Array.isArray(fn) ? fn[0] : fn;
if (keepOldValueOnFalseyReturn)
newItem = functor(newItem, itemIndex, itemArray) || newItem;else
newItem = functor(newItem, itemIndex, itemArray);
}
catch (error) {
if (log) {
console.error(error);
}
}
});
items[itemIndex] = newItem;
});
}
return items;
}
|
javascript
|
{
"resource": ""
}
|
q7501
|
cautiouslyApply
|
train
|
function cautiouslyApply(
item,
fns,
log = true,
keepOldValueOnFalseyReturn = false)
{
if (fns && Array.isArray(fns)) {
fns.forEach(fn => {
try {
let bindFunctor = Array.isArray(fn) && fn[1];
let functor = bindFunctor ?
fn[0].bind(item) :
Array.isArray(fn) ? fn[0] : fn;
if (keepOldValueOnFalseyReturn)
item = functor(item) || item;else
item = functor(item);
}
catch (error) {
if (log) {
console.error(error);
}
}
});
}
return item;
}
|
javascript
|
{
"resource": ""
}
|
q7502
|
measureIndents
|
train
|
function measureIndents(
string,
config = {
preWork: [],
perLine: [],
postWork: [] },
whitespace = /[ \t]/)
{
let regexp = new RegExp(`(^${whitespace.source}*)`);
let strings;
let indents;
if (Array.isArray(string)) {
string = string.join('\n');
}
string = cautiouslyApply(string, config.preWork, true, true);
strings = string.split(/\r?\n/);
indents = strings.map((s, i, a) => {
let search;
s = cautiouslyApply(s, config.perLine, true, false);
search = regexp.exec(s);
return search && search[1].length || 0;
});
return cautiouslyApply([strings, indents], config.postWork);
}
|
javascript
|
{
"resource": ""
}
|
q7503
|
stripEmptyFirstAndLast
|
train
|
function stripEmptyFirstAndLast(string) {
let strings = string.split(/\r?\n/);
// construct a small resuable function for trimming all initial whitespace
let trimL = s => s.replace(/^([ \t]*)/, '');
let trimR = s => s.replace(/([ \t]*)($)/, '$1');
// the first line is usually a misnomer, discount it if it is only
// whitespace
if (!trimL(strings[0]).length) {
strings.splice(0, 1);
}
// the same goes for the last line
if (
strings.length &&
strings[strings.length - 1] &&
!trimL(strings[strings.length - 1]).length)
{
strings.splice(strings.length - 1, 1);
}
return strings.join('\n');
}
|
javascript
|
{
"resource": ""
}
|
q7504
|
dropLowestIndents
|
train
|
function dropLowestIndents(
values)
{
let [strings, indents] = values;
let set = new Set(indents);
let lowest = Math.min(...indents);
set.delete(lowest);
return [strings, Array.from(set)];
}
|
javascript
|
{
"resource": ""
}
|
q7505
|
GregorianCalendar
|
train
|
function GregorianCalendar(timezoneOffset, locale) {
var args = util.makeArray(arguments);
if (typeof timezoneOffset === 'object') {
locale = timezoneOffset;
timezoneOffset = locale.timezoneOffset;
} else if (args.length >= 3) {
timezoneOffset = locale = null;
}
locale = locale || defaultLocale;
this.locale = locale;
this.fields = []; /**
* The currently set time for this date.
* @protected
* @type Number|undefined
*/
/**
* The currently set time for this date.
* @protected
* @type Number|undefined
*/
this.time = undefined; /**
* The timezoneOffset in minutes used by this date.
* @type Number
* @protected
*/
/**
* The timezoneOffset in minutes used by this date.
* @type Number
* @protected
*/
this.timezoneOffset = timezoneOffset || locale.timezoneOffset; /**
* The first day of the week
* @type Number
* @protected
*/
/**
* The first day of the week
* @type Number
* @protected
*/
this.firstDayOfWeek = locale.firstDayOfWeek; /**
* The number of days required for the first week in a month or year,
* with possible values from 1 to 7.
* @@protected
* @type Number
*/
/**
* The number of days required for the first week in a month or year,
* with possible values from 1 to 7.
* @@protected
* @type Number
*/
this.minimalDaysInFirstWeek = locale.minimalDaysInFirstWeek;
this.fieldsComputed = false;
if (arguments.length >= 3) {
this.set.apply(this, args);
}
}
|
javascript
|
{
"resource": ""
}
|
q7506
|
train
|
function (field) {
if (MIN_VALUES[field] !== undefined) {
return MIN_VALUES[field];
}
var fields = this.fields;
if (field === WEEK_OF_MONTH) {
var cal = new GregorianCalendar(fields[YEAR], fields[MONTH], 1);
return cal.get(WEEK_OF_MONTH);
}
throw new Error('minimum value not defined!');
}
|
javascript
|
{
"resource": ""
}
|
|
q7507
|
train
|
function (field) {
if (MAX_VALUES[field] !== undefined) {
return MAX_VALUES[field];
}
var value, fields = this.fields;
switch (field) {
case DAY_OF_MONTH:
value = getMonthLength(fields[YEAR], fields[MONTH]);
break;
case WEEK_OF_YEAR:
var endOfYear = new GregorianCalendar(fields[YEAR], GregorianCalendar.DECEMBER, 31);
value = endOfYear.get(WEEK_OF_YEAR);
if (value === 1) {
value = 52;
}
break;
case WEEK_OF_MONTH:
var endOfMonth = new GregorianCalendar(fields[YEAR], fields[MONTH], getMonthLength(fields[YEAR], fields[MONTH]));
value = endOfMonth.get(WEEK_OF_MONTH);
break;
case DAY_OF_YEAR:
value = getYearLength(fields[YEAR]);
break;
case DAY_OF_WEEK_IN_MONTH:
value = toInt((getMonthLength(fields[YEAR], fields[MONTH]) - 1) / 7) + 1;
break;
}
if (value === undefined) {
throw new Error('maximum value not defined!');
}
return value;
}
|
javascript
|
{
"resource": ""
}
|
|
q7508
|
train
|
function (field, v) {
var len = arguments.length;
if (len === 2) {
this.fields[field] = v;
} else if (len < MILLISECONDS + 1) {
for (var i = 0; i < len; i++) {
this.fields[YEAR + i] = arguments[i];
}
} else {
throw new Error('illegal arguments for KISSY GregorianCalendar set');
}
this.time = undefined;
}
|
javascript
|
{
"resource": ""
}
|
|
q7509
|
train
|
function (value, amount, min, max) {
var diff = value - min;
var range = max - min + 1;
amount %= range;
return min + (diff + amount + range) % range;
}
|
javascript
|
{
"resource": ""
}
|
|
q7510
|
train
|
function (field, amount) {
if (!amount) {
return;
}
var self = this; // computer and retrieve original value
// computer and retrieve original value
var value = self.get(field);
var min = self.getActualMinimum(field);
var max = self.getActualMaximum(field);
value = self.getRolledValue(value, amount, min, max);
self.set(field, value); // consider compute time priority
// consider compute time priority
switch (field) {
case MONTH:
adjustDayOfMonth(self);
break;
default:
// other fields are set already when get
self.updateFieldsBySet(field);
break;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q7511
|
train
|
function (field) {
var fields = this.fields;
switch (field) {
case WEEK_OF_MONTH:
fields[DAY_OF_MONTH] = undefined;
break;
case DAY_OF_YEAR:
fields[MONTH] = undefined;
break;
case DAY_OF_WEEK:
fields[DAY_OF_MONTH] = undefined;
break;
case WEEK_OF_YEAR:
fields[DAY_OF_YEAR] = undefined;
fields[MONTH] = undefined;
break;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q7512
|
train
|
function () {
var weekYear = this.getWeekYear();
if (weekYear === this.get(YEAR)) {
return this.getActualMaximum(WEEK_OF_YEAR);
} // Use the 2nd week for calculating the max of WEEK_OF_YEAR
// Use the 2nd week for calculating the max of WEEK_OF_YEAR
var gc = this.clone();
gc.setWeekDate(weekYear, 2, this.get(DAY_OF_WEEK));
return gc.getActualMaximum(WEEK_OF_YEAR);
}
|
javascript
|
{
"resource": ""
}
|
|
q7513
|
train
|
function () {
var year = this.get(YEAR); // implicitly complete
// implicitly complete
var weekOfYear = this.get(WEEK_OF_YEAR);
var month = this.get(MONTH);
if (month === GregorianCalendar.JANUARY) {
if (weekOfYear >= 52) {
--year;
}
} else if (month === GregorianCalendar.DECEMBER) {
if (weekOfYear === 1) {
++year;
}
}
return year;
}
|
javascript
|
{
"resource": ""
}
|
|
q7514
|
train
|
function () {
if (this.time === undefined) {
this.computeTime();
}
var cal = new GregorianCalendar(this.timezoneOffset, this.locale);
cal.setTime(this.time);
return cal;
}
|
javascript
|
{
"resource": ""
}
|
|
q7515
|
Pass
|
train
|
function Pass(style, fields, opts, cb) {
Stream.call(this)
// Get our own shallow copy of the fields
this.fields = _.extend({}, fields)
this.style = style
this.opts = opts
if (!this.fields[style]) {
this.fields[style] = {}
}
// Copy structure fields to style
if (this.fields.structure) {
this.fields[style] = this.fields.structure
}
// Structure no longer needed
delete this.fields.structure
// setup images and certs
this._setupImages()
this._setupCerts(opts.certs)
// Transform relevantData to ISO Date if its a Date instance
if (fields.relevantDate instanceof Date) {
fields.relavantDate = fields.relavantDate.toISOString()
}
// Validate pass fields and generate
this.validate()
this.cb = cb
process.nextTick(this._generate.bind(this))
}
|
javascript
|
{
"resource": ""
}
|
q7516
|
sync
|
train
|
function sync() {
// retrieve latency, then wait 1 sec
function getLatencyAndWait() {
var result = null;
if (isDestroyed) {
return Promise.resolve(result);
}
return getLatency(slave)
.then(function (latency) { result = latency }) // store the retrieved latency
.catch(function (err) { console.log(err) }) // just log failed requests
.then(function () { return util.wait(DELAY) }) // wait 1 sec
.then(function () { return result}); // return the retrieved latency
}
return util
.repeat(getLatencyAndWait, REPEAT)
.then(function (all) {
debug('latencies', all);
// filter away failed requests
var latencies = all.filter(function (latency) {
return latency !== null;
});
// calculate the limit for outliers
var limit = stat.median(latencies) + stat.std(latencies);
// filter away outliers: all latencies largereq than the mean+std
var filtered = latencies.filter(function (latency) {
return latency < limit;
});
// return the mean latency
return (filtered.length > 0) ? stat.mean(filtered) : null;
})
.then(function (latency) {
if (isDestroyed) {
return Promise.resolve(null);
}
else {
return slave.request('time').then(function (timestamp) {
var time = timestamp + latency;
slave.emit('change', time);
return time;
});
}
})
.catch(function (err) {
slave.emit('error', err)
});
}
|
javascript
|
{
"resource": ""
}
|
q7517
|
getLatencyAndWait
|
train
|
function getLatencyAndWait() {
var result = null;
if (isDestroyed) {
return Promise.resolve(result);
}
return getLatency(slave)
.then(function (latency) { result = latency }) // store the retrieved latency
.catch(function (err) { console.log(err) }) // just log failed requests
.then(function () { return util.wait(DELAY) }) // wait 1 sec
.then(function () { return result}); // return the retrieved latency
}
|
javascript
|
{
"resource": ""
}
|
q7518
|
getLatency
|
train
|
function getLatency(emitter) {
var start = Date.now();
return emitter.request('time')
.then(function (timestamp) {
var end = Date.now();
var latency = (end - start) / 2;
var time = timestamp + latency;
// apply the first ever retrieved offset immediately.
if (isFirst) {
isFirst = false;
emitter.emit('change', time);
}
return latency;
})
}
|
javascript
|
{
"resource": ""
}
|
q7519
|
build
|
train
|
function build(data) {
const resources = resources_1.ResourcesStructure.create();
const annotations = annotations_1.AnnotationsStructure.create();
data.content[0].content.forEach((content) => {
if (content.element === 'annotation') {
annotations.add(content.content);
return;
}
const resource = resources.createResource(content.attributes.href.content);
content.content.forEach((transition_data) => {
const transition = resource.createTransition(transition_data);
transition_data.content.forEach((http_transaction_data) => {
const http_transaction = transition.createHttpTransaction();
http_transaction.setHttpRequest(http_transaction.createHttpRequest(http_transaction_data.content[0]));
http_transaction.setHttpResponse(http_transaction.createHttpResponse(http_transaction_data.content[1]));
transition.addHttpTransaction(http_transaction);
});
resource.addTransition(transition);
});
resources.add(resource);
});
return resources;
}
|
javascript
|
{
"resource": ""
}
|
q7520
|
Logger
|
train
|
function Logger (level, name) {
if (name) {
debug = require('debug')(typeof name === 'string' ? name : 'vxx');
}
this.level = level;
this.debug('Logger started');
}
|
javascript
|
{
"resource": ""
}
|
q7521
|
error
|
train
|
function error(status, req, res, msg) {
debug('%s %s', status, req.originalUrl);
msg = msg || '';
var page = generator.page$['/' + status];
// 404 with no matching status page => redirect to home
if (!page && status === 404) {
if (generator.home) return res.redirect(302, '/');
if (server.statics.defaultFile) return res.redirect(302, server.statics.defaultFile);
}
// avoid exposing error pages unless authorized
if (page) {
if (!server.isPageAuthorized || !server.isPageAuthorized(req, page)) {
if (server.login) return server.login(req, res);
else page = null;
}
}
if (!page) return res.status(status).send(u.escape(msg));
res.status(status).send(
generator.renderDoc(page)
.replace(/%s/g, u.escape(msg)) // TODO - replace with humane.js or proper template
.replace('<body', '<body data-err-status="' + status + '"' + (msg ? ' data-err-msg="' + u.escape(msg) + '"' : ''))
);
}
|
javascript
|
{
"resource": ""
}
|
q7522
|
train
|
function(frame) {
if (script2) {
script2.parentNode.removeChild(script2);
script2 = null;
}
if (script) {
clearTimeout(tref);
script.parentNode.removeChild(script);
script.onreadystatechange = script.onerror =
script.onload = script.onclick = null;
script = null;
callback(frame);
callback = null;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q7523
|
train
|
function(url, constructReceiver, user_callback) {
var id = 'a' + utils.random_string(6);
var url_id = url + '?c=' + escape(WPrefix + '.' + id);
// Callback will be called exactly once.
var callback = function(frame) {
delete _window[WPrefix][id];
user_callback(frame);
};
var close_script = constructReceiver(url_id, callback);
_window[WPrefix][id] = close_script;
var stop = function() {
if (_window[WPrefix][id]) {
_window[WPrefix][id](utils.closeFrame(1000, "JSONP user aborted read"));
}
};
return stop;
}
|
javascript
|
{
"resource": ""
}
|
|
q7524
|
wrapWorkAndCallback
|
train
|
function wrapWorkAndCallback(work, callback) {
return function(err) {
work.stop(err);
callback.apply(this, arguments);
};
}
|
javascript
|
{
"resource": ""
}
|
q7525
|
train
|
function(reaped) {
childCount += 1;
if (reaped) {
self.options.log.trace1('Incrementing reapCount', {current: reapCount});
reapCount += 1;
}
if (childCount >= children.length) {
cbWrapper(function() {
callback(null, reapCount);
});
}
}
|
javascript
|
{
"resource": ""
}
|
|
q7526
|
throttleMiddleware
|
train
|
function throttleMiddleware (request, response, next) {
var ip = null
if (config.useCustomHeader && request.headers[config.useCustomHeader]) {
ip = request.headers[config.useCustomHeader]
} else {
ip = request.headers['x-forwarded-for'] ||
request.connection.remoteAddress ||
request.socket.remoteAddress ||
request.connection.socket.remoteAddress || ''
ip = ip.split(',')[0]
if (!ipRegex().test(ip) || ip.substr(0, 7) === '::ffff:' || ip === '::1') {
ip = '127.0.0.1'
} else {
ip = ip.match(ipRegex())[0]
}
}
Throttle
.findOneAndUpdate({ip: ip}, { $inc: { hits: 1 } }, { upsert: false })
.exec(function (error, throttle) {
if (errHandler(response, next, error)) { return }
if (!throttle) {
throttle = new Throttle({
createdAt: new Date(),
ip: ip
})
throttle.save(function (error, throttle) {
// THERE'S NO ERROR, BUT THROTTLE WAS NOT SAVE
if (!throttle && !error) {
error = new Error('Error checking rate limit.')
}
if (errHandler(response, next, error)) { return }
respondWithThrottle(request, response, next, throttle)
})
} else {
respondWithThrottle(request, response, next, throttle)
}
})
}
|
javascript
|
{
"resource": ""
}
|
q7527
|
send
|
train
|
function send (event, data) {
var envelope = {
event: event,
data: data
};
debug('send', envelope);
socket.send(JSON.stringify(envelope));
}
|
javascript
|
{
"resource": ""
}
|
q7528
|
request
|
train
|
function request (event, data) {
return new Promise(function (resolve, reject) {
// put the data in an envelope with id
var id = getId();
var envelope = {
event: event,
id: id,
data: data
};
// add the request to the list with requests in progress
queue[id] = {
resolve: resolve,
reject: reject,
timeout: setTimeout(function () {
delete queue[id];
reject(new Error('Timeout'));
}, TIMEOUT)
};
debug('request', envelope);
socket.send(JSON.stringify(envelope));
}).catch(function (err) {console.log('ERROR', err)});
}
|
javascript
|
{
"resource": ""
}
|
q7529
|
dummyMarkdown
|
train
|
function dummyMarkdown() {
var codeBlock = /^```/;
var quoteBlock = /^>/;
var listBlock = /^\* /;
var commentInline = '<!--.*-->';
var codeInline = '`.+`';
function split(content) {
var pattern = new RegExp([commentInline, codeInline].join('|'), 'g');
var result = null;
var last = 0;
var output = [];
while ((result = pattern.exec(content)) !== null) {
output.push({ transform: true, content: content.slice(last, result.index)});
output.push({ transform: false, content: result[0]});
last = pattern.lastIndex;
}
output.push({ transform: true, content: content.slice(last)});
return output;
}
return function (input) {
var output = [];
var lines = input.split('\n');
for (var l = 0; l < lines.length; l++) {
var line = lines[l];
var e;
var content;
if (codeBlock.test(line)) {
e = l + 1;
while (!codeBlock.test(lines[e])) {
e++;
}
output.push({ transform: false, content: lines.slice(l, e + 1).join('\n') + '\n\n' });
l = e;
} else if (quoteBlock.test(line)) {
e = l + 1;
while (quoteBlock.test(lines[e])) {
e++;
}
content = [line].concat(lines.slice(l + 1, e).map(function (nextLine) {
return nextLine.slice(2);
})).join(' ') + '\n\n';
output = output.concat(split(content));
l = e - 1;
} else if (listBlock.test(line)) {
e = l + 1;
while (lines[e] !== '') {
if (!listBlock.test(lines[e])) {
lines[e - 1] += ' ' + lines[e];
lines[e] = '';
}
e++;
}
content = lines.slice(l, e).filter(function (line) {
return line !== '';
}).join('\n') + '\n';
output = output.concat(split(content));
l = e - 1;
} else if (line !== '') {
e = l + 1;
while (lines[e] !== '') {
e++;
}
content = lines.slice(l, e).join(' ') + '\n\n';
output = output.concat(split(content));
l = e - 1;
}
}
return output;
};
}
|
javascript
|
{
"resource": ""
}
|
q7530
|
parser
|
train
|
function parser(file, callback) {
// file exit conditions
if(file.isNull()) {
return callback(null, file); // pass along
}
if(file.isStream()) {
return callback(new Error('Streaming not supported'));
}
try {
var
/** @type {string} */
text = String(file.contents.toString('utf8')),
lines = text.split('\n'),
filename = file.path.substring(0, file.path.length - 4),
key = 'server/documents',
position = filename.indexOf(key)
;
// exit conditions
if(!lines) {
return;
}
if(position < 0) {
return callback(null, file);
}
filename = filename.substring(position + key.length + 1, filename.length);
var
lineCount = lines.length,
active = false,
yaml = [],
categories = [
'UI Element',
'UI Global',
'UI Collection',
'UI View',
'UI Module',
'UI Behavior'
],
index,
meta,
line
;
for(index = 0; index < lineCount; index++) {
line = lines[index];
// Wait for metadata block to begin
if(!active) {
if(startsWith(line, '---')) {
active = true;
}
continue;
}
// End of metadata block, stop parsing.
if(startsWith(line, '---')) {
break;
}
yaml.push(line);
}
// Parse yaml.
meta = YAML.parse(yaml.join('\n'));
if(meta && meta.type && meta.title && inArray(meta.type, categories) ) {
meta.category = meta.type;
meta.filename = filename;
meta.url = '/' + filename;
meta.title = meta.title;
// Primary key will by filepath
data[meta.element] = meta;
}
else {
// skip
// console.log(meta);
}
}
catch(error) {
console.log(error, filename);
}
callback(null, file);
}
|
javascript
|
{
"resource": ""
}
|
q7531
|
train
|
function (element, deep) {
var
childNodes = element.childNodes || [],
index = -1,
key, value, childNode;
if (element.nodeType === 1 && element.constructor !== Element) {
element.constructor = Element;
for (key in cache) {
value = cache[key];
element[key] = value;
}
}
while (childNode = deep && childNodes[++index]) {
shiv(childNode, deep);
}
return element;
}
|
javascript
|
{
"resource": ""
}
|
|
q7532
|
bodyCheck
|
train
|
function bodyCheck() {
if (!(loopLimit--)) clearTimeout(interval);
if (document.body && !document.body.prototype && /(complete|interactive)/.test(document.readyState)) {
shiv(document, true);
if (interval && document.body.prototype) clearTimeout(interval);
return (!!document.body.prototype);
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
q7533
|
_getConfig
|
train
|
function _getConfig () {
return {
paced: paced,
rate: rate,
deterministic: deterministic,
time: configuredTime,
master: master,
port: port
}
}
|
javascript
|
{
"resource": ""
}
|
q7534
|
_rescheduleIntervals
|
train
|
function _rescheduleIntervals(now) {
for (var i = 0; i < timeouts.length; i++) {
var timeout = timeouts[i];
if (timeout.type === TYPE.INTERVAL) {
_rescheduleInterval(timeout, now);
}
}
}
|
javascript
|
{
"resource": ""
}
|
q7535
|
_rescheduleInterval
|
train
|
function _rescheduleInterval(timeout, now) {
timeout.occurrence = Math.round((now - timeout.firstTime) / timeout.interval);
timeout.time = timeout.firstTime + timeout.occurrence * timeout.interval;
}
|
javascript
|
{
"resource": ""
}
|
q7536
|
_execTimeout
|
train
|
function _execTimeout(timeout, callback) {
// store the timeout in the queue with timeouts in progress
// it can be cleared when a clearTimeout is executed inside the callback
current[timeout.id] = timeout;
function finish() {
// in case of an interval we have to reschedule on next cycle
// interval must not be cleared while executing the callback
if (timeout.type === TYPE.INTERVAL && current[timeout.id]) {
timeout.occurrence++;
timeout.time = timeout.firstTime + timeout.occurrence * timeout.interval;
_queueTimeout(timeout);
//console.log('queue timeout', timer.getTime().toISOString(), new Date(timeout.time).toISOString(), timeout.occurrence) // TODO: cleanup
}
// remove the timeout from the queue with timeouts in progress
delete current[timeout.id];
callback && callback();
}
// execute the callback
try {
if (timeout.callback.length == 0) {
// synchronous timeout, like `timer.setTimeout(function () {...}, delay)`
timeout.callback();
finish();
} else {
// asynchronous timeout, like `timer.setTimeout(function (done) {...; done(); }, delay)`
timeout.callback(finish);
}
} catch (err) {
// emit or log the error
if (hasListeners(timer, 'error')) {
timer.emit('error', err);
}
else {
console.log('Error', err);
}
finish();
}
}
|
javascript
|
{
"resource": ""
}
|
q7537
|
_getExpiredTimeouts
|
train
|
function _getExpiredTimeouts(time) {
var i = 0;
while (i < timeouts.length && ((timeouts[i].time <= time) || !isFinite(timeouts[i].time))) {
i++;
}
var expired = timeouts.splice(0, i);
if (deterministic == false) {
// the array with expired timeouts is in deterministic order
// shuffle them
util.shuffle(expired);
}
return expired;
}
|
javascript
|
{
"resource": ""
}
|
q7538
|
_schedule
|
train
|
function _schedule() {
// do not _schedule when there are timeouts in progress
// this can be the case with async timeouts in non-paced mode.
// _schedule will be executed again when all async timeouts are finished.
if (!paced && Object.keys(current).length > 0) {
return;
}
var next = timeouts[0];
// cancel timer when running
if (timeoutId) {
clearTimeout(timeoutId);
timeoutId = null;
}
if (running && next) {
// schedule next timeout
var time = next.time;
var delay = time - timer.now();
var realDelay = paced ? delay / rate : 0;
function onTimeout() {
// when running in non-paced mode, update the hyperTime to
// adjust the time of the current event
if (!paced) {
hyperTime = (time > hyperTime && isFinite(time)) ? time : hyperTime;
}
// grab all expired timeouts from the queue
var expired = _getExpiredTimeouts(time);
// note: expired.length can never be zero (on every change of the queue, we reschedule)
// execute all expired timeouts
if (paced) {
// in paced mode, we fire all timeouts in parallel,
// and don't await their completion (they can do async operations)
expired.forEach(function (timeout) {
_execTimeout(timeout);
});
// schedule the next round
_schedule();
}
else {
// in non-paced mode, we execute all expired timeouts serially,
// and wait for their completion in order to guarantee deterministic
// order of execution
function next() {
var timeout = expired.shift();
if (timeout) {
_execTimeout(timeout, next);
}
else {
// schedule the next round
_schedule();
}
}
next();
}
}
timeoutId = setTimeout(onTimeout, Math.round(realDelay));
// Note: Math.round(realDelay) is to defeat a bug in node.js v0.10.30,
// see https://github.com/joyent/node/issues/8065
}
}
|
javascript
|
{
"resource": ""
}
|
q7539
|
toTimestamp
|
train
|
function toTimestamp(date) {
var value =
(typeof date === 'number') ? date : // number
(date instanceof Date) ? date.valueOf() : // Date
new Date(date).valueOf(); // ISOString, momentjs, ...
if (isNaN(value)) {
throw new TypeError('Invalid date ' + JSON.stringify(date) + '. ' +
'Date, number, or ISOString expected');
}
return value;
}
|
javascript
|
{
"resource": ""
}
|
q7540
|
pick
|
train
|
function pick(obj, keys) {
var result = {};
for (var i = 0, length = keys.length; i < length; i++) {
var key = keys[i];
if (key in obj) result[key] = obj[key];
}
return result;
}
|
javascript
|
{
"resource": ""
}
|
q7541
|
copyAndPush
|
train
|
function copyAndPush(arr, obj) {
var result = arr.slice();
result.push(obj);
return result;
}
|
javascript
|
{
"resource": ""
}
|
q7542
|
Walker
|
train
|
function Walker(traversalStrategy) {
if (!(this instanceof Walker))
return new Walker(traversalStrategy);
// There are two different strategy shorthands: if a single string is
// specified, treat the value of that property as the traversal target.
// If an array is specified, the traversal target is the node itself, but
// only the properties contained in the array will be traversed.
if (isString(traversalStrategy)) {
var prop = traversalStrategy;
traversalStrategy = function(node) {
if (isObject(node) && prop in node) return node[prop];
};
} else if (Array.isArray(traversalStrategy)) {
var props = traversalStrategy;
traversalStrategy = function(node) {
if (isObject(node)) return pick(node, props);
};
}
this._traversalStrategy = traversalStrategy || defaultTraversal;
}
|
javascript
|
{
"resource": ""
}
|
q7543
|
createMiddleware
|
train
|
function createMiddleware(router, validator) {
/**
* Checks request and response against a swagger spec
* Uses the usual koa context attributes
* Uses the koa-bodyparser context attribute
* Sets a new context attribute: {object} parameter
*/
return function* middleware(next) {
// Routing matches
try {
var routeMatch = match.path(router, this.path);
} catch(e) {
// TODO: let an option before doing that, strict mode throws the error
yield next;
return false;
}
this.pathParam = routeMatch.param; // Add the path's params to the context
var methodDef = match.method(routeMatch.def, this.method);
// Parameters check & assign
this.parameter = check.parameters(validator,
methodDef.parameters || [], this);
// Let the implementation happen
yield next;
// Response check
var statusDef = match.status(methodDef.responses || {}, this.status);
check.sentHeaders(validator, statusDef.headers || {}, this.sentHeaders);
if(statusDef.schema) {
check.body(validator, statusDef.schema, yield this.body);
}
};
}
|
javascript
|
{
"resource": ""
}
|
q7544
|
start
|
train
|
function start(projectConfig) {
var config = initConfig(projectConfig);
if (traceApi.isActive() && !config.forceNewAgent_) { // already started.
throw new Error('Cannot call start on an already started agent.');
}
if (!config.enabled) {
return traceApi;
}
if (config.logLevel < 0) {
config.logLevel = 0;
} else if (config.logLevel >= Logger.LEVELS.length) {
config.logLevel = Logger.LEVELS.length - 1;
}
var logger = new Logger(config.logLevel, config.logger === 'debug' ? 'vxx' : undefined);
if (onUncaughtExceptionValues.indexOf(config.onUncaughtException) === -1) {
logger.error('The value of onUncaughtException should be one of ',
onUncaughtExceptionValues);
throw new Error('Invalid value for onUncaughtException configuration.');
}
var headers = {};
headers[constants.TRACE_AGENT_REQUEST_HEADER] = 1;
if (modulesLoadedBeforeTrace.length > 0) {
logger.error('Tracing might not work as the following modules ' +
'were loaded before the trace agent was initialized: ' +
JSON.stringify(modulesLoadedBeforeTrace));
}
agent = require('./src/trace-agent.js').get(config, logger);
traceApi.enable_(agent);
pluginLoader.activate(agent);
traceApi.getCls = function() {
return agent.getCls();
};
traceApi.getBus = function() {
return agent.traceWriter;
};
return traceApi;
}
|
javascript
|
{
"resource": ""
}
|
q7545
|
train
|
function (signed, bytes, size) {
if (signed) {
switch(bytes) {
case 1:
return new Int8Array(size);
case 2:
return new Int16Array(size);
case 4:
return new Int32Array(size);
default:
throw new RangeError("Invalid newArray parameter element_bytes:" + bytes);
}
} else {
switch(bytes) {
case 1:
return new Uint8Array(size);
case 2:
return new Uint16Array(size);
case 4:
return new Uint32Array(size);
default:
throw new RangeError("Invalid newArray parameter element_bytes:" + bytes);
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q7546
|
scan
|
train
|
function scan(sp, cb) {
cb = u.onceMaybe(cb);
var timer = u.timer();
sp.route = sp.route || '/';
var src = sp.src;
// only construct src, defaults, sendOpts etc. once
if (!src) {
sp.name = sp.name || 'staticPath:' + sp.path;
sp.depth = sp.depth || opts.staticDepth || 5;
sp.maxAge = 'maxAge' in sp ? sp.maxAge : '10m';
sp.includeBinaries = true;
src = sp.src = fsbase(sp);
if (src.isfile()) { sp.depth = 1; }
sp.sendOpts = u.assign(
u.pick(sp, 'maxAge', 'lastModified', 'etag'),
{ dotfiles:'ignore',
index:false, // handled at this level
extensions:false, // ditto
root:src.path } );
}
src.listfiles(function(err, files) {
if (err) return cb(log(err));
sp.files = files;
self.scanCnt++;
mapAllFiles();
debug('static scan %s-deep %sms %s', sp.depth, timer(), sp.path.replace(/.*\/node_modules\//g, ''));
debug(files.length > 10 ? '[' + files.length + ' files]' : u.pluck(files, 'filepath'));
cb();
});
}
|
javascript
|
{
"resource": ""
}
|
q7547
|
train
|
function () {
var gamepadSupportAvailable = navigator.getGamepads ||
!!navigator.webkitGetGamepads ||
!!navigator.webkitGamepads;
if (!gamepadSupportAvailable) {
// It doesn't seem Gamepad API is available, show a message telling
// the visitor about it.
window.tester.showNotSupported();
} else {
// Check and see if gamepadconnected/gamepaddisconnected is supported.
// If so, listen for those events and don't start polling until a
// gamepad has been connected.
if (gamepadSupport.hasEvents) {
// If connection events are not supported, just start polling.
gamepadSupport.startPolling();
} else {
window.addEventListener('gamepadconnected',
gamepadSupport.onGamepadConnect);
window.addEventListener('gamepaddisconnected',
gamepadSupport.onGamepadDisconnect);
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q7548
|
train
|
function (event) {
// Add the new gamepad on the list of gamepads to look after.
gamepadSupport.gamepads.push(event.gamepad);
// Ask the tester to update the screen to show more gamepads.
window.tester.updateGamepads(gamepadSupport.gamepads);
// Start the polling loop to monitor button changes.
gamepadSupport.startPolling();
}
|
javascript
|
{
"resource": ""
}
|
|
q7549
|
train
|
function (event) {
// Remove the gamepad from the list of gamepads to monitor.
for (var i in gamepadSupport.gamepads) {
if (gamepadSupport.gamepads[i].index === event.gamepad.index) {
gamepadSupport.gamepads.splice(i, 1);
break;
}
}
// If no gamepads are left, stop the polling loop (but only if
// `gamepadconnected` will get fired when a gamepad is reconnected).
if (!gamepadSupport.gamepads.length && gamepadSupport.hasEvents) {
gamepadSupport.stopPolling();
}
// Ask the tester to update the screen to remove the gamepad.
window.tester.updateGamepads(gamepadSupport.gamepads);
}
|
javascript
|
{
"resource": ""
}
|
|
q7550
|
train
|
function (gamepadId) {
var gamepad = gamepadSupport.gamepads[gamepadId];
// Update all the buttons (and their corresponding labels) on screen.
window.tester.updateButton(gamepad.buttons[0], gamepadId, 'button-1');
window.tester.updateButton(gamepad.buttons[1], gamepadId, 'button-2');
window.tester.updateButton(gamepad.buttons[2], gamepadId, 'button-3');
window.tester.updateButton(gamepad.buttons[3], gamepadId, 'button-4');
window.tester.updateButton(gamepad.buttons[4], gamepadId,
'button-left-shoulder-top');
window.tester.updateButton(gamepad.buttons[6], gamepadId,
'button-left-shoulder-bottom');
window.tester.updateButton(gamepad.buttons[5], gamepadId,
'button-right-shoulder-top');
window.tester.updateButton(gamepad.buttons[7], gamepadId,
'button-right-shoulder-bottom');
window.tester.updateButton(gamepad.buttons[8], gamepadId, 'button-select');
window.tester.updateButton(gamepad.buttons[9], gamepadId, 'button-start');
window.tester.updateButton(gamepad.buttons[10], gamepadId, 'stick-1');
window.tester.updateButton(gamepad.buttons[11], gamepadId, 'stick-2');
window.tester.updateButton(gamepad.buttons[12], gamepadId, 'button-dpad-top');
window.tester.updateButton(gamepad.buttons[13], gamepadId, 'button-dpad-bottom');
window.tester.updateButton(gamepad.buttons[14], gamepadId, 'button-dpad-left');
window.tester.updateButton(gamepad.buttons[15], gamepadId, 'button-dpad-right');
// Update all the analogue sticks.
window.tester.updateAxis(gamepad.axes[0], gamepadId,
'stick-1-axis-x', 'stick-1', true);
window.tester.updateAxis(gamepad.axes[1], gamepadId,
'stick-1-axis-y', 'stick-1', false);
window.tester.updateAxis(gamepad.axes[2], gamepadId,
'stick-2-axis-x', 'stick-2', true);
window.tester.updateAxis(gamepad.axes[3], gamepadId,
'stick-2-axis-y', 'stick-2', false);
// Update extraneous buttons.
var extraButtonId = gamepadSupport.TYPICAL_BUTTON_COUNT;
while (typeof gamepad.buttons[extraButtonId] !== 'undefined') {
window.tester.updateButton(gamepad.buttons[extraButtonId], gamepadId,
'extra-button-' + extraButtonId);
extraButtonId++;
}
// Update extraneous axes.
var extraAxisId = gamepadSupport.TYPICAL_AXIS_COUNT;
while (typeof gamepad.axes[extraAxisId] !== 'undefined') {
window.tester.updateAxis(gamepad.axes[extraAxisId], gamepadId,
'extra-axis-' + extraAxisId);
extraAxisId++;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q7551
|
pushFiles
|
train
|
function pushFiles() {
console.info('Pushing files for ' + component);
git.push('origin', 'master', { args: '', cwd: outputDirectory }, function(error) {
console.info('Push completed successfully');
getSHA();
});
}
|
javascript
|
{
"resource": ""
}
|
q7552
|
getSHA
|
train
|
function getSHA() {
git.exec(versionOptions, function(error, version) {
version = version.trim();
createRelease(version);
});
}
|
javascript
|
{
"resource": ""
}
|
q7553
|
nextRepo
|
train
|
function nextRepo() {
console.log('Sleeping for 1 second...');
// avoid rate throttling
global.clearTimeout(timer);
timer = global.setTimeout(stepRepo, 100);
}
|
javascript
|
{
"resource": ""
}
|
q7554
|
Template
|
train
|
function Template(style, fields, opts) {
// throw early if style is incorrect
if (passFields.STYLES.indexOf(style) === -1) {
throw new Error('Incorrect passbook style ' + style)
}
this.style = style
this.opts = opts || {}
this.fields = fields || {}
// Set formatVersion by default
this.fields.formatVersion = 1
}
|
javascript
|
{
"resource": ""
}
|
q7555
|
headingRange
|
train
|
function headingRange(node, options, callback) {
var test = options
var ignoreFinalDefinitions = false
// Object, not regex.
if (test && typeof test === 'object' && !('exec' in test)) {
ignoreFinalDefinitions = test.ignoreFinalDefinitions === true
test = test.test
}
if (typeof test === 'string') {
test = toExpression(test)
}
// Regex
if (test && 'exec' in test) {
test = wrapExpression(test)
}
if (typeof test !== 'function') {
throw new Error(
'Expected `string`, `regexp`, or `function` for `test`, not `' +
test +
'`'
)
}
search(node, test, ignoreFinalDefinitions, callback)
}
|
javascript
|
{
"resource": ""
}
|
q7556
|
search
|
train
|
function search(root, test, skip, callback) {
var index = -1
var children = root.children
var length = children.length
var depth = null
var start = null
var end = null
var nodes
var clean
var child
while (++index < length) {
child = children[index]
if (closing(child, depth)) {
end = index
break
}
if (opening(child, depth, test)) {
start = index
depth = child.depth
}
}
if (start !== null) {
if (end === null) {
end = length
}
if (skip) {
while (end > start) {
child = children[end - 1]
if (!definition(child)) {
break
}
end--
}
}
nodes = callback(
children[start],
children.slice(start + 1, end),
children[end],
{
parent: root,
start: start,
end: children[end] ? end : null
}
)
clean = []
index = -1
length = nodes && nodes.length
// Ensure no empty nodes are inserted. This could be the case if `end` is
// in `nodes` but no `end` node exists.
while (++index < length) {
if (nodes[index]) {
clean.push(nodes[index])
}
}
if (nodes) {
splice.apply(children, [start, end - start + 1].concat(clean))
}
}
}
|
javascript
|
{
"resource": ""
}
|
q7557
|
init
|
train
|
function init (prefs, callback) {
options = _.extend(defaults, prefs);
app = options.app || express();
app.use(cors());
ramlMocker.generate(options, process(function(requestsToMock){
requestsToMock.forEach(function(reqToMock){
addRoute(reqToMock);
});
log(new Array(30).join('='));
log('%s[%s]%s API routes generated', colors.qyan, requestsToMock.length, colors.default);
if(typeof callback === 'function'){
callback(app);
}
}));
var watcher = watch();
var server = launchServer(app);
function close () {
if (watcher) { watcher.close(); }
if (server) { server.close(); }
}
return {
close: close,
server: server,
watcher: watcher
};
}
|
javascript
|
{
"resource": ""
}
|
q7558
|
logout
|
train
|
function logout(_ref3) {
var state = _ref3.state,
commit = _ref3.commit;
commit('c3s/user/SET_CURRENT_USER', null, {
root: true
});
commit('SET_ANON', false);
}
|
javascript
|
{
"resource": ""
}
|
q7559
|
getActivities
|
train
|
function getActivities(_ref, _ref2) {
var state = _ref.state,
commit = _ref.commit,
dispatch = _ref.dispatch,
rootState = _ref.rootState;
var _ref3 = _slicedToArray(_ref2, 2),
search = _ref3[0],
limit = _ref3[1];
search = rison.encode(search);
return makeRequest(commit, rootState.c3s.client.apis.Activities.get_activities, {
search_term: search || undefined,
limit: limit || 100
}, 'c3s/activity/SET_ACTIVITIES');
}
|
javascript
|
{
"resource": ""
}
|
q7560
|
createActivity
|
train
|
function createActivity(_ref9, activity) {
var state = _ref9.state,
commit = _ref9.commit,
rootState = _ref9.rootState;
return makeRequest(commit, rootState.c3s.client.apis.Activities.create_activity, {
activity: activity
}, 'c3s/activity/SET_ACTIVITY');
}
|
javascript
|
{
"resource": ""
}
|
q7561
|
deleteActivity
|
train
|
function deleteActivity(_ref10, _ref11) {
var state = _ref10.state,
commit = _ref10.commit,
rootState = _ref10.rootState;
var _ref12 = _slicedToArray(_ref11, 2),
pid = _ref12[0],
localRemove = _ref12[1];
if (localRemove) commit('c3s/activity/SET_ACTIVITY', null);
return makeRequest(commit, rootState.c3s.client.apis.Activities.delete_activity, {
id: pid
}, undefined);
}
|
javascript
|
{
"resource": ""
}
|
q7562
|
deleteTasks
|
train
|
function deleteTasks(_ref12, tasks) {
var state = _ref12.state,
commit = _ref12.commit,
dispatch = _ref12.dispatch,
rootState = _ref12.rootState;
dispatch('SET_TASKS', null);
return makeRequest(commit, rootState.c3s.client.apis.Tasks.delete_tasks, {
tasks: tasks
}, 'c3s/task/SET_TASKS');
}
|
javascript
|
{
"resource": ""
}
|
q7563
|
getProjects
|
train
|
function getProjects(_ref, _ref2) {
var state = _ref.state,
commit = _ref.commit,
dispatch = _ref.dispatch,
rootState = _ref.rootState;
var _ref3 = _slicedToArray(_ref2, 2),
search = _ref3[0],
limit = _ref3[1];
search = rison.encode(search);
return makeRequest(commit, rootState.c3s.client.apis.Projects.get_projects, {
search_term: search || undefined,
limit: limit || 100
}, 'c3s/project/SET_PROJECTS');
}
|
javascript
|
{
"resource": ""
}
|
q7564
|
createProject
|
train
|
function createProject(_ref8, project) {
var state = _ref8.state,
commit = _ref8.commit,
rootState = _ref8.rootState;
return makeRequest(commit, rootState.c3s.client.apis.Projects.create_project, {
project: project
}, 'c3s/project/SET_PROJECT');
}
|
javascript
|
{
"resource": ""
}
|
q7565
|
deleteProject
|
train
|
function deleteProject(_ref9, _ref10) {
var state = _ref9.state,
commit = _ref9.commit,
rootState = _ref9.rootState;
var _ref11 = _slicedToArray(_ref10, 2),
pid = _ref11[0],
localRemove = _ref11[1];
if (localRemove) commit('c3s/project/SET_PROJECT', null);
return makeRequest(commit, rootState.c3s.client.apis.Projects.delete_project, {
id: pid
}, undefined);
}
|
javascript
|
{
"resource": ""
}
|
q7566
|
install
|
train
|
function install(Vue) {
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
Swagger({
url: options.swaggerURL,
requestInterceptor: function requestInterceptor(req) {
// req.headers['content-type'] = 'application/json'
if (options.store.state.c3s && options.store.state.c3s.user) {
var u = options.store.state.c3s.user.currentUser;
if (u) {
req.headers['X-API-KEY'] = u.api_key;
}
} else {
console.log('c3s: state not loaded or not found');
}
return req;
}
}).then(function (client) {
var store = options.store;
var swaggerURL = options.swaggerURL;
if (!store || !swaggerURL) {
console.error('C3S: Missing store and/or Swagger URL params.');
return;
}
console.log('Loaded from ' + options.swaggerURL);
for (var i in modules) {
var m = modules[i];
var name = m['name'];
var preserve = true;
if (Array.isArray(name)) {
if (store.state.c3s && store.state.c3s[name[1]] === undefined) {
preserve = false;
}
} else {
if (store.state[name] === undefined) {
preserve = false;
}
}
store.registerModule(name, m['module'], {
preserveState: preserve
}); // if (store.state.hasOwnProperty(m['name']) === false) {
// console.error('C3S: C3S vuex module is not correctly initialized. Please check the module name:', m['name']);
// return;
// }
// TODO check why store reports this as false when it is created
}
store.commit('c3s/SET_API', client);
var isLoaded = function isLoaded() {
if (store.c3s !== undefined && store.c3s.client !== null) {
return true;
} else {
return false;
}
};
Vue.prototype.$c3s = {
store: C3SStore,
loaded: isLoaded
};
Vue.c3s = {
store: C3SStore,
loaded: isLoaded
};
}).catch(function (err) {
console.error('C3S: URL was not found or an initialisation error occurred');
console.error(err);
});
}
|
javascript
|
{
"resource": ""
}
|
q7567
|
TraceWriter
|
train
|
function TraceWriter(logger, options) {
options = options || {};
EventEmitter.call(this);
/** @private */
this.logger_ = logger;
/** @private */
this.config_ = options;
/** @private {Array<string>} stringified traces to be published */
this.buffer_ = [];
/** @private {Object} default labels to be attached to written spans */
this.defaultLabels_ = {};
/** @private {Boolean} whether the trace writer is active */
this.isActive = true;
}
|
javascript
|
{
"resource": ""
}
|
q7568
|
arraySpliceOut
|
train
|
function arraySpliceOut(mutate, at, arr) {
var newLen = arr.length - 1;
var i = 0;
var g = 0;
var out = arr;
if (mutate) {
i = g = at;
} else {
out = new Array(newLen);
while (i < at) {
out[g++] = arr[i++];
}
}
++i;
while (i <= newLen) {
out[g++] = arr[i++];
}if (mutate) {
out.length = newLen;
}
return out;
}
|
javascript
|
{
"resource": ""
}
|
q7569
|
arraySpliceIn
|
train
|
function arraySpliceIn(mutate, at, v, arr) {
var len = arr.length;
if (mutate) {
var _i = len;
while (_i >= at) {
arr[_i--] = arr[_i];
}arr[at] = v;
return arr;
}
var i = 0,
g = 0;
var out = new Array(len + 1);
while (i < at) {
out[g++] = arr[i++];
}out[at] = v;
while (i < len) {
out[++g] = arr[i++];
}return out;
}
|
javascript
|
{
"resource": ""
}
|
q7570
|
Leaf
|
train
|
function Leaf(edit, hash, key, value) {
return {
type: LEAF,
edit: edit,
hash: hash,
key: key,
value: value,
_modify: Leaf__modify
};
}
|
javascript
|
{
"resource": ""
}
|
q7571
|
Collision
|
train
|
function Collision(edit, hash, children) {
return {
type: COLLISION,
edit: edit,
hash: hash,
children: children,
_modify: Collision__modify
};
}
|
javascript
|
{
"resource": ""
}
|
q7572
|
IndexedNode
|
train
|
function IndexedNode(edit, mask, children) {
return {
type: INDEX,
edit: edit,
mask: mask,
children: children,
_modify: IndexedNode__modify
};
}
|
javascript
|
{
"resource": ""
}
|
q7573
|
ArrayNode
|
train
|
function ArrayNode(edit, size, children) {
return {
type: ARRAY,
edit: edit,
size: size,
children: children,
_modify: ArrayNode__modify
};
}
|
javascript
|
{
"resource": ""
}
|
q7574
|
isLeaf
|
train
|
function isLeaf(node) {
return node === empty || node.type === LEAF || node.type === COLLISION;
}
|
javascript
|
{
"resource": ""
}
|
q7575
|
pack
|
train
|
function pack(edit, count, removed, elements) {
var children = new Array(count - 1);
var g = 0;
var bitmap = 0;
for (var i = 0, len = elements.length; i < len; ++i) {
if (i !== removed) {
var elem = elements[i];
if (elem && !isEmptyNode(elem)) {
children[g++] = elem;
bitmap |= 1 << i;
}
}
}
return IndexedNode(edit, bitmap, children);
}
|
javascript
|
{
"resource": ""
}
|
q7576
|
mergeLeaves
|
train
|
function mergeLeaves(edit, shift, h1, n1, h2, n2) {
if (h1 === h2) return Collision(edit, h1, [n2, n1]);
var subH1 = hashFragment(shift, h1);
var subH2 = hashFragment(shift, h2);
return IndexedNode(edit, toBitmap(subH1) | toBitmap(subH2), subH1 === subH2 ? [mergeLeaves(edit, shift + SIZE, h1, n1, h2, n2)] : subH1 < subH2 ? [n1, n2] : [n2, n1]);
}
|
javascript
|
{
"resource": ""
}
|
q7577
|
updateCollisionList
|
train
|
function updateCollisionList(mutate, edit, keyEq, h, list, f, k, size) {
var len = list.length;
for (var i = 0; i < len; ++i) {
var child = list[i];
if (keyEq(k, child.key)) {
var value = child.value;
var _newValue = f(value);
if (_newValue === value) return list;
if (_newValue === nothing) {
--size.value;
return arraySpliceOut(mutate, i, list);
}
return arrayUpdate(mutate, i, Leaf(edit, h, k, _newValue), list);
}
}
var newValue = f();
if (newValue === nothing) return list;
++size.value;
return arrayUpdate(mutate, len, Leaf(edit, h, k, newValue), list);
}
|
javascript
|
{
"resource": ""
}
|
q7578
|
lazyVisitChildren
|
train
|
function lazyVisitChildren(len, children, i, f, k) {
while (i < len) {
var child = children[i++];
if (child && !isEmptyNode(child)) return lazyVisit(child, f, [len, children, i, f, k]);
}
return appk(k);
}
|
javascript
|
{
"resource": ""
}
|
q7579
|
lazyVisit
|
train
|
function lazyVisit(node, f, k) {
switch (node.type) {
case LEAF:
return {
value: f(node),
rest: k
};
case COLLISION:
case ARRAY:
case INDEX:
var children = node.children;
return lazyVisitChildren(children.length, children, 0, f, k);
default:
return appk(k);
}
}
|
javascript
|
{
"resource": ""
}
|
q7580
|
truncate
|
train
|
function truncate(string, length) {
if (Buffer.byteLength(string, 'utf8') <= length) {
return string;
}
string = string.substr(0, length - 3);
while (Buffer.byteLength(string, 'utf8') > length - 3) {
string = string.substr(0, string.length - 1);
}
return string + '...';
}
|
javascript
|
{
"resource": ""
}
|
q7581
|
findModulePath
|
train
|
function findModulePath(request, parent) {
var mainScriptDir = path.dirname(Module._resolveFilename(request, parent));
var resolvedModule = Module._resolveLookupPaths(request, parent);
var paths = resolvedModule[1];
for (var i = 0, PL = paths.length; i < PL; i++) {
if (mainScriptDir.indexOf(paths[i]) === 0) {
return path.join(paths[i], request.replace('/', path.sep));
}
}
return null;
}
|
javascript
|
{
"resource": ""
}
|
q7582
|
findModuleVersion
|
train
|
function findModuleVersion(modulePath, load) {
if (modulePath) {
var pjson = path.join(modulePath, 'package.json');
if (fs.existsSync(pjson)) {
return load(pjson).version;
}
}
return process.version;
}
|
javascript
|
{
"resource": ""
}
|
q7583
|
train
|
function( queryOptions, callback ) {
var _this = this;
if ( typeof queryOptions === 'function' ) {
callback = queryOptions;
this.capabilities( function( err, capabilities ) {
if ( err ) {
debug( "Error getting layers for server '%s': %j", _this.baseUrl,
err.stack );
return callback( err );
}
try {
callback( null, capabilities.capability.layer.layer );
} catch ( e ) {
callback( e );
}
} );
} else if ( typeof callback === 'function' ) {
this.capabilities( queryOptions, function( err, capabilities ) {
if ( err ) {
debug( "Error getting layers for server '%s': %j", _this.baseUrl,
err.stack );
return callback( err );
}
callback( null, capabilities.capability.layer.layer );
} );
}
}
|
javascript
|
{
"resource": ""
}
|
|
q7584
|
train
|
function( queryOptions, callback ) {
var _this = this;
if ( typeof queryOptions === 'function' ) {
callback = queryOptions;
this.capabilities( function( err, capabilities ) {
if ( err ) {
debug( 'Error getting layers: %j', err );
return callback( err );
}
if ( _this.version === '1.3.0' ) {
callback( null, capabilities.capability.layer.crs );
} else {
callback( null, capabilities.capability.layer.srs );
}
} );
} else if ( typeof callback === 'function' ) {
this.capabilities( queryOptions, function( err, capabilities ) {
if ( err ) {
debug( 'Error getting layers: %j', err );
return callback( err );
}
if ( _this.version === '1.3.0' ) {
callback( null, capabilities.capability.layer.crs );
} else {
callback( null, capabilities.capability.layer.srs );
}
} );
}
}
|
javascript
|
{
"resource": ""
}
|
|
q7585
|
train
|
function( queryOptions, callback ) {
if ( typeof queryOptions === 'function' ) {
callback = queryOptions;
queryOptions = {};
}
this.capabilities( queryOptions, function( err, capabilities ) {
if ( err ) {
debug( 'Error getting service metadata: %j', err );
return callback( err );
}
callback( null, capabilities.service );
} );
}
|
javascript
|
{
"resource": ""
}
|
|
q7586
|
train
|
function( wmsBaseUrl, queryOptions ) {
queryOptions = extend( {
request: 'GetCapabilities',
version: this.version,
service: 'WMS'
}, queryOptions );
// Append user provided GET parameters in the URL to required queryOptions
var urlQueryParams = new urijs( wmsBaseUrl ).search( true );
queryOptions = extend( queryOptions, urlQueryParams );
// Merge queryOptions GET parameters to the URL
var url = new urijs( wmsBaseUrl ).search( queryOptions );
debug( 'Using capabilities URL: %s', url );
return url.toString();
}
|
javascript
|
{
"resource": ""
}
|
|
q7587
|
train
|
function( minx, miny, maxx, maxy ) {
var bbox = '';
if ( this.version === '1.3.0' ) {
bbox = [minx, miny, maxx, maxy].join( ',' );
} else {
bbox = [miny, minx, maxy, maxx].join( ',' );
}
return bbox;
}
|
javascript
|
{
"resource": ""
}
|
|
q7588
|
checkParameter
|
train
|
function checkParameter(validator, def, context) {
var value = match.fromContext(def.name, def.in, context);
// Check requirement
if(def.required && !value) {
throw new ValidationError(def.name + " is required");
} else if(!value) {
return def.default;
}
// Select the right schema according to the spec
var schema;
if(def.in === "body") {
schema = def.schema;
// TODO: clean and sanitize recursively
} else {
// TODO: coerce other types
if(def.type === "integer") {
value = parseInt(value);
} else if(def.type === "number") {
value = parseFloat(value);
} else if(def.type === "file") {
def.type = "object";
}
if (def.in === "query" && def.type === "array") {
if(!def.collectionFormat || def.collectionFormat === "csv") {
value = value.split(",");
} else if (def.collectionFormat === "tsv") {
value = value.split("\t");
} else if (def.collectionFormat === "ssv") {
value = value.split(" ");
} else if (def.collectionFormat === "psv") {
value = value.split("|");
} else if (def.collectionFormat === "multi") {
throw new ValidationError("multi collectionFormat query parameters currently unsupported");
} else {
throw new ValidationError("unknown collectionFormat " + def.collectionFormat);
}
}
schema = def;
}
var err = validator(value, schema);
if(err.length > 0) {
throw new ValidationError(def.name + " has an invalid format: " +
JSON.stringify(err));
}
return value;
}
|
javascript
|
{
"resource": ""
}
|
q7589
|
createError
|
train
|
function createError(code, type, desc) {
errors[code] = function (msg, meta) {
const err = new type(msg);
if (desc) {
if (!meta) {
meta = {};
}
meta.desc = desc;
}
return Object.defineProperties(err, {
code: {
configurable: true,
enumerable: true,
writable: true,
value: `ERR_${code}`
},
meta: {
configurable: true,
value: meta || undefined,
writable: true
}
});
};
Object.defineProperties(errors[code], {
name: {
configurable: true,
value: code,
writable: true
},
toString: {
configurable: true,
value: function toString() {
return `ERR_${code}`;
},
writable: true
}
});
}
|
javascript
|
{
"resource": ""
}
|
q7590
|
train
|
function(config) {
config = config || extend(false, {}, defaults);
/*--------------
File Paths
---------------*/
var
configPath = this.getPath(),
sourcePaths = {},
outputPaths = {},
folder
;
// resolve paths (config location + base + path)
for(folder in config.paths.source) {
if(config.paths.source.hasOwnProperty(folder)) {
sourcePaths[folder] = path.resolve(path.join(configPath, config.base, config.paths.source[folder]));
}
}
for(folder in config.paths.output) {
if(config.paths.output.hasOwnProperty(folder)) {
outputPaths[folder] = path.resolve(path.join(configPath, config.base, config.paths.output[folder]));
}
}
// set config paths to full paths
config.paths.source = sourcePaths;
config.paths.output = outputPaths;
// resolve "clean" command path
config.paths.clean = path.resolve( path.join(configPath, config.base, config.paths.clean) );
/*--------------
CSS URLs
---------------*/
// determine asset paths in css by finding relative path between themes and output
// force forward slashes
config.paths.assets = {
source : '../../themes', // source asset path is always the same
uncompressed : './' + path.relative(config.paths.output.uncompressed, config.paths.output.themes).replace(/\\/g, '/'),
compressed : './' + path.relative(config.paths.output.compressed, config.paths.output.themes).replace(/\\/g, '/'),
packaged : './' + path.relative(config.paths.output.packaged, config.paths.output.themes).replace(/\\/g, '/')
};
/*--------------
Permission
---------------*/
if(config.permission) {
config.hasPermissions = true;
}
else {
// pass blank object to avoid causing errors
config.permission = {};
config.hasPermissions = false;
}
/*--------------
Globs
---------------*/
if(!config.globs) {
config.globs = {};
}
// remove duplicates from component array
if(config.components instanceof Array) {
config.components = config.components.filter(function(component, index) {
return config.components.indexOf(component) == index;
});
}
// takes component object and creates file glob matching selected components
config.globs.components = (typeof config.components == 'object')
? (config.components.length > 1)
? '{' + config.components.join(',') + '}'
: config.components[0]
: '{' + defaults.components.join(',') + '}'
;
return config;
}
|
javascript
|
{
"resource": ""
}
|
|
q7591
|
train
|
function(exists, cb) {
if(!exists) {
fs.mkdir(rootDir + '/node_modules', function(error) {
cb(error);
});
} else {
cb(null);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q7592
|
SpanData
|
train
|
function SpanData(agent, trace, name, parentSpanId, isRoot, skipFrames) {
var spanId = uid++;
this.agent = agent;
var spanName = traceUtil.truncate(name, constants.TRACE_SERVICE_SPAN_NAME_LIMIT);
this.span = new TraceSpan(spanName, spanId, parentSpanId);
this.trace = trace;
this.isRoot = isRoot;
trace.spans.push(this.span);
if (agent.config().stackTraceLimit > 0) {
// This is a mechanism to get the structured stack trace out of V8.
// prepareStackTrace is called th first time the Error#stack property is
// accessed. The original behavior is to format the stack as an exception
// throw, which is not what we like. We customize it.
//
// See: https://code.google.com/p/v8-wiki/wiki/JavaScriptStackTraceApi
//
var origLimit = Error.stackTraceLimit;
Error.stackTraceLimit = agent.config().stackTraceLimit + skipFrames;
var origPrepare = Error.prepareStackTrace;
Error.prepareStackTrace = function(error, structured) {
return structured;
};
var e = {};
Error.captureStackTrace(e, SpanData);
var stackFrames = [];
e.stack.forEach(function(callSite, i) {
if (i < skipFrames) {
return;
}
var functionName = callSite.getFunctionName();
var methodName = callSite.getMethodName();
var name = (methodName && functionName) ?
functionName + ' [as ' + methodName + ']' :
functionName || methodName || '<anonymous function>';
stackFrames.push(new StackFrame(undefined, name,
callSite.getFileName(), callSite.getLineNumber(),
callSite.getColumnNumber()));
});
// Set the label on the trace span directly to bypass truncation to
// config.maxLabelValueSize.
this.span.setLabel(TraceLabels.STACK_TRACE_DETAILS_KEY,
traceUtil.truncate(JSON.stringify({stack_frame: stackFrames}),
constants.TRACE_SERVICE_LABEL_VALUE_LIMIT));
Error.stackTraceLimit = origLimit;
Error.prepareStackTrace = origPrepare;
}
}
|
javascript
|
{
"resource": ""
}
|
q7593
|
wrapCallback
|
train
|
function wrapCallback(api, span, done) {
var fn = function(err, res) {
if (api.enhancedDatabaseReportingEnabled()) {
if (err) {
// Errors may contain sensitive query parameters.
span.addLabel('mongoError', err);
}
if (res) {
var result = res.result ? res.result : res;
span.addLabel('result', result);
}
}
span.endSpan();
if (done) {
done(err, res);
}
};
return api.wrap(fn);
}
|
javascript
|
{
"resource": ""
}
|
q7594
|
TraceSpan
|
train
|
function TraceSpan(name, spanId, parentSpanId) {
this.name = name;
this.parentSpanId = parentSpanId;
this.spanId = spanId;
this.kind = 'RPC_CLIENT';
this.labels = {};
this.startTime = (new Date()).toISOString();
this.endTime = '';
}
|
javascript
|
{
"resource": ""
}
|
q7595
|
printHeadingCB
|
train
|
function printHeadingCB(err, heading) {
if (err) {
console.log(err);
return;
}
console.log(heading * 180 / Math.PI);
}
|
javascript
|
{
"resource": ""
}
|
q7596
|
ChildSpan
|
train
|
function ChildSpan(agent, span) {
this.agent_ = agent;
this.span_ = span;
this.serializedTraceContext_ = agent.generateTraceContext(span, true);
}
|
javascript
|
{
"resource": ""
}
|
q7597
|
RootSpan
|
train
|
function RootSpan(agent, span) {
this.agent_ = agent;
this.span_ = span;
this.serializedTraceContext_ = agent.generateTraceContext(span, true);
}
|
javascript
|
{
"resource": ""
}
|
q7598
|
TraceApiImplementation
|
train
|
function TraceApiImplementation(agent, pluginName) {
this.agent_ = agent;
this.logger_ = agent.logger;
this.pluginName_ = pluginName;
}
|
javascript
|
{
"resource": ""
}
|
q7599
|
createRootSpan_
|
train
|
function createRootSpan_(api, options, skipFrames) {
options = options || {};
// If the options object passed in has the getTraceContext field set,
// try to retrieve the header field containing incoming trace metadata.
var incomingTraceContext;
if (is.string(options.traceContext)) {
incomingTraceContext = api.agent_.parseContextFromHeader(options.traceContext);
}
incomingTraceContext = incomingTraceContext || {};
if (!api.agent_.shouldTrace(options, incomingTraceContext.options)) {
cls.setRootContext(nullSpan);
return null;
}
var rootContext = api.agent_.createRootSpanData(options.name,
incomingTraceContext.traceId,
incomingTraceContext.spanId,
skipFrames + 1);
return new RootSpan(api.agent_, rootContext);
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.