_id stringlengths 2 6 | title stringlengths 0 58 | partition stringclasses 3
values | text stringlengths 27 233k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q14700 | subgen | train | function subgen (key, ...params) {
return random(createSeed([...seed, | javascript | {
"resource": ""
} |
q14701 | logout | train | function logout(mongoClient, dbName, callback) {
mongoClient.topology.logout(dbName, err => {
if (err) | javascript | {
"resource": ""
} |
q14702 | validOptions | train | function validOptions(options) {
const _validOptions = validOptionNames.concat(legacyOptionNames);
for (const name in options) {
if (ignoreOptionNames.indexOf(name) !== -1) {
continue;
}
if (_validOptions.indexOf(name) === -1 && options.validateOptions) {
return new MongoError(`option ${na... | javascript | {
"resource": ""
} |
q14703 | Converter | train | function Converter() {
// Validate arguments
if (arguments.length === 1) {
this._bl = 2;
if (typeof arguments[0] !== "function")
throw new TypeError("Converter requires at least a callback function");
else
this._fx = arguments[0];
} else if (arguments.length >= 2) {
this._bl = arg... | javascript | {
"resource": ""
} |
q14704 | getCommonActions | train | function getCommonActions(device) {
const actions = []
actions.push(new BackAction(device))
actions.push(new HomeAction(device)) | javascript | {
"resource": ""
} |
q14705 | mutation | train | function mutation(target, handler) {
target.addEventListener("mutation", function(evt) {
| javascript | {
"resource": ""
} |
q14706 | Request | train | function Request(reqBytes){
var parsed;
var err
try {
parsed = types.Request.decode(reqBytes);
} catch (e) {
err = e;
}
//Check for request errors here
if(err){
this.BadRequest = true;
this.errCode = types.CodeType.EncodingError;
this.errMsg = "The request failed to be decoded"
} ... | javascript | {
"resource": ""
} |
q14707 | fire | train | function fire (event, $el, evt) {
var handler = $el.data('dragon-opts')[event];
// Patch | javascript | {
"resource": ""
} |
q14708 | ComponentModel | train | function ComponentModel(key, impl, cfg) {
this.key = key
/**
* @property {Any} impl The implementation to use for `resolve`
* */
this.impl =impl
this._cfg = cfg || {}
/**
* @property {Array} inject The {String} dependencies array a service may declare
* */
this.inject = (this... | javascript | {
"resource": ""
} |
q14709 | fetchLogs | train | function fetchLogs(root, msg, callback) {
const number = msg.number;
const logfile = msg.logfile;
const serverId = msg.serverId;
const filePath = path.join(root, getLogFileName(logfile, serverId));
const endLogs = [];
exec(`tail -n ${number} ${filePath}`, (error, output) => {
const endO... | javascript | {
"resource": ""
} |
q14710 | train | function(parser) {
return highland.map(function(item) {
if (_.isFunction(parser)) {
return parser(item);
}
if (_.isObject(parser) && (parser.parse | javascript | {
"resource": ""
} | |
q14711 | train | function(done) {
var p, parser, stream, _i, _len;
parser = this.parser();
stream = highland(this.source());
if (_.isArray(parser)) {
for (_i = 0, _len = parser.length; _i < _len; _i++) {
p = parser[_i];
stream = this._mapWith(p)(stream).flatten().compact();
}
} else {
| javascript | {
"resource": ""
} | |
q14712 | mergeInto | train | function mergeInto(target, source) {
var a = target;
var b = source;
if (a && b) {
for (var key in b) {
if (!(key in a)) {
continue;
}
| javascript | {
"resource": ""
} |
q14713 | tryWatch | train | function tryWatch(target, callback) {
if (!target) {
return logger.halt('invalid watch target')
}
if (!callback || typeof callback !== 'function') {
return logger.halt('invalid watch callback')
}
return fs.watch(
| javascript | {
"resource": ""
} |
q14714 | getBabelConfig | train | function getBabelConfig(env) {
var babelrcPath = path.join(__dirname, '.babelrc')
var babelrc = JSON.parse(fs.readFileSync(babelrcPath))
babelrc.presets = resolve(
| javascript | {
"resource": ""
} |
q14715 | isNested | train | function isNested(obj) {
if (getType(obj)==='object') {
for (let tag in obj) {
if (tag != TEXT | javascript | {
"resource": ""
} |
q14716 | getAttributes | train | function getAttributes(obj) {
let attrString = '';
let attrArray = Object.keys(obj);
for (let tag of attrArray) {
if (tag != ATTR && ATTRTAG.test(tag)) {
attrString | javascript | {
"resource": ""
} |
q14717 | getType | train | function getType(obj) {
let typeStr = typeof(obj);
if (obj) {
return Array.isArray(obj) ? 'array' : typeStr;
} else {
switch (typeStr) {
case 'number':
return obj === 0 | javascript | {
"resource": ""
} |
q14718 | injectWatcher | train | function injectWatcher(handler) {
return function(module, filename) { | javascript | {
"resource": ""
} |
q14719 | loadNext | train | function loadNext() {
var script;
if ( ( script = pending[ 0 ] ) )
| javascript | {
"resource": ""
} |
q14720 | callbackWrapper | train | function callbackWrapper() {
callback && callback.apply( this, arguments ); | javascript | {
"resource": ""
} |
q14721 | Lexer | train | function Lexer(sourcetext, filename, options) {
options = options || {};
this.options = options || {};
this.dialects = []; // the "stack" dialects are pushed/popped from
if(filename) {
this.filename = filename; | javascript | {
"resource": ""
} |
q14722 | regexes_for_category | train | function regexes_for_category(lexer, category) {
var REs = [];
var done = false;
for(var i = 0; !done && i < lexer.dialects.length; i++) {
var dialect = lexer.dialects[i];
if(dialect.lextab) {
var categoryentry = dialect.lextab.find(function(lextabentry) {
return lextabentry.category == cat... | javascript | {
"resource": ""
} |
q14723 | oncharincategory | train | function oncharincategory(lexer, lookahead, categoryREs) {
var c = lexer.peek_char(lookahead);
return categoryREs.find(function(re) { | javascript | {
"resource": ""
} |
q14724 | next_lextab_token | train | function next_lextab_token(lexer) {
var token;
if(lexer.eos()) {
return undefined;
}
// skip leading whitespace or comments...
lexer.skip_filler();
var previouslyPeeked = lexer.getPeekedToken();
if(previouslyPeeked) {
return previouslyPeeked;
}
lexer.mark_token_start();
trace(lexer.mess... | javascript | {
"resource": ""
} |
q14725 | match_in_lextabs | train | function match_in_lextabs(lexer, options) {
options = options || {};
var token;
var replaced = {};
// for each dialect's lextab...
for(var d = 0; !token && d < lexer.dialects.length; d++) {
var dialect = lexer.dialects[d];
if(!dialect.lextab) {
continue; // no lextab for the dialect so move on
... | javascript | {
"resource": ""
} |
q14726 | formatTokenDump | train | function formatTokenDump(tokens, formatter, resultPrefix, resultSuffix) {
var tokensSexpStr = "";
var currentLine = -999;
tokens.forEach(function(token, index) {
// skip the wrapping () it's annoying in the dump
if(!((index === 0 && token.text === "(") ||
(index === tokens.length-1 && token.text =... | javascript | {
"resource": ""
} |
q14727 | Suite | train | function Suite(name, fn){
if (! (this instanceof Suite))
return | javascript | {
"resource": ""
} |
q14728 | generateNamedFieldExtractors | train | function generateNamedFieldExtractors(input) {
var names = input.filter(function(matcher, index, array) {
// has a name?
return matcher.name;
});
// has duplicates?
names.forEach(function(matcher, index, array) {
var isDuplicate = array.slice(0, index).some(function(previousMatcher) {
| javascript | {
"resource": ""
} |
q14729 | extractNamedFields | train | function extractNamedFields(fields, input) {
var output = Object.create(null);
fields.forEach(function(field) {
var subObject = input;
for (var i = 0; i < field.path.length; i += 1) {
if (subObject == undefined) {
throw new Error("Unreachable: matched input will always have fields");
}
... | javascript | {
"resource": ""
} |
q14730 | rawContent | train | function rawContent(tagName, string, templ, innerTemplate) {
var index = string.indexOf('</' + tagName + '>'),
raw;
if (index === -1)
throw new Error(tagName + ' tag badly closed.');
if | javascript | {
"resource": ""
} |
q14731 | train | function(markupList) {
("production" !== "development" ? invariant(
ExecutionEnvironment.canUseDOM,
'dangerouslyRenderMarkup(...): Cannot render markup in a worker ' +
'thread. Make sure `window` and `document` are available globally ' +
'before requiring React when unit testing or use ' +
... | javascript | {
"resource": ""
} | |
q14732 | recomputePluginOrdering | train | function recomputePluginOrdering() {
if (!EventPluginOrder) {
// Wait until an `EventPluginOrder` is injected.
return;
}
for (var pluginName in namesToPlugins) {
var PluginModule = namesToPlugins[pluginName];
var pluginIndex = EventPluginOrder.indexOf(pluginName);
("production" !== "developmen... | javascript | {
"resource": ""
} |
q14733 | publishEventForPlugin | train | function publishEventForPlugin(dispatchConfig, PluginModule, eventName) {
("production" !== "development" ? invariant(
!EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName),
'EventPluginHub: More than one plugin attempted to publish the same ' +
'event name, `%s`.',
eventName
) : i... | javascript | {
"resource": ""
} |
q14734 | train | function(spec) {
var Constructor = function(props, context) {
// This constructor is overridden by mocks. The argument is used
// by mocks to assert on what gets mounted.
if ("production" !== "development") {
("production" !== "development" ? warning(
this instanceof Constructor... | javascript | {
"resource": ""
} | |
q14735 | train | function(propTypes, props, location) {
// TODO: Stop validating prop types here and only use the element
// validation.
var componentName = this.getName();
for (var propName in propTypes) {
if (propTypes.hasOwnProperty(propName)) {
var error;
try {
// This is intentionall... | javascript | {
"resource": ""
} | |
q14736 | warnForPropsMutation | train | function warnForPropsMutation(propName, element) {
var type = element.type;
var elementName = typeof type === 'string' ? type : type.displayName;
var ownerName = element._owner ?
element._owner.getPublicInstance().constructor.displayName : null;
var warningKey = propName + '|' + elementName + '|' + ownerNa... | javascript | {
"resource": ""
} |
q14737 | train | function(object) {
if ("production" !== "development") {
if (typeof object !== 'object' || !object || Array.isArray(object)) {
("production" !== "development" ? warning(
false,
'React.addons.createFragment only accepts a single object.',
object
) : null);
... | javascript | {
"resource": ""
} | |
q14738 | train | function(container) {
// Various parts of our code (such as ReactCompositeComponent's
// _renderValidatedComponent) assume that calls to render aren't nested;
// verify that that's the case. (Strictly speaking, unmounting won't cause a
// render but we still don't expect to be in a render call here.)
... | javascript | {
"resource": ""
} | |
q14739 | train | function(objName, fnName, func) {
if ("production" !== "development") {
var measuredFunc = null;
var wrapper = function() {
if (ReactPerf.enableMeasure) {
if (!measuredFunc) {
measuredFunc = ReactPerf.storedMeasure(objName, fnName, func);
}
| javascript | {
"resource": ""
} | |
q14740 | train | function() {
var acc = arguments.callee.caller;
var nom = ((acc ? acc.nom : "") || "(instance method)") + ":";
| javascript | {
"resource": ""
} | |
q14741 | mv | train | function mv (sourceURI, destURI, callback) {
if (!sourceURI) {
callback(new Error('source URI is required'))
}
if (!destURI) {
callback(new Error('dest URI is required'))
}
util.get(sourceURI, function (err, val, uri) {
util.put(destURI, val, function (err, ret, uri) {
if (!err) {
ut... | javascript | {
"resource": ""
} |
q14742 | update | train | function update() {
connection = new Connection(room)
// set our funcitonal code on the ready event, so we are sure that the socket has been created and is connected to the server
connection.on('ready', _ => {
connection.on('snapshot-event', event => {
// | javascript | {
"resource": ""
} |
q14743 | render | train | function render(list) {
const blank = new Array(process.stdout.rows).fill('\n')
console.log(blank)
readline.cursorTo(process.stdout, | javascript | {
"resource": ""
} |
q14744 | getMeasureStations | train | function getMeasureStations(latitude, longitude, params, callback) {
if(!latitude || !longitude) {
callback(new Error("WaterFlow.getMeasureStations: latitude and | javascript | {
"resource": ""
} |
q14745 | getWaterLevel | train | function getWaterLevel(stationId, startDate, endDate, params, callback) {
if(!stationId) {
callback(new Error("WaterFlow.getWaterLevel: stationId required"));
return;
}
params = params || {};
params.stationid = stationId;
if(!startDate && !endDate) {
startDate = new Date();
s... | javascript | {
"resource": ""
} |
q14746 | matches | train | function matches(url, command) {
var cap;
if (cap | javascript | {
"resource": ""
} |
q14747 | Pending | train | function Pending(runner) {
runner.on('start', function(){
console.log('* ')
console.log('*********************');
console.log('*** Pending tests ***');
console.log('*********************');
console.log('* ')
});
var scope = [];
runner.on('pending', function(test){
| javascript | {
"resource": ""
} |
q14748 | train | function (d, use_UTC) {
if (typeof d === "string") {
if (d.match(/[0-9][0-9][0-9][0-9][\s]*-[0-1][0-9]-[\s]*[0-3][0-9]/)) {
return d.replace(/\s+/, "");
}
d = new Date(d);
} else if (typeof d === "number") {
d = new Date(d);
} else if (typeof d !== "object" &&
typeof d.getFullYear !== "functio... | javascript | {
"resource": ""
} | |
q14749 | train | function (options) {
var ky,
default_keys = [
"normalize_date",
"hours",
"save_parse",
"tags",
"map"
],
defaults = {},
map = {};
default_keys.forEach(function (ky) {
defaults[ky] = true;
});
this.defaults = defaults;
this.map = false;
this.parse_tree = {};
this.msgs = ... | javascript | {
"resource": ""
} | |
q14750 | train | function (msg) {
var i = this.msgs.length;
this.msgs.push('ERROR: ' + msg);
if ((i + 1) | javascript | {
"resource": ""
} | |
q14751 | train | function (no_clear) {
var result;
if (this.msgs === undefined) {
this.msgs = [];
}
result = this.msgs.join("\n");
// set optional default i needed
if (no_clear !== undefined) {
no_clear = false; | javascript | {
"resource": ""
} | |
q14752 | train | function () {
var self = this,
dates = Object.keys(this.parse_tree),
lines = [];
dates.sort();
dates.forEach(function (dy, i) {
var times = Object.keys(self.parse_tree[dy]);
lines.push(dy);
times.sort();
times.forEach(function (tm) {
var tags = "", maps = "", notes = "", rec;
rec... | javascript | {
"resource": ""
} | |
q14753 | addFiles | train | function addFiles(pattern, cb){
glob(pattern, function(err, files){
if(err) throw err; | javascript | {
"resource": ""
} |
q14754 | find | train | function find(source, fn) {
glob('**', {cwd: source, dot: true}, function(err, | javascript | {
"resource": ""
} |
q14755 | filterIgnored | train | function filterIgnored(files, ignore, fn) {
fn(null, files.filter(function(file) { | javascript | {
"resource": ""
} |
q14756 | statFiles | train | function statFiles(files, source, fn) {
var batch = new Batch();
files.forEach(function(file) {
| javascript | {
"resource": ""
} |
q14757 | statFile | train | function statFile(file, source) {
return function(cb) {
var abs = join(source, file);
stat(abs, function(err, stats) {
if (err) return cb(err);
var manifest = {
name: file,
abs: abs,
mtime: Math.floor(stats.mtime.getTime() / 1000),
mode: '' + parseInt(stats.mode.to... | javascript | {
"resource": ""
} |
q14758 | calculateHash | train | function calculateHash(file, fn) {
read(file, function(err, bin) {
if (err) return fn(err); | javascript | {
"resource": ""
} |
q14759 | normalizeManifest | train | function normalizeManifest(manifest, fn) {
var obj = {};
manifest.forEach(function(file) {
if (!file) return;
obj[file.name] = {
mtime: file.mtime,
| javascript | {
"resource": ""
} |
q14760 | findMissing | train | function findMissing(manifest, request, host, fn) {
request
.post(host + '/manifest/diff')
.send({manifest: JSON.stringify(manifest)}) | javascript | {
"resource": ""
} |
q14761 | selectMissing | train | function selectMissing(missing, manifest, fn) {
fn(null, manifest.filter(function(file) {
| javascript | {
"resource": ""
} |
q14762 | uploadMissing | train | function uploadMissing(missing, request, host, log, fn) {
var batch = new Batch();
missing.forEach(function(file) {
batch.push(uploadFile(file, | javascript | {
"resource": ""
} |
q14763 | uploadFile | train | function uploadFile(file, request, host) {
return function(cb) {
request
.post(host + '/file/' + file.hash)
.attach('data', file.abs)
.end(function(err, res) {
| javascript | {
"resource": ""
} |
q14764 | saveManifest | train | function saveManifest(manifest, request, host, fn) {
request
.post(host + '/manifest')
.send({manifest: JSON.stringify(manifest)})
.end(function(err, res) {
if (err) return fn(err);
| javascript | {
"resource": ""
} |
q14765 | use | train | function use(type) {
// Convert args to array.
var args = Array.prototype.slice.call(arguments);
// Check if type not provided.
if ('string' !== typeof type && type instanceof Array === false) {
type = [];
} else {
if ('string' === typeof type) {
| javascript | {
"resource": ""
} |
q14766 | handle | train | function handle(type, req, res, out) {
var index = 0;
var ended = false;
// When called stop middlewares execution.
res.end = end;
// Handle next middleware in stack.
function next(err) {
var middleware = stack[index++];
// No more middlewares or early end.
if (!middleware |... | javascript | {
"resource": ""
} |
q14767 | writeToConsoleOrStderr | train | function writeToConsoleOrStderr(message) {
if (typeof console == 'object' && typeof console.warn == 'function')
console.warn(message);
else if (typeof process == 'object' && typeof | javascript | {
"resource": ""
} |
q14768 | train | function(value) {
switch (typeof value) {
case 'undefined':
return this.undefined;
case 'string':
return this.string;
case 'number':
if (value % 1 === 0) {
return this.integer;
} else {
return this.double;
}
... | javascript | {
"resource": ""
} | |
q14769 | preamble | train | function preamble(opts) {
var str = '';
var index = opts.section || SECTION;
var date = opts.date || new Date().toISOString();
var version = opts.version || '1.0';
// section name
var sname = section(index);
var title = opts.title || opts.name;
if(!title) {
throw new TypeError('manual preamble requi... | javascript | {
"resource": ""
} |
q14770 | splitActionName | train | function splitActionName(actionName) {
if(actionName.indexOf('_') > 0) return actionName.split('_')
else return | javascript | {
"resource": ""
} |
q14771 | parseMethodName | train | function parseMethodName(parts, argsNames) {
/**
* argsName could be in different case from that
* of function's name.
*/
const argsNamesLower = argsNames.map(arg => arg.toLowerCase())
/**
* Suppresses HTTP method if exists
*/
if(keysMethods.indexOf(parts[0].toLowerCase... | javascript | {
"resource": ""
} |
q14772 | parseHttpMethod | train | function parseHttpMethod(parts) {
const prefix = parts[0].toLowerCase()
if(keysMethods.indexOf(prefix) >= 0)
| javascript | {
"resource": ""
} |
q14773 | lookupParameterOnReq | train | function lookupParameterOnReq(name, index, length) {
return (req, res) => {
if(req[name]) return req[name]
if(req.query && req.query[name]) return req.query[name]
if(req.body && req.body[name]) return req.body[name]
if(res.locals && res.locals[name]) return res.locals[name]
... | javascript | {
"resource": ""
} |
q14774 | appLoader | train | function appLoader(app, config) {
app.define('load', load('view', config));
var fn = app.view;
app.define('view', function() {
| javascript | {
"resource": ""
} |
q14775 | createLoader | train | function createLoader(options, fn) {
var loader = new utils.Loader(options);
return function() {
if (!this.isApp) loader.cache = this.views;
loader.options.loaderFn | javascript | {
"resource": ""
} |
q14776 | load | train | function load(method, config) {
return function(patterns, options) {
var opts = mergeOptions(this, config, options);
var loader = | javascript | {
"resource": ""
} |
q14777 | train | function () {
waitForServers--;
if (waitForServers) return;
if (seminarjs.get('logger')) | javascript | {
"resource": ""
} | |
q14778 | randstr | train | function randstr(options) {
var opt = _validateOptions(options);
var from, to;
if (Array.isArray(opt.length)) {
_a = opt.length, from = _a[0], to = _a[1];
}
else {
from = to = opt.length;
}
var str = '';
if (0 === to) {
return str;
}
var charsIsString = 's... | javascript | {
"resource": ""
} |
q14779 | updateStatus | train | function updateStatus(evType, opts) {
var t2 = new Date()
var elapsed = (t2.getTime() - t1.getTime()) / 1000
var msg = {
timeElapsed:elapsed,
stdout: opts.stdout || "",
stderr: opts.stderr || "",
stdmerged: opts.stdmerged || "",
info: opts.info,
step: opts.step,
dep... | javascript | {
"resource": ""
} |
q14780 | train | function(s_thing) {
if(H_SPARQL_CHARS[s_thing[0]]) return s_thing;
else if(s_thing.indexOf(':') | javascript | {
"resource": ""
} | |
q14781 | train | function(s_str) {
if(H_SPARQL_CHARS[s_str[0]]) return s_str;
else if(s_str.indexOf(':') | javascript | {
"resource": ""
} | |
q14782 | train | function(sq_prefixes) {
var s_select = this.select || '*';
var sq_select = 'SELECT '+s_select+' WHERE {';
var sq_where = this.where;
var sq_tail = this.tail;
var sq_group = this.group? ' GROUP BY '+this.group: '';
var sq_order = this.order? ' ORDER BY '+this.order: '';
| javascript | {
"resource": ""
} | |
q14783 | train | function(s_query, f_okay) {
$.ajax({
url: s_endpoint_url+'query',
method: 'GET',
data: {
query: s_query,
},
| javascript | {
"resource": ""
} | |
q14784 | train | function(h_subjects, b_raw) {
// initiliaze output
var s_out = '';
// add slot for tail
var s_tail = '';
// newline + indent
var _ = '\n\t'+(b_raw? '\t':'');
// root nodes must be subjects
for(var s_rs in h_subjects) {
//
var z_predicates = h_subjects[s_rs];
// declaring option... | javascript | {
"resource": ""
} | |
q14785 | train | function(s_query) {
// execute function
var f_exec = function(f_okay) {
submit_query(s_query, f_okay);
};
var d_self = {
exec: f_exec,
results: function(f_okay) {
f_exec(function(h_res) {
f_okay && f_okay(h_res.results.bindings);
});
},
each: function(f_each, f_okay) {
... | javascript | {
"resource": ""
} | |
q14786 | train | function(channel) {
return function() {
var args = Array.prototype.slice.call(arguments);
| javascript | {
"resource": ""
} | |
q14787 | into | train | function into(impl) {
/**
* @param {string} selector
* @param {Document|Element} [context]
*/
return function(selector, context) {
var callContext = this,
extra;
if (typeof selector === "string") {
if (context && context.querySelector) {
ex... | javascript | {
"resource": ""
} |
q14788 | select | train | function select(selector, context, fn) {
var nodes;
if (arguments.length === 2 && typeof context === "function") {
fn = context;
context = undefined;
}
| javascript | {
"resource": ""
} |
q14789 | LooseInterval | train | function LooseInterval(fn, interval, callback) {
if (!(this instanceof LooseInterval)) return new LooseInterval(fn, interval, callback)
if (typeof fn != "function") throw new Error("LooseInterval requires a function")
if (typeof interval == "function") {
callback = interval
interval = null
}
this.fn ... | javascript | {
"resource": ""
} |
q14790 | process | train | function process(){
if (!conf.configured) that.configure();
var args = command.args.slice(0);
for(var i in args){
var arg = args[i];
if(conf.regexp.test(arg)){
var catchWord = RegExp.$2;
switch(RegExp.$1){
case '-':
processShortKey(catchWord, i, args);
break;
| javascript | {
"resource": ""
} |
q14791 | getPlatforms | train | function getPlatforms(options) {
return request('GET', 'https://saucelabs.com/rest/v1/info/platforms/webdriver')
.getBody('utf8').then(JSON.parse).then(function (platforms) {
var obj = {};
platforms.map(function (platform) {
return {
browserName: platform.api_name,
version: platform.sh... | javascript | {
"resource": ""
} |
q14792 | Blob | train | function Blob(source, parent, githubClient) {
this.gh = githubClient;
this.parent = parent;
this.sha = | javascript | {
"resource": ""
} |
q14793 | pJson | train | function pJson(events, top = '') {
Object.keys(events).forEach((i) => {
if (typeof events[i] === 'object' && events[i] != null) {
let rtn;
if (Object.prototype.toString.call(events) === '[object Array]') {
rtn = (`${top}[${i}]`);
} else { rtn = (`${top}.${i}`); }
| javascript | {
"resource": ""
} |
q14794 | jPretty | train | function jPretty(obj) {
// make sure data is a json obj
if(typeof obj === "string") {
obj = obj.replace(/\s/g,"");
obj = obj.replace(/'/g,'"');
}
let gl;
try {
const p = JSON.parse(obj);
gl = obj; // already stringified
} catch (e) { // not stringified
if(typeof obj === "string")... | javascript | {
"resource": ""
} |
q14795 | Client | train | function Client(options) {
options = options || { };
this._key = options.key || null;
this._secret = options.secret | javascript | {
"resource": ""
} |
q14796 | parallel | train | async function parallel(resolvers, limit=-1){
// set default limit
if (limit < 1){
limit = 1000;
}
// buffer
const results = [];
// calculate chunk size
// limit step size to input array size
const chunkSize = Math.min(limit, resolvers.length);
// process resolvers in chun... | javascript | {
"resource": ""
} |
q14797 | train | function(error, newIndex) {
if (error) {
console.log('Data error for ' + dataurl + '\n' + error)
}
if (!error) {
index = newIndex
var timeStart = Date.now()
request(dataurl)
.pipe(JSONStream.parse())
.pipe(index.defaultPipeline())
.pipe(index.add())
.on('data', function(dat... | javascript | {
"resource": ""
} | |
q14798 | train | function(str, len, padChar) {
str = stringIt(str);
if (str.length >= len) {
return str;
}
| javascript | {
"resource": ""
} | |
q14799 | train | function(str, start) {
return (str.length >= start.length &&
| javascript | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.