_id stringlengths 2 6 | title stringlengths 0 58 | partition stringclasses 3 values | text stringlengths 52 373k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q32600 | syncBatch | train | function syncBatch(batch, cb) {
if (batch && batch.length > 0) {
var mbaasClient = new MBaaSClient(ENVIRONMENT, {
url: URL.format(PROTOCOL + '://' + HOST),
accessKey: ACCESS_KEY,
project: PROJECT,
app: GUID,
appApiKey: API_KEY
});
// /api/app/:domain/:environment/:projectid/:appid/message/:topic with [] or messages for data (a batch)
mbaasClient.app.message.sendbatch({
'host': HOST,
'environment': ENVIRONMENT,
'domain': DOMAIN,
'data': batch,
'topic': 'fhact' //the only other topic is fhweb which is not longer used
}, function(err) {
if (err) {
return cb(err, {message: 'Error sending message batch to MBaaS', host: HOST, environment: ENVIRONMENT, domain: DOMAIN, topic:'fhact', batch: batch});
} else {
return cb(undefined, {message: 'Batch sent to MBaaS'});
}
});
} else {
return cb(undefined, {message: 'Batch empty...nothing to sync at this time'});
}
} | javascript | {
"resource": ""
} |
q32601 | normalizeBlocks | train | function normalizeBlocks(input) {
var numberOfLinesToIndent = 0;
var thisLineContainsStuff = false;
var thisLinesIndentation = '';
var out = '';
for (var i = 0; i < input.length; i++) {
var chr = input[i];
if (chr == '\r') {
continue;
}
if (chr === '\n') {
if (!thisLineContainsStuff) {
numberOfLinesToIndent++;
} else {
out += '\n';
}
thisLineContainsStuff = false;
thisLinesIndentation = '';
continue;
}
if (!thisLineContainsStuff && (chr === ' ' || chr === '\t')) {
thisLinesIndentation += chr;
continue;
}
if (chr !== ' ' || chr !== '\t') {
if (!thisLineContainsStuff) {
for (var j = 0; j < numberOfLinesToIndent; j++) {
out += thisLinesIndentation + '\n';
}
out += thisLinesIndentation + chr;
} else {
out += chr;
}
numberOfLinesToIndent = 0;
thisLineContainsStuff = true;
}
}
return out;
} | javascript | {
"resource": ""
} |
q32602 | addPosition | train | function addPosition (error, message) {
error.message = (
message + ' at ' +
'line ' + token.position.line + ', ' +
'column ' + token.position.column
)
error.position = token.position
return error
} | javascript | {
"resource": ""
} |
q32603 | format | train | function format (form) {
return formToMarkup(form)
// Split lines.
.split('\n')
.map(function (line, index) {
return EMPTY_LINE.test(line)
// If the line is empty, leave it empty.
? line
: index === 0
? line
// On subsequent lines with indentation, add spaces
// to existing indentation.
: ' '.repeat(token.position.column - 1) + line
})
.join('\n')
} | javascript | {
"resource": ""
} |
q32604 | train | function (path, done) {
fs.access(path, fs.R_OK, function (error) {
done(!error)
})
} | javascript | {
"resource": ""
} | |
q32605 | logStage | train | function logStage(stage) {
if (!spinner) {
spinner = ora({
color: 'green',
text: chalk.green(defaults.text)
}).info();
}
if (!stage || (lastStage && lastStage !== stage)) {
spinner.succeed(chalk.grey(lastStage));
}
if (stage) {
spinner.start(stage);
}
} | javascript | {
"resource": ""
} |
q32606 | addUpdated | train | function addUpdated(results) {
results.forEach(function(result) {
result = normalizeResult(result);
if (!lastQuery.results.hits) {
lastQuery = { results: { hits: { total : 0, hits: [] } } };
} else {
var i = 0, l = lastQuery.results.hits.hits.length;
for (i; i < l; i++) {
if (lastQuery.results.hits.hits[i]._source.uri === result._source.uri) {
lastQuery.results.hits.hits.splice(i, 1);
break;
}
}
}
lastQuery.results.hits.hits.unshift(result);
});
updateResults(lastQuery);
} | javascript | {
"resource": ""
} |
q32607 | normalizeResult | train | function normalizeResult(result) {
if (result.uri) {
console.log('normalizing', result);
if (!result._source) {
result._source = {};
}
['title', 'timestamp', 'uri', 'annotationSummary', 'annotations', 'visitors'].forEach(function(f) {
result._source[f] = result[f];
});
}
return result;
} | javascript | {
"resource": ""
} |
q32608 | gotResults | train | function gotResults(results) {
results.JSONquery = JSON.stringify(results.query, null, 2);
console.log('gotResults', results);
updateResults(results);
} | javascript | {
"resource": ""
} |
q32609 | gotNavigation | train | function gotNavigation(results) {
console.log('gotNavigation', results, browser);
var browser;
if (results.navigator === 'treemap') {
browser = browseTreemap;
} else if (results.navigator === 'facet') {
browser = browseFacet;
} else if (results.navigator === 'cluster') {
browser = browseCluster;
} else if (results.navigator === 'debug') {
browser = browseDebug;
}
if (browser) {
$('.browse.sidebar').sidebar('show');
$('#browse').html();
browser.render('#browse', results, resultView, context);
} else {
$('.browse.sidebar').sidebar('hide');
}
} | javascript | {
"resource": ""
} |
q32610 | updateResults | train | function updateResults(res) {
if (res === undefined) {
res = lastQuery;
}
var results = res.results;
lastQuery = res;
// content is being viewed or edited, delay updates
if (noUpdates) {
console.log('in noUpdates');
hasQueuedUpdates = true;
clearTimeout(queuedNotifier);
queuedNotifier = setInterval(function() { $('.toggle.item').toggleClass('red'); }, 2000);
return;
}
// clear queued notifier
$('.toggle.item').removeClass('red');
clearInterval(queuedNotifier);
$('.query.button').animate({opacity: 1}, 500, 'linear');
// use arbitrary rendering to fill results
var container = '#results';
$('.selected.fields').html('<option value="">Select a field</option>');
var baseFields = ['title'];
if (res.options.query.selectFields) {
res.options.query.selectFields.forEach(function(f) {
$('.selected.fields').append('<option>' + f + '</option>');
});
}
$('.all.fields').html('<option value="">Select a field</option>');
baseFields.forEach(function(f) {
$('.all.fields').append('<option>' + f + '</option>');
});
if (results.hits) {
$(container).html('');
$('#queryCount').html(results.hits.hits.length === results.hits.total ? results.hits.total : (results.hits.hits.length + '/' + results.hits.total));
resultView.render(container, res, context);
} else {
$(container).html('<i>No items.</i>');
$('#queryCount').html('0');
resultView.render(container, res, context);
}
} | javascript | {
"resource": ""
} |
q32611 | getSelected | train | function getSelected() {
var selected = [];
$('.selectItem').each(function() {
if ($(this).is(':checked')) {
selected.push(utils.deEncID($(this).attr('name').replace('cb_', '')));
}
});
return selected;
} | javascript | {
"resource": ""
} |
q32612 | ValidationError | train | function ValidationError(message, errors) {
Error.call(this, message);
if (Error.captureStackTrace) {
Error.captureStackTrace(this, ValidationError);
}
this.message = message;
this.errors = errors;
} | javascript | {
"resource": ""
} |
q32613 | Air | train | function Air(el, context) {
if(!(this instanceof Air)) {
return new Air(el, context);
}
if(typeof context === 'string') {
context = document.querySelector(context);
}else if(context instanceof Air) {
context = context.get(0);
}
context = context || document;
// NOTE: do not pass empty string to querySelectorAll
if(!arguments.length || el === '') {
this.dom = [];
}else{
this.dom = typeof el === 'string' ? context.querySelectorAll(el) : el;
}
if(el instanceof Air) {
this.dom = el.dom.slice(0);
}else if(!Array.isArray(el)) {
if(this.dom instanceof NodeList) {
this.dom = Array.prototype.slice.call(this.dom);
}else if(el) {
this.dom = ((el instanceof Node) || el === window) ? [el] : [];
}
}
// shortcut to Array.prototype.slice
this.slice = Array.prototype.slice;
} | javascript | {
"resource": ""
} |
q32614 | findById | train | function findById(method, req, res, next) {
res.__apiMethod = method;
var self = this;
var id = req.params.id;
var fields = this.option(method, 'fields');
var populate = this.option(method, 'populate');
var filter = this.option(method, 'filter');
if (filter instanceof Function) filter = filter.call(this, req);
var query = extend({_id: id}, filter);
var dbQuery = this.model.findOne(query, fields);
if (populate) {
dbQuery = dbQuery.populate(populate);
}
dbQuery.exec(function (err, obj) {
if (err) return next(err);
if (!obj) {
return next(new ModelAPIError(
404, `The ${self.nameSingle} was not found by ${id}`
));
}
if (method === 'details') res.status(200);
res.json(obj);
});
} | javascript | {
"resource": ""
} |
q32615 | commandAttr | train | function commandAttr(context, attributes) {
let ii, jj, len, jlen, result;
let entity = context.entity;
// let debug = context.debug;
const componentIDs = context.componentIDs;
// printIns( context,1 );
// if( debug ){ console.log('ATTR> ' + stringify(componentIDs) + ' ' + stringify( _.rest(arguments)) ); }
// if( !componentIDs ){
// throw new Error('no componentIDs in context');
// }
if (!entity) {
// console.log('ATTR> no entity');
return (context.last = [VALUE, null]);
}
attributes = Array.isArray(attributes) ? attributes : [attributes];
// components = entity.components;
result = [];
const components = entity.getComponents(componentIDs);
// console.log('commandComponentAttribute', attributes);
for (ii = 0, len = components.length; ii < len; ii++) {
const component = components[ii];
for (jj = 0, jlen = attributes.length; jj < jlen; jj++) {
const attr = attributes[jj];
const val = component.get(attr);
if (val !== undefined) {
result.push(val);
}
}
}
if (result.length === 0) {
result = null;
} else if (result.length === 1) {
result = result[0];
}
return (context.last = [VALUE, result]);
} | javascript | {
"resource": ""
} |
q32616 | partial | train | function partial(fn) {
var preset=_slice.call(arguments, 1), self=this
return function(){ return fn.apply(self, arrfill(preset, arguments)) }
} | javascript | {
"resource": ""
} |
q32617 | setupContext | train | function setupContext(node) {
if (node.type === 'Program') {
node.context = GLOBAL_CONTEXT;
return;
}
// default context is the parent context
node.context = node.parent.context;
// IIFE (function(win){ win.x = 'x' }(window))
if ( isIIFE(node) ) {
var args = node.arguments;
var params = node.callee.params;
if (args.length && params.length) {
params.forEach(function(param, i){
var arg = args[i] || {};
var init = arg.type === 'ThisExpression'? node.context : arg.name;
addVarToScope(node, {
name: param.name,
init: init
});
});
}
node.context = node.parent.context;
return;
}
// function.call and function.apply change the context
if (node.type === 'CallExpression' &&
node.callee.type === 'MemberExpression' &&
(node.callee.property.name === 'call' || node.callee.property.name === 'apply')) {
var arg = node.arguments[0];
var ctx = (!arg || arg.type === 'ThisExpression' ||
(arg.type === 'Literal' && arg.value == null))? GLOBAL_CONTEXT : CUSTOM_CONTEXT;
addVarToScope(node, {
name: 'this',
init: ctx,
pointer: ctx
});
node.context = ctx;
return;
}
if ((node.type === 'FunctionExpression' || node.type === 'FunctionDeclaration') && !isIIFE(node.parent)) {
// params are "free variables"
node.params.forEach(function(param){
addVarToScope(node, {
name: param.name,
init: undefined
});
});
// by default we assume that all properties of object use "this" to referece
// itself even tho this might not be true depending on how the method is
// called
if (node.parent.type === 'Property' ||
(node.parent.type === 'AssignmentExpression' &&
node.parent.left.type === 'MemberExpression')) {
node.context = CUSTOM_CONTEXT;
return;
}
}
} | javascript | {
"resource": ""
} |
q32618 | assertHistoryType | train | function assertHistoryType (history) {
assertType("history", "object", history);
assertType("history.listen", "function", history.listen);
assertType("history.push", "function", history.push);
assertType("history.replace", "function", history.replace);
assertType("history.goBack", "function", history.goBack);
} | javascript | {
"resource": ""
} |
q32619 | createDefaultHandler | train | function createDefaultHandler (history) {
return function (context, runMiddleware) {
runMiddleware(context, function (err, redirect) {
if (err) {
console.error(`${context.uri} -> ${err.message}`, err);
} else if (redirect) {
history.replace(redirect);
}
});
}
} | javascript | {
"resource": ""
} |
q32620 | flatten | train | function flatten(level, map) {
for (var key in map) {
var kmap = map[key];
// we found a definition
if (kmap._VAL_ || kmap._TAG_) {
if (kmap._VAL_) {
flatFields[key] = { level: level, _VAL_ : kmap._VAL_};
} else {
flatFields[key] = { level: level, _TAG_ : kmap._TAG_};
}
// presumed a level def
} else {
var here = level.slice(0);
here.push(key);
flatten(here, kmap);
}
}
} | javascript | {
"resource": ""
} |
q32621 | bind | train | function bind( fn, context ) {
if ( Function.prototype.bind ) {
return fn.bind.apply( fn, Array.prototype.slice.call( arguments, 1 ) );
}
return function() {
return fn.apply( context, arguments );
};
} | javascript | {
"resource": ""
} |
q32622 | openSerialPortDevice | train | function openSerialPortDevice(readFd) {
//Save TTY streams
self._readStream = new tty.ReadStream(readFd);
self._readStream.setRawMode(true);
self._writeStream = self._readStream;
//Setup error handlers
self._readStream.on("error", function(err) {
self.emit("error", err);
});
//Setup read event handlers
self._readStream.on("data", function(chunk) {
self.push(chunk);
});
self._readStream.on("end", function() {
self.push(null);
});
self._readStream.on("close", function() {
self.emit("close");
});
//Emit open event
self.emit("open",self._readStream);
} | javascript | {
"resource": ""
} |
q32623 | findIntf | train | function findIntf(intf, osIntfs) {
var keys = Object.keys(osIntfs);
for (var i = 0, len = keys.length; i < len; i++) {
var key = keys[i];
if (intf === key) {
return osIntfs[key];
}
}
return null;
} | javascript | {
"resource": ""
} |
q32624 | train | function(route, name, callback)
{
var regExp = conbo.isRegExp(route) ? route : this.__routeToRegExp(route);
if (!callback)
{
callback = this[name];
}
if (conbo.isFunction(name))
{
callback = name;
name = '';
}
if (!callback)
{
callback = this[name];
}
this.__history.addRoute(regExp, (function(path)
{
var args = this.__extractParameters(regExp, path);
var params = conbo.isString(route)
? conbo.object((route.match(/:\w+/g) || []).map(function(r) { return r.substr(1); }), args)
: {}
;
callback && callback.apply(this, args);
var options =
{
router: this,
route: regExp,
name: name,
parameters: args,
params: params,
path: path
};
this.dispatchEvent(new conbo.ConboEvent('route:'+name, options));
this.dispatchEvent(new conbo.ConboEvent(conbo.ConboEvent.ROUTE, options));
}).bind(this));
return this;
} | javascript | {
"resource": ""
} | |
q32625 | train | function(path, options)
{
options = conbo.setDefaults({}, options, {trigger:true});
this.__history.setPath(path, options);
return this;
} | javascript | {
"resource": ""
} | |
q32626 | train | function()
{
if (!this.routes) return;
var route;
var routes = conbo.keys(this.routes);
while ((route = routes.pop()) != null)
{
this.addRoute(route, this.routes[route]);
}
} | javascript | {
"resource": ""
} | |
q32627 | convertConfig | train | function convertConfig(jsonConfig) {
var bunyanConfig = extend({}, jsonConfig);
if (Array.isArray(bunyanConfig.streams)) {
bunyanConfig.streams = bunyanConfig.streams.map(convertStream);
}
if (bunyanConfig.serializers) {
bunyanConfig.serializers = convertSerializers(bunyanConfig.serializers);
}
return bunyanConfig;
} | javascript | {
"resource": ""
} |
q32628 | def | train | function def(p) {
if (p && p.tagName && p.cls) {
if (customElements.get(p.tagName)) {
console.warn(p.tagName + '!!');
}
else {
customElements.define(p.tagName, p.cls);
}
}
} | javascript | {
"resource": ""
} |
q32629 | formatProperties | train | function formatProperties (properties) {
const result = {}
Object.keys(properties).forEach(key => {
debug('formatProperties: key: ' + key)
if (properties.hasOwnProperty(key)) {
result[ key ] = _.clone(properties[ key ])
result[ key ].type = properties[ key ].type.name
}
})
return result
} | javascript | {
"resource": ""
} |
q32630 | getModelInfo | train | function getModelInfo (modelName) {
debug('getModelInfo: ' + modelName)
// Get the model
const model = Meta.app.models[ modelName ]
// Create the base return object
const result = {
id: model.definition.name,
name: model.definition.name,
properties: formatProperties(model.definition.properties)
}
// Get the following keys from the settings object, if they are set
const keys = {
'acls': [],
'base': '',
'description': '',
'hidden': [],
'idInjection': true,
'methods': {},
'mixins': {},
'persistUndefinedAsNull': false,
'plural': '',
'relations': {},
'strict': false,
'validations': [],
}
// Loop through the keys and add them to the result with their value
Object.keys(keys).forEach(key => {
result[ key ] = _.get(model.definition.settings, key, keys[ key ])
})
return result
} | javascript | {
"resource": ""
} |
q32631 | train | function (req, res) {
self.getItems(function (err, result) {
if (!err) {
res.json( result );
} else {
res.json(500, { error: err });
}
});
} | javascript | {
"resource": ""
} | |
q32632 | train | function (req, res) {
// Add items
if (req.body.items instanceof Array) {
self.removeItems(req.body.items, function (err, result) {
if (!err) {
res.json( result );
} else {
res.json(500, { error: err });
}
});
} else {
res.json(500, { error: "No `items` array in request body" });
}
} | javascript | {
"resource": ""
} | |
q32633 | mzData | train | function mzData(xml) {
xml = ensureText(xml);
if (typeof xml !== 'string') throw new TypeError('xml must be a string');
let parsed = FastXmlParser.parse(xml, {
textNodeName: '_data',
attributeNamePrefix: '',
parseAttributeValue: true,
attrNodeName: '_attr',
ignoreAttributes: false
});
if (!parsed.mzData) throw new Error('The parent node is not mzData');
let result = {
metadata: {},
times: [],
series: {
ms: {
data: []
}
}
};
processMetadata(parsed.mzData, result.metadata);
processSpectrumList(parsed.mzData, result.times, result.series.ms.data);
return result;
} | javascript | {
"resource": ""
} |
q32634 | triggerIfHandlers | train | function triggerIfHandlers(that, handlerListName, event) {
triggerIfHandlerList(that[handlerListName][event], event)
triggerIfHandlerList(that[normalHandlerToAllHandlerProperty(handlerListName)], event)
} | javascript | {
"resource": ""
} |
q32635 | raw | train | function raw (options) {
var opts = options || {}
var inflate = opts.inflate !== false
var limit = typeof opts.limit !== 'number'
? bytes.parse(opts.limit || '100kb')
: opts.limit
var type = opts.type || 'application/octet-stream'
var verify = opts.verify || false
if (verify !== false && typeof verify !== 'function') {
throw new TypeError('option verify must be function')
}
// create the appropriate type checking function
var shouldParse = typeof type !== 'function'
? typeChecker(type)
: type
function parse (buf) {
return buf
}
return function rawParser (req, res, next) {
if (req._body) {
debug('body already parsed')
next()
return
}
req.body = req.body || {}
// skip requests without bodies
if (!typeis.hasBody(req)) {
debug('skip empty body')
next()
return
}
debug('content-type %j', req.headers['content-type'])
// determine if request should be parsed
if (!shouldParse(req)) {
debug('skip parsing')
next()
return
}
// read
read(req, res, next, parse, debug, {
encoding: null,
inflate: inflate,
limit: limit,
verify: verify
})
}
} | javascript | {
"resource": ""
} |
q32636 | filter_attributes | train | function filter_attributes(str) {
var comments = /\/\*.*?\*\//g;
return str.replace(/\s*[a-z-]+\s*=\s*'[^']*'/gi, function (m) {
return m.replace(comments, '');
}).replace(/\s*[a-z-]+\s*=\s*"[^"]*"/gi, function (m) {
return m.replace(comments, '');
}).replace(/\s*[a-z-]+\s*=\s*[^\s]+/gi, function (m) {
return m.replace(comments, '');
});
} | javascript | {
"resource": ""
} |
q32637 | getMaskTemplate | train | function getMaskTemplate(mask) {
if (opts.numericInput) {
mask = mask.split('').reverse().join('');
}
var escaped = false, outCount = 0, greedy = opts.greedy, repeat = opts.repeat;
if (repeat == "*") greedy = false;
//if (greedy == true && opts.placeholder == "") opts.placeholder = " ";
if (mask.length == 1 && greedy == false && repeat != 0) { opts.placeholder = ""; } //hide placeholder with single non-greedy mask
var singleMask = $.map(mask.split(""), function (element, index) {
var outElem = [];
if (element == opts.escapeChar) {
escaped = true;
}
else if ((element != opts.optionalmarker.start && element != opts.optionalmarker.end) || escaped) {
var maskdef = opts.definitions[element];
if (maskdef && !escaped) {
for (var i = 0; i < maskdef.cardinality; i++) {
outElem.push(opts.placeholder.charAt((outCount + i) % opts.placeholder.length));
}
} else {
outElem.push(element);
escaped = false;
}
outCount += outElem.length;
return outElem;
}
});
//allocate repetitions
var repeatedMask = singleMask.slice();
for (var i = 1; i < repeat && greedy; i++) {
repeatedMask = repeatedMask.concat(singleMask.slice());
}
return { "mask": repeatedMask, "repeat": repeat, "greedy": greedy };
} | javascript | {
"resource": ""
} |
q32638 | _isValid | train | function _isValid(position, activeMaskset, c, strict) {
var testPos = determineTestPosition(position), loopend = c ? 1 : 0, chrs = '', buffer = activeMaskset["buffer"];
for (var i = activeMaskset['tests'][testPos].cardinality; i > loopend; i--) {
chrs += getBufferElement(buffer, testPos - (i - 1));
}
if (c) {
chrs += c;
}
//return is false or a json object => { pos: ??, c: ??} or true
return activeMaskset['tests'][testPos].fn != null ?
activeMaskset['tests'][testPos].fn.test(chrs, buffer, position, strict, opts)
: (c == getBufferElement(activeMaskset['_buffer'], position, true) || c == opts.skipOptionalPartCharacter) ?
{ "refresh": true, c: getBufferElement(activeMaskset['_buffer'], position, true), pos: position }
: false;
} | javascript | {
"resource": ""
} |
q32639 | prepareBuffer | train | function prepareBuffer(buffer, position) {
var j;
while (buffer[position] == undefined && buffer.length < getMaskLength()) {
j = 0;
while (getActiveBufferTemplate()[j] !== undefined) { //add a new buffer
buffer.push(getActiveBufferTemplate()[j++]);
}
}
return position;
} | javascript | {
"resource": ""
} |
q32640 | shiftL | train | function shiftL(start, end, c, maskJumps) {
var buffer = getActiveBuffer();
if (maskJumps !== false) //jumping over nonmask position
while (!isMask(start) && start - 1 >= 0) start--;
for (var i = start; i < end && i < getMaskLength() ; i++) {
if (isMask(i)) {
setReTargetPlaceHolder(buffer, i);
var j = seekNext(i);
var p = getBufferElement(buffer, j);
if (p != getPlaceHolder(j)) {
if (j < getMaskLength() && isValid(i, p, true) !== false && getActiveTests()[determineTestPosition(i)].def == getActiveTests()[determineTestPosition(j)].def) {
setBufferElement(buffer, i, p, true);
} else {
if (isMask(i))
break;
}
}
} else {
setReTargetPlaceHolder(buffer, i);
}
}
if (c != undefined)
setBufferElement(buffer, seekPrevious(end), c);
if (getActiveMaskSet()["greedy"] == false) {
var trbuffer = truncateInput(buffer.join('')).split('');
buffer.length = trbuffer.length;
for (var i = 0, bl = buffer.length; i < bl; i++) {
buffer[i] = trbuffer[i];
}
if (buffer.length == 0) getActiveMaskSet()["buffer"] = getActiveBufferTemplate().slice();
}
return start; //return the used start position
} | javascript | {
"resource": ""
} |
q32641 | train | function(){
baseSchema.constructor.apply(this, arguments);
//copy base schema
var This = this;
baseSchema.eachPath(function(key, val) {
if (key != '__t')
This.paths[key] = val;
});
} | javascript | {
"resource": ""
} | |
q32642 | tree | train | function tree(root) {
var structure = {};
var _files = fs.readdirSync(root);
for(var i=0; i<_files.length; i++) {
if ((_files[i] !== '.') && (_files[i] !== '..')) {
var stats = fs.statSync(root + '/' + _files[i]);
if (stats.isDirectory()) {
structure[_files[i]] = tree(root + '/' + _files[i]);
} else if (stats.isFile() && xIsJsFile.test(_files[i])) {
try {
structure[_files[i]] = require(root + '/' + _files[i]);
} catch(err) {
console.log('Could not load task in: ' + _files[i]);
console.error(err);
}
}
}
}
return structure;
} | javascript | {
"resource": ""
} |
q32643 | _createTasks | train | function _createTasks(tree, parent, tasks) {
parent = parent || "";
tasks = tasks || {};
for (var id in tree) {
if (tree[id].deps && tree[id].fn) {
tasks[parentId(parent, id)] = tree[id];
} else {
_createTasks(tree[id], parentId(parent, id) + ':', tasks)
}
}
return tasks;
} | javascript | {
"resource": ""
} |
q32644 | createTask | train | function createTask(taskId) {
return function (done) {
var stream = tasks[taskId].fn(gulp, done);
if (stream) {
if (stream.on) stream.on('end', done);
if (stream.then) stream.then(done);
}
};
} | javascript | {
"resource": ""
} |
q32645 | getComponents | train | function getComponents(templateSrc, filename, options){
var $ = cheerio.load('<div>' + templateSrc + '</div>');
var components = [];
var nodeIndex = 0;
$('*').contents().map(function(index, $el) {
if ($el.type === 'comment') {
var src = $el.data.trim();
// keyword check
if(isComponentComment(src, options.keyword)){
src = src.substring(options.keyword.length);
var meta = YAML.safeLoad(src) || {};
var nodes = getComponentHtml($, $el, $.html($($el).nextAll()), options.keyword, meta);
var html = nodes.filter(function(node) {
return (node.trim() !== '');
}).join('\n');
var output = render(html, meta, options.block);
var component = {
meta: meta,
file: filename,
output: output.trim()
};
// push comment
return components.push(component);
}
}
}.bind(this));
return components;
} | javascript | {
"resource": ""
} |
q32646 | getComponentHtml | train | function getComponentHtml($, $el, $siblings, keyword, meta) {
var capture = meta.capture;
// default to single node
if (typeof capture === 'undefined') {
capture = 1;
}
// capture fixed number of nodes
if (Number.isInteger(capture) || typeof capture === 'undefined') {
return captureNumber($, $siblings, capture);
}
// capture all
if (capture === CAPTURE_ALL) {
return captureAll($, $siblings);
}
// capture section
if (capture === CAPTURE_SECTION) {
return captureSection($, $el, keyword, meta);
}
} | javascript | {
"resource": ""
} |
q32647 | captureNumber | train | function captureNumber($, $siblings, capture) {
var nodes = [];
if (typeof capture === 'undefined') {
capture = 1;
}
$($siblings).each(function(n, $node) {
if (n < capture) {
nodes.push($.html($node))
}
});
return nodes;
} | javascript | {
"resource": ""
} |
q32648 | getExamples | train | function getExamples(meta){
var examples = [];
if(meta.example){
examples = examples.concat(meta.example);
}
if(meta.examples){
examples = examples.concat(meta.examples);
}
return examples;
} | javascript | {
"resource": ""
} |
q32649 | write | train | function write(data) {
if (typeof process.send == 'function') process.send(data)
else console.log(emitter.id, 'ipc not available')
} | javascript | {
"resource": ""
} |
q32650 | createUpdateStream | train | function createUpdateStream(origin, target, options, completeCb) {
// console.log('[EntitySetAsyncView][createUpdateStream]', 'from', origin.cid, 'to', target.cid );
// let source = origin.source(options);
// let sink = target.sink({}, completeCb);
options = { ...options, emitEntities: true };
let args = [origin.source(options)];
if (options.debug) {
args.push(
PullMap(val => {
let [data, dataOptions] = val;
console.log('[EntitySetAsyncView][>]', origin.cid, target.cid, stringify(data));
return val;
})
);
}
if (options.query) {
args.push(QueryFilter(options.query, options));
}
args.push(target.sink({ source: origin }, completeCb));
return Pull.apply(null, args);
} | javascript | {
"resource": ""
} |
q32651 | search | train | function search(options, callback) {
var queryURI = 'http://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi?db=pubmed&term=' + options.terms + '&retmode=json&retmax=' + (options.count || 10);
utils.retrieve(queryURI, callback);
} | javascript | {
"resource": ""
} |
q32652 | train | function(trigger, job){
this.nextTime = (!!trigger.start)?trigger.start:Date.now();
//The rec
this.period = (!!trigger.period)?trigger.period:-1;
//The running count of the job, -1 means no limit
this.count = (!!trigger.count)?trigger.count:-1;
this.job = job;
} | javascript | {
"resource": ""
} | |
q32653 | RestClient | train | function RestClient(apikey, options) {
//Required client config
if (!apikey) {
if (process.env.GAVAGAI_APIKEY) {
this.apikey = process.env.GAVAGAI_APIKEY;
}
else {
throw new Error('RestClient requires an apikey set explicitly or via the GAVAGAI_APIKEY environment variable');
}
}
else {
this.apikey = apikey.trim();
}
//Optional client config
options = options || {};
this.host = options.host || defaultHost;
this.apiVersion = options.apiVersion || defaultApiVersion;
this.timeout = options.timeout || defaultTimeOut;
// Resources
this.stories = require('./stories')(this);
this.tonality = require('./tonality')(this);
this.topics = require('./topics')(this);
this.keywords = require('./keywords')(this);
this.lexicon = require('./lexicon')(this);
} | javascript | {
"resource": ""
} |
q32654 | makeMatrix | train | function makeMatrix(columns, rows) {
let matrix = [];
for (let i = 0; i < columns; i++) {
let column = [];
for (let j = 0; j < rows; j++) {
column.push(0);
}
matrix.push(column);
}
return matrix;
} | javascript | {
"resource": ""
} |
q32655 | ssq | train | function ssq(j, i, sums, sumsOfSquares) {
let sji; // s(j, i)
if (j > 0) {
let muji = (sums[i] - sums[j - 1]) / (i - j + 1); // mu(j, i)
sji = sumsOfSquares[i] - sumsOfSquares[j - 1] - (i - j + 1) * muji * muji;
} else {
sji = sumsOfSquares[i] - sums[i] * sums[i] / (i + 1);
}
if (sji < 0) {
return 0;
}
return sji;
} | javascript | {
"resource": ""
} |
q32656 | fillMatrixColumn | train | function fillMatrixColumn(
iMin,
iMax,
cluster,
matrix,
backtrackMatrix,
sums,
sumsOfSquares
) {
if (iMin > iMax) {
return;
}
// Start at midpoint between iMin and iMax
let i = Math.floor((iMin + iMax) / 2);
matrix[cluster][i] = matrix[cluster - 1][i - 1];
backtrackMatrix[cluster][i] = i;
let jlow = cluster; // the lower end for j
if (iMin > cluster) {
jlow = Math.max(jlow, backtrackMatrix[cluster][iMin - 1] || 0);
}
jlow = Math.max(jlow, backtrackMatrix[cluster - 1][i] || 0);
let jhigh = i - 1; // the upper end for j
if (iMax < matrix.length - 1) {
jhigh = Math.min(jhigh, backtrackMatrix[cluster][iMax + 1] || 0);
}
let sji;
let sjlowi;
let ssqjlow;
let ssqj;
for (let j = jhigh; j >= jlow; --j) {
sji = ssq(j, i, sums, sumsOfSquares);
if (sji + matrix[cluster - 1][jlow - 1] >= matrix[cluster][i]) {
break;
}
// Examine the lower bound of the cluster border
sjlowi = ssq(jlow, i, sums, sumsOfSquares);
ssqjlow = sjlowi + matrix[cluster - 1][jlow - 1];
if (ssqjlow < matrix[cluster][i]) {
// Shrink the lower bound
matrix[cluster][i] = ssqjlow;
backtrackMatrix[cluster][i] = jlow;
}
jlow++;
ssqj = sji + matrix[cluster - 1][j - 1];
if (ssqj < matrix[cluster][i]) {
matrix[cluster][i] = ssqj;
backtrackMatrix[cluster][i] = j;
}
}
fillMatrixColumn(
iMin,
i - 1,
cluster,
matrix,
backtrackMatrix,
sums,
sumsOfSquares
);
fillMatrixColumn(
i + 1,
iMax,
cluster,
matrix,
backtrackMatrix,
sums,
sumsOfSquares
);
} | javascript | {
"resource": ""
} |
q32657 | fillMatrices | train | function fillMatrices(data, matrix, backtrackMatrix) {
let nValues = matrix[0].length;
// Shift values by the median to improve numeric stability
let shift = data[Math.floor(nValues / 2)];
// Cumulative sum and cumulative sum of squares for all values in data array
let sums = [];
let sumsOfSquares = [];
// Initialize first column in matrix & backtrackMatrix
for (let i = 0, shiftedValue; i < nValues; ++i) {
shiftedValue = data[i] - shift;
if (i === 0) {
sums.push(shiftedValue);
sumsOfSquares.push(shiftedValue * shiftedValue);
} else {
sums.push(sums[i - 1] + shiftedValue);
sumsOfSquares.push(sumsOfSquares[i - 1] + shiftedValue * shiftedValue);
}
// Initialize for cluster = 0
matrix[0][i] = ssq(0, i, sums, sumsOfSquares);
backtrackMatrix[0][i] = 0;
}
// Initialize the rest of the columns
let iMin;
for (let cluster = 1; cluster < matrix.length; ++cluster) {
if (cluster < matrix.length - 1) {
iMin = cluster;
} else {
// No need to compute matrix[K-1][0] ... matrix[K-1][N-2]
iMin = nValues - 1;
}
fillMatrixColumn(
iMin,
nValues - 1,
cluster,
matrix,
backtrackMatrix,
sums,
sumsOfSquares
);
}
} | javascript | {
"resource": ""
} |
q32658 | invoke | train | function invoke(object, method, ...args) {
if (object && typeof object[method] === 'function') {
return object[method].call(object, ...args)
}
} | javascript | {
"resource": ""
} |
q32659 | buildComponentAndCheckConformance | train | function buildComponentAndCheckConformance(filepath) {
var componentDir = path.join(process.cwd(), path.dirname(filepath));
var deferred = Q.defer();
resolve(componentDir, options.resolveOpts, function(err, tree) {
if (err) {
return deferred.reject(err);
}
var build = Build(flatten(tree));
build.stylePlugins = function(build) {
build.use('styles', function(file, done) {
file.read(function(err, string) {
if (err) {
return deferred.reject(err);
}
if (options.conform) {
try {
file.string = conform(string);
} catch (e) {
return deferred.reject(e);
}
}
done();
});
});
};
build.styles(function(err, builtCSS) {
if (err) {
return deferred.reject(err);
}
deferred.resolve(builtCSS);
});
});
return deferred.promise;
} | javascript | {
"resource": ""
} |
q32660 | checkConformance | train | function checkConformance(filepath) {
var file = grunt.file.read(filepath);
var deferred = Q.defer();
if (options.conform) {
try {
conform(file);
} catch (e) {
deferred.reject(e);
return deferred.promise;
}
}
deferred.resolve(file);
return deferred.promise;
} | javascript | {
"resource": ""
} |
q32661 | startJob | train | function startJob(params, cb) {
var resourcePath = config.addURIParams(constants.APPDATA_BASE_PATH + "/import", params);
var method = "POST";
params.resourcePath = resourcePath;
params.method = method;
params.data = {
filename: params.filename,
filesize: params.filesize
};
mbaasRequest.admin(params, cb);
} | javascript | {
"resource": ""
} |
q32662 | create | train | function create(req, res, next) {
res.__apiMethod = 'create';
const self = this;
const readonly = this.option('create', 'readonly');
const method = this.option('create', 'method');
let data = (method !== 'get') ? req.body : req.query;
if (readonly) {
try {
data = helpers.validateReadonly(
helpers.flat(data),
readonly
);
} catch(e) {
return next(e)
}
}
const obj = new (this.model)(data);
obj.save(function (err) {
if (err) {
if (err.name && err.name == "ValidationError") {
return next(new ModelAPIError(422, err));
}
return next(err);
}
req.params.id = obj._id;
res.status(201);
return findById.call(self, 'create', req, res, next);
});
} | javascript | {
"resource": ""
} |
q32663 | loadConfig | train | function loadConfig(id, copyProps, defaultPropValues) {
var cwd = path.normalize(__dirname + '/../');
/**
* Get the package file without error-ing on fail,
*
* @param {string} [filename='package.json'] Package source name.
* @returns {Object} The package file.
*/
function getPackageData(filename) {
filename = filename || 'package.json';
try {
return require(cwd + './' + filename);
} catch(err) {
return {};
}
}
/**
* A local version of Object.assign() for old node versions.
*
* @param {Array} [...=[{}]] Objects to assign (in order).
* @returns {Object}
*/
function assign() {
arguments[0] = arguments[0] || {};
for (var n=1; n<arguments.length; n++) {
for (var key in arguments[n]) {
if (arguments[n].hasOwnProperty(key)) arguments[0][key] = arguments[n][key];
}
}
return arguments[0];
}
/**
* Pick the given properties from the given object, returning a new object.
*
* @param {Object} from Object to take from.
* @param {Array} [picks=[]] Properties to pick.
* @param {Object} [defaults={}] Defaults to apply.
* @returns {Object}
*/
function pick(from, picks, defaults) {
picks = picks || [];
defaults = defaults || {};
var obj = {};
for (var n=0; n<picks.length; n++) obj[picks[n]] = from[picks[n]] || defaults[picks[n]];
return obj;
}
var packageData = getPackageData();
var local = getPackageData('local.json');
var exported = assign(
packageData[id],
pick(packageData, copyProps, defaultPropValues),
{nodeVersion: parseFloat(process.versions.node.split('.').slice(0, 2).join('.'))},
local,
{cwd: cwd}
);
return exported;
} | javascript | {
"resource": ""
} |
q32664 | pick | train | function pick(from, picks, defaults) {
picks = picks || [];
defaults = defaults || {};
var obj = {};
for (var n=0; n<picks.length; n++) obj[picks[n]] = from[picks[n]] || defaults[picks[n]];
return obj;
} | javascript | {
"resource": ""
} |
q32665 | train | function() {
if ( !this.modifiers ) {
return;
}
this.modifiers.forEach( function( modifier ) {
if ( classList.contains( this.element, modifier.ui.base ) ) {
if ( modifier.initialize ) {
this.initializers.push( modifier.initialize );
delete modifier.initialize;
}
assign( this, modifier );
}
}, this );
} | javascript | {
"resource": ""
} | |
q32666 | result | train | function result(object, propName) {
var value = object[propName];
return isFunction(value) ? value() : value;
} | javascript | {
"resource": ""
} |
q32667 | getLoggers | train | function getLoggers() {
return _.sortBy(
loggers.map(function (logger) {
return {
name: logger.name,
level: logger.getLevel(),
parent: logger.getParent() ? logger.getParent().name : ''
};
}),
function (logger) {
return logger.name.toUpperCase();
});
} | javascript | {
"resource": ""
} |
q32668 | print | train | function print() {
getLoggers().forEach(function (logger) {
consoleAppender.log(formatText('Logger %b: %b, parent:%b', logger.name, logger.level, logger.parent));
});
} | javascript | {
"resource": ""
} |
q32669 | setLogger | train | function setLogger(name, level, appenderNames) {
try {
var logger = getLogger(name);
logger.setLevel(level);
if (appenderNames) {
logger.clearAppenders();
appenderNames.forEach(function (name) {
logger.addAppender(name);
});
}
return logger;
} catch (err) {
err.message += formatText(' - Logger %b definition error', name);
throw err;
}
} | javascript | {
"resource": ""
} |
q32670 | writeLog | train | function writeLog(logLevel, writeArgs) {
var logName = loggerName || 'ROOT';
var levelAppenders = [];
var logger;
// child level always overwrite parent levels
// if the child does not allow, no appender even parents' ones won't show
if (getLevelNumber(thisLogger.getLevel()) <= getLevelNumber(logLevel)) {
logger = thisLogger;
while (logger) {
levelAppenders = _.concat(levelAppenders, logger.getAppenders()); logger = logger.getParent();
}
}
// write the message to each appender no more than once!
_.uniq(levelAppenders).forEach(function (appender) {
var fmt = appender.pattern.format(logName, logLevel, writeArgs[0], _.slice(writeArgs, 1));
var args = _.concat(logName, logLevel, fmt.message);
// any more arguments ?
if (fmt.otherArgs) {
args = _.concat(args, fmt.otherArgs);
}
appender.writeLog.apply(this, args);
});
} | javascript | {
"resource": ""
} |
q32671 | findLoggerParent | train | function findLoggerParent(logger) {
if (rootLogger === logger) {
return null;
}
var deep = true;
var hierachy = getHierarchy(logger.name);
var parent;
for (var n = hierachy.length - 1; n >= 0 && !parent; n--) {
parent = _.find(loggers, { name: hierachy[n] })
}
return parent || rootLogger;
} | javascript | {
"resource": ""
} |
q32672 | define | train | function define(obj, property, value, setter = false) {
if (setter) {
return Object.defineProperty(obj, property, {
value: value,
writable: true,
configurable: false,
enumerable: true
});
} else {
return Object.defineProperty(obj, property, {
get: function () {
return value;
},
configurable: false,
enumerable: true
});
}
} | javascript | {
"resource": ""
} |
q32673 | isNumberString | train | function isNumberString(value) {
let numberReg = /^((-?\d*\.?\d*(?:e[+-]?\d*(?:\d?\.?|\.?\d?)\d*)?)|(0[0-7]+)|(0x[0-9a-f]+))$/i;
return lodash.isString(value) && !isEmpty(value) && numberReg.test(value);
} | javascript | {
"resource": ""
} |
q32674 | isJSONStr | train | function isJSONStr(value) {
if (!lodash.isString(value)) {
return false;
}
try {
return isJSONObj(JSON.parse(value));
} catch (e) {
return false;
}
} | javascript | {
"resource": ""
} |
q32675 | isTrueEmpty | train | function isTrueEmpty(value) {
if (value === undefined || value === null || value === '') {
return true;
}
if (lodash.isNumber(value)) {
return isNaN(value);
}
return false;
} | javascript | {
"resource": ""
} |
q32676 | ucFirst | train | function ucFirst(value) {
value = lodash.toString(value || '');
return value.slice(0, 1).toUpperCase() + value.slice(1).toLowerCase();
} | javascript | {
"resource": ""
} |
q32677 | md5 | train | function md5(value) {
let ins = crypto.createHash('md5');
ins.update(value);
return ins.digest('hex');
} | javascript | {
"resource": ""
} |
q32678 | md5Salt | train | function md5Salt(value, salt = 'abcdefghijklmnopqrstuvwxyz1234567890') {
let ins = crypto.createHash('md5');
value = value + salt.slice(value.length % salt.length, salt.length);
ins.update(value);
return ins.digest('hex');
} | javascript | {
"resource": ""
} |
q32679 | inArray | train | function inArray(value, arr) {
let len = arr.length;
for (let i = 0; i < len; i++) {
if (arr[i] == value) {
return true;
}
}
return false;
} | javascript | {
"resource": ""
} |
q32680 | arrRemove | train | function arrRemove(arr, index) {
return lodash.remove(arr, function (n, i) {
return i !== index;
});
} | javascript | {
"resource": ""
} |
q32681 | isFile | train | function isFile(p) {
if (!fs.existsSync(p)) {
return false;
}
try {
let stats = fs.statSync(p);
return stats.isFile();
} catch (e) {
return false;
}
} | javascript | {
"resource": ""
} |
q32682 | isDir | train | function isDir(p) {
if (!fs.existsSync(p)) {
return false;
}
try {
let stats = fs.statSync(p);
return stats.isDirectory();
} catch (e) {
return false;
}
} | javascript | {
"resource": ""
} |
q32683 | isWritable | train | function isWritable(p) {
if (!fs.existsSync(p)) {
return false;
}
let stats = fs.statSync(p);
let mode = stats.mode;
let uid = process.getuid ? process.getuid() : 0;
let gid = process.getgid ? process.getgid() : 0;
let owner = uid === stats.uid;
let group = gid === stats.gid;
return !!(owner && (mode & parseInt('00200', 8)) ||
group && (mode & parseInt('00020', 8)) ||
(mode & parseInt('00002', 8)));
} | javascript | {
"resource": ""
} |
q32684 | chmod | train | function chmod(p, mode) {
mode = mode || 0777;
if (!fs.existsSync(p)) {
return true;
}
return fs.chmodSync(p, mode);
} | javascript | {
"resource": ""
} |
q32685 | readFile | train | function readFile(filename, enc) {
return new Promise(function (fulfill, reject) {
fs.readFile(filename, enc || 'utf8', function (err, res) {
return err ? reject(err) : fulfill(res);
});
});
} | javascript | {
"resource": ""
} |
q32686 | writeFile | train | function writeFile(filename, data) {
return new Promise(function (fulfill, reject) {
fs.writeFile(filename, data, function (err, res) {
return err ? reject(err) : fulfill(res);
});
});
} | javascript | {
"resource": ""
} |
q32687 | reFile | train | function reFile(filename, nfilename) {
return new Promise(function (fulfill, reject) {
fs.rename(filename, nfilename, function (err) {
return err ? reject(err) : fulfill();
});
});
} | javascript | {
"resource": ""
} |
q32688 | mkDir | train | function mkDir(p, mode = 0777) {
if (fs.existsSync(p)) {
chmod(p, mode);
return true;
} else {
if (mkDir(path.dirname(p))) {
fs.mkdirSync(p, mode);
return true;
}
}
} | javascript | {
"resource": ""
} |
q32689 | readDir | train | function readDir(p, filter, files, prefix) {
prefix = prefix || '';
files = files || [];
filter = filter || function (x) {
return x[0] !== '.';
};
let dir = path.join(p, prefix);
if (!fs.existsSync(dir)) {
return files;
}
if (fs.statSync(dir).isDirectory()) {
fs.readdirSync(dir).filter(filter).forEach(function (name) {
readDir(p, filter, files, path.join(prefix, name));
});
} else {
files.push(prefix);
}
return files;
} | javascript | {
"resource": ""
} |
q32690 | rmDir | train | function rmDir(p, reserve) {
if (!isDir(p)) {
return Promise.resolve(null);
}
let deferred = getDefer();
fs.readdir(p, function (err, files) {
if (err) {
return deferred.reject(err);
}
let spromise = Promise.resolve(null);
if (files.length > 0) {
let promises = files.map(function (item) {
let filePath = path.normalize(`${p}${path.sep}${item}`);
if (isDir(filePath)) {
return rmDir(filePath, false);
} else {
let defer = getDefer();
fs.unlink(filePath, function (er) {
return er ? defer.reject(er) : defer.resolve();
});
return defer.promise;
}
});
spromise = Promise.all(promises);
}
return spromise.then(function () {
if (!reserve) {
let deferr = getDefer();
fs.rmdir(p, function (e) {
return e ? deferr.reject(e) : deferr.resolve();
});
return deferr.promise;
}
return Promise.resolve();
}).then(function () {
deferred.resolve();
}).catch(function (e) {
deferred.reject(e);
});
});
return deferred.promise;
} | javascript | {
"resource": ""
} |
q32691 | generatorToPromise | train | function generatorToPromise(fn) {
if (typeof fn !== 'function') {
throw Error('fn is not a function');
}
if (!isGenerator(fn)) {
// assume it's Promise-based
return fn;
}
return co.wrap(fn);
} | javascript | {
"resource": ""
} |
q32692 | clone | train | function clone(source, deep) {
if (deep) {
return lodash.cloneDeep(source);
} else {
return lodash.clone(source);
}
} | javascript | {
"resource": ""
} |
q32693 | extend | train | function extend(source, target, deep) {
if (deep) {
return lodash.merge(lodash.cloneDeep(source), target);
} else {
return lodash.assignIn(source, target);
}
} | javascript | {
"resource": ""
} |
q32694 | pushComponent | train | function pushComponent(pushable, component, cdefMap, isAnonymous = false, options) {
// if( cdefMap ){
let json = component.toJSON({ cdefMap });
if (isAnonymous) {
delete json[ENTITY_ID];
delete json[COMPONENT_ID];
}
return pushable.push([json, options]);
// }
// pushable.push( component );
} | javascript | {
"resource": ""
} |
q32695 | define | train | function define() {
var defaults = this.defaults
, data = this.data
, load = data.load || defaults.load
, href = this.href
, def = [];
//
// Check what social media to load, if none provided load defaults in `load`.
//
Object.keys(load).forEach(function checkLoad(key) {
if (!load[key] || !(key in href)) return;
def.push(href[key]);
});
this.queue.enlist('loader', { plain: def });
return this;
} | javascript | {
"resource": ""
} |
q32696 | _extractEmptyResponse | train | function _extractEmptyResponse(xml, dfrd) {
var parser = new xml2js.Parser();
parser.parseString(xml, function(err, res) {
if (err) {
dfrd.reject();
return MODULE_ERRORS.xmlParseError;
}
if (res.response.error) {
dfrd.reject(res.response.error);
}
});
} | javascript | {
"resource": ""
} |
q32697 | logoff | train | function logoff() {
var token = cache.get('token');
var dfrd = Q.defer();
if (!token) {
dfrd.reject(MODULE_ERRORS.undefinedToken);
} else {
request(format(URLs.logoff, PROTOCOL, conf.host, token),
function(err) {
if (err) {
dfrd.reject(err);
} else {
dfrd.resolve(true);
}
});
}
return dfrd.promise;
} | javascript | {
"resource": ""
} |
q32698 | logon | train | function logon() {
var dfrd = Q.defer();
var token = cache.get('token');
function extractToken(xml) {
var r = _parse(xml, dfrd);
if (r) {
return r.response.token[0];
}
}
if (token) {
dfrd.resolve({
token: token,
cached: true
});
}
request(format(URLs.logon, PROTOCOL, conf.host, conf.username,
conf.password),
function(err, res, body) {
var newToken;
if (err) {
dfrd.reject(err);
} else {
newToken = extractToken(body);
if (!newToken) {
dfrd.reject(MODULE_ERRORS.unknown);
} else {
cache.put('token', newToken);
dfrd.resolve({
token: newToken,
cached: false
});
}
}
});
return dfrd.promise;
} | javascript | {
"resource": ""
} |
q32699 | setCurrentFilter | train | function setCurrentFilter(filter) {
var token = cache.get('token');
var dfrd = Q.defer();
var id;
if (!token) {
dfrd.reject(MODULE_ERRORS.undefinedToken);
} else {
id = typeof filter === 'string' ? filter : filter.id;
request(format(URLs.setCurrentFilter, PROTOCOL, conf.host, id,
token), function(err, res, body) {
if (err) {
dfrd.reject(err);
} else {
_extractEmptyResponse(body, dfrd);
dfrd.resolve(true);
}
});
}
return dfrd.promise;
} | javascript | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.