_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q55300
|
slotsAPIObject
|
train
|
function slotsAPIObject(vueObj) {
slotsObj = vueObj["slots"] || {}
let slots = []
for (const slot in slotsObj) {
if (slotsObj.hasOwnProperty(slot)) {
const ele = {
"name": `${slot}`,
"description": `${slotsObj[slot]["description"] || 'MISSING DESCRIPTION'}`
}
slots.push(ele)
}
}
return slots.length > 0 ? {slots} : null
}
|
javascript
|
{
"resource": ""
}
|
q55301
|
validateProp
|
train
|
function validateProp(propValue, validArr, responsive = true) {
const strArr = propValue.split(' ');
return strArr.every((mod) => {
const modValid = validArr.some((validStr) => {
if (responsive) {
return (
mod === validStr
|| mod === `${validStr}@xs`
|| mod === `${validStr}@sm`
|| mod === `${validStr}@md`
|| mod === `${validStr}@lg`
);
}
return (mod === validStr);
});
if (!modValid) {
console.error(`Invalid prop value: ${mod}`); // eslint-disable-line no-console
}
return modValid;
});
}
|
javascript
|
{
"resource": ""
}
|
q55302
|
build
|
train
|
function build(info, sharedOpts={}, compOpts={}, pluginOpts={}) {
const dir = process.cwd();
const [org, name] = info.name.split('/');
const outputPath = `${dir}/${config.outDir}`;
console.log(chalk.cyan(`Building ${name}...\n`));
return new Promise((resolve, reject)=>{
rm(
outputPath,
(err) => {
if (err) {
// throw err
reject(err);
}
webpack(createWebpackConfig(dir, name, sharedOpts, compOpts, pluginOpts), (err2, stats) => {
if (err2) {
// throw err2;
reject(err2);
}
stats.stats.forEach(stat => {
process.stdout.write(`${stat.toString({
colors: true,
modules: false,
children: false,
chunks: false,
chunkModules: false,
})}\n\n`);
})
console.log(chalk.cyan(`Build of ${name} complete.\n`));
resolve();
});
}
);
});
}
|
javascript
|
{
"resource": ""
}
|
q55303
|
getQueryObj
|
train
|
function getQueryObj(query='') {
const qObj = {};
const pairs = (query[0] === '?' ? query.substr(1) : query).split('&');
for (let i = 0, j = pairs.length; i < j; i++) {
let pair = pairs[i].split('=');
qObj[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1] || '');
}
return qObj;
}
|
javascript
|
{
"resource": ""
}
|
q55304
|
createScenario
|
train
|
function createScenario(def) {
const finalScenario = Object.assign({}, scenarioDefaults, def);
scenariosArr.push(finalScenario);
}
|
javascript
|
{
"resource": ""
}
|
q55305
|
globSearch
|
train
|
function globSearch(searchRegex) {
const search = path.join(__dirname, '..', `${searchRegex}`)
return glob(`${search}`, {ignore: ['**/node_modules/**']})
.then(files => {
return new Promise((resolve, reject) => {
resolve(archiveComps(files))
})
})
.catch(globErr)
}
|
javascript
|
{
"resource": ""
}
|
q55306
|
archiveComps
|
train
|
function archiveComps(compFiles) {
return compFiles.reduce((compObjCollection, file) => {
const compObj = require(`${file}`)
if (compObj !== null) {
compObjCollection.push(compObj)
console.log(`Added object for ${compObj.name} to Cedar Data Object`)
}
return compObjCollection
}, [])
}
|
javascript
|
{
"resource": ""
}
|
q55307
|
isPre
|
train
|
function isPre(p1, p2) {
// remove the ^
const stripped = semver.coerce(p2).raw;
const diff = semver.diff(p1, stripped);
return ['premajor', 'preminor', 'prepatch', 'prerelease'].indexOf(diff) >= 0 ? true : false;
}
|
javascript
|
{
"resource": ""
}
|
q55308
|
quantizedNumber
|
train
|
function quantizedNumber(i) {
var adjust = [1, 2.5, 5];
return Math.floor(Math.pow(10, Math.floor(i/3)) * adjust[i % 3]);
}
|
javascript
|
{
"resource": ""
}
|
q55309
|
appendTransform
|
train
|
function appendTransform(defaults, transform) {
defaults = angular.isArray(defaults) ? defaults : [defaults];
return (transform) ? defaults.concat(transform) : defaults;
}
|
javascript
|
{
"resource": ""
}
|
q55310
|
train
|
function(relationshipModelName, kind) {
var key = decamelize(relationshipModelName);
if (kind === "belongsTo") {
return key + "_id";
} else if (kind === "hasMany") {
return singularize(key) + "_ids";
} else {
return key;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q55311
|
train
|
function(snapshot, json, relationship) {
var key = relationship.key;
var belongsTo = snapshot.belongsTo(key);
var jsonKey = underscore(key + "_type");
if (Ember.isNone(belongsTo)) {
json[jsonKey] = null;
} else {
json[jsonKey] = classify(belongsTo.modelName).replace('/', '::');
}
}
|
javascript
|
{
"resource": ""
}
|
|
q55312
|
train
|
function(data) {
if (data.links) {
var links = data.links;
for (var link in links) {
var camelizedLink = camelize(link);
if (camelizedLink !== link) {
links[camelizedLink] = links[link];
delete links[link];
}
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q55313
|
platformPostfix
|
train
|
function platformPostfix() {
if (/^win/.test(process.platform)) {
return process.arch == 'x64' ? 'win64' : 'win32';
} else if (/^darwin/.test(process.platform)) {
return 'osx64';
}
// This might not be ideal, but we don't have anything else and there is always a chance that it will work
return process.arch == 'x64' ? 'linux64' : 'linux32';
}
|
javascript
|
{
"resource": ""
}
|
q55314
|
unpack
|
train
|
function unpack(filename, callback, entryCallback) {
var input = fs.createReadStream(filename, { flags: 'r', encoding: null }),
files = {},
dir = path.dirname(filename),
returned = false,
to = null;
// Finishs the unpack if all files are done
function maybeFinish() {
if (to !== null) clearTimeout(to);
to = setTimeout(function() {
var alldone = true;
var names = Object.keys(files);
for (var i=0; i<names.length; i++) {
if (!files[names[i]]["done"]) {
alldone = false;
break;
}
}
if (alldone && !returned) {
returned = true;
callback(null);
}
}, 1000);
}
input.pipe(zlib.createGunzip()).pipe(tar.Parse()).on("entry", function(entry) {
if (entryCallback) entryCallback(entry);
if (entry["type"] == 'File') {
files[entry["path"]] = fs.createWriteStream(path.join(dir, entry["path"]), { flags: 'w', encoding: null });
entry.pipe(files[entry["path"]]);
entry.on("end", function() {
files[entry["path"]].end();
files[entry["path"]]["done"] = true;
maybeFinish();
});
} else if (entry["type"] == "Directory") {
try {
fs.mkdirSync(path.join(dir, entry["path"]));
} catch (e) {
if (!fs.existsSync(path.join(dir, entry["path"]))) {
if (!returned) {
returned = true;
callback(e);
}
}
}
}
}).on("error", function(e) {
if (!returned) {
returned = true;
callback(e);
}
});
}
|
javascript
|
{
"resource": ""
}
|
q55315
|
maybeFinish
|
train
|
function maybeFinish() {
if (to !== null) clearTimeout(to);
to = setTimeout(function() {
var alldone = true;
var names = Object.keys(files);
for (var i=0; i<names.length; i++) {
if (!files[names[i]]["done"]) {
alldone = false;
break;
}
}
if (alldone && !returned) {
returned = true;
callback(null);
}
}, 1000);
}
|
javascript
|
{
"resource": ""
}
|
q55316
|
configure
|
train
|
function configure() {
var java = path.normalize(path.join(__dirname, "..", "jre", "bin", "java"+ClosureCompiler.JAVA_EXT));
console.log(" Configuring bundled JRE for platform '"+platformPostfix()+"' ...");
if (!/^win/.test(process.platform)) {
var jre = path.normalize(path.join(__dirname, "..", "jre"));
console.log(" | 0755 "+jre);
fs.chmodSync(jre, 0755);
console.log(" | 0755 "+path.join(jre, "bin"));
fs.chmodSync(path.join(jre, "bin"), 0755);
console.log(" | 0755 "+java);
fs.chmodSync(java, 0755);
console.log(" Complete.\n");
} else {
console.log(" Complete (not necessary).\n");
}
}
|
javascript
|
{
"resource": ""
}
|
q55317
|
exec
|
train
|
function exec(cmd, args, stdin, callback) {
var stdout = concat();
var stderr = concat();
var process = child_process.spawn(cmd, args, {
stdio: [stdin || 'ignore', 'pipe', 'pipe']
});
process.stdout.pipe(stdout);
process.stderr.pipe(stderr);
process.on('exit', function(code, signal) {
var err;
if (code) {
err = new Error(code);
err.code = code;
err.signal = signal;
}
callback(err, stdout, stderr);
});
process.on('error', function (err) {
callback(err, stdout, stderr);
});
}
|
javascript
|
{
"resource": ""
}
|
q55318
|
fromBoot
|
train
|
function fromBoot (options) {
var version
var bootPath = Path.resolve(
options.directory,
'bundle',
'programs',
'server',
'boot.js')
try {
version = Fs.readFileSync(bootPath, 'utf8')
.split('\n')
.find((line) => line.indexOf('MIN_NODE_VERSION') >= 0)
.split(' ')[3] // eslint-disable no-magic-numbers
.replace(/[v;']/g, '')
} catch (err) {
return false
}
return version
}
|
javascript
|
{
"resource": ""
}
|
q55319
|
Location
|
train
|
function Location(base, somePath) {
if (base == null) {
throw new Error('base == null');
}
this.base = base;
this.path = somePath;
}
|
javascript
|
{
"resource": ""
}
|
q55320
|
AbstractVersioner
|
train
|
function AbstractVersioner(options, taskData) {
this.options = options;
this.taskData = taskData;
/**
* Map of versioned files
* @type {Array.<{version, originalPath: string, versionedPath: string}>}
*/
this.versionsMap = [];
/**
* Get one of the tagger functions: hash or date
* @type {function}
*/
this.versionTagger = taggers[this.options.tag];
// is task a post versioning task?
this.isPostVersioningTask = grunt.config(this.getAssetsVersioningTaskConfigKey() + '.isPostVersioningTaskFor');
}
|
javascript
|
{
"resource": ""
}
|
q55321
|
_minFile
|
train
|
function _minFile(rawFile, compressedFile) {
if (compressedFile.size < rawFile.size) {
return qfs.move(compressedFile.name, rawFile.name)
.then(function () {
return new File(rawFile.name, compressedFile.size);
});
}
return compressedFile.remove()
.then(function () {
return rawFile;
});
}
|
javascript
|
{
"resource": ""
}
|
q55322
|
_isSmallerAfterCompression
|
train
|
function _isSmallerAfterCompression(rawFile, compressedFile, opts) {
return compressedFile.remove()
.then(function () {
var tolerance = opts.tolerance < 1
? opts.tolerance * rawFile.size
: opts.tolerance;
return rawFile.size > compressedFile.size + tolerance;
});
}
|
javascript
|
{
"resource": ""
}
|
q55323
|
_getSavedBytes
|
train
|
function _getSavedBytes(rawFile, compressedFile) {
var savedBytes = rawFile.size - compressedFile.size;
if (savedBytes > 0) return savedBytes;
return 0;
}
|
javascript
|
{
"resource": ""
}
|
q55324
|
_initCompressedFile
|
train
|
function _initCompressedFile(filename, tmpDir) {
return new File(path.join(tmpDir, path.basename(filename) + md5(filename) + path.extname(filename)));
}
|
javascript
|
{
"resource": ""
}
|
q55325
|
_imageOptim
|
train
|
function _imageOptim(rawFile, algorithms, reduceFunc, initVal) {
return Q.all([rawFile.loadSize(), rawFile.loadType()])
.then(function () {
return algorithms[rawFile.type].reduce(reduceFunc, initVal);
})
.fail(function (err) {
throw err;
});
}
|
javascript
|
{
"resource": ""
}
|
q55326
|
train
|
function (rawFile, algorithms, opts) {
return _imageOptim(rawFile, algorithms, function (prev, next) {
return prev.then(function (res) {
return next(rawFile, _initCompressedFile(rawFile.name, opts._tmpDir))
.then(function (compressed) {
return _minFile(res, compressed);
});
});
}, new Q(rawFile))
.then(function (minFile) {
return {
name: rawFile.name,
savedBytes: _getSavedBytes(rawFile, minFile),
exitCode: exit.SUCCESS
};
})
.fail(function (err) {
return _handleError(err, rawFile);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q55327
|
train
|
function (rawFile, algorithms, opts) {
return _imageOptim(rawFile, algorithms, function (prev, next) {
return prev.then(function (res) {
return res || next(rawFile, _initCompressedFile(rawFile.name, opts._tmpDir))
.then(function (compressed) {
return _isSmallerAfterCompression(rawFile, compressed, opts);
});
});
}, new Q(false))
.then(function (isSmaller) {
return {
name: rawFile.name,
isOptimized: !isSmaller,
exitCode: 0
};
})
.fail(function (err) {
return _handleError(err, rawFile);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q55328
|
sha512half
|
train
|
function sha512half(buffer) {
var sha512 = createHash('sha512');
return sha512.update(buffer).digest('hex').toUpperCase().slice(0, 64);
}
|
javascript
|
{
"resource": ""
}
|
q55329
|
_compress
|
train
|
function _compress(command, outputFile) {
return qexec(command)
.then(function () {
return outputFile.loadSize();
})
.fail(function (err) {
// Before using of 'advpng' a raw file has to be copied
// This algorithm can not compress a file and write a result to another file
return qfs.exists(outputFile.name)
.then(function (exists) {
if (exists) {
outputFile.remove();
}
throw err;
});
});
}
|
javascript
|
{
"resource": ""
}
|
q55330
|
_splice
|
train
|
function _splice(files, length) {
var spliced = [];
while (files.length) {
spliced.push(files.splice(0, length));
}
return spliced;
}
|
javascript
|
{
"resource": ""
}
|
q55331
|
_reduceImageOptimFunc
|
train
|
function _reduceImageOptimFunc(prev, next) {
return prev.then(function (res) {
return Q.all(next.map(function (filename) {
return modes[mode](new File(filename), algorithms, opts);
}))
.then(function (stepRes) {
return res.concat(stepRes);
});
});
}
|
javascript
|
{
"resource": ""
}
|
q55332
|
SHAMapTreeNodeLeaf
|
train
|
function SHAMapTreeNodeLeaf(tag, data, type) {
SHAMapTreeNode.call(this);
if (typeof tag !== 'string') {
throw new Error('Tag is unexpected type.');
}
this.tag = tag;
this.type = type;
this.data = data;
}
|
javascript
|
{
"resource": ""
}
|
q55333
|
SHAMap
|
train
|
function SHAMap(version) {
this.version = version === undefined ? 1 : version;
this.root = this.version === 1 ? new SHAMapTreeNodeInner(0) :
new SHAMapTreeNodeInnerV2(0);
}
|
javascript
|
{
"resource": ""
}
|
q55334
|
train
|
function (taskName, taskFiles) {
grunt.log.writeln("Versioning files from " + taskName + " task.");
this.taskName = taskName;
this.taskConfig = this.getTaskConfig();
if (!this.taskConfig) {
grunt.fail.warn("Task '" + this.taskName + "' doesn't exist or doesn't have any configuration.", 1);
}
this.taskFiles = taskFiles || this.getFiles();
if (!this.taskFiles || this.taskFiles.length === 0) {
grunt.fail.warn("Task '" + this.taskName + "' doesn't have any src-dest file mappings.", 1);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q55335
|
disallowNodeType
|
train
|
function disallowNodeType(type) {
return function() {
function check(node, reporter) {
if (is(node, type)) {
reporter.report(node.id, 'Element has disallowed type <' + type + '>');
}
}
return {
check
};
};
}
|
javascript
|
{
"resource": ""
}
|
q55336
|
parseDiagram
|
train
|
function parseDiagram(diagramXML) {
return new Promise((resolve, reject) => {
moddle.fromXML(diagramXML, (error, moddleElement, context) => {
if (error) {
return resolve({
error
});
}
const warnings = context.warnings || [];
return resolve({
moddleElement,
warnings
});
});
});
}
|
javascript
|
{
"resource": ""
}
|
q55337
|
tableEntry
|
train
|
function tableEntry(report) {
const category = report.category;
const color = category === 'error' ? red : yellow;
return [ report.id || '', color(categoryMap[category] || category), report.message, report.name || '' ];
}
|
javascript
|
{
"resource": ""
}
|
q55338
|
printReports
|
train
|
function printReports(filePath, results) {
let errorCount = 0;
let warningCount = 0;
const table = createTable();
Object.entries(results).forEach(function([ name, reports ]) {
reports.forEach(function(report) {
const {
category,
id,
message,
name: reportName
} = report;
table.push(tableEntry({
category,
id,
message,
name: reportName || name
}));
if (category === 'error') {
errorCount++;
} else {
warningCount++;
}
});
});
const problemCount = warningCount + errorCount;
if (problemCount) {
console.log();
console.log(underline(path.resolve(filePath)));
console.log(table.toString());
}
return {
errorCount,
warningCount
};
}
|
javascript
|
{
"resource": ""
}
|
q55339
|
awaitPromise
|
train
|
function awaitPromise(promise) {
var Promise = promise.constructor;
var Fiber = Promise.Fiber;
assert.strictEqual(
typeof Fiber, "function",
"Cannot await unless Promise.Fiber is defined"
);
var fiber = Fiber.current;
assert.ok(
fiber instanceof Fiber,
"Cannot await without a Fiber"
);
var run = fiber.run;
var throwInto = fiber.throwInto;
if (process.domain) {
run = process.domain.bind(run);
throwInto = process.domain.bind(throwInto);
}
// The overridden es6PromiseThen function is adequate here because these
// two callbacks do not need to run in a Fiber.
es6PromiseThen.call(promise, function (result) {
tryCatchNextTick(fiber, run, [result]);
}, function (error) {
tryCatchNextTick(fiber, throwInto, [error]);
});
return stackSafeYield(Fiber, awaitPromise);
}
|
javascript
|
{
"resource": ""
}
|
q55340
|
initialize
|
train
|
function initialize() {
if (aurelia_pal_1.isInitialized) {
return;
}
let pal = nodejs_pal_builder_1.buildPal();
aurelia_pal_1.initializePAL((platform, feature, dom) => {
Object.assign(platform, pal.platform);
Object.setPrototypeOf(platform, pal.platform.constructor.prototype);
Object.assign(dom, pal.dom);
Object.setPrototypeOf(dom, pal.dom.constructor.prototype);
Object.assign(feature, pal.feature);
Object.setPrototypeOf(feature, pal.feature.constructor.prototype);
(function (global) {
global.console = global.console || {};
let con = global.console;
let prop;
let method;
let empty = {};
let dummy = function () { };
let properties = 'memory'.split(',');
let methods = ('assert,clear,count,debug,dir,dirxml,error,exception,group,' +
'groupCollapsed,groupEnd,info,log,markTimeline,profile,profiles,profileEnd,' +
'show,table,time,timeEnd,timeline,timelineEnd,timeStamp,trace,warn').split(',');
while (prop = properties.pop())
if (!con[prop])
con[prop] = empty;
while (method = methods.pop())
if (!con[method])
con[method] = dummy;
})(platform.global);
if (platform.global.console && typeof console.log === 'object') {
if (typeof console['debug'] === 'undefined') {
console['debug'] = this.bind(console['log'], console);
}
['log', 'info', 'warn', 'error', 'assert', 'dir', 'clear', 'profile', 'profileEnd'].forEach(function (method) {
console[method] = this.bind(console[method], console);
}, Function.prototype.call);
}
Object.defineProperty(dom, 'title', {
get: function () {
return pal.global.document.title;
},
set: function (value) {
pal.global.document.title = value;
}
});
Object.defineProperty(dom, 'activeElement', {
get: function () {
return pal.global.document.activeElement;
}
});
Object.defineProperty(platform, 'XMLHttpRequest', {
get: function () {
return pal.global.XMLHttpRequest;
}
});
});
}
|
javascript
|
{
"resource": ""
}
|
q55341
|
train
|
function (jws, pubKey, alg) {
/*
convert various public key format to RSAKey object
see @KEYUTIL.getKey for a full list of supported input format
*/
var rsaKey = KEYUTIL.getKey(pubKey);
return KJUR.jws.JWS.verify(jws, rsaKey, [alg]);
}
|
javascript
|
{
"resource": ""
}
|
|
q55342
|
train
|
function (id_token) {
var jws = new KJUR.jws.JWS();
jws.parseJWS(id_token);
return [jws.parsedJWS.headS, jws.parsedJWS.payloadS, jws.parsedJWS.si];
}
|
javascript
|
{
"resource": ""
}
|
|
q55343
|
train
|
function (jsonS) {
var jws = KJUR.jws.JWS;
if(jws.isSafeJSONString(jsonS)) {
return jws.readSafeJSONString(jsonS);
}
return null;
}
|
javascript
|
{
"resource": ""
}
|
|
q55344
|
train
|
function(params){
service.token = service.token || {}; // init the token
angular.extend(service.token, params); // set the access token params
setTokenInSession(); // save the token into the session
setExpiresAtEvent(); // event to fire when the token expires
return service.token;
}
|
javascript
|
{
"resource": ""
}
|
|
q55345
|
train
|
function(hash){
var params = {},
regex = /([^&=]+)=([^&]*)/g,
m;
while ((m = regex.exec(hash)) !== null) {
params[decodeURIComponent(m[1])] = decodeURIComponent(m[2]);
}
// OpenID Connect
if (params.id_token && !params.error) {
IdToken.validateTokensAndPopulateClaims(params);
return params;
}
// Oauth2
if(params.access_token || params.error){
return params;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q55346
|
train
|
function(){
// Don't bother if there's no expires token
if (typeof(service.token.expires_at) === 'undefined' || service.token.expires_at === null) {
return;
}
cancelExpiresAtEvent();
var time = (new Date(service.token.expires_at))-(new Date());
if(time && time > 0 && time <= 2147483647){
expiresAtEvent = $interval(function(){
$rootScope.$broadcast('oauth:expired', service.token);
}, time, 1);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q55347
|
train
|
function(){
var curHash = $location.hash();
angular.forEach(hashFragmentKeys,function(hashKey){
var re = new RegExp('&'+hashKey+'(=[^&]*)?|^'+hashKey+'(=[^&]*)?&?');
curHash = curHash.replace(re,'');
});
$location.hash(curHash);
}
|
javascript
|
{
"resource": ""
}
|
|
q55348
|
JWTError
|
train
|
function JWTError (message) {
Error.call(this)
Error.captureStackTrace(this, this.constructor)
this.name = this.constructor.name
this.message = message
}
|
javascript
|
{
"resource": ""
}
|
q55349
|
appendData
|
train
|
function appendData(data, builder) {
if(Array.isArray(data) || Buffer.isBuffer(data)) {
data = Buffer.from(data);
} else {
data = Buffer.from(data, 'ascii');
}
builder.appendBuffer(data);
}
|
javascript
|
{
"resource": ""
}
|
q55350
|
train
|
function(header,body){
//footer = [],
let Table = require('../src/factory.js');
options.terminalAdapter = true;
let t1 = Table(header, body,options);
//hide cursor
console.log('\u001b[?25l');
//wipe existing if already rendered
if(alreadyRendered){
//move cursor up number to the top of the previous print
//before deleting
console.log('\u001b['+(previousHeight+3)+'A');
//delete to end of terminal
console.log('\u001b[0J');
}
else{
alreadyRendered = true;
}
console.log(t1.render());
//reset the previous height to the height of this output
//for when we next clear the print
previousHeight = t1.height;
}
|
javascript
|
{
"resource": ""
}
|
|
q55351
|
train
|
function () {
var chunks = [];
return through2.obj(function (file, enc, cb) {
chunks.push(file);
var string = file._contents.toString();
var regex = /\/\*\*debug:start\*\*\/[\s\S]*\/\*\*debug:end\*\*\//g;
var stripped = string.replace(regex, "");
file.contents = new Buffer(stripped);
this.push(file);
cb();
});
}
|
javascript
|
{
"resource": ""
}
|
|
q55352
|
train
|
function (key, value) {
var hash = hashFunction(key);
var bucket = null;
if ((bucket = this.__map[hash]) == null) {
bucket = (this.__map[hash] = new Bucket());
}
bucket.pushValue(key, value);
return value;
}
|
javascript
|
{
"resource": ""
}
|
|
q55353
|
train
|
function (cb, scope) {
var es = this.__entrySet(), ret = new this._static();
es = es.filter.apply(es, arguments);
for (var i = es.length - 1; i >= 0; i--) {
var e = es[i];
ret.put(e.key, e.value);
}
return ret;
}
|
javascript
|
{
"resource": ""
}
|
|
q55354
|
train
|
function (cb, scope) {
var es = this.__entrySet(), l = es.length, f = cb.bind(scope || this);
es.forEach.apply(es, arguments);
}
|
javascript
|
{
"resource": ""
}
|
|
q55355
|
train
|
function (cb) {
if (cb) {
if (isPromise(cb)) {
cb = cb.callback;
}
if (this.__fired && this.__results) {
this.__callNextTick(cb, this.__results);
} else {
this.__cbs.push(cb);
}
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q55356
|
train
|
function (cb) {
if (cb) {
if (isPromise(cb)) {
cb = cb.errback;
}
if (this.__fired && this.__error) {
this.__callNextTick(cb, this.__error);
} else {
this.__errorCbs.push(cb);
}
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q55357
|
train
|
function (args) {
args = argsToArray(arguments);
if (this.__fired) {
throw new Error("Already fired!");
}
this.__results = args;
this.__resolve();
return this.promise();
}
|
javascript
|
{
"resource": ""
}
|
|
q55358
|
train
|
function (callback, errback) {
if (isPromise(callback)) {
errback = callback.errback;
callback = callback.callback;
}
this.addCallback(callback);
this.addErrback(errback);
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q55359
|
train
|
function (callback, errback) {
var promise = new Promise(),
self = this;
function _errback(e) {
if (isFunction(errback)) {
try {
var res = spreadArgs(errback, [e]);
isPromiseLike(res) ? res.then(promise.callback, promise.errback) : promise.callback(res);
} catch (e) {
promise.errback(e);
}
} else {
promise.errback(e);
}
}
function _callback() {
try {
var res = isFunction(callback) ? spreadArgs(callback, arguments) : callback;
if (isPromiseLike(res)) {
res.then(promise.callback, _errback);
} else {
promise.callback(res);
promise = null;
}
callback = res = null;
} catch (e) {
_errback(e);
}
}
self.addCallback(_callback);
self.addErrback(_errback);
return promise.promise();
}
|
javascript
|
{
"resource": ""
}
|
|
q55360
|
train
|
function (callback) {
var promise = new Promise();
this.addCallback(function () {
try {
when(isFunction(callback) ? callback.apply(this, arguments) : callback).then(promise);
} catch (e) {
promise.errback(e);
}
});
this.addErrback(function () {
try {
when(isFunction(callback) ? callback.apply(this, arguments) : callback).then(promise);
} catch (e) {
promise.errback(e);
}
});
return promise.promise();
}
|
javascript
|
{
"resource": ""
}
|
|
q55361
|
train
|
function () {
var ret = {
promise: function () {
return ret;
}
};
var self = this;
ret["chain"] = function () {
return spreadArgs(self["chain"], arguments, self);
};
ret["chainBoth"] = function () {
return spreadArgs(self["chainBoth"], arguments, self);
};
ret["addCallback"] = function () {
spreadArgs(self["addCallback"], arguments, self);
return ret;
};
ret["addErrback"] = function () {
spreadArgs(self["addErrback"], arguments, self);
return ret;
};
ret["then"] = function () {
spreadArgs(self["then"], arguments, self);
return ret;
};
ret["both"] = function () {
spreadArgs(self["both"], arguments, self);
return ret;
};
ret["classic"] = function () {
spreadArgs(self["classic"], arguments, self);
return ret;
};
return ret;
}
|
javascript
|
{
"resource": ""
}
|
|
q55362
|
train
|
function (defs, normalizeResults) {
this.__errors = [];
this.__results = [];
this.normalizeResults = base.isBoolean(normalizeResults) ? normalizeResults : false;
this._super(arguments);
if (defs && defs.length) {
this.__defLength = defs.length;
forEach(defs, this.__addPromise, this);
} else {
this.__resolve();
}
}
|
javascript
|
{
"resource": ""
}
|
|
q55363
|
train
|
function (promise, i) {
var self = this;
promise.then(
function () {
var args = argsToArray(arguments);
args.unshift(i);
spreadArgs(self.callback, args, self);
promise = i = self = null;
},
function () {
var args = argsToArray(arguments);
args.unshift(i);
spreadArgs(self.errback, args, self);
promise = i = self = null;
});
}
|
javascript
|
{
"resource": ""
}
|
|
q55364
|
train
|
function () {
if (!this.__fired) {
this.__fired = true;
var self = this;
nextTick(function () {
var cbs = self.__errors.length ? self.__errorCbs : self.__cbs,
len = cbs.length, i,
results = self.__errors.length ? self.__errors : self.__results;
for (i = 0; i < len; i++) {
spreadArgs(cbs[i], [results]);
}
});
}
}
|
javascript
|
{
"resource": ""
}
|
|
q55365
|
callNext
|
train
|
function callNext(list, results, propogate) {
var ret = new Promise().callback();
forEach(list, function (listItem) {
ret = ret.chain(propogate ? listItem : bindIgnore(null, listItem));
if (!propogate) {
ret.addCallback(function (res) {
results.push(res);
res = null;
});
}
});
return propogate ? ret.promise() : ret.chain(results);
}
|
javascript
|
{
"resource": ""
}
|
q55366
|
when
|
train
|
function when(args, cb, eb) {
var p;
args = argsToArray(arguments);
eb = base.isFunction(args[args.length - 1]) ? args.pop() : null;
cb = base.isFunction(args[args.length - 1]) ? args.pop() : null;
if (eb && !cb) {
cb = eb;
eb = null;
}
if (!args.length) {
p = new Promise().callback(args);
} else if (args.length === 1) {
args = args.pop();
if (isPromiseLike(args)) {
p = args;
} else if (isArray(args) && array.every(args, isPromiseLike)) {
p = new PromiseList(args, true);
} else {
p = new Promise().callback(args);
}
} else {
p = new PromiseList(args.map(function (a) {
return isPromiseLike(a) ? a : new Promise().callback(a);
}), true);
}
if (cb) {
p.addCallback(cb);
}
if (eb) {
p.addErrback(eb);
}
return p.promise();
}
|
javascript
|
{
"resource": ""
}
|
q55367
|
serial
|
train
|
function serial(list, callback, errback) {
if (base.isArray(list)) {
return callNext(list, [], false);
} else {
throw new Error("When calling comb.serial the first argument must be an array");
}
}
|
javascript
|
{
"resource": ""
}
|
q55368
|
wait
|
train
|
function wait(args, fn) {
var resolved = false;
args = argsToArray(arguments);
fn = args.pop();
var p = when(args);
return function waiter() {
if (!resolved) {
var args = arguments;
return p.chain(function () {
resolved = true;
p = null;
return fn.apply(this, args);
}.bind(this));
} else {
return when(fn.apply(this, arguments));
}
};
}
|
javascript
|
{
"resource": ""
}
|
q55369
|
promisfyStream
|
train
|
function promisfyStream(stream) {
var ret = new Promise(), called;
function errorHandler() {
if (!called) {
called = true;
spreadArgs(ret.errback, arguments, ret);
stream.removeListener("error", endHandler);
stream.removeListener("end", endHandler);
stream = ret = null;
}
}
function endHandler() {
if (!called) {
called = true;
spreadArgs(ret.callback, arguments, ret);
stream.removeListener("error", endHandler);
stream.removeListener("end", endHandler);
stream = ret = null;
}
}
stream.on("error", errorHandler).on("end", endHandler);
return ret.promise();
}
|
javascript
|
{
"resource": ""
}
|
q55370
|
difference
|
train
|
function difference(arr1, arr2) {
var ret = arr1, args = flatten(argsToArray(arguments, 1));
if (isArray(arr1)) {
ret = filter(arr1, function (a) {
return indexOf(args, a) === -1;
});
}
return ret;
}
|
javascript
|
{
"resource": ""
}
|
q55371
|
removeDuplicates
|
train
|
function removeDuplicates(arr) {
if (isArray(arr)) {
return reduce(arr, function (a, b) {
if (indexOf(a, b) === -1) {
return a.concat(b);
} else {
return a;
}
}, []);
}
}
|
javascript
|
{
"resource": ""
}
|
q55372
|
partition
|
train
|
function partition(array, partitionSize) {
partitionSize = partitionSize || array.length;
var ret = [];
for (var i = 0, l = array.length; i < l; i += partitionSize) {
ret.push(array.slice(i, i + partitionSize));
}
return ret;
}
|
javascript
|
{
"resource": ""
}
|
q55373
|
train
|
function (node, order, callback) {
if (node) {
order = order || Tree.PRE_ORDER;
if (order === Tree.PRE_ORDER) {
callback(node.data);
this.traverse(node.left, order, callback);
this.traverse(node.right, order, callback);
} else if (order === Tree.IN_ORDER) {
this.traverse(node.left, order, callback);
callback(node.data);
this.traverse(node.right, order, callback);
} else if (order === Tree.POST_ORDER) {
this.traverse(node.left, order, callback);
this.traverse(node.right, order, callback);
callback(node.data);
} else if (order === Tree.REVERSE_ORDER) {
this.traverseWithCondition(node.right, order, callback);
callback(node.data);
this.traverseWithCondition(node.left, order, callback);
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q55374
|
train
|
function (timerFormat) {
timerFormat = timerFormat || " [Duration: %dms]";
function timerLog(level, start) {
return function (message) {
var args = argsToArray(arguments, 1);
message += timerFormat;
args.push(new Date() - start);
self.log.apply(self, [level, message].concat(args));
return ret;
};
}
var start = new Date(),
self = this,
ret = {
info: timerLog(Level.INFO, start),
debug: timerLog(Level.DEBUG, start),
error: timerLog(Level.ERROR, start),
warn: timerLog(Level.WARN, start),
trace: timerLog(Level.TRACE, start),
fatal: timerLog(Level.FATAL, start),
log: function (level) {
return timerLog(level, start).apply(this, argsToArray(arguments, 1));
},
end: function () {
start = self = null;
}
};
return ret;
}
|
javascript
|
{
"resource": ""
}
|
|
q55375
|
getLogEvent
|
train
|
function getLogEvent(level, message, rawMessage) {
return {
hostname: os.hostname(),
pid: process.pid,
gid: hasGetGid ? process.getgid() : null,
processTitle: process.title,
level: level,
levelName: level.name,
message: message,
timeStamp: new Date(),
name: this.fullName,
rawMessage: rawMessage
};
}
|
javascript
|
{
"resource": ""
}
|
q55376
|
log
|
train
|
function log(level, message) {
var rawMessage = message;
level = Level.toLevel(level);
if (this.hasLevelGt(level)) {
var args = argsToArray(arguments, 1);
if (args.length > 1) {
message = format.apply(null, args);
}
if (Level.TRACE.equals(level)) {
var err = new Error;
err.name = "Trace";
err.message = message || '';
Error.captureStackTrace(err, log);
message = err.stack;
} else if (Level.ERROR.equals(level) && isInstanceOf(message, Error)) {
message = message.stack;
}
var type = level.name.toLowerCase(), appenders = this.__appenders;
var event = this.getLogEvent(level, message, rawMessage);
Object.keys(appenders).forEach(function (i) {
appenders[i].append(event);
});
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
q55377
|
train
|
function (appender, opts) {
var args = argsToArray(arguments);
if (isString(appender)) {
this.addAppender(Appender.createAppender(appender, opts));
} else {
if (!isUndefinedOrNull(appender)) {
var name = appender.name;
if (!(name in this.__appenders)) {
this.__appenders[name] = appender;
if (!appender.level) {
appender.level = this.level;
}
this._tree.addAppender(appender);
}
}
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q55378
|
train
|
function (key, value) {
if (!base.isString(key)) {
var l = this.__heap.push(this.__makeNode(key, value));
this.__upHeap(l - 1);
} else {
throw new TypeError("Invalid key");
}
}
|
javascript
|
{
"resource": ""
}
|
|
q55379
|
train
|
function () {
var heap = this.__heap,
l = heap.length,
ret;
if (l) {
ret = heap[0];
if (l === 1) {
heap.length = 0;
} else {
heap[0] = heap.pop();
this.__downHeap(0);
}
}
return ret ? ret.value : ret;
}
|
javascript
|
{
"resource": ""
}
|
|
q55380
|
train
|
function () {
var heap = this.__heap,
l = heap.length,
ret;
if (l) {
ret = heap[0];
}
return ret ? ret.value : ret;
}
|
javascript
|
{
"resource": ""
}
|
|
q55381
|
train
|
function () {
var heap = this.__heap,
l = heap.length,
ret;
if (l) {
ret = heap[0];
}
return ret ? ret.key : ret;
}
|
javascript
|
{
"resource": ""
}
|
|
q55382
|
roundCeil
|
train
|
function roundCeil(num, precision){
return Math.ceil(num * Math.pow(10, precision))/Math.pow(10, precision);
}
|
javascript
|
{
"resource": ""
}
|
q55383
|
train
|
function (obj, method, cb, scope) {
var index,
listeners;
if (typeof method !== "string") {
throw new Error("When calling connect the method must be string");
}
if (!func.isFunction(cb)) {
throw new Error("When calling connect callback must be a string");
}
scope = obj || global;
if (typeof scope[method] === "function") {
listeners = scope[method].__listeners;
if (!listeners) {
var newMethod = wrapper();
newMethod.func = obj[method];
listeners = (newMethod.__listeners = []);
scope[method] = newMethod;
}
index = listeners.push(cb);
} else {
throw new Error("unknow method " + method + " in object " + obj);
}
return [obj, method, index];
}
|
javascript
|
{
"resource": ""
}
|
|
q55384
|
train
|
function (topic, callback) {
if (!func.isFunction(callback)) {
throw new Error("callback must be a function");
}
var handle = {
topic: topic,
cb: callback,
pos: null
};
var list = listeners[topic];
if (!list) {
list = (listeners[topic] = []);
}
list.push(handle);
handle.pos = list.length - 1;
return handle;
}
|
javascript
|
{
"resource": ""
}
|
|
q55385
|
train
|
function (handle) {
if (handle) {
var topic = handle.topic, list = listeners[topic];
if (list) {
for (var i = list.length - 1; i >= 0; i--) {
if (list[i] === handle) {
list.splice(i, 1);
}
}
if (!list.length) {
delete listeners[topic];
}
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q55386
|
train
|
function() {
var state = $H({
activeTab: PDoc.Sidebar.getActiveTab(),
menuScrollOffset: $('menu_pane').scrollTop,
searchScrollOffset: $('search_results').scrollTop,
searchValue: $('search').getValue()
});
return escape(state.toJSON());
}
|
javascript
|
{
"resource": ""
}
|
|
q55387
|
train
|
function(state) {
try {
state = unescape(state).evalJSON();
var filterer = $('search').retrieve('filterer');
filterer.setSearchValue(state.searchValue);
(function() {
$('menu_pane').scrollTop = state.menuScrollOffset;
$('search_results').scrollTop = state.searchScrollOffset;
}).defer();
} catch(error) {
console.log(error);
if (!(error instanceof SyntaxError)) throw error;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q55388
|
train
|
function(event) {
// Clear the text box on ESC.
if (event.keyCode && event.keyCode === Event.KEY_ESC) {
this.element.setValue('');
}
if (PDoc.Sidebar.Filterer.INTERCEPT_KEYS.include(event.keyCode))
return;
// If there's nothing in the text box, clear the results list.
var value = $F(this.element).strip().toLowerCase();
if (value === '') {
this.emptyResults();
this.hideResults();
return;
}
var urls = this.findURLs(value);
this.buildResults(urls);
}
|
javascript
|
{
"resource": ""
}
|
|
q55389
|
train
|
function(str) {
var results = [];
for (var name in PDoc.elements) {
if (name.toLowerCase().include(str.toLowerCase()))
results.push(PDoc.elements[name]);
}
return results;
}
|
javascript
|
{
"resource": ""
}
|
|
q55390
|
isHash
|
train
|
function isHash(obj) {
var ret = comb.isObject(obj);
return ret && obj.constructor === Object;
}
|
javascript
|
{
"resource": ""
}
|
q55391
|
extend
|
train
|
function extend(parent, ext) {
var proto = parent.prototype || parent;
merge(proto, ext);
return parent;
}
|
javascript
|
{
"resource": ""
}
|
q55392
|
isEmpty
|
train
|
function isEmpty(object) {
if (comb.isObject(object)) {
for (var i in object) {
if (object.hasOwnProperty(i)) {
return false;
}
}
}
return true;
}
|
javascript
|
{
"resource": ""
}
|
q55393
|
values
|
train
|
function values(hash) {
if (!isHash(hash)) {
throw new TypeError();
}
var keys = Object.keys(hash), ret = [];
for (var i = 0, len = keys.length; i < len; ++i) {
ret.push(hash[keys[i]]);
}
return ret;
}
|
javascript
|
{
"resource": ""
}
|
q55394
|
train
|
function () {
var ret;
if (this.count <= this.__maxObjects && this.freeCount > 0) {
ret = this.__freeObjects.dequeue();
this.__inUseObjects.push(ret);
} else if (this.count < this.__maxObjects) {
ret = this.createObject();
this.__inUseObjects.push(ret);
}
return ret;
}
|
javascript
|
{
"resource": ""
}
|
|
q55395
|
train
|
function (obj) {
var index;
if (this.validate(obj) && this.count <= this.__maxObjects && (index = this.__inUseObjects.indexOf(obj)) > -1) {
this.__freeObjects.enqueue(obj);
this.__inUseObjects.splice(index, 1);
} else {
this.removeObject(obj);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q55396
|
train
|
function (obj) {
var index;
if (this.__freeObjects.contains(obj)) {
this.__freeObjects.remove(obj);
} else if ((index = this.__inUseObjects.indexOf(obj)) > -1) {
this.__inUseObjects.splice(index, 1);
}
//otherwise its not contained in this pool;
return obj;
}
|
javascript
|
{
"resource": ""
}
|
|
q55397
|
train
|
function (/*Date*/date1, /*Date*/date2, /*String*/portion) {
date1 = new Date(date1);
date2 = new Date((date2 || new Date()));
if (portion === "date") {
// Ignore times and compare dates.
date1.setHours(0, 0, 0, 0);
date2.setHours(0, 0, 0, 0);
} else if (portion === "time") {
// Ignore dates and compare times.
date1.setFullYear(0, 0, 0);
date2.setFullYear(0, 0, 0);
}
return date1 > date2 ? 1 : date1 < date2 ? -1 : 0;
}
|
javascript
|
{
"resource": ""
}
|
|
q55398
|
train
|
function (type, options) {
var caseType = type.toLowerCase();
if (caseType in APPENDER_TYPES) {
return new APPENDER_TYPES[caseType](options);
} else {
throw new Error(type + " appender is not registered!");
}
}
|
javascript
|
{
"resource": ""
}
|
|
q55399
|
train
|
function (appender) {
var rootLogger = Logger.getRootLogger();
rootLogger.removeAllAppenders();
if (base.isInstanceOf(appender, appenders.Appender)) {
rootLogger.addAppender(appender);
} else {
rootLogger.addAppender(new appenders.ConsoleAppender());
}
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.