_id stringlengths 2 6 | title stringlengths 0 58 | partition stringclasses 3
values | text stringlengths 52 373k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q39000 | train | function () {
var order = [],
el,
children = this.el.children,
i = 0,
n = children.length,
options = this.options;
for (; i < n; i++) {
el = children[i];
if (_closest(el, options.draggable, this.el)) {
order.push(el.getAttribute(options.dataIdAttr) || _generateId(el));
}
}... | javascript | {
"resource": ""
} | |
q39001 | train | function (order) {
var items = {}, rootEl = this.el;
this.toArray().forEach(function (id, i) {
var el = rootEl.children[i];
if (_closest(el, this.options.draggable, rootEl)) {
items[id] = el;
}
}, this);
order.forEach(function (id) {
if (items[id]) {
rootEl.removeChild(items[id]... | javascript | {
"resource": ""
} | |
q39002 | _index | train | function _index(/**HTMLElement*/el) {
var index = 0;
while (el && (el = el.previousElementSibling)) {
if (el.nodeName.toUpperCase() !== 'TEMPLATE') {
index++;
}
}
return index;
} | javascript | {
"resource": ""
} |
q39003 | setaddall | train | function setaddall(set, iterable) {
var changed = false;
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = iterable[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompl... | javascript | {
"resource": ""
} |
q39004 | getName | train | function getName(name) {
const ext = path.extname(name);
const nameCrypt = crypto.createHash('sha1')
.update(name)
.digest('hex') + ext;
return getDir() + nameCrypt;
} | javascript | {
"resource": ""
} |
q39005 | train | function(password, salt) {
var hash = npm_crypto.createHmac('sha512', salt); /** Hashing algorithm sha512 */
hash.update(password);
var value = hash.digest('hex');
return {
salt: salt,
passwordHash: value
};
} | javascript | {
"resource": ""
} | |
q39006 | writeFileUtf8 | train | function writeFileUtf8 (filePath, content, callback) {
// Argument callback defaults to throwError.
if (typeof callback !== 'function') callback = throwError
if (typeof content === 'string') {
fs.writeFile(filePath, content, 'utf8', callback)
} else {
throw TypeError(error.contentIsNotString)
}
} | javascript | {
"resource": ""
} |
q39007 | train | function (stream) {
var self = this;
stream.on('data', function (chunk) {
self.push(chunk);
});
stream.on('end', function () {
self.push(null);
});
this.readableUnit = stream;
return this;
} | javascript | {
"resource": ""
} | |
q39008 | buildPushManifest | train | function buildPushManifest (bundles, manifestFilename) {
const manifestableBundles = filter(bundles, bundle => bundle.module);
const bundlesByModuleId = chain(manifestableBundles)
.map(bundle => [ bundle.module.id, bundle ])
.fromPairs()
.value();
const bundleDepGraph = chain... | javascript | {
"resource": ""
} |
q39009 | checkCamelCase | train | function checkCamelCase(idNode) {
var reported = false;
var fakeContext = {
report: function() { reported = true; },
options: []
};
camelcase(fakeContext).Identifier(idNode); // eslint-disable-line new-cap
return !reported;
} | javascript | {
"resource": ""
} |
q39010 | checkSemanticActionName | train | function checkSemanticActionName(node) {
var name = node.name;
var underscoreIdx = name.indexOf('_');
// The underscore should not appear on the ends,
// case names should begin with a lowercase letter,
// and there should be only one underscore in the name.
if ((underscoreIdx > 0 && underscoreIdx < (name.... | javascript | {
"resource": ""
} |
q39011 | setAttribute | train | function setAttribute(element, name, value) {
assertType(element, Node, false, 'Invalid element specified');
if (value === undefined || value === null || value === false)
element.removeAttribute(name);
else if (value === true)
element.setAttribute(name, '');
else
element.setAttribute(name, value);
... | javascript | {
"resource": ""
} |
q39012 | DisplayObject | train | function DisplayObject()
{
EventEmitter.call(this);
/**
* The coordinate of the object relative to the local coordinates of the parent.
*
* @member {Point}
*/
this.position = new math.Point();
/**
* The scale factor of the object.
*
* @member {Point}
*/
this... | javascript | {
"resource": ""
} |
q39013 | loadReporter | train | function loadReporter(reporterPath) {
var reporter;
reporterPath = reporterPath || 'checkstyle';
if (!fs.existsSync(path.resolve(reporterPath))) {
try {
reporter = require('./lib/reporters/' + reporterPath);
} catch (e) {
try {
reporter = require('jscs... | javascript | {
"resource": ""
} |
q39014 | generateRandomString | train | function generateRandomString(length) {
let s = "";
let i = length;
while (length-- > 0) {
let c = Math.floor(Math.random() * (MAX_HEX_SYMBOL - MIN_HEX_SYMBOL + 1)) + MIN_HEX_SYMBOL;
c = c.toString(16).toLowerCase();
s += c;
}
return s;
} | javascript | {
"resource": ""
} |
q39015 | send | train | function send() {
'use strict';
var req = new XMLHttpRequest(),
specs = jsApiReporter.specs(),
payload;
if (specs.length) {
specs.push(logs);
}
payload = JSON.stringify(specs);
req.open('post', 'http://localhost:' + port + '/put', true);
req.onload = function () {
if (this.responseText =... | javascript | {
"resource": ""
} |
q39016 | train | function(name) {
// "name" encapsulates some simple options like precision
rgen.random = rgen.algorithms[name].random;
rgen.setSeed = rgen.algorithms[name].setSeed;
return rgen.setRandomSeed();
} | javascript | {
"resource": ""
} | |
q39017 | validate | train | function validate(cmd, args, info) {
AbstractCommand.prototype.validate.apply(this, arguments);
var value = parseInt('' + args[2]);
if(value !== 0 && value !== 1) throw InvalidBit;
args[2] = value;
} | javascript | {
"resource": ""
} |
q39018 | tokenizeText | train | function tokenizeText(text, callback) {
"use strict";
processTokens(tokenizer.tokenize(text) || [], function (error, tokens) {
process.nextTick(function () {
callback(error, tokens);
});
});
} | javascript | {
"resource": ""
} |
q39019 | load | train | function load(mod) {
var base = path.dirname(mod.filename);
var folders = [].slice.call(arguments, 1);
return function refractory() {
var files = [].slice.call(arguments);
var paths = [];
files
.map(function(file) {
return path.basename(file);
})
.forEach(function(file) {
fol... | javascript | {
"resource": ""
} |
q39020 | SpriteMaskFilter | train | function SpriteMaskFilter(sprite)
{
var maskMatrix = new math.Matrix();
AbstractFilter.call(this,
fs.readFileSync(__dirname + '/spriteMaskFilter.vert', 'utf8'),
fs.readFileSync(__dirname + '/spriteMaskFilter.frag', 'utf8'),
{
mask: { type: 'sampler2D', value: sprit... | javascript | {
"resource": ""
} |
q39021 | hasPrettier | train | function hasPrettier() {
if (hasPrettierCache === true || hasPrettierCache === false) {
return hasPrettierCache
}
hasPrettierCache = false
try {
const requireOptions = { paths: [getRootPath()] }
const manifestPath = require.resolve('./package.json', requireOptions)
const manifest = JSON.parse(fs... | javascript | {
"resource": ""
} |
q39022 | wrapNodeSocket | train | function wrapNodeSocket(ws, reportError) {
// Data traveling from websocket to consumer
var incoming = makeChannel();
// Data traveling from consumer to websocket
var outgoing = makeChannel();
onTake = wrapHandler(onTake, onError);
outgoing.take(onTake);
ws.onerror = onError;
ws.onmessage = wrap(onMes... | javascript | {
"resource": ""
} |
q39023 | search | train | function search(user, pass, userArray) {
return _.findWhere(userArray, { user: user, pass: pass });
} | javascript | {
"resource": ""
} |
q39024 | ask | train | function ask(question, cbk, skip) {
if (skip) {
cbk(skip);
return;
}
self.prompt(question, function(answ) {
if (String(answ.answer).trim() === "") {
return ask(question, cbk);
} else {
cbk(answ.answer);
}
});
} | javascript | {
"resource": ""
} |
q39025 | gather | train | function gather(cbk) {
ask(questions[0], function(user) {
state.user = user;
ask(questions[1], function(pass){
state.pass = pass;
cbk(state.user, state.pass);
}, state.pass);
}, state.user);
} | javascript | {
"resource": ""
} |
q39026 | attempt | train | function attempt() {
connections[id].attempts++;
if (connections[id].attempts > retry) {
connections[id].attempts = 0;
connections[id].deny++;
self.log(chalk.yellow("Access denied: too many attempts."));
callback("Access denied: too many attempts.", false);
ret... | javascript | {
"resource": ""
} |
q39027 | sendAlertEmail | train | function sendAlertEmail(alertEmailData, cb) {
var mongoAlert = alertEmailData.alert;
var eventDetails = alertEmailData.eventDetails;
var emailConfig = config.getConfig().email;
var from = emailConfig ? emailConfig.alert_email_from : 'noreply@feedhenry.com';
fs.readFile(ALERT_EMAIL_TEMPLATE, function(err, dat... | javascript | {
"resource": ""
} |
q39028 | createRule | train | function createRule(path, handler) {
if ('*' !== path && 0 != path.indexOf(watch.__base)) {
path = watch.__base + (path == '/' ? '' : path)
}
let rule = pathToRegExp(path)
if (handler instanceof String) {
let target = handler
handler = function() {
watch({
url: target
})
}
... | javascript | {
"resource": ""
} |
q39029 | initialize | train | function initialize(done) {
debug('prepare');
parser(options.index, options, function(err, modules) {
if(err) return done(err)
debug('Parser return, now build the tree...');
tree = buildTree(options, modules, true);
debug('Tree builded');
// Extract from tree as a flatten list of packet... | javascript | {
"resource": ""
} |
q39030 | tokenizeWord | train | function tokenizeWord(word, callback) {
"use strict";
var match, parts = [], stemmedPart, singularPart, singularMetaphones, stemmedMetaphones, token;
// TODO: Improve that. Should be in the stemmer actually
//if (-1 === (match = word.match(/^([#"',;:!?(.\[{])*([a-z0-9]+)+([,;:!?)\]}"'.])*$/i))) {
/... | javascript | {
"resource": ""
} |
q39031 | train | function (ordered) {
var self = this;
if (ordered) {
return self.fetch();
} else {
var results = new LocalCollection._IdMap;
self.forEach(function (doc) {
results.set(doc._id, doc);
});
return results;
}
} | javascript | {
"resource": ""
} | |
q39032 | train | function(arg) {
readOnly(this, ID, COUNT++);
readOnly(this, "_listeners", new Listeners());
readOnly(this, "_links", []);
// An object with the attribute `isContentChangeAware === true`
// can fire a property value changed when its contant has change.
readOnly(this, "isContentChangeAware", tr... | javascript | {
"resource": ""
} | |
q39033 | Stats | train | function Stats(state) {
this.state = state;
this.clear();
this.onConnect = onConnect.bind(this);
this.onDisconnect = onDisconnect.bind(this);
this.onRejected = onRejected.bind(this);
this.onHit = onHit.bind(this);
this.onMiss = onMiss.bind(this);
this.onExpired = onExpired.bind(this);
this.onExpired =... | javascript | {
"resource": ""
} |
q39034 | train | function(error) {
if (!error.stack) return error.message;
var stack = error.stack;
var firstLine = stack.substring(0, stack.indexOf('\n'));
if (error.message && firstLine.indexOf(error.message) === -1) stack = error.message + '\n' + stack;
return stack.replace(/\n.+\/adapter(\/lib)?\/hydro.js\?\d*\:... | javascript | {
"resource": ""
} | |
q39035 | defaults | train | function defaults(defs,opts) {
if (!opts)
opts = {}
if (opts.context == null)
opts.context = true;
if (opts.coerce == null)
opts.coerce = true;
completeMonad(defs);
if (opts.control === "token")
defs = M.addControlByToken(defs);
if (opts.wrap)
defs = M.wrap(defs,opts.wrap);
if (opts.co... | javascript | {
"resource": ""
} |
q39036 | liftContext | train | function liftContext(ctx, func) {
if (!ctx.pure) {
throw new Error("no monad's definition is provided");
}
return function() {
var saved;
saved = context;
context = ctx;
try {
return func.apply(null, arguments);
} finally {
context = saved;
}
};
} | javascript | {
"resource": ""
} |
q39037 | liftContextG | train | function liftContextG(ctx, gen) {
return liftContext(ctx, function() {
return liftContextIterator(ctx, gen.apply(null, arguments));
});
} | javascript | {
"resource": ""
} |
q39038 | Config | train | function Config(options) {
if (!(this instanceof Config)) {
return new Config(options);
}
utils.is(this, 'config');
use(this);
define(this, 'count', 0);
this.options = options || {};
this.targets = {};
this.tasks = {};
if (utils.isConfig(options)) {
this.options = {};
this.expand(option... | javascript | {
"resource": ""
} |
q39039 | handler | train | function handler(req, next) {
var conf = this.configure();
var pkg = this.package();
var copyright = conf.copyright || (pkg ? pkg.copyright : null);
var opts = [this._version];
var msg = this._name + ' %s';
// NOTE: allows deferring to this handler from a custom handler
if(arguments.length > 1 && typeof(... | javascript | {
"resource": ""
} |
q39040 | _start | train | function _start() {
var now = Date.now();
var config = this._config;
var missing = !config ? required : required.filter(function(key) {
return config[key] === undefined;
});
if (missing.length) {
throw TypeError('Missing config properties: ' + missing.join(', '));
}
if (this._... | javascript | {
"resource": ""
} |
q39041 | _stop | train | function _stop() {
if (!this._started) {
throw Error('Ticker not started');
}
clearTimeout(this._timeout);
delete this._started;
delete this._before;
delete this._count;
if (this._config.stop) {
this._config.stop();
}
return this;
} | javascript | {
"resource": ""
} |
q39042 | _use | train | function _use(config) {
var _config = this._config;
Object.keys(config).forEach(function(key) {
_config[key] = config[key];
});
return this;
} | javascript | {
"resource": ""
} |
q39043 | _tick | train | function _tick() {
var config = this._config;
var now = Date.now();
var dt = now - this._before;
if (!this._started) {
// The ticker has been stopped
return;
}
if (config.async) {
config.task(this._tock, dt);
} else {
config.task(dt);
this._tock();
}
} | javascript | {
"resource": ""
} |
q39044 | _tock | train | function _tock() {
var config = this._config;
var now = Date.now();
var taskTime = now - this._started; // The time it took to finish the last task
var delay = Math.max(0, config.delay - (taskTime)); // Delay until the next task is run
if (config.limit) {
this._count += 1;
if (this._co... | javascript | {
"resource": ""
} |
q39045 | indexOfDeepestElement | train | function indexOfDeepestElement (elements) {
var dropzone,
deepestZone = elements[0],
index = deepestZone? 0: -1,
parent,
deepestZoneParents = [],
dropzoneParents = [],
child,
i,
n;
for (i = 1; i < elements.l... | javascript | {
"resource": ""
} |
q39046 | train | function (pointer, event, eventTarget, curEventTarget, matches, matchElements) {
var target = this.target;
if (!this.prepared.name && this.mouse) {
var action;
// update pointer coords for defaultActionChecker to use
this.setEventXY(this.curCoor... | javascript | {
"resource": ""
} | |
q39047 | train | function (dragElement) {
// get dropzones and their elements that could receive the draggable
var possibleDrops = this.collectDrops(dragElement, true);
this.activeDrops.dropzones = possibleDrops.dropzones;
this.activeDrops.elements = possibleDrops.elements;
... | javascript | {
"resource": ""
} | |
q39048 | validateAction | train | function validateAction (action, interactable) {
if (!isObject(action)) { return null; }
var actionName = action.name,
options = interactable.options;
if (( (actionName === 'resize' && options.resize.enabled )
|| (actionName === 'drag' && options.drag.enabl... | javascript | {
"resource": ""
} |
q39049 | delegateListener | train | function delegateListener (event, useCapture) {
var fakeEvent = {},
delegated = delegatedEvents[event.type],
eventTarget = getActualElement(event.path
? event.path[0]
: event.target),
elemen... | javascript | {
"resource": ""
} |
q39050 | modulePathToId | train | function modulePathToId(path) {
// We can only transform if there's no plugin used.
if (path.indexOf('!') === -1) {
// If it ends with ".js", chop it off.
var extension = '.js'
if (path.slice(-extension.length) === '.js') {
path = path.slice(0, path.length - extension.length)... | javascript | {
"resource": ""
} |
q39051 | moduleSize | train | function moduleSize(id, paths) {
var path = id;
var extension = '.js';
// Use `paths:` to resolve an alias.
if (paths[id]) {
path = paths[id];
}
// Does the dependency reference a plugin?
if (path.indexOf('!') !== -1) {
// Split into plugin and path.
var pathParts = p... | javascript | {
"resource": ""
} |
q39052 | createHandler | train | function createHandler(options) {
/**
* Client request handler
* Data from the incoming request (plus options) is forwarded to the AWS module
*/
return async (ctx) => {
const { credentials, endpoint, region } = options
const { rawBody: body, header: headers, method, url: path } = ctx.request
c... | javascript | {
"resource": ""
} |
q39053 | getInitOptions | train | async function getInitOptions(args) {
const { debug, endpoint, host, port, profile, region } = args
const options = { debug, host, port, profile, region }
options.endpoint = getAWSEndpoint({ endpoint })
options.credentials = await getAWSCredentials()
return options
} | javascript | {
"resource": ""
} |
q39054 | registerListeners | train | function registerListeners() {
const exit = function exit(signal) {
console.log(chalk.bgBlack.yellow(`Received ${signal} => Exiting`))
process.exit()
}
const SIGABRT = 'SIGABRT'
const SIGHUP = 'SIGHUP'
const SIGINT = 'SIGINT'
const SIGQUIT = 'SIGQUIT'
const SIGTERM = 'SIGTERM'
process.on(SIGABR... | javascript | {
"resource": ""
} |
q39055 | stripProxyResHeaders | train | function stripProxyResHeaders(res) {
return Object.entries(res.headers).reduce((memo, header) => {
const [key, val] = header
const invalid = [undefined, 'connection', 'content-encoding']
if (invalid.indexOf(key) === -1) {
memo[key] = val // eslint-disable-line
}
return memo
}, {})
} | javascript | {
"resource": ""
} |
q39056 | transfer | train | function transfer(xmlFiles, output, dir, needAppend, _callback){
/**
* If needAppend is true, output must be a file but not a directory
*/
Step(
function(){
if(typeof output === 'undefined'){
output = path.dirname(xmlFiles[0]);
}
output = output.indexOf(path.sep) === 0 ? output :... | javascript | {
"resource": ""
} |
q39057 | transferSingleFile | train | function transferSingleFile(sfXML, dir, callback){
var xmlParser;
var groups;
var responders = [];
var fileList = [];
var entry;
var responder;
var stat;
if(typeof sfXML === 'undefined'){
throw new Error('No input file specified');
}
if(!/\.xml$/.test(sfXML)){
throw new Error('Input file ... | javascript | {
"resource": ""
} |
q39058 | _getRuleAsString | train | function _getRuleAsString(responders, callback){
var respondersArr = [];
var respondersLen = responders.length;
var srcLen;
var fileStr;
responders.forEach(function(entry, i){
respondersArr.push(TAP + '{');
respondersArr.push(TAP + TAP + 'pattern: \'' + entry.pattern + '\',' + entry.comment);
r... | javascript | {
"resource": ""
} |
q39059 | _append | train | function _append(target, rules, isTargetEmpty){
var concatedRules = [];
var rulesContent;
var l = rules.length;
rules.forEach(function(rule, i){
if(i < l - 1){
concatedRules.push(rule + ',');
}else{
concatedRules.push(rule + '/*{{more}}*/');
}
});
if(isTargetEmpty){
rulesContent... | javascript | {
"resource": ""
} |
q39060 | end | train | function end() {
var group = stack.pop();
if (!requests) return;
var data = JSON.stringify(requests);
var dest = path.join(options.fixtures, group + '.json');
fs.writeFileSync(dest, data, 'utf8');
requests = null;
} | javascript | {
"resource": ""
} |
q39061 | recorder | train | function recorder(opts, fn) {
var group = stack[stack.length - 1];
var response = null;
assert(group, 'please specify copycat group');
recordings = load(group) || [];
recordings.forEach(function(recording) {
if (!deepEqual(recording.opts, opts)) return;
response = recording;
});
if (response) {... | javascript | {
"resource": ""
} |
q39062 | load | train | function load(group) {
var dest = path.join(options.fixtures, group + '.json');
var ret = null;
var json = null;
try {
json = fs.readFileSync(dest, 'utf8');
ret = JSON.parse(json);
} catch (err) {}
return ret;
} | javascript | {
"resource": ""
} |
q39063 | createRunQueue | train | function createRunQueue(modules) {
return modules
.map((mod) => mod._runQueue)
.reduce((acc, res) => acc.concat(res), []);
} | javascript | {
"resource": ""
} |
q39064 | create | train | async function create(options) {
const {
org,
name,
description,
homepage,
license_template,
gitignore_template,
auto_init = false,
} = options
const p = org ? `orgs/${org}` : 'user'
const endpoint = `/${p}/repos`
const { body } = await this._request({
data: {
name,
... | javascript | {
"resource": ""
} |
q39065 | TimeoutError | train | function TimeoutError(message) {
// Like http://www.ecma-international.org/ecma-262/6.0/#sec-error-message
if (!(this instanceof TimeoutError)) { return new TimeoutError(message); }
Error.captureStackTrace(this, TimeoutError);
if (message !== undefined) {
Object.defineProperty(this, 'message', {
value... | javascript | {
"resource": ""
} |
q39066 | parseCoverageResults | train | function parseCoverageResults(src) {
var collector = new istanbul.Collector();
var utils = istanbul.utils;
var results = [];
grunt.file.expand({filter: 'isFile'}, src).forEach(function (file) {
var browser = path.dirname(file).substring(path.dirname(file)... | javascript | {
"resource": ""
} |
q39067 | parseJshintResults | train | function parseJshintResults(fileName, showDetails) {
var result = {};
if (grunt.file.exists(fileName)) {
var content = grunt.file.read(fileName);
xml2js.parseString(content, {}, function (err, res) {
var consoleStatements = content.match(/(cons... | javascript | {
"resource": ""
} |
q39068 | parse | train | function parse(obj, options) {
var result = {},
key,
value,
momentValue;
for (key in obj) {
if (obj.hasOwnProperty(key)) {
value = obj[key];
if (typeof value === 'string' || typeof value === 'number') {
momentValue = moment.call(null, value, options.formats, options.stric... | javascript | {
"resource": ""
} |
q39069 | main | train | function main(content, callback) {
parser(content, function(error, result) {
if (error) {
callback(error);
} else {
callback(null, result);
}
});
} | javascript | {
"resource": ""
} |
q39070 | toBatchStateItem | train | function toBatchStateItem(batch, context) {
const states = batch.states;
// const messages = batch.allMessages();
const messages = batch.messages;
const rejectedMessages = batch.rejectedMessages;
const unusableRecords = batch.unusableRecords;
// Resolve the messages' states to be saved (if any)
const mes... | javascript | {
"resource": ""
} |
q39071 | toStorableMessageState | train | function toStorableMessageState(messageState, message, context) {
if (!messageState) {
context.warn(`Skipping save of state for message, since it has no state - message (${JSON.stringify(message)})`);
return undefined;
}
// Convert the message's state into a safely storable object to get a clean, simplif... | javascript | {
"resource": ""
} |
q39072 | toStorableUnusableRecordState | train | function toStorableUnusableRecordState(unusableRecordState, unusableRecord, context) {
if (!unusableRecordState) {
context.warn(`Skipping save of state for unusable record, since it has no state - record (${JSON.stringify(unusableRecord)})`);
return undefined;
}
// Convert the record's state into a safel... | javascript | {
"resource": ""
} |
q39073 | updateBatchWithPriorState | train | function updateBatchWithPriorState(batch, item, context) {
restoreMessageAndRejectedMessageStates(batch, item, context);
restoreUnusableRecordStates(batch, item, context);
} | javascript | {
"resource": ""
} |
q39074 | hasMessageIdentifier | train | function hasMessageIdentifier(msgState) {
const md5s = msgState.md5s;
return isNotBlank(msgState.eventID) || // isNotBlank(msgState.eventSeqNo) || isNotBlank(msgState.eventSubSeqNo) ||
(msgState.idVals && msgState.idVals.some(isNotBlank)) ||
((msgState.keyVals && msgState.keyVals.some(isNotBlank)) &&
... | javascript | {
"resource": ""
} |
q39075 | hasUnusableRecordIdentifier | train | function hasUnusableRecordIdentifier(recState) {
const md5s = recState.md5s;
return isNotBlank(recState.eventID) || // isNotBlank(recState.eventSeqNo) || isNotBlank(recState.eventSubSeqNo) ||
(md5s && (isNotBlank(md5s.userRec) || isNotBlank(md5s.rec) || isNotBlank(md5s.data)));
} | javascript | {
"resource": ""
} |
q39076 | validate | train | function validate (data, schema) {
if (!data || !schema) {
throw new Error('Trying to validate without passing data and schema')
}
return Joi.validate(data, schema)
} | javascript | {
"resource": ""
} |
q39077 | verifyChain | train | function verifyChain(certificate, chain, trustedCAs) {
if (certificate === null) return Promise.resolve(false);
return Promise.resolve().then(function () {
var certificateChainEngine = new pkijs.CertificateChainValidationEngine({
certs: chain,
trustedCerts: trustedCAs.filter(function (cert) {
... | javascript | {
"resource": ""
} |
q39078 | getProperties | train | function getProperties (header) {
return header.split(',').map((split) => {
const components = split.replace(/\s+/, '').split(';');
const priorityRegex = /^q=([0-1](\.[0-9]{1,3})?)$/;
/* assign null to priority when invaild quarity values */
return {
lang: components[0],... | javascript | {
"resource": ""
} |
q39079 | matchAccept | train | function matchAccept (properties, langs) {
let match = null;
let priority = 0;
base: for(const lang of langs) {
for (const property of properties) {
if (property.priority === 0) {
break;
}
if (priority < property.priority){
if (la... | javascript | {
"resource": ""
} |
q39080 | train | function() {
var stat = fs.existsSync('/var/run/docker.sock');
if (!stat) {
stat = process.env.DOCKER_HOST || false;
}
return stat;
} | javascript | {
"resource": ""
} | |
q39081 | contents | train | function contents(map, tight) {
var minDepth = Infinity;
var index = -1;
var length = map.length;
var table;
/*
* Find minimum depth.
*/
while (++index < length) {
if (map[index].depth < minDepth) {
minDepth = map[index].depth;
}
}
/*
* Norma... | javascript | {
"resource": ""
} |
q39082 | train | function() {
var cmdArguments = process.argv.slice(2)
var lookup = {
values: [],
keyValues: {}
};
cmdArguments.forEach(function(cmdArgument) {
var keyValue = cmdArgument.split('=');
//Flag of key value type
if(typeof keyValue[0] === 'string' && keyValue[0].ch... | javascript | {
"resource": ""
} | |
q39083 | _directoryToStream | train | function _directoryToStream (directory, separator, callback) {
if ("undefined" === typeof directory) {
throw new ReferenceError("missing \"directory\" argument");
}
else if ("string" !== typeof directory) {
throw new TypeError("\"directory\" argument is not a string");
}
else if ("" === dire... | javascript | {
"resource": ""
} |
q39084 | requireLogin | train | function requireLogin (options) {
// merge with default options
options = mergeOptions({
'login': '/login',
'home': '/',
'user': 'user',
'referer': 'referer',
'excepts': []
}, options)
// add login to except page
options.excepts.push(options.login)
return function(req, res, next) {
var url = req.orig... | javascript | {
"resource": ""
} |
q39085 | Dispatcher | train | function Dispatcher(req, res, next) {
_classCallCheck(this, Dispatcher);
this.req = req;
this.res = res;
this.next = next;
} | javascript | {
"resource": ""
} |
q39086 | getUrlParameters | train | function getUrlParameters() {
var params = [ "allume" ];
location.search.substr(1).split("&").forEach(function (part) {
if (!part) return;
var item = part.split("=");
params.push(decodeURIComponent(item[0]));
});
return params;
} | javascript | {
"resource": ""
} |
q39087 | getNodeParameters | train | function getNodeParameters() {
return typeof process !== "undefined" && process.argv && process.argv.length > 1 ? process.argv.slice(1) : null;
} | javascript | {
"resource": ""
} |
q39088 | channels | train | function channels(req, res) {
res.send(null, this.state.pubsub.getChannels(req.args[0]));
} | javascript | {
"resource": ""
} |
q39089 | numsub | train | function numsub(req, res) {
res.send(null, this.state.pubsub.getChannelList(req.args));
} | javascript | {
"resource": ""
} |
q39090 | validate | train | function validate(cmd, args, info) {
AbstractCommand.prototype.validate.apply(this, arguments);
var sub = info.command.sub
, cmd = sub.cmd
, args = sub.args
if(('' + cmd) === Constants.SUBCOMMAND.pubsub.channels.name) {
if(args.length > 1) {
throw UnknownSubcommand;
}
}
} | javascript | {
"resource": ""
} |
q39091 | GrayFilter | train | function GrayFilter()
{
core.AbstractFilter.call(this,
// vertex shader
null,
// fragment shader
fs.readFileSync(__dirname + '/gray.frag', 'utf8'),
// set the uniforms
{
gray: { type: '1f', value: 1 }
}
);
} | javascript | {
"resource": ""
} |
q39092 | Texture | train | function Texture(baseTexture, frame, crop, trim, rotate)
{
EventEmitter.call(this);
/**
* Does this Texture have any frame data assigned to it?
*
* @member {boolean}
*/
this.noFrame = false;
if (!frame)
{
this.noFrame = true;
frame = new math.Rectangle(0, 0, 1, ... | javascript | {
"resource": ""
} |
q39093 | plugin | train | function plugin(params) {
logger = params.logger;
params.dirname = params.dirname ? _.template(params.dirname)(params) : params.event.dir.resourcesPlatform;
logger.trace("running babel in directory: " + params.dirname);
_.defaults(params, {
options: {},
includes: ["**/*.js", "!backbone.js"]
});
if (params... | javascript | {
"resource": ""
} |
q39094 | transformFile | train | function transformFile(filepath, options) {
logger.trace("transforming file - " + filepath);
var content = fs.readFileSync(filepath, 'utf8');
var result = transformCode(content, options);
fs.writeFileSync(filepath, result);
} | javascript | {
"resource": ""
} |
q39095 | transformCode | train | function transformCode(code, options) {
var result = babel.transform(code, options);
var modified = result.code;
return modified;
} | javascript | {
"resource": ""
} |
q39096 | kwire | train | function kwire(appRoot, globalShadow) {
appRoot = appRoot == null ? {} : appRoot;
globalShadow = globalShadow || window;
if (typeof appRoot !== 'object') {
throw 'root object must be an object.'
}
if (isServerSide() ||
isUsingRequireJS() ||
rootIsAlreadyConfigured(globalShadow)) {
return;
}
... | javascript | {
"resource": ""
} |
q39097 | getInstance | train | function getInstance(options) {
var bucket = options.bucket;
var upyunInstance = instances[bucket];
// If can not found instance, then new one.
if (!upyunInstance) {
instances[bucket] = upyunInstance = new UPYUN(options.bucket, options.operator, options.password, options.endpoing, options.apiVersion);
}
... | javascript | {
"resource": ""
} |
q39098 | uploadToUpyun | train | function uploadToUpyun(path, file, __newFile, done) {
var options = this.options;
var upyun = getInstance(options);
upyun.uploadFile(path, file, __newFile.headers['content-type'], true, function (err, data) {
if (err) {
return done(err);
}
if (!data) {
return done(new Error('Upload failed!... | javascript | {
"resource": ""
} |
q39099 | buildUpyunReceiverStream | train | function buildUpyunReceiverStream(opts) {
var options = opts || {};
_.defaults(options, {
endpoing: 'v0',
apiVersion: 'legacy',
// Upload limit (in bytes)
// defaults to ~15MB
maxBytes: 15000000,
// Upload limit for per coming file (in bytes)
// falsy means no limit
perMaxBytes: ... | javascript | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.