_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q500 | colorize | train | function colorize(color, str) {
return str
.split('\n')
.map(part => color(part))
.join('\n');
} | javascript | {
"resource": ""
} |
q501 | formatTrace | train | function formatTrace(level, context, message, args, err) {
var recontext = {
time: (new Date()).toISOString(),
lvl: level,
corr: context.corr || notAvailable,
trans: context.trans || notAvailable,
op: context.op || notAvailable
};
Object.keys(context)
.filter((key) => {
return !(context[key] && Object.prototype.toString.call(context[key]) === '[object Function]');
})
.forEach((key) => {
recontext[key] = context[key] || notAvailable;
});
if (message instanceof Date || message instanceof Error) {
// Node6 related hack. See https://github.com/telefonicaid/logops/issues/36
recontext.msg = util.format(message);
} else {
recontext.msg = message;
}
var str = Object.keys(recontext)
.map((key) => key + '=' + recontext[key])
.join(' | ');
args.unshift(str);
if (err && message !== '' + err) {
args.push(err);
}
return util.format.apply(global, args);
} | javascript | {
"resource": ""
} |
q502 | formatJsonTrace | train | function formatJsonTrace(level, context, message, args, err) {
return formatJsonTrace.stringify(formatJsonTrace.toObject(level, context, message, args, err));
} | javascript | {
"resource": ""
} |
q503 | makeRespondMiddleware | train | function makeRespondMiddleware(opts) {
opts = Object.assign({}, opts)
// Make the respond function.
const respond = makeRespond(opts)
/**
* Installs the functions in the context.
*
* @param {KoaContext} ctx
*/
function patch(ctx) {
const statusMethods = Object.assign({}, opts.statusMethods, statusCodeMap)
ctx.send = respond.bind(ctx, ctx)
// Bind status methods.
for (const method in statusMethods) {
const code = statusMethods[method]
ctx[method] = respond.bind(ctx, ctx, code)
}
// Bind other methods
const methods = Object.assign({}, opts.methods)
for (const method in methods) {
const fn = methods[method]
ctx[method] = fn.bind(ctx, ctx)
}
return ctx
}
/**
* The respond middleware adds the methods to the context.
*
* @param {KoaContext} ctx
*/
function respondMiddleware(ctx, next) {
patch(ctx)
return next()
}
// Tack on the patch method to allow Koa 1 users
// to install it, too.
respondMiddleware.patch = patch
return respondMiddleware
} | javascript | {
"resource": ""
} |
q504 | patch | train | function patch(ctx) {
const statusMethods = Object.assign({}, opts.statusMethods, statusCodeMap)
ctx.send = respond.bind(ctx, ctx)
// Bind status methods.
for (const method in statusMethods) {
const code = statusMethods[method]
ctx[method] = respond.bind(ctx, ctx, code)
}
// Bind other methods
const methods = Object.assign({}, opts.methods)
for (const method in methods) {
const fn = methods[method]
ctx[method] = fn.bind(ctx, ctx)
}
return ctx
} | javascript | {
"resource": ""
} |
q505 | bundle | train | function bundle() {
return new Promise((resolve, reject) => {
webpack(webpackConfig).run((err, stats) => {
if (err) {
return reject(err);
}
console.log(stats.toString(webpackConfig[0].stats));
return resolve();
});
});
} | javascript | {
"resource": ""
} |
q506 | detectExtension | train | function detectExtension() {
var mimeType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
var favoredExtension = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
mimeType = mimeType.toString().toLowerCase().replace(/\s/g, '');
if (!(mimeType in _listTypes.types)) {
return 'bin';
}
if (typeof _listTypes.types[mimeType] === 'string') {
return _listTypes.types[mimeType];
}
favoredExtension = favoredExtension.toString().toLowerCase().replace(/\s/g, '');
if (favoredExtension && _listTypes.types[mimeType].includes(favoredExtension)) {
return favoredExtension;
}
// search for name match
var mimePart = mimeType.split('/')[1];
for (var i = 0, len = _listTypes.types[mimeType].length; i < len; i++) {
if (mimePart === _listTypes.types[mimeType][i]) {
return _listTypes.types[mimeType][i];
}
}
// use the first one
return _listTypes.types[mimeType][0];
} | javascript | {
"resource": ""
} |
q507 | mapSync | train | function mapSync(transformation) {
return through2.obj(function write(chunk, _, callback) {
let mappedData;
try {
mappedData = transformation(chunk);
} catch (error) {
callback(error);
}
if (mappedData !== undefined) {
this.push(mappedData);
}
callback();
});
} | javascript | {
"resource": ""
} |
q508 | resolveNewPath | train | function resolveNewPath(newBase) {
return mapSync(file => {
file.cwd += newBase;
file.base = file.cwd;
return file;
});
} | javascript | {
"resource": ""
} |
q509 | train | function(modulesPath, viewsPath, areasPath) {
modulesPath = modulesPath || 'viewmodels';
viewsPath = viewsPath || 'views';
areasPath = areasPath || viewsPath;
var reg = new RegExp(escape(modulesPath), 'gi');
this.convertModuleIdToViewId = function (moduleId) {
return moduleId.replace(reg, viewsPath);
};
this.translateViewIdToArea = function (viewId, area) {
if (!area || area == 'partial') {
return areasPath + '/' + viewId;
}
return areasPath + '/' + area + '/' + viewId;
};
} | javascript | {
"resource": ""
} |
|
q510 | train | function(obj, area, elementsToSearch) {
var view;
if (obj.getView) {
view = obj.getView();
if (view) {
return this.locateView(view, area, elementsToSearch);
}
}
if (obj.viewUrl) {
return this.locateView(obj.viewUrl, area, elementsToSearch);
}
var id = system.getModuleId(obj);
if (id) {
return this.locateView(this.convertModuleIdToViewId(id), area, elementsToSearch);
}
return this.locateView(this.determineFallbackViewId(obj), area, elementsToSearch);
} | javascript | {
"resource": ""
} |
|
q511 | train | function (obj) {
var funcNameRegex = /function (.{1,})\(/;
var results = (funcNameRegex).exec((obj).constructor.toString());
var typeName = (results && results.length > 1) ? results[1] : "";
return 'views/' + typeName;
} | javascript | {
"resource": ""
} |
|
q512 | train | function(viewOrUrlOrId, area, elementsToSearch) {
if (typeof viewOrUrlOrId === 'string') {
var viewId;
if (viewEngine.isViewUrl(viewOrUrlOrId)) {
viewId = viewEngine.convertViewUrlToViewId(viewOrUrlOrId);
} else {
viewId = viewOrUrlOrId;
}
if (area) {
viewId = this.translateViewIdToArea(viewId, area);
}
if (elementsToSearch) {
var existing = findInElements(elementsToSearch, viewId);
if (existing) {
return system.defer(function(dfd) {
dfd.resolve(existing);
}).promise();
}
}
return viewEngine.createView(viewId);
}
return system.defer(function(dfd) {
dfd.resolve(viewOrUrlOrId);
}).promise();
} | javascript | {
"resource": ""
} |
|
q513 | processCompressedData | train | function processCompressedData (o) {
// Save the packet counter
o.lastSampleNumber = parseInt(o.rawDataPacket[0]);
const samples = [];
// Decompress the buffer into array
if (o.lastSampleNumber <= k.OBCIGanglionByteId18Bit.max) {
decompressSamples(o, decompressDeltas18Bit(o.rawDataPacket.slice(k.OBCIGanglionPacket18Bit.dataStart, k.OBCIGanglionPacket18Bit.dataStop)));
samples.push(buildSample(o.lastSampleNumber * 2 - 1, o.decompressedSamples[1], o.sendCounts));
samples.push(buildSample(o.lastSampleNumber * 2, o.decompressedSamples[2], o.sendCounts));
switch (o.lastSampleNumber % 10) {
case k.OBCIGanglionAccelAxisX:
o.accelArray[0] = o.sendCounts ? o.rawDataPacket.readInt8(k.OBCIGanglionPacket18Bit.auxByte - 1) : o.rawDataPacket.readInt8(k.OBCIGanglionPacket18Bit.auxByte - 1) * k.OBCIGanglionAccelScaleFactor;
break;
case k.OBCIGanglionAccelAxisY:
o.accelArray[1] = o.sendCounts ? o.rawDataPacket.readInt8(k.OBCIGanglionPacket18Bit.auxByte - 1) : o.rawDataPacket.readInt8(k.OBCIGanglionPacket18Bit.auxByte - 1) * k.OBCIGanglionAccelScaleFactor;
break;
case k.OBCIGanglionAccelAxisZ:
o.accelArray[2] = o.sendCounts ? o.rawDataPacket.readInt8(k.OBCIGanglionPacket18Bit.auxByte - 1) : o.rawDataPacket.readInt8(k.OBCIGanglionPacket18Bit.auxByte - 1) * k.OBCIGanglionAccelScaleFactor;
if (o.sendCounts) {
samples[0].accelData = o.accelArray;
} else {
samples[0].accelDataCounts = o.accelArray;
}
break;
default:
break;
}
} else {
decompressSamples(o, decompressDeltas19Bit(o.rawDataPacket.slice(k.OBCIGanglionPacket19Bit.dataStart, k.OBCIGanglionPacket19Bit.dataStop)));
samples.push(buildSample((o.lastSampleNumber - 100) * 2 - 1, o.decompressedSamples[1], o.sendCounts));
samples.push(buildSample((o.lastSampleNumber - 100) * 2, o.decompressedSamples[2], o.sendCounts));
}
// Rotate the 0 position for next time
for (let i = 0; i < k.OBCINumberOfChannelsGanglion; i++) {
o.decompressedSamples[0][i] = o.decompressedSamples[2][i];
}
return samples;
} | javascript | {
"resource": ""
} |
q514 | processImpedanceData | train | function processImpedanceData (o) {
const byteId = parseInt(o.rawDataPacket[0]);
let channelNumber;
switch (byteId) {
case k.OBCIGanglionByteIdImpedanceChannel1:
channelNumber = 1;
break;
case k.OBCIGanglionByteIdImpedanceChannel2:
channelNumber = 2;
break;
case k.OBCIGanglionByteIdImpedanceChannel3:
channelNumber = 3;
break;
case k.OBCIGanglionByteIdImpedanceChannel4:
channelNumber = 4;
break;
case k.OBCIGanglionByteIdImpedanceChannelReference:
channelNumber = 0;
break;
}
let output = {
channelNumber: channelNumber,
impedanceValue: 0
};
let end = o.rawDataPacket.length;
while (Number.isNaN(Number(o.rawDataPacket.slice(1, end))) && end !== 0) {
end--;
}
if (end !== 0) {
output.impedanceValue = Number(o.rawDataPacket.slice(1, end));
}
return output;
} | javascript | {
"resource": ""
} |
q515 | processMultiBytePacket | train | function processMultiBytePacket (o) {
if (o.multiPacketBuffer) {
o.multiPacketBuffer = Buffer.concat([Buffer.from(o.multiPacketBuffer), Buffer.from(o.rawDataPacket.slice(k.OBCIGanglionPacket19Bit.dataStart, k.OBCIGanglionPacket19Bit.dataStop))]);
} else {
o.multiPacketBuffer = o.rawDataPacket.slice(k.OBCIGanglionPacket19Bit.dataStart, k.OBCIGanglionPacket19Bit.dataStop);
}
} | javascript | {
"resource": ""
} |
q516 | processMultiBytePacketStop | train | function processMultiBytePacketStop (o) {
processMultiBytePacket(o);
const str = o.multiPacketBuffer.toString();
o.multiPacketBuffer = null;
return {
'message': str
};
} | javascript | {
"resource": ""
} |
q517 | decompressSamples | train | function decompressSamples (o, receivedDeltas) {
// add the delta to the previous value
for (let i = 1; i < 3; i++) {
for (let j = 0; j < 4; j++) {
o.decompressedSamples[i][j] = o.decompressedSamples[i - 1][j] - receivedDeltas[i - 1][j];
}
}
} | javascript | {
"resource": ""
} |
q518 | buildSample | train | function buildSample (sampleNumber, rawData, sendCounts) {
let sample;
if (sendCounts) {
sample = newSampleNoScale(sampleNumber);
sample.channelDataCounts = rawData;
} else {
sample = newSample(sampleNumber);
for (let j = 0; j < k.OBCINumberOfChannelsGanglion; j++) {
sample.channelData.push(rawData[j] * k.OBCIGanglionScaleFactorPerCountVolts);
}
}
sample.timestamp = Date.now();
return sample;
} | javascript | {
"resource": ""
} |
q519 | processRouteSampleData | train | function processRouteSampleData (o) {
if (parseInt(o.rawDataPacket[0]) === k.OBCIGanglionByteIdUncompressed) {
return processUncompressedData(o);
} else {
return processCompressedData(o);
}
} | javascript | {
"resource": ""
} |
q520 | processUncompressedData | train | function processUncompressedData (o) {
// Resets the packet counter back to zero
o.lastSampleNumber = k.OBCIGanglionByteIdUncompressed; // used to find dropped packets
for (let i = 0; i < 4; i++) {
o.decompressedSamples[0][i] = utilitiesModule.interpret24bitAsInt32(o.rawDataPacket.slice(1 + (i * 3), 1 + (i * 3) + 3)); // seed the decompressor
}
return [buildSample(0, o.decompressedSamples[0], o.sendCounts)];
} | javascript | {
"resource": ""
} |
q521 | convertGanglionArrayToBuffer | train | function convertGanglionArrayToBuffer (arr, data) {
for (let i = 0; i < k.OBCINumberOfChannelsGanglion; i++) {
data.writeInt16BE(arr[i] >> 8, (i * 3));
data.writeInt8(arr[i] & 255, (i * 3) + 2);
}
} | javascript | {
"resource": ""
} |
q522 | getBooleanFromRegisterQuery | train | function getBooleanFromRegisterQuery (str, regEx, offset) {
let regExArr = str.match(regEx);
if (regExArr) {
const num = parseInt(str.charAt(regExArr.index + offset));
if (!Number.isNaN(num)) {
return Boolean(num);
} else {
throw new Error(k.OBCIErrorInvalidData);
}
} else {
throw new Error(k.OBCIErrorMissingRegisterSetting);
}
} | javascript | {
"resource": ""
} |
q523 | getNumFromThreeCSVADSRegisterQuery | train | function getNumFromThreeCSVADSRegisterQuery (str, regEx, offset) {
let regExArr = str.match(regEx);
if (regExArr) {
const bit2 = parseInt(str.charAt(regExArr.index + offset));
const bit1 = parseInt(str.charAt(regExArr.index + offset + 3));
const bit0 = parseInt(str.charAt(regExArr.index + offset + 6));
if (!Number.isNaN(bit2) && !Number.isNaN(bit1) && !Number.isNaN(bit0)) {
return bit2 << 2 | bit1 << 1 | bit0;
} else {
throw new Error(k.OBCIErrorInvalidData);
}
} else {
throw new Error(k.OBCIErrorMissingRegisterSetting);
}
} | javascript | {
"resource": ""
} |
q524 | setChSetFromADSRegisterQuery | train | function setChSetFromADSRegisterQuery (str, channelSettings) {
let key = k.OBCIRegisterQueryNameCHnSET[channelSettings.channelNumber];
if (key === undefined) key = k.OBCIRegisterQueryNameCHnSET[channelSettings.channelNumber - k.OBCINumberOfChannelsCyton];
channelSettings.powerDown = getBooleanFromRegisterQuery(str, key, 16);
channelSettings.gain = k.gainForCommand(getNumFromThreeCSVADSRegisterQuery(str, key, 19));
channelSettings.inputType = k.inputTypeForCommand(getNumFromThreeCSVADSRegisterQuery(str, key, 31));
channelSettings.srb2 = getBooleanFromRegisterQuery(str, key, 28);
} | javascript | {
"resource": ""
} |
q525 | getFirmware | train | function getFirmware (dataBuffer) {
const regexPattern = /v\d.\d*.\d*/;
const ret = dataBuffer.toString().match(regexPattern);
if (ret) {
const elems = ret[0].split('.');
return {
major: Number(elems[0][1]),
minor: Number(elems[1]),
patch: Number(elems[2]),
raw: ret[0]
};
} else return ret;
} | javascript | {
"resource": ""
} |
q526 | train | function(obj) {
if (!obj) {
return null;
}
if (typeof obj == 'function') {
return obj.prototype.__moduleId__;
}
if (typeof obj == 'string') {
return null;
}
return obj.__moduleId__;
} | javascript | {
"resource": ""
} |
|
q527 | train | function(obj, id) {
if (!obj) {
return;
}
if (typeof obj == 'function') {
obj.prototype.__moduleId__ = id;
return;
}
if (typeof obj == 'string') {
return;
}
obj.__moduleId__ = id;
} | javascript | {
"resource": ""
} |
|
q528 | train | function() {
var modules,
first = arguments[0],
arrayRequest = false;
if(system.isArray(first)){
modules = first;
arrayRequest = true;
}else{
modules = slice.call(arguments, 0);
}
return this.defer(function(dfd) {
require(modules, function() {
var args = arguments;
setTimeout(function() {
if(args.length > 1 || arrayRequest){
dfd.resolve(slice.call(args, 0));
}else{
dfd.resolve(args[0]);
}
}, 1);
}, function(err){
dfd.reject(err);
});
}).promise();
} | javascript | {
"resource": ""
} |
|
q529 | train | function(obj) {
var rest = slice.call(arguments, 1);
for (var i = 0; i < rest.length; i++) {
var source = rest[i];
if (source) {
for (var prop in source) {
obj[prop] = source[prop];
}
}
}
return obj;
} | javascript | {
"resource": ""
} |
|
q530 | validation | train | function validation() {
const target = this._obj;
this.assert(_.isObject(target), '#{this} is not a Joi validation because it must be an object');
this.assert(!_.isEmpty(target), '#{this} is not a Joi validation because it is an empty object');
const fields = _.keys(target);
const allFieldsPresent = _.every(FIELDS_TO_VALIDATE.map(field => _.includes(fields, field)));
this.assert(
allFieldsPresent,
`${this} is not a validation because it does not contain expected keys`
);
} | javascript | {
"resource": ""
} |
q531 | validate | train | function validate() {
const target = this._obj;
isValidation(target);
this.assert(_.has(target, 'error') && null === target.error,
'#{this} should validate but does not because '+getErrorMessages(target),
'#{this} should not validate but it does'
);
} | javascript | {
"resource": ""
} |
q532 | value | train | function value(utils) {
const target = this._obj,
value = target.value || null;
isValidation(target);
this.assert(null !== value,
'#{this} should have value',
'#{this} should not have value'
);
utils.flag(this, 'object', value);
} | javascript | {
"resource": ""
} |
q533 | train | function(config, baseUrl){
var pluginIds = system.keys(config);
baseUrl = baseUrl || 'plugins/';
if(baseUrl.indexOf('/', baseUrl.length - 1) === -1){
baseUrl += '/';
}
for(var i = 0; i < pluginIds.length; i++){
var key = pluginIds[i];
allPluginIds.push(baseUrl + key);
allPluginConfigs.push(config[key]);
}
} | javascript | {
"resource": ""
} |
|
q534 | train | function() {
system.log('Application:Starting');
if (this.title) {
document.title = this.title;
}
return system.defer(function (dfd) {
$(function() {
loadPlugins().then(function(){
dfd.resolve();
system.log('Application:Started');
});
});
}).promise();
} | javascript | {
"resource": ""
} |
|
q535 | K8sutil | train | function K8sutil() {
// this.getNamespace();
podName = os.hostname();
podGenerateName = podName.substr(0, podName.lastIndexOf('-'));
logger.debug('k8sutil', 'K8sutil()', 'The pod name: ', podName);
fetchContainerID();
try {
// var kubeconfig = Api.config.fromKubeconfig();
var kubeconfig = Api.config.getInCluster();
kubeconfig.promises = true;
// kubeconfig.namespace = 'default';
logger.debug('k8sutil', 'K8sutil()', 'Kubeconfig', kubeconfig);
core = new Api.Core(kubeconfig);
ext = new Api.Extensions(kubeconfig);
namespace = core.namespaces.namespace;
logger.info('k8sutil', 'K8sutil()', 'Current namespace', namespace);
if (!podJson) {
core.ns(namespace).pods(this.getPodName()).get().then(parsePodInfo).catch(
function(err) {
logger.error('k8sutil', 'K8sutil()', err.message);
}
);
}
} catch (e) {
logger.debug('k8sutil', 'K8sutil()',
'Failed to load K8S configuration, is not a ICp environment.');
}
findIngressSvc();
setNodeIPs();
} | javascript | {
"resource": ""
} |
q536 | Actor | train | function Actor(stream) {
if (!(this instanceof Actor)) return new Actor(stream);
var that = this;
this.parser = new amp.Stream;
this.parser.on('data', this.onmessage.bind(this));
stream.pipe(this.parser);
this.stream = stream;
this.callbacks = {};
this.ids = 0;
this.id = ++ids;
this.secret_key = null;
Actor.emit('actor', this);
} | javascript | {
"resource": ""
} |
q537 | reply | train | function reply(id, args) {
var msg = new Array(2 + args.length);
msg[0] = '_reply_';
msg[1] = id;
for (var i = 0; i < args.length; i++) {
msg[i + 2] = args[i];
}
return msg;
} | javascript | {
"resource": ""
} |
q538 | inputTypeForCommand | train | function inputTypeForCommand (cmd) {
switch (String(cmd)) {
case obciChannelCmdADCNormal:
return obciStringADCNormal;
case obciChannelCmdADCShorted:
return obciStringADCShorted;
case obciChannelCmdADCBiasMethod:
return obciStringADCBiasMethod;
case obciChannelCmdADCMVDD:
return obciStringADCMvdd;
case obciChannelCmdADCTemp:
return obciStringADCTemp;
case obciChannelCmdADCTestSig:
return obciStringADCTestSig;
case obciChannelCmdADCBiasDRP:
return obciStringADCBiasDrp;
case obciChannelCmdADCBiasDRN:
return obciStringADCBiasDrn;
default:
throw new Error('Invalid input type, must be less than 8');
}
} | javascript | {
"resource": ""
} |
q539 | gainForCommand | train | function gainForCommand (cmd) {
switch (String(cmd)) {
case obciChannelCmdGain1:
return 1;
case obciChannelCmdGain2:
return 2;
case obciChannelCmdGain4:
return 4;
case obciChannelCmdGain6:
return 6;
case obciChannelCmdGain8:
return 8;
case obciChannelCmdGain12:
return 12;
case obciChannelCmdGain24:
return 24;
default:
throw new Error(`Invalid gain setting of ${cmd} gain must be (0,1,2,3,4,5,6)`);
}
} | javascript | {
"resource": ""
} |
q540 | handleGuardedRoute | train | function handleGuardedRoute(activator, instance, instruction) {
var resultOrPromise = router.guardRoute(instance, instruction);
if (resultOrPromise) {
if (resultOrPromise.then) {
resultOrPromise.then(function(result) {
if (result) {
if (system.isString(result)) {
redirect(result);
} else {
activateRoute(activator, instance, instruction);
}
} else {
cancelNavigation(instance, instruction);
}
});
} else {
if (system.isString(resultOrPromise)) {
redirect(resultOrPromise);
} else {
activateRoute(activator, instance, instruction);
}
}
} else {
cancelNavigation(instance, instruction);
}
} | javascript | {
"resource": ""
} |
q541 | train | function( error ) {
if( error instanceof Buffer && error.toString().match( app.options.errorMessage ) ) {
initialized( 'Development server has error.' );
}
} | javascript | {
"resource": ""
} |
|
q542 | train | function(kind) {
ko.bindingHandlers[kind] = {
init: function() {
return { controlsDescendantBindings: true };
},
update: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
var settings = widget.getSettings(valueAccessor);
settings.kind = kind;
extractParts(element, settings);
widget.create(element, settings, bindingContext, true);
}
};
ko.virtualElements.allowedBindings[kind] = true;
composition.composeBindings.push(kind + ':');
} | javascript | {
"resource": ""
} |
|
q543 | train | function(kind, viewId, moduleId) {
if (viewId) {
kindViewMaps[kind] = viewId;
}
if (moduleId) {
kindModuleMaps[kind] = moduleId;
}
} | javascript | {
"resource": ""
} |
|
q544 | train | function(element, settings, bindingContext, fromBinding) {
if(!fromBinding){
settings = widget.getSettings(function() { return settings; }, element);
}
var compositionSettings = widget.createCompositionSettings(element, settings);
composition.compose(element, compositionSettings, bindingContext);
} | javascript | {
"resource": ""
} |
|
q545 | train | function(config){
config.bindingName = config.bindingName || 'widget';
if(config.kinds){
var toRegister = config.kinds;
for(var i = 0; i < toRegister.length; i++){
widget.registerKind(toRegister[i]);
}
}
ko.bindingHandlers[config.bindingName] = {
init: function() {
return { controlsDescendantBindings: true };
},
update: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
var settings = widget.getSettings(valueAccessor);
extractParts(element, settings);
widget.create(element, settings, bindingContext, true);
}
};
composition.composeBindings.push(config.bindingName + ':');
ko.virtualElements.allowedBindings[config.bindingName] = true;
} | javascript | {
"resource": ""
} |
|
q546 | train | function(value) {
if(system.isObject(value)) {
value = value.can || false;
}
if(system.isString(value)) {
return ko.utils.arrayIndexOf(this.affirmations, value.toLowerCase()) !== -1;
}
return value;
} | javascript | {
"resource": ""
} |
|
q547 | cloneWrap | train | function cloneWrap(obj, circularValue) {
circularValue = safeDeepClone(undefined, [], circularValue);
return safeDeepClone(circularValue, [], obj);
} | javascript | {
"resource": ""
} |
q548 | train | function(opts) {
this.load_balancer = opts.load_balancer;
this.task_manager = opts.task_manager;
this.file_manager = opts.file_manager;
this.net_manager = opts.net_manager;
this.port = opts.port || 10000;
this.tls = opts.tls;
} | javascript | {
"resource": ""
} |
|
q549 | train | function(bindingContext, view, obj) {
if (obj && bindingContext) {
bindingContext = bindingContext.createChildContext(obj);
}
return doBind(obj, view, bindingContext, obj || (bindingContext ? bindingContext.$data : null));
} | javascript | {
"resource": ""
} |
|
q550 | train | function(allElements){
if (allElements.length == 1) {
return allElements[0];
}
var withoutCommentsOrEmptyText = [];
for (var i = 0; i < allElements.length; i++) {
var current = allElements[i];
if (current.nodeType != 8) {
if (current.nodeType == 3) {
var result = /\S/.test(current.nodeValue);
if (!result) {
continue;
}
}
withoutCommentsOrEmptyText.push(current);
}
}
if (withoutCommentsOrEmptyText.length > 1) {
return $(withoutCommentsOrEmptyText).wrapAll('<div class="durandal-wrapper"></div>').parent().get(0);
}
return withoutCommentsOrEmptyText[0];
} | javascript | {
"resource": ""
} |
|
q551 | train | function(viewId) {
var that = this;
var requirePath = this.convertViewIdToRequirePath(viewId);
return system.defer(function(dfd) {
system.acquire(requirePath).then(function(markup) {
var element = that.processMarkup(markup);
element.setAttribute('data-view', viewId);
dfd.resolve(element);
}).fail(function(err){
that.createFallbackView(viewId, requirePath, err).then(function(element){
element.setAttribute('data-view', viewId);
dfd.resolve(element);
});
});
}).promise();
} | javascript | {
"resource": ""
} |
|
q552 | train | function (viewId, requirePath, err) {
var that = this,
message = 'View Not Found. Searched for "' + viewId + '" via path "' + requirePath + '".';
return system.defer(function(dfd) {
dfd.resolve(that.processMarkup('<div class="durandal-view-404">' + message + '</div>'));
}).promise();
} | javascript | {
"resource": ""
} |
|
q553 | train | function(message, title, options) {
this.message = message;
this.title = title || MessageBox.defaultTitle;
this.options = options || MessageBox.defaultOptions;
} | javascript | {
"resource": ""
} |
|
q554 | train | function(obj){
var theDialog = this.getDialog(obj);
if(theDialog){
var rest = Array.prototype.slice.call(arguments, 1);
theDialog.close.apply(theDialog, rest);
}
} | javascript | {
"resource": ""
} |
|
q555 | train | function(obj, activationData, context) {
var that = this;
var dialogContext = contexts[context || 'default'];
return system.defer(function(dfd) {
ensureDialogInstance(obj).then(function(instance) {
var dialogActivator = activator.create();
dialogActivator.activateItem(instance, activationData).then(function (success) {
if (success) {
var theDialog = instance.__dialog__ = {
owner: instance,
context: dialogContext,
activator: dialogActivator,
close: function () {
var args = arguments;
dialogActivator.deactivateItem(instance, true).then(function (closeSuccess) {
if (closeSuccess) {
dialogCount--;
dialogContext.removeHost(theDialog);
delete instance.__dialog__;
if (args.length === 0) {
dfd.resolve();
} else if (args.length === 1) {
dfd.resolve(args[0]);
} else {
dfd.resolve.apply(dfd, args);
}
}
});
}
};
theDialog.settings = that.createCompositionSettings(instance, dialogContext);
dialogContext.addHost(theDialog);
dialogCount++;
composition.compose(theDialog.host, theDialog.settings);
} else {
dfd.resolve(false);
}
});
});
}).promise();
} | javascript | {
"resource": ""
} |
|
q556 | train | function(message, title, options){
if(system.isString(this.MessageBox)){
return dialog.show(this.MessageBox, [
message,
title || MessageBox.defaultTitle,
options || MessageBox.defaultOptions
]);
}
return dialog.show(new this.MessageBox(message, title, options));
} | javascript | {
"resource": ""
} |
|
q557 | train | function(config){
app.showDialog = function(obj, activationData, context) {
return dialog.show(obj, activationData, context);
};
app.showMessage = function(message, title, options) {
return dialog.showMessage(message, title, options);
};
if(config.messageBox){
dialog.MessageBox = config.messageBox;
}
if(config.messageBoxView){
dialog.MessageBox.prototype.getView = function(){
return config.messageBoxView;
};
}
} | javascript | {
"resource": ""
} |
|
q558 | train | function(theDialog) {
var body = $('body');
var blockout = $('<div class="modalBlockout"></div>')
.css({ 'z-index': dialog.getNextZIndex(), 'opacity': this.blockoutOpacity })
.appendTo(body);
var host = $('<div class="modalHost"></div>')
.css({ 'z-index': dialog.getNextZIndex() })
.appendTo(body);
theDialog.host = host.get(0);
theDialog.blockout = blockout.get(0);
if (!dialog.isOpen()) {
theDialog.oldBodyMarginRight = body.css("margin-right");
theDialog.oldInlineMarginRight = body.get(0).style.marginRight;
var html = $("html");
var oldBodyOuterWidth = body.outerWidth(true);
var oldScrollTop = html.scrollTop();
$("html").css("overflow-y", "hidden");
var newBodyOuterWidth = $("body").outerWidth(true);
body.css("margin-right", (newBodyOuterWidth - oldBodyOuterWidth + parseInt(theDialog.oldBodyMarginRight, 10)) + "px");
html.scrollTop(oldScrollTop); // necessary for Firefox
}
} | javascript | {
"resource": ""
} |
|
q559 | train | function(theDialog) {
$(theDialog.host).css('opacity', 0);
$(theDialog.blockout).css('opacity', 0);
setTimeout(function() {
ko.removeNode(theDialog.host);
ko.removeNode(theDialog.blockout);
}, this.removeDelay);
if (!dialog.isOpen()) {
var html = $("html");
var oldScrollTop = html.scrollTop(); // necessary for Firefox.
html.css("overflow-y", "").scrollTop(oldScrollTop);
if(theDialog.oldInlineMarginRight) {
$("body").css("margin-right", theDialog.oldBodyMarginRight);
} else {
$("body").css("margin-right", '');
}
}
} | javascript | {
"resource": ""
} |
|
q560 | train | function (child, parent, context) {
var theDialog = dialog.getDialog(context.model);
var $child = $(child);
var loadables = $child.find("img").filter(function () {
//Remove images with known width and height
var $this = $(this);
return !(this.style.width && this.style.height) && !($this.attr("width") && $this.attr("height"));
});
$child.data("predefinedWidth", $child.get(0).style.width);
var setDialogPosition = function () {
//Setting a short timeout is need in IE8, otherwise we could do this straight away
setTimeout(function () {
//We will clear and then set width for dialogs without width set
if (!$child.data("predefinedWidth")) {
$child.css({ width: '' }); //Reset width
}
var width = $child.outerWidth(false);
var height = $child.outerHeight(false);
var windowHeight = $(window).height();
var constrainedHeight = Math.min(height, windowHeight);
$child.css({
'margin-top': (-constrainedHeight / 2).toString() + 'px',
'margin-left': (-width / 2).toString() + 'px'
});
if (!$child.data("predefinedWidth")) {
//Ensure the correct width after margin-left has been set
$child.outerWidth(width);
}
if (height > windowHeight) {
$child.css("overflow-y", "auto");
} else {
$child.css("overflow-y", "");
}
$(theDialog.host).css('opacity', 1);
$child.css("visibility", "visible");
$child.find('.autofocus').first().focus();
}, 1);
};
setDialogPosition();
loadables.load(setDialogPosition);
if ($child.hasClass('autoclose')) {
$(theDialog.blockout).click(function () {
theDialog.close();
});
}
} | javascript | {
"resource": ""
} |
|
q561 | train | function(name, config, initOptionsFactory){
var key,
dataKey = 'composition-handler-' + name,
handler;
config = config || ko.bindingHandlers[name];
initOptionsFactory = initOptionsFactory || function(){ return undefined; };
handler = ko.bindingHandlers[name] = {
init: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
if(compositionCount > 0){
var data = {
trigger:ko.observable(null)
};
composition.current.complete(function(){
if(config.init){
config.init(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext);
}
if(config.update){
ko.utils.domData.set(element, dataKey, config);
data.trigger('trigger');
}
});
ko.utils.domData.set(element, dataKey, data);
}else{
ko.utils.domData.set(element, dataKey, config);
if(config.init){
config.init(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext);
}
}
return initOptionsFactory(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext);
},
update: function (element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
var data = ko.utils.domData.get(element, dataKey);
if(data.update){
return data.update(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext);
}
if(data.trigger){
data.trigger();
}
}
};
for (key in config) {
if (key !== "init" && key !== "update") {
handler[key] = config[key];
}
}
} | javascript | {
"resource": ""
} |
|
q562 | train | function(elements, parts, isReplacementSearch) {
parts = parts || {};
if (!elements) {
return parts;
}
if (elements.length === undefined) {
elements = [elements];
}
for (var i = 0, length = elements.length; i < length; i++) {
var element = elements[i];
if (element.getAttribute) {
if(!isReplacementSearch && hasComposition(element)){
continue;
}
var id = element.getAttribute(partAttributeName);
if (id) {
parts[id] = element;
}
if(!isReplacementSearch && element.hasChildNodes()){
composition.getParts(element.childNodes, parts);
}
}
}
return parts;
} | javascript | {
"resource": ""
} |
|
q563 | train | function (element, settings, bindingContext, fromBinding) {
compositionCount++;
if(!fromBinding){
settings = composition.getSettings(function() { return settings; }, element);
}
if (settings.compositionComplete) {
compositionCompleteCallbacks.push(function () {
settings.compositionComplete(settings.child, settings.parent, settings);
});
}
compositionCompleteCallbacks.push(function () {
if(settings.composingNewView && settings.model && settings.model.compositionComplete){
settings.model.compositionComplete(settings.child, settings.parent, settings);
}
});
var hostState = getHostState(element);
settings.activeView = hostState.activeView;
settings.parent = element;
settings.triggerAttach = triggerAttach;
settings.bindingContext = bindingContext;
if (settings.cacheViews && !settings.viewElements) {
settings.viewElements = hostState.childElements;
}
if (!settings.model) {
if (!settings.view) {
this.bindAndShow(null, settings);
} else {
settings.area = settings.area || 'partial';
settings.preserveContext = true;
viewLocator.locateView(settings.view, settings.area, settings.viewElements).then(function (child) {
composition.bindAndShow(child, settings);
});
}
} else if (system.isString(settings.model)) {
system.acquire(settings.model).then(function (module) {
settings.model = system.resolveObject(module);
composition.inject(settings);
}).fail(function(err){
system.error('Failed to load composed module (' + settings.model + '). Details: ' + err.message);
});
} else {
composition.inject(settings);
}
} | javascript | {
"resource": ""
} |
|
q564 | removeFailedPredicate | train | function removeFailedPredicate(predicates, items) {
return items.filter((_,i) => predicates[i]===true);
} | javascript | {
"resource": ""
} |
q565 | train | function(object, settings) {
settings = (settings === undefined) ? {} : settings;
if(system.isString(settings) || system.isNumber(settings)) {
settings = { space: settings };
}
return JSON.stringify(object, settings.replacer || this.replacer, settings.space || this.space);
} | javascript | {
"resource": ""
} |
|
q566 | train | function(key, value, getTypeId, getConstructor) {
var typeId = getTypeId(value);
if (typeId) {
var ctor = getConstructor(typeId);
if (ctor) {
if (ctor.fromJSON) {
return ctor.fromJSON(value);
}
return new ctor(value);
}
}
return value;
} | javascript | {
"resource": ""
} |
|
q567 | train | function(text, settings) {
var that = this;
settings = settings || {};
var getTypeId = settings.getTypeId || function(object) { return that.getTypeId(object); };
var getConstructor = settings.getConstructor || function(id) { return that.typeMap[id]; };
var reviver = settings.reviver || function(key, value) { return that.reviver(key, value, getTypeId, getConstructor); };
return JSON.parse(text, reviver);
} | javascript | {
"resource": ""
} |
|
q568 | train | function(opts) {
if (!opts) opts = {};
this.port_offset = opts.port_offset ? parseInt(opts.port_offset) : 10001;
this.task_list = {};
this.can_accept_queries = false;
this.can_local_compute = true;
this.app_folder = opts.app_folder;
var pm2_opts = {};
if (process.env.NODE_ENV == 'test') {
pm2_opts = {
independent : true,
daemon_mode : true
};
}
this.pm2 = new PM2.custom(pm2_opts);
// Defaults values
this.task_meta = {
instances : 0,
json_conf : null,
task_folder : 'tasks',
env : {}
};
if (opts.task_meta)
this.task_meta = opts.task_meta;
this.controller = Controller;
} | javascript | {
"resource": ""
} |
|
q569 | convertProperty | train | function convertProperty(obj, propertyName, original){
var observable,
isArray,
lookup = obj.__observable__ || (obj.__observable__ = {});
if(original === undefined){
original = obj[propertyName];
}
if (system.isArray(original)) {
observable = ko.observableArray(original);
makeObservableArray(original, observable);
isArray = true;
} else if (typeof original == "function") {
if(ko.isObservable(original)){
observable = original;
}else{
return null;
}
} else if(system.isPromise(original)) {
observable = ko.observable();
original.then(function (result) {
if(system.isArray(result)) {
var oa = ko.observableArray(result);
makeObservableArray(result, oa);
result = oa;
}
observable(result);
});
} else {
observable = ko.observable(original);
convertObject(original);
}
Object.defineProperty(obj, propertyName, {
configurable: true,
enumerable: true,
get: observable,
set: ko.isWriteableObservable(observable) ? (function (newValue) {
if (newValue && system.isPromise(newValue)) {
newValue.then(function (result) {
innerSetter(observable, result, system.isArray(result));
});
} else {
innerSetter(observable, newValue, isArray);
}
}) : undefined
});
lookup[propertyName] = observable;
return observable;
} | javascript | {
"resource": ""
} |
q570 | defineProperty | train | function defineProperty(obj, propertyName, evaluatorOrOptions) {
var computedOptions = { owner: obj, deferEvaluation: true },
computed;
if (typeof evaluatorOrOptions === 'function') {
computedOptions.read = evaluatorOrOptions;
} else {
if ('value' in evaluatorOrOptions) {
system.error('For defineProperty, you must not specify a "value" for the property. You must provide a "get" function.');
}
if (typeof evaluatorOrOptions.get !== 'function') {
system.error('For defineProperty, the third parameter must be either an evaluator function, or an options object containing a function called "get".');
}
computedOptions.read = evaluatorOrOptions.get;
computedOptions.write = evaluatorOrOptions.set;
}
computed = ko.computed(computedOptions);
obj[propertyName] = computed;
return convertProperty(obj, propertyName, computed);
} | javascript | {
"resource": ""
} |
q571 | _libraryFiles | train | function _libraryFiles(directory) {
return new Promise((fulfill) => {
const files = [];
klaw(directory)
.on('data', (item) => {
const relativePath = path.relative(directory, item.path);
files.push(relativePath);
})
.on('end', () => {
fulfill(files);
});
});
} | javascript | {
"resource": ""
} |
q572 | train | function (url, query, callbackParam) {
if (url.indexOf('=?') == -1) {
callbackParam = callbackParam || this.callbackParam;
if (url.indexOf('?') == -1) {
url += '?';
} else {
url += '&';
}
url += callbackParam + '=?';
}
return $.ajax({
url: url,
dataType:'jsonp',
data:query
});
} | javascript | {
"resource": ""
} |
|
q573 | train | function(url, data) {
return $.ajax({
url: url,
data: ko.toJSON(data),
type: 'POST',
contentType: 'application/json',
dataType: 'json'
});
} | javascript | {
"resource": ""
} |
|
q574 | fsmEvent | train | function fsmEvent (start, events) {
if (typeof start === 'object') {
events = start
start = 'START'
}
assert.equal(typeof start, 'string')
assert.equal(typeof events, 'object')
assert.ok(events[start], 'invalid starting state ' + start)
assert.ok(fsm.validate(events))
const emitter = new EventEmitter()
emit._graph = fsm.reachable(events)
emit._emitter = emitter
emit._events = events
emit._state = start
emit.emit = emit
emit.on = on
return emit
// set a state listener
// str, fn -> null
function on (event, cb) {
emitter.on(event, cb)
}
// change the state
// str -> null
function emit (str) {
const nwState = emit._events[emit._state][str]
if (!reach(emit._state, nwState, emit._graph)) {
const err = 'invalid transition: ' + emit._state + ' -> ' + str
return emitter.emit('error', err)
}
const leaveEv = emit._state + ':leave'
const enterEv = nwState + ':enter'
if (!emit._state) return enter()
return leave()
function leave () {
if (!emitter._events[leaveEv]) enter()
else emitter.emit(leaveEv, enter)
}
function enter () {
if (!emitter._events[enterEv]) done()
else emitter.emit(enterEv, done)
}
function done () {
emit._state = nwState
emitter.emit(nwState)
emitter.emit('done')
}
}
} | javascript | {
"resource": ""
} |
q575 | emit | train | function emit (str) {
const nwState = emit._events[emit._state][str]
if (!reach(emit._state, nwState, emit._graph)) {
const err = 'invalid transition: ' + emit._state + ' -> ' + str
return emitter.emit('error', err)
}
const leaveEv = emit._state + ':leave'
const enterEv = nwState + ':enter'
if (!emit._state) return enter()
return leave()
function leave () {
if (!emitter._events[leaveEv]) enter()
else emitter.emit(leaveEv, enter)
}
function enter () {
if (!emitter._events[enterEv]) done()
else emitter.emit(enterEv, done)
}
function done () {
emit._state = nwState
emitter.emit(nwState)
emitter.emit('done')
}
} | javascript | {
"resource": ""
} |
q576 | reach | train | function reach (curr, next, reachable) {
if (!next) return false
if (!curr) return true
const here = reachable[curr]
if (!here || !here[next]) return false
return here[next].length === 1
} | javascript | {
"resource": ""
} |
q577 | LanguagePicker | train | function LanguagePicker(lang = 'en', config = {}) {
const scripts = ls.adjust({ override: dataOverrides });
this.userLang = lang;
this.nameTag = config.nameTag;
// The prefix is either given or is the nameTag
// with an underscore
// See Babel.js#24
this.prefix = config.multiTag || (this.nameTag && `${this.nameTag}_`) || '';
this.forceLocal = !!config.forceLocal;
if (this.forceLocal) {
// If we are forcing a local language, we don't need
// any of the fallback calculations
return;
}
// Store language script
this.langScript = scripts[lang] || 'Latn';
// Add known fallbacks for the language
let fallbacks;
if (config.languageMap) {
fallbacks = config.languageMap[lang];
if (fallbacks && !Array.isArray(fallbacks)) {
fallbacks = [fallbacks];
}
}
if (!fallbacks) {
fallbacks = [];
}
// Use the given language as first choice
fallbacks = [lang].concat(fallbacks);
// Remove duplicates
fallbacks = fallbacks.filter((item, i) => fallbacks.indexOf(item) === i);
// Add prefix to all languages if exists
// eslint-disable-next-line arrow-body-style
fallbacks = fallbacks.map((code) => {
return code === this.nameTag ? code : this.prefix + code;
});
// Store initial fallbacks
this.fallbacks = fallbacks;
this.prefixedEnglish = this.prefix ? `${this.prefix}en` : 'en';
this.prefixedLangScript = `-${this.langScript}`;
} | javascript | {
"resource": ""
} |
q578 | PbfSplicer | train | function PbfSplicer(options) {
// tag which will be auto-removed and auto-injected. Usually 'name'
this.nameTag = options.nameTag;
// tag that contains JSON initially, and which works as a prefix for multiple values
this.multiTag = options.multiTag;
// If options.namePicker is given, this class converts multiple language tags into one
// Otherwise, it assumes that a single name_ tag exists with JSON content, and it will replace
// it with multiple tags "name_en", "name_fr", ... depending on the JSON language codes
this.namePicker = options.namePicker;
// Flag to make requested_name (local_name) form
this.combineName = options.combineName;
} | javascript | {
"resource": ""
} |
q579 | train | function(cb) {
var lockFile = path.join(repoDir, '.git', 'index.lock');
path.exists(lockFile, function(exists) {
if (exists) {
fs.unlink(lockFile, function(err) {
if (err) {
log.warn('removing file ' + lockFile + ' failed with:', err);
}
else {
log.info('removed lock file: ' + lockFile);
}
cb(err, {removelock: 'remove git lock ' + lockFile + ', result ' + err});
});
return;
}
log.log('There is no lock file left, which is a good thing');
cb(null, {removelock: 'no lock was present'});
});
} | javascript | {
"resource": ""
} |
|
q580 | train | function(cb) {
git(repoDir, ['status'], function(err, stdout, stderr) {
if (err) {
log.warn('git status failed on ' + repoDir + ":", err.msg);
var indexFile = path.join(repoDir, '.git', 'index');
path.exists(indexFile, function(exists) {
if (exists) {
fs.unlink(indexFile, function(err) {
if (err) {
log.warn('removing file ' + indexFile + ' failed with:', err);
}
else {
log.info('removed index file: ' + indexFile);
}
cb(err, {status: {stdout: stdout, stderr: stderr}, removeIndex: 'remove git index ' + indexFile + ', result ' + err});
});
return;
}
log.warn('No index file ' + indexFile);
cb(err, {status: {stdout: stdout, stderr: stderr}, removeIndex: 'no index present'});
});
return;
}
cb(null, {status: {stdout: stdout, stderr: stderr}});
});
} | javascript | {
"resource": ""
} |
|
q581 | train | function(cb) {
log.log('git remote prune origin ' + repoDir);
self.pruneOrigin(repoDir, function(err, stdout, stderr) {
if (err) {
log.warn(err.msg + ":", err.err.msg);
}
cb(null, {prune: {stdout: stdout, stderr: stderr}});
});
} | javascript | {
"resource": ""
} |
|
q582 | train | function(cb) {
log.log('git fetch origin ' + repoDir);
git(repoDir, ['fetch', 'origin'], function(err, stdout, stderr) {
if (err) {
log.error('Unable to fetch at ' + repoDir + ':', err.msg);
}
cb(null, {fetch: {stdout: stdout, stderr: stderr}})
});
} | javascript | {
"resource": ""
} |
|
q583 | _ensureExists | train | function _ensureExists(dir, callback) {
dir = path.resolve(dir); // make full path
path.exists(dir, function(exists) {
if (!exists) {
// ensure that the parent dir exists
_ensureExists(path.dirname(dir), function(err) {
if (err) {
callback(err);
return;
}
// make the dir
log.log('Creating ' + dir);
fs.mkdir(dir, function(err) {
if (err) {
callback(err);
return;
}
callback(null);
});
});
}
else {
callback(null);
}
});
} | javascript | {
"resource": ""
} |
q584 | combine | train | function combine(at, shares){
var setBits, share, x = [], y = [], result = '', idx;
for(var i=0, len = shares.length; i<len; i++){
share = processShare(shares[i]);
if(typeof setBits === 'undefined'){
setBits = share['bits'];
}else if(share['bits'] !== setBits){
throw new Error('Mismatched shares: Different bit settings.')
}
if(config.bits !== setBits){
init(setBits);
}
if(inArray(x, share['id'])){ // repeated x value?
continue;
}
idx = x.push(share['id']) - 1;
share = split(hex2bin(share['value']));
for(var j=0, len2 = share.length; j<len2; j++){
y[j] = y[j] || [];
y[j][idx] = share[j];
}
}
for(var i=0, len=y.length; i<len; i++){
result = padLeft(lagrange(at, x, y[i]).toString(2)) + result;
}
if(at===0){// reconstructing the secret
var idx = result.indexOf('1'); //find the first 1
return bin2hex(result.slice(idx+1));
}else{// generating a new share
return bin2hex(result);
}
} | javascript | {
"resource": ""
} |
q585 | lagrange | train | function lagrange(at, x, y){
var sum = 0,
product,
i, j;
for(var i=0, len = x.length; i<len; i++){
if(!y[i]){
continue;
}
product = config.logs[y[i]];
for(var j=0; j<len; j++){
if(i === j){ continue; }
if(at === x[j]){ // happens when computing a share that is in the list of shares used to compute it
product = -1; // fix for a zero product term, after which the sum should be sum^0 = sum, not sum^1
break;
}
product = ( product + config.logs[at ^ x[j]] - config.logs[x[i] ^ x[j]] + config.max/* to make sure it's not negative */ ) % config.max;
}
sum = product === -1 ? sum : sum ^ config.exps[product]; // though exps[-1]= undefined and undefined ^ anything = anything in chrome, this behavior may not hold everywhere, so do the check
}
return sum;
} | javascript | {
"resource": ""
} |
q586 | padLeft | train | function padLeft(str, bits){
bits = bits || config.bits
var missing = str.length % bits;
return (missing ? new Array(bits - missing + 1).join('0') : '') + str;
} | javascript | {
"resource": ""
} |
q587 | getNotIncrementedTopicPayloads | train | function getNotIncrementedTopicPayloads(previousConsumerReadOffset, consumer) {
let notIncrementedTopicPayloads = consumer.topicPayloads.filter((topicPayload) => {
let {topic, partition, offset: currentOffset} = topicPayload;
let previousTopicPayloadForPartition = _.find(previousConsumerReadOffset, {topic, partition});
return previousTopicPayloadForPartition && currentOffset === previousTopicPayloadForPartition.offset;
});
return notIncrementedTopicPayloads;
} | javascript | {
"resource": ""
} |
q588 | isOffsetsInSync | train | function isOffsetsInSync(notIncrementedTopicPayloads, zookeeperOffsets, kafkaOffsetDiffThreshold, logger) {
logger.trace('Monitor Offset: Topics offsets', zookeeperOffsets);
let lastErrorToHealthCheck;
notIncrementedTopicPayloads.forEach(function (topicPayload) {
let {topic, partition, offset} = topicPayload;
if (zookeeperOffsets && zookeeperOffsets[topic] && zookeeperOffsets[topic][partition]) {
let zkLatestOffset = zookeeperOffsets[topic][partition][0];
let unhandledMessages = zkLatestOffset - offset;
if (unhandledMessages > kafkaOffsetDiffThreshold) {
let state = {
topic: topic,
partition: partition,
partitionLatestOffset: zkLatestOffset,
partitionReadOffset: offset,
unhandledMessages: unhandledMessages
};
logger.error('Monitor Offset: Kafka consumer offsets found to be out of sync', state);
lastErrorToHealthCheck = new Error('Monitor Offset: Kafka consumer offsets found to be out of sync:' + JSON.stringify(state));
}
} else {
logger.error('Monitor Offset: Kafka consumer topics/partitions found to be out of sync in topic: ' + topic + ' and in partition:' + partition);
lastErrorToHealthCheck = new Error('Monitor Offset: Kafka consumer topics/partitions found to be out of sync in topic: ' + topic + ' and in partition:' + partition);
}
});
return lastErrorToHealthCheck;
} | javascript | {
"resource": ""
} |
q589 | applyPatches | train | function applyPatches (versions) {
versions = sortVersions(versions, 'ASC')
let state = []
// iterate patches to the final one => get previous commit state
versions.forEach((v) => {
v.changes.forEach((c) => {
if (c.operation === 'insert') {
return state.push({
entityId: c.entityId,
entitySet: c.entitySet,
entity: parse(c.serializedDoc),
path: c.path
})
}
if (c.operation === 'remove') {
state = state.filter((e) => e.entityId !== c.entityId)
return
}
const entityState = state.find((e) => e.entityId === c.entityId)
applyPatch(entityState.entity, parse(c.serializedPatch), c.entitySet, documentModel)
})
})
return state
} | javascript | {
"resource": ""
} |
q590 | generateCodebook | train | function generateCodebook() {
var codebook = {};
reverse_codebook.forEach(function (value, i) {
codebook[value] = i;
});
return codebook;
} | javascript | {
"resource": ""
} |
q591 | train | function (logLevel) {
return chalk.bgHex(logLevel.label.bgColor).hex(logLevel.label.color).bold;
} | javascript | {
"resource": ""
} |
|
q592 | train | function (logLevel, args) {
const time = dateFormat(new Date(), 'dd/mm/yyyy, h:MM:ss.l tt');
// Each logger can have its own name. If this is
// not provided, it will default to Unknown.
const loggerName = __private.name || Constants.LOG_UNKNOWN_APP_ID;
return [ (logLevel.name.length === 4 ? ' ' : '') +
getLogLabel(logLevel)('[' + logLevel.name + ']'), time, '-',
loggerName.padEnd(Constants.LOG_APP_ID_WIDTH), ':'].concat(Object.values(args));
} | javascript | {
"resource": ""
} |
|
q593 | train | function (name, state) {
if (!module.exports.operations.validateState || module.exports.operations.validateState(state)) {
module.exports.config.states[name] = state;
} else {
log.error('Unable to update invalid state:', state, 'with name:', name);
}
} | javascript | {
"resource": ""
} |
|
q594 | train | function (sectionId, state) {
if (!module.exports.operations.validateState || module.exports.operations.validateState(state)) {
appState.set('state[' + sectionId + ']', state);
} else {
log.error('Unable to update invalid state:', state, 'in section:', sectionId);
}
} | javascript | {
"resource": ""
} |
|
q595 | train | function (state, transformation, res) {
if (!module.exports.operations.canTransform || !module.exports.operations.transform) {
log.warn('Transform State operation not implemented by application');
Utils.sendMessage(res, HttpStatus.NOT_IMPLEMENTED, JSON.stringify({ error: 'operation not implemented' }));
return state;
} else if (Utils.isNullOrEmpty(transformation)) {
log.error('Transformation not provided');
Utils.sendMessage(res, HttpStatus.BAD_REQUEST, JSON.stringify({ error: 'invalid transformation' }));
return state;
} else if (!module.exports.operations.canTransform(state, transformation)) {
log.error('Unable to apply transformation:', transformation);
Utils.sendMessage(res, HttpStatus.BAD_REQUEST, JSON.stringify({ error: 'invalid transformation' }));
return state;
}
const result = module.exports.operations.transform(state, transformation);
log.info('Successfully transformed state');
log.debug('Transformed state from:', state, 'into:', result, 'using transformation:', transformation);
Utils.sendMessage(res, HttpStatus.OK, JSON.stringify(result));
return result;
} | javascript | {
"resource": ""
} |
|
q596 | train | function (source, target, res) {
if (!module.exports.operations.canDiff || !module.exports.operations.diff) {
log.warn('Difference operation not implemented by application');
Utils.sendMessage(res, HttpStatus.NOT_IMPLEMENTED, JSON.stringify({ error: 'operation not implemented' }));
} else if (Utils.isNullOrEmpty(target)) {
log.error('Target state not provided');
Utils.sendMessage(res, HttpStatus.BAD_REQUEST, JSON.stringify({ error: 'invalid states' }));
} else if (!module.exports.operations.canDiff(source, target)) {
log.error('Unable to get difference from source:', source, 'to target:', target);
Utils.sendMessage(res, HttpStatus.BAD_REQUEST, JSON.stringify({ error: 'invalid states' }));
} else {
const result = module.exports.operations.diff(source, target);
log.debug('Successfully computed difference', result, 'from source:', source, 'to target:', target);
Utils.sendMessage(res, HttpStatus.OK, JSON.stringify(result));
}
} | javascript | {
"resource": ""
} |
|
q597 | runPrompts | train | function runPrompts (opts) {
if (opts.questionnaire && this.init.configure) {
this.sprout.emit('msg', 'running questionnaire function')
const unansweredConfig = lodash.filter(this.init.configure, (q) => {
return !lodash.includes(lodash.keys(this.config), q.name)
})
return opts.questionnaire(unansweredConfig)
.then((answers) => { return lodash.assign(this.config, answers) })
}
} | javascript | {
"resource": ""
} |
q598 | reverse | train | function reverse (arr) {
const reversedArray = [];
for (let i = arr.length - 1; i >= 0; i--) {
reversedArray.push(arr[i]);
}
return reversedArray;
} | javascript | {
"resource": ""
} |
q599 | renderTemplateLoader | train | function renderTemplateLoader(source) {
// Get the loader options object.
var options = getOptions(this)
// Get the template locals.
var locals = getLocals.call(this, options)
// Create info object of the filename of the resource being loaded.
var info = { filename: this.resourcePath }
// Get the engine options to be passed to the engine.
var engineOptions = getEngineOptions.call(this, options.engineOptions, info)
// Get the template renderer
var renderer = getRenderer.call(this, options.engine)
// Call options.init.
init.call(this, renderer.engine, info, options)
// Render the template
var result = render(renderer, source, locals, engineOptions)
// Assign the tempate to module.exports.
return 'module.exports = ' + JSON.stringify(result)
} | javascript | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.