_id stringlengths 2 6 | title stringlengths 0 58 | partition stringclasses 3 values | text stringlengths 52 373k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q42500 | mergeHooks | train | function mergeHooks( target, source ) {
const propNames = Object.keys( source );
for ( let i = 0, numNames = propNames.length; i < numNames; i++ ) {
const name = propNames[i];
let hook = source[name];
if ( typeof hook === "function" ) {
hook = [hook];
}
if ( !Array.isArray( hook ) ) {
throw new TypeError( `invalid definition of hook named "${name}": must be a function or list of functions` );
}
for ( let hi = 0, numHooks = hook.length; hi < numHooks; hi++ ) {
if ( typeof hook[hi] !== "function" ) {
throw new TypeError( `invalid definition of hook named "${name}": not a function at index #${hi}` );
}
}
target[name] = hook;
}
} | javascript | {
"resource": ""
} |
q42501 | byteof | train | function byteof(object){
const objects = [object]
let bytes = 0;
for (let index = 0; index < objects.length; index ++){
const object=objects[index]
switch (typeof object){
case 'boolean':
bytes += BYTES.BOOLEAN
break
case 'number':
bytes += BYTES.NUMBER
break
case 'string':
bytes += BYTES.CHAR * object.length
break
case 'object':
//ignore the key's memory usage
for (let key in object){
let processed = false
for (let search = 0; search < objects.length; search ++){
if (objects[search] === object[key]){
processed = true
break
}
}
if (!processed) {
objects.push(object[key])
}
}
}
}
return bytes
} | javascript | {
"resource": ""
} |
q42502 | promesso | train | function promesso (handler) {
const handleFn = isFunction(handler) ? [handler] : handler;
const middlewares = [];
let validations = 0;
handleFn.forEach(h => {
if (!isFunction(h)) throw new Error('Handler is expected to be a function or an Array of functions.');
if (isObject(handleFn['@validation'])) {
middlewares.push(validation(h['@validation']), validationMiddleware);
if (++validations > 1) throw new Error('Every handler can have only one validator per chain.');
}
middlewares.push(h);
});
return middlewares.map(rawOrPromise);
} | javascript | {
"resource": ""
} |
q42503 | validationMiddleware | train | function validationMiddleware (err, req, res, next) {
if (!err instanceof ValidationError) return next(err);
return res.status(err.status).send({ errors: err.errors });
} | javascript | {
"resource": ""
} |
q42504 | sum | train | function sum(list, fun) {
fun = toString.call(fun) == '[object String]' ? selectn(fun) : fun;
end = list.length;
sum = -0;
idx = -1;
while (++idx < end) {
sum += typeof fun == 'function' ? fun(list[idx]) * 1000 : list[idx] * 1000;
}
return sum && (sum / 1000);
} | javascript | {
"resource": ""
} |
q42505 | StreamHandler | train | function StreamHandler(host, port, delimiter) {
events.EventEmitter.call(this);
var self = this;
self.delimiter = delimiter || "\r\n";
self.host = host;
self.port = port;
self.buffer = '';
self.conn = net.createConnection(self.port, self.host);
self.conn.setEncoding("utf8");
self.conn.on('error', function(err) {
try {
self.emit('error', 'Stream error: ' + err, err);
} catch (e) {
console.log('' + err);
}
});
self.conn.on('data', function(data) {
self.conn.pause();
self.buffer += data;
if (self.buffer.match(/\n/)) {
var arr = self.buffer.split(self.delimiter);
//Everything except the last one
for(var i = 0; i < arr.length - 1; i++) {
self.emit('line', arr[i]);
}
self.buffer = arr[arr.length - 1];
}
if (self.conn.readyState == 'open') {
self.conn.resume();
}
});
self.conn.on('close', function(had_error) {
if (!had_error && self.buffer.length > 0) {
self.emit('line', self.buffer);
}
});
} | javascript | {
"resource": ""
} |
q42506 | train | function(file, file_done) {
var item = {};
item.file_path = path.join(nell_site[type_path_key], file);
item.file_output = generateOutputDetails(nell_site, file, type);
item.link = item.file_output.link_path;
var processContent = concat(function(err, file_content_raw) {
if (err) {
return file_done(err);
}
item.file_content_raw = file_content_raw;
item.file_metadata = mde.metadata(item.file_content_raw);
item.file_content = mde.content(item.file_content_raw);
async.series([
function(callback) {
processMarkdown(nell_site, item, callback);
},
function(callback) {
nell_site[type_plural].push(item);
callback();
}
], file_done);
});
var fh = fs.createReadStream(item.file_path, {encoding: 'utf8'});
fh.on('error', file_done);
fh.pipe(processContent);
} | javascript | {
"resource": ""
} | |
q42507 | connect | train | function connect()
{
if(scope._conn)
{
if(scope._conn.readyState === 1)
{
return;
}
scope._conn.close();
}
var url = (scope._redirectURL.length>0) ? scope._redirectURL : scope._url;
scope._conn = new WebSocket(url);
scope._conn.binaryType = "arraybuffer";
scope._conn.open = onOpen;
scope._conn.onerror = onerror;
scope._conn.onclose = onClose;
scope._conn.onmessage = onMessage;
} | javascript | {
"resource": ""
} |
q42508 | onArrayBuffer | train | function onArrayBuffer(data)
{
var arr = bufferToArray(scope.byteType,data);
if(arr)
{
if(arr[arr.length-1] == MessageType.RTC_FAIL && scope.rtcFallback == true && scope.useRTC == true)
{
if(scope.onRTCFallback)
{
scope.onRTCFallback(arr[arr.length-2],arr,true);
}
}
else
{
if(scope.onBytesMessage)
{
scope.onBytesMessage(arr);
}
}
}
} | javascript | {
"resource": ""
} |
q42509 | changeServer | train | function changeServer(url)
{
scope._redirectURL = url;
if(scope._conn)
{
scope._conn.onopen = null;
scope._conn.onerror = null;
scope._conn.onclose = null;
scope._conn.onmessage = null;
scope._conn.close();
}
connect();
} | javascript | {
"resource": ""
} |
q42510 | Exception | train | function Exception(code, message) {
Error.captureStackTrace(this, Exception);
this.name = Exception.name;
this.code = code;
this.message = message;
} | javascript | {
"resource": ""
} |
q42511 | bemDirs | train | function bemDirs(bemdeps) {
const dirFilter = {};
bemdeps.forEach((dep) => {
const depPath = bemPath(dep);
const depDir = path.dirname(depPath);
dirFilter[depDir] = true;
});
return Object.keys(dirFilter);
} | javascript | {
"resource": ""
} |
q42512 | train | function(options) {
options = langx.mixin({parse: true}, options);
var entity = this;
var success = options.success;
options.success = function(resp) {
var serverAttrs = options.parse ? entity.parse(resp, options) : resp;
if (!entity.set(serverAttrs, options)) return false;
if (success) success.call(options.context, entity, resp, options);
entity.trigger('sync', entity, resp, options);
};
wrapError(this, options);
return this.sync('read', this, options);
} | javascript | {
"resource": ""
} | |
q42513 | train | function(entities, options) {
return this.set(entities, langx.mixin({merge: false}, options, addOptions));
} | javascript | {
"resource": ""
} | |
q42514 | train | function(entities, options) {
options = langx.mixin({}, options);
var singular = !langx.isArray(entities);
entities = singular ? [entities] : entities.slice();
var removed = this._removeEntitys(entities, options);
if (!options.silent && removed.length) {
options.changes = {added: [], merged: [], removed: removed};
this.trigger('update', this, options);
}
return singular ? removed[0] : removed;
} | javascript | {
"resource": ""
} | |
q42515 | train | function(entities, options) {
options = options ? langx.clone(options) : {};
for (var i = 0; i < this.entities.length; i++) {
this._removeReference(this.entities[i], options);
}
options.previousEntitys = this.entities;
this._reset();
entities = this.add(entities, langx.mixin({silent: true}, options));
if (!options.silent) this.trigger('reset', this, options);
return entities;
} | javascript | {
"resource": ""
} | |
q42516 | train | function(obj) {
if (obj == null) return void 0;
return this._byId[obj] ||
this._byId[this.entityId(obj.attributes || obj)] ||
obj.cid && this._byId[obj.cid];
} | javascript | {
"resource": ""
} | |
q42517 | train | function(entity, options) {
this._byId[entity.cid] = entity;
var id = this.entityId(entity.attributes);
if (id != null) this._byId[id] = entity;
entity.on('all', this._onEntityEvent, this);
} | javascript | {
"resource": ""
} | |
q42518 | train | function(entity, options) {
delete this._byId[entity.cid];
var id = this.entityId(entity.attributes);
if (id != null) delete this._byId[id];
if (this === entity.collection) delete entity.collection;
entity.off('all', this._onEntityEvent, this);
} | javascript | {
"resource": ""
} | |
q42519 | train | function(event, entity, collection, options) {
if (entity) {
if ((event === 'add' || event === 'remove') && collection !== this) return;
if (event === 'destroy') this.remove(entity, options);
if (event === 'change') {
var prevId = this.entityId(entity.previousAttributes());
var id = this.entityId(entity.attributes);
if (prevId !== id) {
if (prevId != null) delete this._byId[prevId];
if (id != null) this._byId[id] = entity;
}
}
}
this.trigger.apply(this, arguments);
} | javascript | {
"resource": ""
} | |
q42520 | train | function (args) {
//console.log('PutModel messageContents: json ' + JSON.stringify(messageContents));
Model.call(this, args);
this.modelType = messageContents.modelType;
this.attributes = [];
var a, attrib, v;
for (a in messageContents.attributes) {
//console.log('PutModel Attribute: json ' + JSON.stringify(messageContents.attributes[a]));
if (messageContents.attributes[a].type == 'Model') {
v = new Attribute.ModelID(createModelFromModelType(messageContents.attributes[a].modelType));
v.value = messageContents.attributes[a].value.value;
if (messageContents.attributes[a].value.name)
v.name = messageContents.attributes[a].value.name;
attrib = new Attribute({name: messageContents.attributes[a].name, type: 'Model', value: v});
} else if (messageContents.attributes[a].type == 'Date') {
attrib = new Attribute(messageContents.attributes[a].name, messageContents.attributes[a].type);
try {
attrib.value = messageContents.attributes[a].value === null ? null : new Date(messageContents.attributes[a].value);
} catch (e) {
attrib.value = null;
}
} else {
attrib = new Attribute(messageContents.attributes[a].name, messageContents.attributes[a].type);
if (attrib.name == 'id') { // TODO only If mongo! or refactor mongo to normalize IDs
if (attrib.value != messageContents.attributes[a].value)
attrib.value = messageContents.attributes[a].value;
} else {
attrib.value = messageContents.attributes[a].value;
}
}
this.attributes.push(attrib);
}
} | javascript | {
"resource": ""
} | |
q42521 | containedInOrder | train | function containedInOrder(needle, haystack) {
var i, j = 0;
for (i = 0; i < needle.length; i++) {
while (j < haystack.length && needle[i] !== haystack[j]) j++;
}
return i === needle.length && j < haystack.length;
} | javascript | {
"resource": ""
} |
q42522 | PackageDependents | train | function PackageDependents(name, version, callback) {
if (typeof version === "function") {
callback = version
version = "latest"
}
GetDependents(name, function(err, packages) {
if (err) { return callback(err) }
SameTime(packages.map(function (c) {
return function (fn) {
PackageJson(c, version).then(function (json) {
fn(null, json)
}).catch(function (err) {
fn(err)
})
}
}), function (err, packages) {
callback(err, packages || [])
})
})
} | javascript | {
"resource": ""
} |
q42523 | train | function () {
if (!filterText) {
var filterTextSelector = $element.find('input');
if (filterTextSelector.length) {
filterText = filterTextSelector[0];
}
}
if (filterText) {
$timeout_(filterText.focus.bind(filterText));
}
} | javascript | {
"resource": ""
} | |
q42524 | newMarkov | train | function newMarkov() {
var options = {
maxLength: 140,
minWords: 10,
minScore: 20,
};
//new instance
markov = new Markov(data, options);
console.log(markov);
var markovStrings = [];
// Build the corpus
markov.buildCorpus();
} | javascript | {
"resource": ""
} |
q42525 | onReadable | train | function onReadable() {
if (self._assimilationState.waiting) {
self._assimilationState.waiting = false;
self._pushChunks();
}
} | javascript | {
"resource": ""
} |
q42526 | train | function () {
if (req.status !== 200) {
console.warn(req.responseText);
return;
}
// Show the raw response text on page
xmlOutput.textContent = req.responseText;
// convert XML to javascript objects
var json = sdmxmllib.mapSDMXMLResponse(req.responseText);
// Convert to json and show on page
jsonOutput.textContent = JSON.stringify(json, null, 2);
} | javascript | {
"resource": ""
} | |
q42527 | convertData | train | function convertData(objectBody, objectChange) {
const keysChange = Object.keys(objectChange);
let objectReturn = {};
keysChange.map(keyChange => {
let changeOption = objectChange[keyChange];
let valueKeyReturn = getValueChangeOption(objectBody, keyChange, changeOption, objectReturn);
if(valueKeyReturn !== undefined && valueKeyReturn !== null){
objectReturn[keyChange] = valueKeyReturn;
}
return keyChange;
});
return objectReturn;
} | javascript | {
"resource": ""
} |
q42528 | cssToSss | train | function cssToSss (css, file) {
if (path.extname(file) === '.css') {
return postcss().process(css, { stringifier: sugarss }).then(function (result) {
return result.css
})
} else {
return css
}
} | javascript | {
"resource": ""
} |
q42529 | generateCode | train | function generateCode (config, is_all_yes) {
console.log(colors.bold('--------------- Code Generator ---------------\n'));
// Check the configuration
if (!config.commands) {
throw new Error('commands undefined in your config.js');
}
// Start the processes
var entry_js = null, handler_js = null, package_json = null, is_modules_installed = false;
Promise.resolve()
.then(function () {
// Generate the entry point script
entry_js = generateCodeEntryJs(config);
// Preview of the entry point script
console.log(entry_js);
// To skip mode
if (is_all_yes) return {isSaveEntryJs: true};
// Confirm to user
return inquirer.prompt([{
type: 'confirm',
name: 'isSaveEntryJs',
message: 'The entry point was generated. Would you write it to ' + ENTRY_POINT_FILENAME + ' ?'
}]);
}).then(function (answer) {
if (!answer.isSaveEntryJs) {
entry_js = null;
return false;
}
// Save the entry point script
console.log('\nWriting to ' + process.cwd() + '/' + ENTRY_POINT_FILENAME);
fs.writeFileSync(ENTRY_POINT_FILENAME, entry_js);
console.log('Writing has been completed.\n\n');
return true;
}).then(function (result) {
// Generate the commands handler script
handler_js = generateCodeHandlerJs(config);
// Preview of the commands handler script
console.log(handler_js);
// To skip mode
if (is_all_yes) return {isSaveHandlerJs: true};
// Confirm to user
return inquirer.prompt([{
type: 'confirm',
name: 'isSaveHandlerJs',
message: 'The commands handler was generated. Would you write it to ' + HANDLER_FILENAME + ' ?'
}]);
}).then(function (answer) {
if (!answer.isSaveHandlerJs) {
handler_js = null;
return false;
}
// Save the commands handler script
console.log('\nWriting to ' + process.cwd() + '/' + HANDLER_FILENAME);
fs.writeFileSync(HANDLER_FILENAME, handler_js);
console.log('Writing has been completed.\n\n');
return true;
}).then(function (result) {
// Generate the package.json
package_json = generatePackageJson(config);
if (package_json == null) { // If user's package.json exists and invalid
// Skip
return { answer: { isSavePackageJson: false} };
}
// Preview of the package.json
console.log(package_json + '\n');
// To skip mode
if (is_all_yes) return {isSavePackageJson: true};
// Confirm to user
return inquirer.prompt([{
type: 'confirm',
name: 'isSavePackageJson',
message: 'The package.json was generated. Would you write it to package.json ?'
}]);
}).then(function (answer) {
if (!answer.isSavePackageJson) {
package_json = null;
return false;
}
// Save the commands handler script
console.log('\nWriting to ' + process.cwd() + '/package.json');
fs.writeFileSync('package.json', package_json);
console.log('Writing has been completed.\n\n');
return true;
}).then(function (result) {
// Confirm to whether the dependency modules are installed
var dir_list = [];
try {
dir_list = fs.readdirSync('./node_modules/');
} catch (e) {
dir_list = [];
}
is_modules_installed = false;
dir_list.forEach(function (name, i) {
if (name == 'denhub-device') {
is_modules_installed = true;
}
});
if (is_modules_installed || is_all_yes) {
return {isDependencyInstall: false};
}
// Confirm to user
return inquirer.prompt([{
type: 'confirm',
name: 'isDependencyInstall',
message: 'The required modules are not installed. Would you install it now ?'
}]);
}).then(function (answer) {
if (!answer.isDependencyInstall) {
return false;
}
// Install the dependency modules
is_modules_installed = true;
return execDependencyInstall();
}).then(function (result) {
console.log(colors.bold.green('All was completed.'));
if (!entry_js && !handler_js) {
console.log('');
process.exit(0);
return;
}
// Show the guide
console.log(colors.bold('Enjoy :)\n'));
if (!is_modules_installed) console.log('$ npm install');
console.log('$ npm start -- --dev\n');
console.log('For details, please refer to https://github.com/odentools/denhub-device/\n');
});
} | javascript | {
"resource": ""
} |
q42530 | generateCodeEntryJs | train | function generateCodeEntryJs (config) {
// Read the entry point script
var entry_js = null;
try {
// Read from current script
entry_js = fs.readFileSync(ENTRY_POINT_FILENAME).toString();
} catch (e) {
// Read from template script
entry_js = fs.readFileSync(__dirname + '/../templates/' + ENTRY_POINT_FILENAME + '.tmpl').toString() + '\n';
}
return entry_js;
} | javascript | {
"resource": ""
} |
q42531 | generateCodeHandlerJs | train | function generateCodeHandlerJs (config) {
// Read the handler script
var handler_js = null;
try {
// Read from current script
handler_js = fs.readFileSync(HANDLER_FILENAME).toString();
} catch (e) {
// Read from template script
handler_js = fs.readFileSync(__dirname + '/../templates/' + HANDLER_FILENAME + '.tmpl').toString();
}
// Iterate the each commands
for (var cmd_name in config.commands) {
if (!cmd_name.match(/^[a-zA-Z][a-zA-Z0-9]+$/)) {
throw new Error('Defined method name is invalid format: ' + cmd_name);
}
if (handler_js.indexOf(cmd_name) != -1) { // handler for this command was written
continue; // skip
}
// Make a handler for this command
var cmd = config.commands[cmd_name];
var js_func = '\n\n\
/**\n\
* %cmdDescription%\n\
* @param {Object} args Arguments of the received command\n\
* @param {Function} cb_runner Callback runner for response\n\
* @return {Boolean} if returns true, handler indicates won\'t use the callback \n\
*/\n\
CommandsHandler.prototype.' + cmd_name + ' = function (args, cb_runner) {\n\
\t\n';
// To align the line length of argument examples
var cmd_args = cmd.arguments || cmd.args || [];
var longest_length_of_arg_name = 0;
for (var name_ in cmd_args) {
if (longest_length_of_arg_name < name_.length) longest_length_of_arg_name = name_.length;
}
// Generate the argument examples
for (var name in cmd_args) {
// Generate an example
var line = '\tthis.logger.log(args.' + name + ');';
// Generate a comment
var comment_spaces = new String(' ');
for (var i = 0, l = longest_length_of_arg_name - name.length; i < l; i++) {
comment_spaces += ' ';
}
var comment = '// ' + cmd_args[name];
js_func += line + comment_spaces + comment + '\n';
}
if (0 < Object.keys(cmd_args).length) {
js_func += '\t\n';
}
js_func += '\tcb_runner.send(null, \'OKAY\');\n\t\n\};\n';
// Replace the command placeholders of the commands handler script
js_func = js_func.replace(/\%cmdName\%/g, cmd_name);
if (cmd.description) {
js_func = js_func.replace(/\%cmdDescription\%/g, cmd.description);
}
// Done
handler_js += js_func;
}
// Replace the placeholders (e.g. %deviceType%) of whole of commands handler script
for (var config_key in config) {
handler_js = handler_js.replace(new RegExp('\\%' + config_key + '\\%', 'g'), config[config_key]);
}
// Append the module.exports
if (!handler_js.match(/module\.exports = CommandsHandler;/)) {
handler_js += '\n\nmodule.exports = CommandsHandler;\n';
}
return handler_js;
} | javascript | {
"resource": ""
} |
q42532 | generatePackageJson | train | function generatePackageJson (config) {
// Read the user's package.json
var user_file;
try {
// Read from current file
user_file = fs.readFileSync('./package.json').toString();
} catch (e) {
user_file = null;
}
// Parse the user's package.json
var user_json = null;
if (user_file) {
try {
user_json = JSON.parse(user_file);
} catch (e) {
console.log(colors.bold.red('Your package.json was invalid!\n\
We skipped the merging of your package.json with template.'));
console.log(user_json);
return null;
}
} else {
user_json = {};
}
// Read the template package.json
var tmpl_file = fs.readFileSync(__dirname + '/../templates/package.json.tmpl').toString();
// Replace the placeholders (e.g. %deviceType%) of whole of template
for (var config_key in config) {
tmpl_file = tmpl_file.replace(new RegExp('\\%' + config_key + '\\%', 'g'), config[config_key]);
}
tmpl_file = tmpl_file.replace(new RegExp('\\%libVersion\\%', 'g'), helper.getPackageInfo().version);
// Parse the template package.json
var tmpl_json = null;
try {
tmpl_json = JSON.parse(tmpl_file);
} catch (e) {
console.error('Could not parse the template file:\n' + tmpl_file + '\n' + e.stack.toString());
process.exit(0);
}
// Merge the fields with template package.json
for (var key in tmpl_json) {
if (user_json[key] == null) {
user_json[key] = tmpl_json[key];
} else if (helper.isType(user_json[key], 'Object')) {
for (var key_ in tmpl_json[key]) {
if (user_json[key][key_] == null) user_json[key][key_] = tmpl_json[key][key_];
}
}
}
// Done
return JSON.stringify(user_json, null, ' ');
} | javascript | {
"resource": ""
} |
q42533 | execDependencyInstall | train | function execDependencyInstall () {
console.log('\nExecuting npm install command...');
return new Promise(function(resolve, reject){
var child = require('child_process').spawn('npm', ['install'], {
cwd: process.cwd,
detached: false,
env: process.env,
stdio: [process.stdin, process.stdout, process.stderr]
});
child.on('error', function (error) {
console.error(colors.bold.red('ERROR: Could not install the required modules:'));
console.error(error.stack.toString());
process.exit(255);
});
child.on('close', function (exit_code) {
if (exit_code !== 0) {
console.error(colors.bold.red('\nERROR: npm install has been failed.'));
process.exit(255);
}
console.log('\nnpm install has been completed.\n\n');
resolve(true);
});
});
} | javascript | {
"resource": ""
} |
q42534 | startCmdEditor | train | function startCmdEditor (config, is_skip_header) {
if (!is_skip_header) {
console.log(colors.bold('--------------- Command Editor ---------------'));
}
// Show a prompt for choose the mode
var promise = inquirer.prompt([{
type: 'list',
name: 'mode',
message: 'What you want to do ?',
choices: [
'Show commands list', 'Add new command', 'Edit command', 'Delete command'
]
}]);
promise.then(function (answer) {
var mode = answer.mode;
var promise = null;
if (mode == 'Add new command') {
promise = addCommandOnCmdEditor(config);
} else if (mode == 'Edit command') {
promise = editCommandOnCmdEditor(config);
} else if (mode == 'Delete command') {
promise = deleteCommandOnCmdEditor(config);
} else if (mode == 'Show commands list') {
promise = showCommandsOnCmdEditor(config);
}
if (!promise) {
startCmdEditor(config, true);
return;
}
promise.then(function () {
startCmdEditor(config, true);
});
});
} | javascript | {
"resource": ""
} |
q42535 | showCommandsOnCmdEditor | train | function showCommandsOnCmdEditor (config) {
console.log(colors.bold('\nAvailable Commands for ' + config.deviceName + ':\n'));
// Iterate the each commands
var commands = config.commands || {};
if (Object.keys(commands).length == 0) {
console.log ('\nThere is no command.');
} else {
for (var name in commands) {
var desc = commands[name].description || '';
console.log(colors.bold('\n' + name + '') + '\n ' + desc + '\n');
// Iterate the each arguments
var args = commands[name].args || {};
if (Object.keys(args).length == 0) {
console.log ('\tThe arguments of this command are not defined');
} else {
for (var arg_name in args) {
var arg_spec = args[arg_name] || '';
console.log('\t* ' + arg_name + ' - ' + arg_spec);
}
}
}
}
console.log('\n');
// Done
return new Promise(function (resolve, reject) {
resolve();
});
} | javascript | {
"resource": ""
} |
q42536 | addCommandOnCmdEditor | train | function addCommandOnCmdEditor (config) {
var cmd_name = null;
var promise = inquirer.prompt([{
type: 'input',
name: 'cmdName',
message: 'What is name of a command (e.g. setMotorPower) ?',
validate: function (value) {
if (value.length == 0) return true;
if (config.commands[value] != null) return 'This command name has already existed.';
if (!value.match(/^[A-Za-z0-9_]+$/)) return 'Available characters for argument name: A-Z, a-z, 0-9, underscore.\n\
Or, if you want to cancel, please press the enter key left empty.';
return true;
}
}]).then(function (answer) {
cmd_name = answer.cmdName || null;
if (cmd_name == null || cmd_name.length == 0) {
return null;
}
return inquirer.prompt([{
type: 'input',
name: 'cmdDesc',
message: 'What is description of ' + cmd_name + ' command ?'
}]);
}).then(function (answer) {
if (cmd_name == null) return false;
var commands = config.commands || {};
commands[cmd_name] = {
description: answer.cmdDesc || null,
args: {}
};
// Done
console.log(colors.bold.green('This command has been created: ' + cmd_name));
// Save to the commands file
console.log('\nWriting to ' + process.cwd() + '/' + COMMANDS_FILENAME);
fs.writeFileSync(COMMANDS_FILENAME, JSON.stringify(config.commands));
console.log('Writing has been completed.\n\n');
return true;
});
return promise;
} | javascript | {
"resource": ""
} |
q42537 | deleteCommandOnCmdEditor | train | function deleteCommandOnCmdEditor (config) {
var commands = config.commands || {};
var command_names = Object.keys(commands);
command_names.unshift('<< Cancel');
var promise = inquirer.prompt([{
type: 'list',
name: 'cmdName',
message: 'Choose the command you want to delete',
choices: command_names
}]);
return promise.then(function (answer) {
if (answer.cmdName == '<< Cancel') {
return false;
}
delete config.commands[answer.cmdName];
// Done
console.log(colors.bold.green('\n\nThis command has been deleted: ' + answer.cmdName));
// Save to the commands file
console.log('\nWriting to ' + process.cwd() + '/' + COMMANDS_FILENAME);
fs.writeFileSync(COMMANDS_FILENAME, JSON.stringify(config.commands));
console.log('Writing has been completed.\n\n');
return true;
});
} | javascript | {
"resource": ""
} |
q42538 | connect | train | function connect (master) {
if (_socket && _socket._master.name === master.name) {
debug(`already connected to master ${master.name}`)
return
}
if (_connectingMaster && _connectingMaster.name === master.name) {
debug(`already connecting to master ${master.name}`)
return
}
_connectingMaster = master
let newSocket = _getSocket(master)
let _messagesToResend = []
let _onMessagePublished = (...args) => {
if (_socket) _messagesToResend.push(args)
}
_publishStream.on('message', _onMessagePublished)
debug(`connecting to ${master.name} at ${master.endpoint}`)
let connectionStart = Date.now()
const onSocketConnected = timingoutCallback((err) => {
_publishStream.removeListener('message', _onMessagePublished)
newSocket.unmonitor()
if (
err ||
!_connectingMaster ||
_connectingMaster.name === !master.name
) {
newSocket.close()
if (err) {
debug(`failed to connect to ${master.name} at ${master.endpoint}`)
disconnect()
}
return
}
_connectingMaster = null
let previousSocket = _socket
debug(`${previousSocket ? 'switched' : 'connected'} to ${master.name} at ${master.endpoint} in ${Date.now() - connectionStart} ms`)
_socket = newSocket
let totalMessagesToResend = _messagesToResend.length
if (totalMessagesToResend) {
debug(`resending ${totalMessagesToResend} messages published while transitioning`)
_messagesToResend.forEach(message => _socket.send(message))
}
if (previousSocket) {
previousSocket.close()
debug(`closed previous connection to ${previousSocket._master.name} at ${previousSocket._master.endpoint}`)
} else {
connection.emit('connect')
}
}, 500)
newSocket.once('connect', () => onSocketConnected())
return connection
} | javascript | {
"resource": ""
} |
q42539 | disconnect | train | function disconnect () {
_connectingMaster = null
if (_socket) {
_socket.close()
_socket = null
debug('disconnected')
connection.emit('disconnect')
}
return connection
} | javascript | {
"resource": ""
} |
q42540 | publish | train | function publish (channel, ...args) {
_publishStream.emit('message', channel, uniqueId(`${node.name}_`), ...args)
} | javascript | {
"resource": ""
} |
q42541 | Tributary | train | function Tributary( options ) {
options = options || {};
stream.Transform.call( this, { encoding: options.encoding } );
this.getStream = options.getStream || function( filename, cb ) {
return cb();
};
this._matcher = new Matcher(
options.placeholderStart || '<!-- include ',
options.placeholderEnd !== undefined ? options.placeholderEnd : ' -->',
options.maxPathLength,
options.delimiter
);
this._tributaryState = {
chunk: null,
cursor: 0,
contentStart: 0,
contentEnd: -1,
remainder: 0
};
} | javascript | {
"resource": ""
} |
q42542 | MysqlTransit | train | function MysqlTransit(dbOriginal, dbTemp, connectionParameters) {
this.dbOriginal = dbOriginal;
this.dbTemp = dbTemp;
this.connectionParameters = connectionParameters;
this.queryQueue = [];
this.tablesToDrop = [];
this.tablesToCreate = [];
this.interactive = true;
return this._init();
} | javascript | {
"resource": ""
} |
q42543 | joint | train | function joint(streams) {
if (!(streams instanceof Array)) {
streams = Array.prototype.slice.call(arguments);
}
return streams.reduce(function(thru, stream) {
if (stream) {
thru.pipe(stream);
}
return thru;
}, through());
} | javascript | {
"resource": ""
} |
q42544 | createNamedClass | train | function createNamedClass (name, klass, baseKlass, superFunc) {
if (!superFunc) {
superFunc = function () {
baseKlass.call(this);
};
}
return new Function(
'klass', 'superFunc',
'return function ' + name + ' () {' +
'superFunc.apply(this, arguments);' +
'klass.apply(this, arguments);' +
'};'
)(klass, superFunc);
} | javascript | {
"resource": ""
} |
q42545 | afterExtends | train | function afterExtends (klass, baseKlass, superFunc) {
var newKlass = createNamedClass(klass.name, klass, baseKlass, superFunc);
newKlass.prototype = createPrototype(klass, baseKlass, newKlass);
return newKlass;
} | javascript | {
"resource": ""
} |
q42546 | processMethodOutTag | train | function processMethodOutTag(tag, typeMarkdown) {
var md = "";
if (tag.type) {
md += applyMarkdown(tag.type, settings.get(typeMarkdown)) + " ";
}
md += tag.comment;
return md;
} | javascript | {
"resource": ""
} |
q42547 | encode | train | function encode(batch, id, ver) {
//producerId min 2 digits
let producerId = b36.int2Str36(batch.producerId).padStart(2, '0');
//producerId min 3 digits
let batchId = b36.int2Str36(batch.id).padStart(3, '0');
//id min 2 digits
id = b36.int2Str36(id).padStart(3, '0');
let msg = composeCode(producerId, batchId, id);
let sign = sign2Str36(dsa.doSign(batch.dsa, batch.privateKey, msg, hash.vsHash));
let codeDescr = generateCodeDescr(producerId, batchId, id, sign, ver);
return codeDescr ? (codeDescr + msg + sign) : '';
} | javascript | {
"resource": ""
} |
q42548 | build | train | function build(writable, options) {
return writable && writable._ansi2 || (writable._ansi2 = new Ansi(writable, options))
} | javascript | {
"resource": ""
} |
q42549 | loadAndParseFile | train | function loadAndParseFile(filename, settings) {
Augmented.ajax({
url: filename,
async: true,
cache: settings.cache,
contentType: 'text/plain;charset=' + settings.encoding,
dataType: 'text',
success: function (data, status) {
logger.debug("message bundel ajax call - success");
parseData(data, settings.mode);
},
error: function(data, status) {
logger.debug("message bundel ajax call - fail " + data);
}
});
} | javascript | {
"resource": ""
} |
q42550 | train | function(array) {
var sarr = [];
var i = 0;
for (i=0; i<array.length;i++) {
var a = array[i];
var o = {};
o.name = a.name;
o.value = a.value;
o.type = a.type;
if (a.type === "checkbox") {
o.value = (a.checked) ? "on" : "off";
}
sarr.push(o);
}
return sarr;
} | javascript | {
"resource": ""
} | |
q42551 | success | train | function success(domain){
if(auth0){
//if auth0 then we don't have user storage
connection.user = new DomainWrapper(domain);
connection.user.join();
sessionPromise.then(resolve);
}else{
//if auth1 use user class to wrap domain and implement user storage and load user data
connection.user = new User(self, domain);
connection.user.join();
sessionPromise.then(load);
}
} | javascript | {
"resource": ""
} |
q42552 | applyModelMethods | train | function applyModelMethods (model, definition) {
for (var i in definition.methods) {
if (i === 'definition') {
throw new Error('Invalid model definition provided. "definition" is a reserved word');
}
model.prototype[i] = definition.methods[i];
}
} | javascript | {
"resource": ""
} |
q42553 | train | function(patterns, options) {
var self = this;
if (!(typeof patterns=='object')){throw new Error('ObsRouter constructor expects patterns object as first argument')}
options = options || {};
EventEmitter.call(self);
if (process.browser){
//bind to window by default
self._bindToWindow = 'bindToWindow' in options ? options.bindToWindow : true;
if (self._bindToWindow){
// add to module-scoped list of routers
routers.push(self);
// override any url input with window location
options.url = window.document.location.pathname + window.document.location.search;
}
}
// initialise state
self.patterns = patterns;
self.name = null;
self.params = {};
self.routes = {};
_.forEach(_.keys(self.patterns), function(route){
self.routes[route] = null;
});
// normalise state
self._update(options.url || '', false);
// implement initialEmit option
if (options.initialEmit){
var cancel = cancellableNextTick(function(){
self._emit();
});
self.once('url', cancel);
}
} | javascript | {
"resource": ""
} | |
q42554 | train | function(object, options) {
var self = this;
return deep.when(getSchema(this))
.done(function(schema) {
return deep.Arguments([object, options]);
});
} | javascript | {
"resource": ""
} | |
q42555 | handleConnectionCallback | train | function handleConnectionCallback(err, resolve, reject, key, connection) {
debug('handleConnectionCallback','start');
//error, remove cached entry, reject the promise
if (err) {
debug('handleConnectionCallback','error',err);
delete promises[key];
return reject(err);
}
//patch close method for caching
shadowClose(connection);
//create a reference to the original connection for cleanup
connection._mssqlngKey = key;
//add connection to the pool
connections[connection._mssqlngKey] = connection;
//resolve the promise
debug('handleConnectionCallback','success');
return resolve(connection);
} | javascript | {
"resource": ""
} |
q42556 | load | train | function load(mod) {
if (typeof(mod.factory) === "function") {
return require(mod.deps, mod.factory);
}
return mod.factory;
} | javascript | {
"resource": ""
} |
q42557 | handle | train | function handle(filePath) {
var file = toVFile(filePath)
var result = test(file)
if (mask(result, INCLUDE)) {
if (one) {
callback(null, file)
return true
}
results.push(file)
}
if (mask(result, BREAK)) {
callback(null, one ? null : results)
return true
}
} | javascript | {
"resource": ""
} |
q42558 | once | train | function once(child) {
if (handle(current) === true) {
return
}
readdir(current, onread)
function onread(error, entries) {
var length = entries ? entries.length : 0
var index = -1
var entry
if (error) {
entries = []
}
while (++index < length) {
entry = entries[index]
if (entry !== child && handle(resolve(current, entry)) === true) {
return
}
}
child = current
current = dirname(current)
if (current === child) {
callback(null, one ? null : results)
return
}
once(basename(child))
}
} | javascript | {
"resource": ""
} |
q42559 | generateTransactionRequest | train | function generateTransactionRequest(signer, transaction, options) {
let iou = {
amt: transaction.amount,
cur: transaction.currency,
sub: signer.address,
aud: transaction.destination,
nce: String(Math.floor(Math.random() * 1000000000))
};
return createTransactionRequestStatement(signer, iou, options);
} | javascript | {
"resource": ""
} |
q42560 | registerWalletAddress | train | function registerWalletAddress(url, body, options) {
options = options || {};
url = resolveURL(url, '/address');
return new P(function (resolve, reject) {
request({
url: url,
method: options.method || 'POST',
body: body,
json: true,
headers: options.headers
}, function (err, res, body) {
if (err) return reject(err);
return resolve(body);
});
});
} | javascript | {
"resource": ""
} |
q42561 | checkAddressBalance | train | function checkAddressBalance(url, address, options) {
options = options || {};
let path = '/address/.../balance'.replace('...', address);
url = resolveURL(url, path);
return new P(function (resolve, reject) {
request({
url: url,
method: 'GET',
headers: options.headers
}, function (err, res, body) {
if (err) return reject(err);
return resolve(body);
});
});
} | javascript | {
"resource": ""
} |
q42562 | generateKeyPair | train | function generateKeyPair(scheme) {
let keypair;
let keys;
switch (scheme) {
case 'ed25519':
case 'secp256k1':
keypair = schemes[scheme].genKeyPair();
keys = {
scheme: scheme,
private: keypair.getPrivate('hex'),
public: keypair.getPublic('hex')
};
break;
default:
throw new Error('invalid-scheme');
break;
}
return keys;
} | javascript | {
"resource": ""
} |
q42563 | deriveWalletAddress | train | function deriveWalletAddress(publicKey, type) {
let keyBuffer = new Buffer(publicKey, 'hex');
let firstHash = crypto.createHash('sha256').update(keyBuffer).digest();
let secondHash = ripemd160(firstHash);
let extendedHash = (type === 'issuer' ? '57' : '87') + secondHash.toString('hex');
let base58Public = bs58check.encode(new Buffer(extendedHash, 'hex'));
return base58Public;
} | javascript | {
"resource": ""
} |
q42564 | createAddressRegistrationStatement | train | function createAddressRegistrationStatement(address, keys, options) {
options = options || {};
/* Create an extended JSON Web Signatures object */
let jws = {
hash: {
type: (hashes.indexOf(options.hash) > -1) ? options.hash : 'sha256',
value: ''
},
payload: {
address: address,
keys: [
keys.public
],
threshold: 1
},
signatures: [
{
header: {
alg: keys.scheme,
kid: '0'
},
signature: ''
}
]
};
/* Generate a cryptogrphic hash of the payload */
jws.hash.value = crypto.createHash(jws.hash.type)
.update(JSON.stringify(jws.payload)).digest('hex');
/* Sign the hash of the payload */
jws.signatures[0].signature = schemes[keys.scheme]
.sign(jws.hash.value, keys.private, 'hex').toDER('hex');
return jws;
} | javascript | {
"resource": ""
} |
q42565 | resolveURL | train | function resolveURL(url, path) {
if (typeof url !== 'string' || typeof path !== 'string') {
return new Error('url-and-path-required');
}
/* Remove leading and duplicate slashes */
url = url.replace(/\/{2,}/g, '/').replace(/^\//, '').replace(':/','://');
let parsedUrl = urlModule.parse(url);
if (protocols.indexOf(parsedUrl.protocol) < 0 || !parsedUrl.host) {
return new Error('invalid-url');
}
let resolvedUrl = urlModule.resolve(parsedUrl.href, path);
return resolvedUrl;
} | javascript | {
"resource": ""
} |
q42566 | merge | train | function merge(target, source) {
if (source === null) {
return target
}
var props = Object.getOwnPropertyNames(target)
props.forEach(function (name) {
var s = gettype(source[name])
if (s !== 'undefined') {
var t = gettype(target[name])
if (t !== s) {
throw new Error(`Type mismatch between '${t}' and '${s}' for '${name}'`)
}
if (t === 'object') {
merge(target[name], source[name])
} else {
target[name] = source[name]
}
}
})
return target
} | javascript | {
"resource": ""
} |
q42567 | findIndexInArray | train | function findIndexInArray(array, callback) {
var _length = array.length;
for (var i = 0; i < _length; i++) {
if (callback(array[i])) return i;
}
return -1;
} | javascript | {
"resource": ""
} |
q42568 | replaceInArray | train | function replaceInArray(array, indexToReplace, indexToInsert) {
var _removedArray = array.splice(indexToReplace, 1);
array.splice(indexToInsert, 0, _removedArray[0]);
return array;
} | javascript | {
"resource": ""
} |
q42569 | getArrayOfPartials | train | function getArrayOfPartials() {
var _partialsArr = [];
for (var file in mainPartialList) {
if (mainPartialList.hasOwnProperty(file)) {
_partialsArr.push(file);
}
}
return _partialsArr;
} | javascript | {
"resource": ""
} |
q42570 | parseFile | train | function parseFile(importKeyword, requiresKeyword, filePath) {
var _lines = grunt.file.read(filePath).split(NEW_LINE),
_values = {
imports: {},
requires: {}
};
// Search for keywords in file
for (var i = _lines.length - 1; i >= 0; i--) {
var line = _lines[i];
if (line.indexOf(importKeyword) !== -1) {
// get import value
var _importValue = line.match(/("|')(.*?)("|')/)[2];
// Create full path to help looking for file and minimalize
// errors if there are duplicated filenames
_importValue = Path.join(Path.dirname(filePath), _importValue.sassToPath());
// Windows support. Replace backslashes into slashes.
_importValue = _importValue.replace(/\\/g, "/");
// Append new import value to list
_values.imports['import' + i] = _importValue;
}
if (line.indexOf(requiresKeyword) !== -1) {
// get require value
var _requireValue = line.match(/("|')(.*?)("|')/)[2];
// Create new dependency object
var _requireObject = {
requires: _requireValue.sassToPath(),
fileName: filePath
};
// Append new require value to list
_values.requires['require' + i] = _requireObject;
}
}
return _values;
} | javascript | {
"resource": ""
} |
q42571 | orderByDependency | train | function orderByDependency(partialsArray) {
var _doPass = true,
_reqCache = {};
// repeat sorting operation until
// there is no replacing procedure during
// one pass (bubble sorting).
while (_doPass) {
_doPass = false;
// Iterate through every partial in the list and check its
// dependency (requirements)
partialsArray.forEach(function (partialName, partialIndex) {
// Get require list for current partial
var _requireList = mainPartialList[partialName].requires;
// for each requirement in require object do...
for (var rKey in _requireList) {
// Check if current key is _requireList property
if (!_requireList.hasOwnProperty(rKey)) {
// if not go to next iteration
continue;
}
// Current partial filename without root folder
var _fileName = mainPartialList[partialName].removedRoot,
// Index of current partial in partialsArray, -1 if not found.
_requireIndex = findIndexInArray(partialsArray, function (partialName) {
return (partialName.match(_requireList[rKey].requires) !== null);
}),
_requireObject = _requireList[rKey];
// Check require cache for dependency loop
if (_reqCache[_requireObject.requires + _fileName]) {
// dependency loop detected, throw an error and break program
grunt.fail.fatal(
'Dependency loop detected!!! \nFiles that have dependency loop: \n' +
mainPartialList[partialsArray[_requireIndex]].fileName + '\n' +
_requireObject.fileName
);
}
// If requirement is found and its position is incorrect
if (_requireIndex > -1 && _requireIndex > partialIndex) {
// Remove partial from current index and insert
// it before partial that requires it.
partialsArray = replaceInArray(partialsArray, _requireIndex, partialIndex);
// Replacing procedure occured so do one more pass.
_doPass = true;
// add requirement to require cache for dependency loop handling
_reqCache[_fileName + _requireObject.requires] = true;
} else if (_requireIndex === -1) {
// invalid requirement, throw a warning
grunt.log.warn(
'File: ' + mainPartialList[partialName].fileName +
' is depending on non existing partial "' +
_requireObject.requires + '"'
);
}
} // end for
}); // end for each
} // end while
// Return reordered file list
return partialsArray;
} | javascript | {
"resource": ""
} |
q42572 | generateBootstrapContent | train | function generateBootstrapContent(partialsArray, lineDelimiter) {
var _bootstrapContent = '',
_folderGroup = '';
partialsArray.forEach(function (partialName) {
var _sassPath = mainPartialList[partialName].removedRoot,
_currentRoot = _sassPath.parseRootFolder();
if (options.useRelativePaths) {
// if useRelativePaths option is set to true the result file will use paths relative to bootstrap file
// in this case filterRootPaths option is not used
_sassPath = Path.relative(Path.dirname(options.bootstrapFile),
mainPartialList[partialName].fileName.toSassFormat());
// remove file extension
_sassPath = _sassPath.replace(Path.extname(_sassPath), '');
// Windows support. Replace backslashes into slashes.
_sassPath = _sassPath.replace(/\\/g, "/");
} else {
_sassPath = _sassPath.toSassFormat();
}
// if current root folder has changed, write new root folder
// as a comment and set new current folder
if (_folderGroup != _currentRoot) {
_bootstrapContent += NEW_LINE + '// ' + _currentRoot + NEW_LINE;
_folderGroup = _currentRoot;
}
// append import line
_bootstrapContent += options.importKeyword + ' "' + _sassPath + '"' + lineDelimiter + NEW_LINE;
});
return _bootstrapContent;
} | javascript | {
"resource": ""
} |
q42573 | StartableModel | train | function StartableModel(model,instance) {
if(!model) {
throw new Error('model is required')
}
if(!instance) {
throw new Error('instance is required')
}
if(!(this instanceof StartableModel)) {
return new StartableModel(model,instance,index)
}
this.model = model
this.key = model.key
this.instance= instance
this.fn = instance[model.startable]
if(!this.fn) {
throw new Error('The instance of ' +
this.key +
' does not have a method ' +
model.startable +
' which is required for starting this service.')
}
this.inject = (this.fn.inject || [])
this.hasDeps = (this.inject.length > 0)
} | javascript | {
"resource": ""
} |
q42574 | fail | train | function fail(err, status=1) {
console.log(process.env.DEBUG ? err.stack : err.message);
process.exit(status);
} | javascript | {
"resource": ""
} |
q42575 | autoSpliceLaunchArray | train | function autoSpliceLaunchArray(LaunchArray, TypeKey){
var indFirstElement = currentPromiseArrays[TypeKey].indexOf(LaunchArray[0]);
var indLastElement = currentPromiseArrays[TypeKey].indexOf(LaunchArray[LaunchArray.length-1]);
Promise.all(LaunchArray.map(e => {return e.result})).then(() => {
currentPromiseArrays[TypeKey].splice(indFirstElement, indLastElement);
}, err => {
currentPromiseArrays[TypeKey].splice(indFirstElement, indLastElement);
});
} | javascript | {
"resource": ""
} |
q42576 | train | function(inParams, inCallbackFunctionName) {
if (enyo.isString(inParams)) {
return inParams.replace("=?", "=" + inCallbackFunctionName);
} else {
var params = enyo.mixin({}, inParams);
params[this.callbackName] = inCallbackFunctionName;
return enyo.Ajax.objectToQuery(params);
}
} | javascript | {
"resource": ""
} | |
q42577 | stupidDirsExist | train | function stupidDirsExist(dirs) {
const check = [];
dirs.forEach((dir) => {
check.push(dirExist(dir));
});
return Promise.all(check).then((results) => {
// Combine to single object
return dirs.reduce(function(prev, item, i) {
prev[item] = !!results[i];
return prev;
}, {});
});
} | javascript | {
"resource": ""
} |
q42578 | dirsExist | train | function dirsExist(dirs) {
if (0 === dirs.length) {
return new Promise((resolve) => {
resolve({});
});
}
// Group dirs by '/' count
const dirsByDepth = dirs.reduce(function(prev, curItem) {
const depth = curItem.split(path.sep).length;
(prev[depth] = prev[depth] || []).push(curItem);
return prev;
}, {});
// Extract min depth dirs
const allDepths = Object.keys(dirsByDepth).map(Number);
const currDepth = Math.min(...allDepths);
const currDirs = dirsByDepth[currDepth];
// Prepare result object
const result = dirs.reduce(function(prev, item) {
prev[item] = null;
return prev;
}, {});
// Check if min depth dirs exist
return stupidDirsExist(currDirs).then((localResult) => {
Object.keys(result).forEach((dir) => {
if (null !== result[dir]) {
return;
}
Object.keys(localResult).forEach((localDir) => {
// Transfer local check result to global "as is"
result[localDir] = localResult[localDir];
// Additionally check if we can mark more deeper directories
// as non-existing
if (false === localResult[localDir] &&
dir.slice(0, localDir.length + 1) === localDir + path.sep) {
result[dir] = false;
}
});
});
// Extract not checked dirs
const restDirs = dirs.filter((dir) => {
return null === result[dir];
});
return dirsExist(restDirs);
}).then((finalResult) => {
// Transfer local check result to global "as is"
Object.keys(finalResult).forEach((finalDir) => {
result[finalDir] = finalResult[finalDir];
});
return result;
});
} | javascript | {
"resource": ""
} |
q42579 | parseASCIIChunk | train | function parseASCIIChunk(workChunk) {
var data = (0, _utils.ensureString)(workChunk);
// console.log('parseASCII')
var result = void 0,
text = void 0;
var patternNormal = /normal[\s]+([\-+]?[0-9]+\.?[0-9]*([eE][\-+]?[0-9]+)?)+[\s]+([\-+]?[0-9]*\.?[0-9]+([eE][\-+]?[0-9]+)?)+[\s]+([\-+]?[0-9]*\.?[0-9]+([eE][\-+]?[0-9]+)?)+/g;
var patternVertex = /vertex[\s]+([\-+]?[0-9]+\.?[0-9]*([eE][\-+]?[0-9]+)?)+[\s]+([\-+]?[0-9]*\.?[0-9]+([eE][\-+]?[0-9]+)?)+[\s]+([\-+]?[0-9]*\.?[0-9]+([eE][\-+]?[0-9]+)?)+/g;
var patternFace = /facet([\s\S]*?)endfacet/g;
var posArray = [];
var normArray = [];
var faces = 0;
var offset = 0;
while ((result = patternFace.exec(data)) !== null) {
var length = 0;
text = result[0];
offset = result.index + text.length;
while ((result = patternNormal.exec(text)) !== null) {
normArray.push(parseFloat(result[1]), parseFloat(result[3]), parseFloat(result[5]));
normArray.push(parseFloat(result[1]), parseFloat(result[3]), parseFloat(result[5]));
normArray.push(parseFloat(result[1]), parseFloat(result[3]), parseFloat(result[5]));
}
while ((result = patternVertex.exec(text)) !== null) {
posArray.push(parseFloat(result[1]), parseFloat(result[3]), parseFloat(result[5]));
length += 1;
}
faces += 1;
}
var positions = new Float32Array(faces * 3 * 3);
var normals = new Float32Array(faces * 3 * 3);
positions.set(posArray);
normals.set(normArray);
// compute offsets, remainderData etc for next chunk etc
var remainderTextData = data.slice(offset);
// console.log('remainderData', remainderTextData)
var remainderData = new Buffer(remainderTextData);
return { faceOffset: faces, remainderData: remainderData, positions: positions, normals: normals };
} | javascript | {
"resource": ""
} |
q42580 | train | function (value) {
var res;
if (this.has(value)) {
res = this.items.splice(
x.indexOf(this.items, value),
1
);
}
return res;
} | javascript | {
"resource": ""
} | |
q42581 | train | function (callback) {
for (var i = 0, l = this.items.length; i < l; i++) {
callback(this.items[i], i, this.items);
}
return this;
} | javascript | {
"resource": ""
} | |
q42582 | argv | train | function argv(k) {
if (!nargv) {
nargv = process.argv.slice(0, 2);
}
var v = '', m = null;
var x = new RegExp(k + regexKeyVal.source);
nargv.every(function(e) {
m = e.match(x);
if (m && m.length) {
v = m[0];
return false;
}
});
return v;
} | javascript | {
"resource": ""
} |
q42583 | clone | train | function clone(c, wl, bl) {
var cl = {}, cp, t;
for (var keys = Object.keys(c), l = 0; l < keys.length; l++) {
cp = c[keys[l]];
if (bl && bl.indexOf(cp) >= 0) {
continue;
}
if (Array.isArray(cp)) {
cl[keys[l]] = cp.slice(0);
} else if ((t = typeof cp) === 'function') {
if (!wl || wl.indexOf(cp) >= 0) {
cl[keys[l]] = cp; // cp.bind(cp);
}
} else if (cp == null || t === 'string' || t === 'number' || t === 'boolean' || util.isRegExp(cp)
|| util.isDate(cp) || util.isError(cp)) {
cl[keys[l]] = cp;
} else if (t !== 'undefined') {
cl[keys[l]] = clone(cp, wl, bl);
}
}
return cl;
} | javascript | {
"resource": ""
} |
q42584 | pkgPropUpd | train | function pkgPropUpd(pd, u, n, r) {
var v = null;
if (u && pd.oldVer !== self.version && self.version) {
v = self.version;
} else if (n && pd.oldVer !== self.next.version && self.next.version) {
v = self.next.version;
} else if (r && self.prev.version) {
v = self.prev.version;
}
pd.version = v;
if (v && !pd.props) {
pd.pkg.version = v;
pd.propChangeCount++;
}
if (pd.props && pd.pkgParent) {
pd.props.forEach(function pkgProp(p) {
if (pd.pkgParent[p] && (!pd.pkg[p] || pd.pkgParent[p] !== pd.pkg[p])) {
// sync parent package property with the current one
pd.pkg[p] = pd.pkgParent[p];
pd.propChangeCount++;
}
});
}
return v;
} | javascript | {
"resource": ""
} |
q42585 | vmtchs | train | function vmtchs(start, end, skips) {
var s = '';
for (var i = start; i <= end; i++) {
if (skips && skips.indexOf(i) >= 0) {
continue;
}
s += self.versionMatch[i] || '';
}
return s;
} | javascript | {
"resource": ""
} |
q42586 | buildHelpContents | train | function buildHelpContents() {
var pageTpl = '<div class="cke_accessibility_legend" role="document" aria-labelledby="' + id + '_arialbl" tabIndex="-1">%1</div>' +
'<span id="' + id + '_arialbl" class="cke_voice_label">' + lang.contents + ' </span>',
sectionTpl = '<h1>%1</h1><dl>%2</dl>',
itemTpl = '<dt>%1</dt><dd>%2</dd>';
var pageHtml = [],
sections = lang.legend,
sectionLength = sections.length;
for ( var i = 0; i < sectionLength; i++ ) {
var section = sections[ i ],
sectionHtml = [],
items = section.items,
itemsLength = items.length;
for ( var j = 0; j < itemsLength; j++ ) {
var item = items[ j ],
itemLegend = item.legend.replace( variablesPattern, replaceVariables );
// (#9765) If some commands haven't been replaced in the legend,
// most likely their keystrokes are unavailable and we shouldn't include
// them in our help list.
if ( itemLegend.match( variablesPattern ) )
continue;
sectionHtml.push( itemTpl.replace( '%1', item.name ).replace( '%2', itemLegend ) );
}
pageHtml.push( sectionTpl.replace( '%1', section.name ).replace( '%2', sectionHtml.join( '' ) ) );
}
return pageTpl.replace( '%1', pageHtml.join( '' ) );
} | javascript | {
"resource": ""
} |
q42587 | getArguments | train | function getArguments(f, amended)
{
var functionCode = f.toString();
if(amended){
//This is a fix for when we are passed anonymous functions (which are passed to us as unassigned)
//ex: "function (a, b, c) { }"
//These are actually parse errors so we'll try adding an assignment to fix the parse error
functionCode = 'var a=' + functionCode;
}
try{
var ast = babylon.parse(functionCode);
var functionDecl = findFunctionDecl(ast);
if(!functionDecl) return [];
return functionDecl.params.map(p => p.name);
}catch(e){
//try one more time
if(!amended){
return getArguments(f, true);
}
throw new Error('Could not parse:\n' + functionCode + '\n' + e);
}
} | javascript | {
"resource": ""
} |
q42588 | runChromedriver | train | function runChromedriver(location, remote, options) {
assert(remote === 'chromedriver', 'expected remote to be chromedriver');
if (!options.chromedriverStarted) {
chromedriver.start();
}
var throttle = options.throttle || function (fn) { return fn(); };
return throttle(function () {
return runSingleBrowser(location, 'http://localhost:9515/',
options.platform || options.capabilities || {}, {
name: options.name,
debug: options.debug,
httpDebug: options.httpDebug,
allowExceptions: options.allowExceptions,
testComplete: options.testComplete,
testPassed: options.testPassed,
timeout: options.timeout
});
}).then(function (result) {
if (!options.keepChromedriverAlive) {
chromedriver.stop();
}
return result;
}, function (err) {
if (!options.keepChromedriverAlive) {
chromedriver.stop();
}
throw err;
});
} | javascript | {
"resource": ""
} |
q42589 | pad | train | function pad (n, width, z) {
if (typeof n !== 'string') throw new Error('bitString#pad: Need String');
z = z || '0';
while(n.length < width) {
n = z + n;
}
return n;
} | javascript | {
"resource": ""
} |
q42590 | checksum | train | function checksum (bits, size) {
if (bits == null || !isValid(bits)) throw new Error('bitString#checksum: Need valid bits');
if (size == null || size % 2 !== 0) throw new Error('bitString#checksum: size needs to be even');
var sumA = 0,
sumB = 0,
i;
for (i = 0; i < bits.length; i++) {
sumA = (sumA + parseInt(bits[i], 2)) % size;
sumB = (sumB + sumA) % size;
}
return pad(sumB.toString(2), size / 2) + pad(sumA.toString(2), size / 2);
} | javascript | {
"resource": ""
} |
q42591 | randomBits | train | function randomBits (n) {
if (typeof n !== 'number') throw new Error('bitString#randomBits: Need number');
var buf = _randomBytes(Math.ceil(n/8)),
bits = '';
for (var i = 0; i < n; i++) {
bits += (buf[Math.floor(i / 8)] & (0x01 << (i % 8))) ? '1' : '0';
}
return bits;
} | javascript | {
"resource": ""
} |
q42592 | createFormatChangelog | train | function createFormatChangelog(inPath) {
if (!inPath) {
throw new Error('Input path argument is required');
}
return function formatChangelog() {
return gulp.src(inPath)
// Replace all version compare links.
.pipe(replace(/\(http.*\) /g, ' '))
// Replace all commit links.
.pipe(replace(/ \(\[.*/g, ''))
.pipe(gulp.dest(file => file.base));
};
} | javascript | {
"resource": ""
} |
q42593 | train | function(parts) {
var urls = [];
var start = '';
// If the first part is empty
// the original path begins with a slash so we
// do that, too
if( _.isEmpty(parts[0]) ) {
start = '/';
urls[0] = '/'; // would not be generated in reduce()
}
_.reduce(parts, function(acc, value){
if( ! _.isString(value) || _.isEmpty(value) )
return acc;
acc += value;
// Push w/out trailing slash
urls.push(acc);
return acc + '/';
}, start );
return urls;
} | javascript | {
"resource": ""
} | |
q42594 | train | function(urls, skipMissing) {
var i = -1;
var j;
var handlers = [];
var url;
var resource;
var urlsLength = urls.length;
var resourcesLength = this._resources.length;
var foundHandler;
// All URLs
while( ++i < urlsLength ) {
url = urls[i];
foundHandler = undefined; // No handler yet
j = -1;
// All resources
while( ++j < resourcesLength ) {
resource = this._resources[j];
if( ! resource.getPattern().matches(url) )
continue;
// If this handler does not want to use cascading
// we remove every handler that might have been executed
// before it
if( false === resource.getOption('cascading') )
handlers = [];
handlers.push({ path: url, handler: resource });
foundHandler = resource;
break;
}
// One handler missing? Chain is broken, return an error if required
if( _.isUndefined(foundHandler) && ! skipMissing )
return null;
}
return handlers;
} | javascript | {
"resource": ""
} | |
q42595 | train | function(resource) {
var handler = resource.handler.getCallback(request.method);
request.api.handler = handler;
request.path = resource.path;
var context = resource.handler.getContext();
context.__espressojs = {
chainIsComplete: chainIsComplete,
// Reference to the currently processed handler
handler: resource.handler,
// Currently processed path
path: resource.path
};
return context;
} | javascript | {
"resource": ""
} | |
q42596 | setup | train | function setup (request, options, ...args) {
const len = request.headers['content-length']
const encoding = request.headers['content-encoding'] || 'identity'
return Object.assign({}, options, {
encoding: options.encoding || 'utf-8',
limit: options.limit || '1mb',
length: (len && encoding === 'identity') ? ~~len : options.length
}, ...args)
} | javascript | {
"resource": ""
} |
q42597 | getRecaptchaResponse | train | function getRecaptchaResponse(field, req) {
return req.get(field) || (req.query && req.query[field]) || (req.body && req.body[field])
} | javascript | {
"resource": ""
} |
q42598 | resolveAsync | train | function resolveAsync(p, base, root) {
if (!path.isAbsolute(p)) {
return new Promise(function(r, j) {
resolve(forceRelative(p), {
basedir: path.resolve(root, base)
}, function(err, res) {
if (err) {
j(err);
} else {
r(res);
}
});
});
} else {
return Promise.resolve(p);
}
} | javascript | {
"resource": ""
} |
q42599 | object | train | function object(pairs) {
let obj = {};
for (let i = 0;i<pairs.length;++i) {
obj[pairs[i][0]] = pairs[i][1];
}
return obj;
} | javascript | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.