_id stringlengths 2 6 | title stringlengths 0 58 | partition stringclasses 3
values | text stringlengths 52 373k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q55200 | run | train | function run() {
platforms.forEach(function(platform) {
var wwwPath;
switch (platform) {
case 'android':
wwwPath = path.join(platformPath, platform, 'assets', 'www');
if (!fs.existsSync(wwwPath)) {
wwwPath = path.join(platformPath, platform, 'app', 'src', 'main', 'assets', 'ww... | javascript | {
"resource": ""
} |
q55201 | processFolders | train | function processFolders(wwwPath) {
foldersToProcess.forEach(function(folder) {
processFiles(path.join(wwwPath, folder));
});
} | javascript | {
"resource": ""
} |
q55202 | compress | train | function compress(file) {
var ext = path.extname(file),
res,
source,
result;
switch (ext) {
case '.js':
console.log('uglifying js file ' + file);
res = ngAnnotate(String(fs.readFileSync(file, 'utf8')), {
add: true
});
result = UglifyJS.minify(res.src, hookConfig.ugl... | javascript | {
"resource": ""
} |
q55203 | hasAttr | train | function hasAttr(fs, path, attr, callback) {
fs.getxattr(path, attr, function(err, attrVal) {
// File doesn't exist locally at all
if(err && err.code === 'ENOENT') {
return callback(null, false);
}
// Deal with unexpected error
if(err && err.code !== 'ENOATTR') {
return callback(err);... | javascript | {
"resource": ""
} |
q55204 | removeAttr | train | function removeAttr(fs, pathOrFd, attr, isFd, callback) {
var removeFn = 'fremovexattr';
if(isFd !== true) {
callback = isFd;
removeFn = 'removexattr';
}
fs[removeFn](pathOrFd, attr, function(err) {
if(err && err.code !== 'ENOATTR') {
return callback(err);
}
callback();
});
} | javascript | {
"resource": ""
} |
q55205 | getAttr | train | function getAttr(fs, pathOrFd, attr, isFd, callback) {
var getFn = 'fgetxattr';
if(isFd !== true) {
callback = isFd;
getFn = 'getxattr';
}
fs[getFn](pathOrFd, attr, function(err, value) {
if(err && err.code !== 'ENOATTR') {
return callback(err);
}
callback(null, value);
});
} | javascript | {
"resource": ""
} |
q55206 | forceCopy | train | function forceCopy(fs, oldPath, newPath, callback) {
fs.unlink(newPath, function(err) {
if(err && err.code !== 'ENOENT') {
return callback(err);
}
fs.readFile(oldPath, function(err, buf) {
if(err) {
return callback(err);
}
fs.writeFile(newPath, buf, callback);
});
}... | javascript | {
"resource": ""
} |
q55207 | isPathUnsynced | train | function isPathUnsynced(fs, path, callback) {
hasAttr(fs, path, constants.attributes.unsynced, callback);
} | javascript | {
"resource": ""
} |
q55208 | removeUnsynced | train | function removeUnsynced(fs, path, callback) {
removeAttr(fs, path, constants.attributes.unsynced, callback);
} | javascript | {
"resource": ""
} |
q55209 | setUnsynced | train | function setUnsynced(fs, path, callback) {
fs.setxattr(path, constants.attributes.unsynced, Date.now(), callback);
} | javascript | {
"resource": ""
} |
q55210 | getUnsynced | train | function getUnsynced(fs, path, callback) {
getAttr(fs, path, constants.attributes.unsynced, callback);
} | javascript | {
"resource": ""
} |
q55211 | removeChecksum | train | function removeChecksum(fs, path, callback) {
removeAttr(fs, path, constants.attributes.checksum, callback);
} | javascript | {
"resource": ""
} |
q55212 | setChecksum | train | function setChecksum(fs, path, checksum, callback) {
fs.setxattr(path, constants.attributes.checksum, checksum, callback);
} | javascript | {
"resource": ""
} |
q55213 | getChecksum | train | function getChecksum(fs, path, callback) {
getAttr(fs, path, constants.attributes.checksum, callback);
} | javascript | {
"resource": ""
} |
q55214 | isPathPartial | train | function isPathPartial(fs, path, callback) {
hasAttr(fs, path, constants.attributes.partial, callback);
} | javascript | {
"resource": ""
} |
q55215 | removePartial | train | function removePartial(fs, path, callback) {
removeAttr(fs, path, constants.attributes.partial, callback);
} | javascript | {
"resource": ""
} |
q55216 | setPartial | train | function setPartial(fs, path, nodeCount, callback) {
fs.setxattr(path, constants.attributes.partial, nodeCount, callback);
} | javascript | {
"resource": ""
} |
q55217 | getPartial | train | function getPartial(fs, path, callback) {
getAttr(fs, path, constants.attributes.partial, callback);
} | javascript | {
"resource": ""
} |
q55218 | setPathsToSync | train | function setPathsToSync(fs, path, pathsToSync, callback) {
fs.setxattr(path, constants.attributes.pathsToSync, pathsToSync, callback);
} | javascript | {
"resource": ""
} |
q55219 | getPathsToSync | train | function getPathsToSync(fs, path, callback) {
getAttr(fs, path, constants.attributes.pathsToSync, callback);
} | javascript | {
"resource": ""
} |
q55220 | request | train | function request(client, path, callback) {
var key = SyncLock.generateKey(client.username);
var id = client.id;
// Try to set this key/value pair, but fail if the path for the key already exists.
redis.hsetnx(key, path, id, function(err, reply) {
if(err) {
log.error({err: err, client: client}, 'Error... | javascript | {
"resource": ""
} |
q55221 | isUserLocked | train | function isUserLocked(username, path, callback) {
var key = SyncLock.generateKey(username);
redis.hget(key, path, function(err, value) {
if(err) {
log.error(err, 'Error getting redis lock key %s.', key);
return callback(err);
}
callback(null, !!value);
});
} | javascript | {
"resource": ""
} |
q55222 | validateParams | train | function validateParams(fs, param2) {
var err;
if(!fs) {
err = new Errors.EINVAL('No filesystem provided');
} else if(!param2) {
err = new Errors.EINVAL('Second argument must be specified');
}
return err;
} | javascript | {
"resource": ""
} |
q55223 | calcWeak32 | train | function calcWeak32(data, prev, start, end) {
var a = 0;
var b = 0;
var M = 1 << 16;
var N = 65521;
if (!prev) {
var len = (start >= 0 && end >= 0) ? (end - start + 1) : data.length;
var datai;
for (var i = 0; i < len; i++) {
datai = data[i];
a += datai;
b += ((len - i) * datai)... | javascript | {
"resource": ""
} |
q55224 | createHashtable | train | function createHashtable(checksums) {
var hashtable = {};
var len = checksums.length;
var checksum;
var weak16;
for (var i = 0; i < len; i++) {
checksum = checksums[i];
weak16 = calcWeak16(checksum.weak);
if (hashtable[weak16]) {
hashtable[weak16].push(checksum);
} else {
hashtabl... | javascript | {
"resource": ""
} |
q55225 | roll | train | function roll(data, checksums, blockSize) {
var results = [];
var hashtable = createHashtable(checksums);
var length = data.length;
var start = 0;
var end = blockSize > length ? length : blockSize;
// Updated when a block matches
var lastMatchedEnd = 0;
// This gets updated every iteration with the prev... | javascript | {
"resource": ""
} |
q55226 | blockChecksums | train | function blockChecksums(fs, path, size, callback) {
var cache = {};
fs.readFile(path, function (err, data) {
if (!err) {
// cache file
cache[path] = data;
} else if (err && err.code === 'ENOENT') {
cache[path] = [];
} else {
return callback(err);
}
var length = cache[pa... | javascript | {
"resource": ""
} |
q55227 | getChecksum | train | function getChecksum(fs, path, callback) {
fs.readFile(path, function(err, data) {
if(!err) {
callback(null, md5sum(data));
} else if(err.code === 'ENOENT') {
// File does not exist so the checksum is an empty string
callback(null, "");
} else {
callback(err);
}
});
} | javascript | {
"resource": ""
} |
q55228 | generateChecksums | train | function generateChecksums(fs, paths, stampNode, callback) {
// Maybe stampNode was not passed in
if(typeof callback !== 'function') {
callback = findCallback(callback, stampNode);
stampNode = false;
}
var paramError = validateParams(fs, paths);
if(paramError) {
return callback(paramError);
}
... | javascript | {
"resource": ""
} |
q55229 | maybeAddChecksumNode | train | function maybeAddChecksumNode(path, nodeType, callback) {
fsUtils.isPathUnsynced(fs, path, function(err, unsynced) {
if(err) {
return callback(err);
}
if(unsynced) {
return callback();
}
getChecksum(fs, path, function(err, checksum) {
if(err) {
retur... | javascript | {
"resource": ""
} |
q55230 | compareContents | train | function compareContents(fs, checksumList, callback) {
var ECHKSUM = "Checksums do not match";
var paramError = validateParams(fs, checksumList);
if(paramError) {
return callback(paramError);
}
function compare(checksumNode, callback) {
var path = checksumNode.path;
fs.lstat(path, function(err,... | javascript | {
"resource": ""
} |
q55231 | createParentDirectories | train | function createParentDirectories(path, callback) {
(new fs.Shell()).mkdirp(Path.dirname(path), function(err) {
if(err && err.code !== 'EEXIST') {
return callback(err);
}
callback();
});
} | javascript | {
"resource": ""
} |
q55232 | findPathIndexInArray | train | function findPathIndexInArray(array, path) {
for(var i = 0; i < array.length; i++) {
if(array[i].path === path) {
return i;
}
}
return -1;
} | javascript | {
"resource": ""
} |
q55233 | handle404 | train | function handle404(url, res) {
var json = {
error: {
code: 404,
message: 'The requested URL ' + url + ' was not found on this server.'
}
};
write(json, res, 404);
} | javascript | {
"resource": ""
} |
q55234 | handleDir | train | function handleDir(fs, path, res) {
var sh = new fs.Shell();
sh.ls(path, {recursive: true}, function(err, listing) {
if(err) {
log.error(err, 'Unable to get listing for path `%s`', path);
handle404(path, res);
return;
}
write(listing, res);
});
} | javascript | {
"resource": ""
} |
q55235 | ensureLock | train | function ensureLock(client, path) {
var lock = client.lock;
if(!(lock && !('unlocked' in lock))) {
// Create an error so we get a stack, too.
var err = new Error('Attempted sync step without lock.');
log.error({client: client, err: err}, 'Client should own lock but does not for ' + path);
return fal... | javascript | {
"resource": ""
} |
q55236 | checkFileSizeLimit | train | function checkFileSizeLimit(client, srcList) {
function maxSizeExceeded(obj) {
var errorMsg;
client.lock.release(function(err) {
if(err) {
log.error({err: err, client: client}, 'Error releasing sync lock');
}
releaseLock(client);
errorMsg = SyncMessage.error.maxsizeExceeded;... | javascript | {
"resource": ""
} |
q55237 | maybeReleaseLock | train | function maybeReleaseLock() {
var lock = self.client.lock;
function done(err) {
log.debug({client: self.client}, 'Closed client sync handler');
self.client.lock = null;
self.client = null;
callback(err);
}
// No lock
if(!lock) {
return done();
}
// Lock refere... | javascript | {
"resource": ""
} |
q55238 | getUsernameByToken | train | function getUsernameByToken(token) {
for(var username in authTable) {
if(authTable[username].indexOf(token) > -1) {
return username;
}
}
return null;
} | javascript | {
"resource": ""
} |
q55239 | handlePatchAckResponse | train | function handlePatchAckResponse() {
var syncedPath = data.content.path;
function complete() {
fsUtils.removeUnsynced(fs, syncedPath, function(err) {
if(err && err.code !== 'ENOENT') {
log.error('Failed to remove unsynced attribute for ' + syncedPath + ' in handlePatchAckResponse, comple... | javascript | {
"resource": ""
} |
q55240 | convert_json_to_objects | train | function convert_json_to_objects(data) {
if (Array.isArray(data)) {
return data.map((item, index, arr) => {
return new this(item, true)
})
} else {
return new this(data, true)
}
} | javascript | {
"resource": ""
} |
q55241 | runClient | train | function runClient(client) {
var ws = client.ws;
function invalidMessage() {
var message = SyncMessage.error.format;
message.content = {error: 'Unable to parse/handle message, invalid message format.'};
client.sendMessage(message);
}
ws.onmessage = function(msg, flags) {
var data;
var mess... | javascript | {
"resource": ""
} |
q55242 | initClient | train | function initClient(client) {
var ws = client.ws;
client.state = States.CONNECTING;
// Wait until we get the user's token so we can finish authorizing
ws.onmessage = function(msg) {
var data;
var info;
try {
// Keep track of how much data we receive
info = client.info();
if(info... | javascript | {
"resource": ""
} |
q55243 | remove | train | function remove(client) {
if(!clients) {
return;
}
var idx = clients.indexOf(client);
if(idx > -1) {
clients.splice(idx, 1);
}
} | javascript | {
"resource": ""
} |
q55244 | add | train | function add(client) {
// Auto-remove clients on close
client.once('closed', function() {
remove(client);
});
clients = clients || [];
clients.push(client);
initClient(client);
} | javascript | {
"resource": ""
} |
q55245 | shutdown | train | function shutdown(callback) {
var closed = 0;
var connected = clients ? clients.length : 0;
function maybeFinished() {
if(++closed >= connected) {
clients = null;
log.info('[Shutdown] All client connections safely closed.');
return callback();
}
log.info('[Shutdown] Closed client %... | javascript | {
"resource": ""
} |
q55246 | apply_data | train | function apply_data(query, files) {
if(startCb){
startCb();
}
if (query !== undefined) {
if (this.method === 'get') {
this.request = this.request.query(query)
} else {
this.request = this.request.send(query)
}
}
if (files !== undefined) {
if (files instanceof FormData) {
... | javascript | {
"resource": ""
} |
q55247 | handleFile | train | function handleFile(fs, path, res) {
var contentType = mime.lookup(path);
var encoding = mime.charsets.lookup(contentType) === "UTF-8" ? "utf8" : null;
fs.readFile(path, {encoding: encoding}, function(err, data) {
if(err) {
log.error(err, 'Unable to read file path `%s`', path);
handle404(path, re... | javascript | {
"resource": ""
} |
q55248 | handleDir | train | function handleDir(fs, path, res) {
var sh = new fs.Shell();
var parent = Path.dirname(path);
var header = '<!DOCTYPE html>' +
'<html><head><title>Index of ' + path + '</title></head>' +
'<body><h1>Index of ' + path + '</h1>' +
'<table><tr><th><img src="/icons/blank.png" alt="[ICO]"></th>... | javascript | {
"resource": ""
} |
q55249 | onmessage | train | function onmessage(channel, message) {
if(closing) {
return;
}
switch(channel) {
case ChannelConstants.syncChannel:
module.exports.emit('sync', message);
break;
case ChannelConstants.lockRequestChannel:
module.exports.emit('lock-request', message);
break;
case ChannelConst... | javascript | {
"resource": ""
} |
q55250 | windowCloseHandler | train | function windowCloseHandler(event) {
if(!options.windowCloseWarning) {
return;
}
if(sync.state !== sync.SYNC_SYNCING) {
return;
}
var confirmationMessage = "Sync currently underway, are you sure you want to close?";
(event || global.event).returnValue = confirmationMessage;
re... | javascript | {
"resource": ""
} |
q55251 | continuousBundle | train | function continuousBundle() {
const bundle = b => b.bundle()
.on('error', (err) => {
notifier.notify({
title: 'Browserify Error',
message: err.message,
});
gutil.log('Browserify Error', err);
})
.pipe(source('crudl.js'))
... | javascript | {
"resource": ""
} |
q55252 | bundleDevelopment | train | function bundleDevelopment() {
const opts = assign({}, browersifyOptions, { debug: true });
const bundler = browserify(opts).transform(babelify.configure(babelifyOptions));
bundler.on('log', gutil.log); // output build logs to terminal
return bundler.bundle()
.on('error', (err) => { // log errors i... | javascript | {
"resource": ""
} |
q55253 | bundleProduction | train | function bundleProduction() {
return browserify(browersifyOptions)
.transform(babelify.configure(babelifyOptions))
.transform(envify({ _: 'purge', NODE_ENV: 'production' }), { global: true })
.on('log', gutil.log)
.bundle()
// minify
.pipe(source('crudl.js'))
.pipe(buffer())
.pipe(u... | javascript | {
"resource": ""
} |
q55254 | sassWatch | train | function sassWatch() {
return gulp
// ... and compile if necessary
.watch(sassSrcFiles, ['sass-compile'])
.on('change', (event) => {
gutil.log(`File ${event.path} was ${event.type}, running tasks...`);
});
} | javascript | {
"resource": ""
} |
q55255 | transit | train | function transit(state, variable, value) {
// FIXME: deep copying of the whole state can be eventually slow...
const newState = cloneDeep(state)
set(newState, variable, value)
return newState
} | javascript | {
"resource": ""
} |
q55256 | getStats | train | function getStats(results, done) {
const databases = results.databases;
const keys = ['document_count', 'storage_size', 'index_count', 'index_size'];
const stats = {};
keys.map(function(k) {
stats[k] = 0;
});
databases.map(function(db) {
keys.map(function(k) {
stats[k] += db[k];
});
});... | javascript | {
"resource": ""
} |
q55257 | getInstanceDetail | train | function getInstanceDetail(client, db, done) {
const tasks = {
client: attach.bind(null, client),
db: attach.bind(null, db),
userInfo: ['client', 'db', getUserInfo],
host: ['client', 'db', getHostInfo],
build: ['client', 'db', getBuildInfo],
cmdLineOpts: ['client', 'db', getCmdLineOpts],
... | javascript | {
"resource": ""
} |
q55258 | saveReturnUrlToSession | train | function saveReturnUrlToSession(req, isReturnUrlAllowed) {
const referrer = req.get("referrer")
const isInternalRequest = Boolean(
referrer && url.parse(referrer).hostname === req.hostname
)
const isUrlAllowed = isReturnUrlAllowed(req.originalUrl)
const isSessionSet = Boolean(req.session && req.session.r... | javascript | {
"resource": ""
} |
q55259 | stop | train | function stop(opts, done) {
debug('stopping...');
killIfRunning(opts, function(err) {
debug('Any running workers have been sent a stop command');
done(err);
});
} | javascript | {
"resource": ""
} |
q55260 | configure | train | function configure(opts, done) {
delete opts._;
opts = defaults(opts, {
topology: process.env.MONGODB_TOPOLOGY || 'standalone'
});
opts = defaults(opts, {
name: opts.topology
});
opts = defaults(opts, {
logpath: untildify(
process.env.MONGODB_LOGPATH ||
format('~/.mongodb/runner... | javascript | {
"resource": ""
} |
q55261 | mongodb_runner_mocha_before | train | function mongodb_runner_mocha_before(opts) {
if (typeof opts === 'function') {
// So you can just do `before(require('mongodb-runner/mocha/before'));`
return mongodb_runner_mocha_before({}).apply(this, arguments);
}
opts = opts || {};
defaults(opts, {
port: 27017,
timeout: 10000,
slow: 10000... | javascript | {
"resource": ""
} |
q55262 | mongodb_runner_mocha_after | train | function mongodb_runner_mocha_after(opts) {
if (typeof opts === 'function') {
// So you can just do `after(require('mongodb-runner/mocha/after'));`
return mongodb_runner_mocha_after({}).apply(this, arguments);
}
opts = opts || {};
defaults(opts, {
port: 27017
});
return function(done) {
if ... | javascript | {
"resource": ""
} |
q55263 | tryParse | train | function tryParse(url) {
if (!url) {
return null;
}
var conf = {};
var parsed = urlParse(url);
conf.protocol = parsed.protocol;
conf.host = parsed.hostname;
conf.port = parseInt(parsed.port,10);
return conf;
} | javascript | {
"resource": ""
} |
q55264 | mixinProxying | train | function mixinProxying(agent, proxyOpts) {
agent.proxy = proxyOpts;
var orig = _.pick(agent, 'createConnection', 'addRequest');
// Make the tcp or tls connection go to the proxy, ignoring the
// destination host:port arguments.
agent.createConnection = function(port, host, options) {
return orig.createC... | javascript | {
"resource": ""
} |
q55265 | train | function () {
if (this.el && this.el.parentNode) this.el.parentNode.removeChild(this.el);
this._rendered = false;
this._downsertBindings();
return this;
} | javascript | {
"resource": ""
} | |
q55266 | train | function (context, templateArg) {
var template = templateArg || this.template;
if (!template) throw new Error('Template string or function needed.');
var newDom = isString(template) ? template : template.call(this, context || this);
if (isString(newDom)) newDom = domify(newDom);
... | javascript | {
"resource": ""
} | |
q55267 | checkSchemaHasReferences | train | function checkSchemaHasReferences(schema) {
if (schema.$ref) {
return true;
}
return Object.values(schema).some((value) => {
if (_.isArray(value)) {
return value.some(checkSchemaHasReferences);
} else if (_.isObject(value)) {
return checkSchemaHasReferences(value);
}
return false... | javascript | {
"resource": ""
} |
q55268 | findReferences | train | function findReferences(schema) {
if (schema.$ref) {
return [schema.$ref];
}
let references = [];
if (schema.allOf) {
references = references.concat(...schema.allOf.map(findReferences));
}
if (schema.anyOf) {
references = references.concat(...schema.anyOf.map(findReferences));
}
if (sche... | javascript | {
"resource": ""
} |
q55269 | getTime | train | function getTime(time) {
var hours = Math.floor(time/3600);
var minutes = Math.floor(time % 3600/60);
var seconds = (time % 3600) % 60;
return hours + 'h ' + minutes + 'min ' + seconds + 's';
} | javascript | {
"resource": ""
} |
q55270 | isStream | train | function isStream(input) {
if (ReadableStream.prototype.isPrototypeOf(input)) {
return 'web';
}
if (NodeReadableStream && NodeReadableStream.prototype.isPrototypeOf(input)) {
return 'node';
}
return false;
} | javascript | {
"resource": ""
} |
q55271 | getPushSettings | train | function getPushSettings(opts) {
assert.ok(opts, 'opts is undefined');
var headers = {
'X-Project-Id': opts.widget,
'X-App-Id': opts.instance
};
fhutils.addAppApiKeyHeader(headers, opts.appapikey);
return {
url: 'https://' + opts.millicore + ':' + opts.port + '/box/api/unifiedpu... | javascript | {
"resource": ""
} |
q55272 | toStream | train | function toStream(input) {
let streamType = isStream(input);
if (streamType === 'node') {
return nodeToWeb(input);
} else if (streamType) {
return input;
}
return new ReadableStream({
start(controller) {
controller.enqueue(input);
controller.close();
}
});
} | javascript | {
"resource": ""
} |
q55273 | concat | train | function concat(list) {
if (list.some(isStream)) {
return concatStream(list);
}
if (typeof list[0] === 'string') {
return list.join('');
}
if (NodeBuffer && NodeBuffer.isBuffer(list[0])) {
return NodeBuffer.concat(list);
}
return concatUint8Array(list);
} | javascript | {
"resource": ""
} |
q55274 | concatStream | train | function concatStream(list) {
list = list.map(toStream);
const transform = transformWithCancel(async function(reason) {
await Promise.all(transforms.map(stream => cancel(stream, reason)));
});
let prev = Promise.resolve();
const transforms = list.map((stream, i) => transformPair(stream, (readable, writabl... | javascript | {
"resource": ""
} |
q55275 | getWriter | train | function getWriter(input) {
const writer = input.getWriter();
const releaseLock = writer.releaseLock;
writer.releaseLock = () => {
writer.closed.catch(function() {});
releaseLock.call(writer);
};
return writer;
} | javascript | {
"resource": ""
} |
q55276 | pipe | train | async function pipe(input, target, options) {
input = toStream(input);
try {
if (input[externalBuffer]) {
const writer = getWriter(target);
for (let i = 0; i < input[externalBuffer].length; i++) {
await writer.ready;
await writer.write(input[externalBuffer][i]);
}
writer.... | javascript | {
"resource": ""
} |
q55277 | transformRaw | train | function transformRaw(input, options) {
const transformStream = new TransformStream(options);
pipe(input, transformStream.writable);
return transformStream.readable;
} | javascript | {
"resource": ""
} |
q55278 | transformWithCancel | train | function transformWithCancel(cancel) {
let pulled = false;
let backpressureChangePromiseResolve;
let outputController;
return {
readable: new ReadableStream({
start(controller) {
outputController = controller;
},
pull() {
if (backpressureChangePromiseResolve) {
ba... | javascript | {
"resource": ""
} |
q55279 | transform | train | function transform(input, process = () => undefined, finish = () => undefined) {
if (isStream(input)) {
return transformRaw(input, {
async transform(value, controller) {
try {
const result = await process(value);
if (result !== undefined) controller.enqueue(result);
} cat... | javascript | {
"resource": ""
} |
q55280 | transformPair | train | function transformPair(input, fn) {
let incomingTransformController;
const incoming = new TransformStream({
start(controller) {
incomingTransformController = controller;
}
});
const pipeDonePromise = pipe(input, incoming.writable);
const outgoing = transformWithCancel(async function() {
in... | javascript | {
"resource": ""
} |
q55281 | passiveClone | train | function passiveClone(input) {
if (isStream(input)) {
return new ReadableStream({
start(controller) {
const transformed = transformPair(input, async (readable, writable) => {
const reader = getReader(readable);
const writer = getWriter(writable);
try {
while... | javascript | {
"resource": ""
} |
q55282 | slice | train | function slice(input, begin=0, end=Infinity) {
if (isStream(input)) {
if (begin >= 0 && end >= 0) {
let bytesRead = 0;
return transformRaw(input, {
transform(value, controller) {
if (bytesRead < end) {
if (bytesRead + value.length >= begin) {
controller.enqu... | javascript | {
"resource": ""
} |
q55283 | cancel | train | async function cancel(input, reason) {
if (isStream(input) && input.cancel) {
return input.cancel(reason);
}
} | javascript | {
"resource": ""
} |
q55284 | fromAsync | train | function fromAsync(fn) {
return new ReadableStream({
pull: async controller => {
try {
controller.enqueue(await fn());
controller.close();
} catch(e) {
controller.error(e);
}
}
});
} | javascript | {
"resource": ""
} |
q55285 | mongoConnectionStringOS3 | train | function mongoConnectionStringOS3(cb) {
debug('Running in OpenShift 3, requesting db connection string from MBaaS');
mbaasClient.app.databaseConnectionString({
"domain": config.fhmbaas.domain,
"environment": config.fhmbaas.environment
}, function retrieved(err, resp) {
if (err) {
return cb(err)... | javascript | {
"resource": ""
} |
q55286 | findFieldDefinition | train | function findFieldDefinition() {
var foundField;
if (!(params.fieldId || params.fieldCode)) {
return undefined;
}
//Iterating through each of the pages to find a matching field.
_.each(self.form.pages, function(page) {
_.each(page.fields, function(field) {
var fieldId = field._i... | javascript | {
"resource": ""
} |
q55287 | processInputValue | train | function processInputValue() {
var value = params.value;
var index = params.index || 0;
var fieldType = field.type;
//Checking for a value.
if (typeof(value) === "undefined" || value === null) {
return "No value entered.";
}
/**
* File-base fields (photo, signature and file) nee... | javascript | {
"resource": ""
} |
q55288 | FHapi | train | function FHapi(cfg) {
var api = {
getVersion: function() {
//Getting The Version of fh-mbaas-api
return packageJSON.version;
},
cache: require('./cache')(cfg),
db: require('./db')(cfg),
events: new EventEmitter(),
forms: require('./forms')(cfg),
log: false,
stringify: fals... | javascript | {
"resource": ""
} |
q55289 | Reader | train | function Reader(input) {
this.stream = input;
if (input[externalBuffer]) {
this[externalBuffer] = input[externalBuffer].slice();
}
let streamType = streams.isStream(input);
if (streamType === 'node') {
input = streams.nodeToWeb(input);
}
if (streamType) {
const reader = input.getReader();
... | javascript | {
"resource": ""
} |
q55290 | createMarkdownTemplate | train | function createMarkdownTemplate(file, vueObj) {
let json2mdTemplate = [], mdTablesTemplate;
mdTablesTemplate = buildTables(vueObj)
if(mdTablesTemplate.length > 0) {
json2mdTemplate = json2mdTemplate.concat(mdTablesTemplate)
}
return json2md(json2mdTemplate)
} | javascript | {
"resource": ""
} |
q55291 | buildTables | train | function buildTables(vueObj) {
let updatedTemplate = [{h3: "<button class='title'>PROPS, METHODS, EVENTS, SLOTS</button>"}]
let mdTable
mdTable = tableFromProps(vueObj["props"])
if(mdTable != null) {
updatedTemplate.push(mdTable)
}
mdTable = tableFromMethods(vueObj["methods"])
if(mdTable != null... | javascript | {
"resource": ""
} |
q55292 | tableFromProps | train | function tableFromProps(propsObj) {
const headers = ["Prop Name", "Type", "Default", "Require", "Description"]
let rows = []
// construct rows of table from object of properties
for(const prop in propsObj) {
// Don't document properties with `@ignore` tag
if (propsObj[prop].tags.ignore) {
continu... | javascript | {
"resource": ""
} |
q55293 | tableFromMethods | train | function tableFromMethods(methodsArr) {
const headers = ["Method Name", "Type", "Parameters", "Description"]
let rows = []
// construct rows of table array of methods
methodsArr.forEach((method) => {
let cols = []
cols.push(method["name"]) // method name
let paramList = ''
method["params"].for... | javascript | {
"resource": ""
} |
q55294 | tableFromEvents | train | function tableFromEvents(eventsObj) {
const headers = ["Event Name", "Type", "Description"]
let rows = []
for(const evt in eventsObj) {
let cols = []
cols.push(`${evt}`) // event name
let typeList = ''
eventsObj[evt]["type"]["names"].forEach((type, idx, arr) => {
typeList += `${type}$... | javascript | {
"resource": ""
} |
q55295 | tableFromSlots | train | function tableFromSlots(slotsObj) {
const headers = ["Slot", "Description"]
let rows = []
for(const slot in slotsObj) {
let cols = []
cols.push(`${slot}`) // name of the slot
cols.push(`${slotsObj[slot]["description"] || ''}`) // description of the slot
rows.push(cols)
}
return rows.length ... | javascript | {
"resource": ""
} |
q55296 | buildAPIs | train | function buildAPIs(vueObj) {
const funcArray = [propsAPIObject, methodsAPIObject, eventsAPIObject, slotsAPIObject]
const compAPIObj = funcArray.reduce((apiObj, curFn) => {
const obj = curFn(vueObj)
if (obj !== null) {
Object.assign(apiObj, obj)
}
return apiObj
}, {})
return compAPIObj... | javascript | {
"resource": ""
} |
q55297 | propsAPIObject | train | function propsAPIObject(vueObj) {
const propsObj = vueObj["props"] || {}
let props = []
// construct array of objects for props
for (const prop in propsObj) {
if (propsObj.hasOwnProperty(prop)) {
// Don't document properties with `@ignore` tag
if (propsObj[prop].tags.ignore) {
contin... | javascript | {
"resource": ""
} |
q55298 | methodsAPIObject | train | function methodsAPIObject(vueObj) {
const methodsArr = vueObj["methods"] || []
let methods = []
// construct array of objects for public methods
methodsArr.forEach((method) => {
const ele = {
"name": `${method["name"]}`,
"parameters": `${method["params"].reduce((paramList, param) => {
... | javascript | {
"resource": ""
} |
q55299 | eventsAPIObject | train | function eventsAPIObject(vueObj) {
const eventsObj = vueObj["events"] || {}
let events = []
for (const evt in eventsObj) {
if (eventsObj.hasOwnProperty(evt)) {
const ele = {
"name": `${evt}`,
"type": `${eventsObj[evt]["type"]["names"].reduce((typeList, type, idx, arr) => {
typ... | javascript | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.