_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q1000 | train | function () {
var me = this;
if (!me._dataInPromise) {
me._dataInPromise = new Promise(function (resolve) {
me._dataInResolve = resolve;
}).then(function (data) {
delete me._dataInPromise;
delete me._dataInResolve;
return data;
});
}
return me._dataInPromise;
} | javascript | {
"resource": ""
} |
|
q1001 | train | function (data) {
var me = this;
me._waitForData();
me._dataInResolve(data);
return new Promise(function (resolve, reject) {
me._dataOutResolve = resolve;
me._dataOutReject = reject;
}).then(function (value) {
delete me._dataOutResolve;
delete me._dataOutReject;
return value;
}, function (reason) {
delete me._dataOutResolve;
delete me._dataOutReject;
return Promise.reject(reason);
});
} | javascript | {
"resource": ""
} |
|
q1002 | _gpfXmlCheckDefinableNamespacePrefixName | train | function _gpfXmlCheckDefinableNamespacePrefixName(name) {
_gpfXmlCheckValidNamespacePrefixName(name);
_gpfXmlCheckNoXmlns(name);
if (name === "xml") {
gpf.Error.invalidXmlUseOfPrefixXml();
}
} | javascript | {
"resource": ""
} |
q1003 | _gpfInterfacesPromisify | train | function _gpfInterfacesPromisify(interfaceSpecifier) {
return function (object) {
var iInterfaceImpl = _gpfInterfaceQuery(interfaceSpecifier, object);
if (!iInterfaceImpl) {
gpf.Error.interfaceExpected({ name: _gpfGetFunctionName(interfaceSpecifier) });
}
return _gpfInterfacesWrap(iInterfaceImpl, interfaceSpecifier, Promise.resolve());
};
} | javascript | {
"resource": ""
} |
q1004 | _gpfAttributesDecorator | train | function _gpfAttributesDecorator() {
var attributes = _gpfArraySlice(arguments);
return function (ClassConstructor, member) {
if (!_gpfIsClass(ClassConstructor)) {
gpf.Error.es6classOnly();
}
_gpfAttributesDecoratorAddAttributes(_gpfDefineClassImport(ClassConstructor), member, attributes);
};
} | javascript | {
"resource": ""
} |
q1005 | parseBuild | train | function parseBuild(builds, fileExtensions, fileFactory, npmModulepaths, runtimeOptions, serverConfig, parent, level) {
if (!parent) {
numBuilds = 0;
level = 1;
}
// Deprecate sources
if ('sources' in builds) {
warn(DEPRECATED_SOURCES, 1);
}
// Deprecate targets
if ('targets' in builds) {
warn(DEPRECATED_VERSION, 1);
builds = builds.targets;
}
// Support basic mode with single build target
if (!Array.isArray(builds)) builds = [builds];
return builds.reduce(
(builds, buildConfig) => {
const childBuilds = buildConfig.build || buildConfig.children;
const options = buildConfig.options;
const version = buildConfig.version;
delete buildConfig.build;
delete buildConfig.options;
delete buildConfig.version;
// Deprecate old formats
if ('js' in buildConfig || 'css' in buildConfig || 'html' in buildConfig || 'targets' in buildConfig) {
warn(DEPRECATED_VERSION);
return builds;
}
// Deprecate aliases
if (buildConfig.alias) warn(DEPRECATED_ALIAS, 1);
// Deprecate modular
if ('modular' in buildConfig) warn(DEPRECATED_MODULAR, 1);
// Deprecate sources
if (buildConfig.sources) warn(DEPRECATED_SOURCES, 1);
if (buildConfig.bootstrap == null) buildConfig.bootstrap = true;
if (buildConfig.label == null) buildConfig.label = '';
if (buildConfig.bundle == null || buildConfig.modular) buildConfig.bundle = true;
buildConfig.batch = false;
buildConfig.boilerplate = true;
buildConfig.index = ++numBuilds;
buildConfig.level = level;
buildConfig.parent = parent;
buildConfig.runtimeOptions = runtimeOptions;
buildConfig.watchOnly = !buildConfig.output;
parseInputOutput(buildConfig, fileExtensions, runtimeOptions);
// Ignore build targets with nulled input (no grep match)
if (!('input' in buildConfig && buildConfig.input != null)) return builds;
const build = buildFactory(buildConfig);
const caches = parent
? { fileCache: parent.fileCache, resolverCache: parent.resolverCache }
: cache.createCaches(runtimeOptions.watch);
build.browser = parent ? parent.browser : buildPlugins.isBrowserEnvironment(version);
build.fileCache = caches.fileCache;
build.resolverCache = caches.resolverCache;
build.fileFactoryOptions = getFileFactoryOptions(build, parent, version, options, {
fileExtensions,
fileFactory,
npmModulepaths,
runtimeOptions,
sourceroot: serverConfig.sourceroot,
webroot: serverConfig.webroot
});
build.fileFactory = build.fileFactoryOptions.fileFactory;
// Flag as app server target
build.isAppServer = isAppServer(build.inputpaths, serverConfig);
// Traverse child build targets
if (childBuilds) {
build.builds = parseBuild(
childBuilds,
fileExtensions,
fileFactory,
npmModulepaths,
runtimeOptions,
serverConfig,
build,
level + 1
);
parseChildInputpaths(build);
}
builds.push(build);
return builds;
},
[]
);
} | javascript | {
"resource": ""
} |
q1006 | getFileFactoryOptions | train | function getFileFactoryOptions(build, parent, version, options, fileFactoryOptions) {
const { fileFactory, runtimeOptions } = fileFactoryOptions;
const hasPlugins = parent ? !!(options || version) : true;
const needsPlugins = 'input' in build && build.input != null && !build.watchOnly;
fileFactoryOptions.browser = build.browser;
fileFactoryOptions.buildFactory = getBuildFactory(build);
fileFactoryOptions.bundle = build.bundle;
fileFactoryOptions.fileCache = build.fileCache;
fileFactoryOptions.level = build.level + 2;
fileFactoryOptions.pluginOptions = {};
fileFactoryOptions.resolverCache = build.resolverCache;
// Only load plugins for active output builds
if (needsPlugins) {
// Use parent's if none defined
fileFactoryOptions.pluginOptions = hasPlugins
? buildPlugins.load(build.type, options, version, runtimeOptions.compress)
: parent.fileFactoryOptions.pluginOptions;
}
// Overwrite fileFactory function with memoized options
fileFactoryOptions.fileFactory = function createFile(filepath) {
return fileFactory(filepath, fileFactoryOptions);
};
return fileFactoryOptions;
} | javascript | {
"resource": ""
} |
q1007 | getBuildFactory | train | function getBuildFactory(build) {
return function createBuild(inputpath, outputname) {
const input = path.relative(process.cwd(), inputpath);
let parent = build;
if (!parent.builds.some(build => build.input == input)) {
const outputpath = path.join(path.dirname(parent.outputpaths[0]), outputname);
const buildConfig = {
batch: parent.batch,
boilerplate: false,
bootstrap: false,
browser: parent.browser,
bundle: parent.bundle,
fileCache: parent.fileCache,
index: ++numBuilds,
input,
inputpaths: [inputpath],
isAppServer: false,
isDynamicBuild: true,
label: '',
level: parent.level + 1,
output: path.relative(process.cwd(), path.dirname(outputpath)),
outputpaths: [outputpath],
parent,
resolverCache: parent.resolverCache,
runtimeOptions: parent.runtimeOptions,
type: parent.type,
watchOnly: parent.watchOnly
};
const build = buildFactory(buildConfig);
build.fileFactoryOptions = getFileFactoryOptions(
build,
parent,
null,
null,
Object.assign({}, parent.fileFactoryOptions)
);
build.fileFactory = build.fileFactoryOptions.fileFactory;
parent.builds.push(build);
parent.childInputpaths.push(inputpath);
}
// Find root build
while (parent.parent)
parent = parent.parent;
parent.processFilesOptions.importBoilerplate = true;
};
} | javascript | {
"resource": ""
} |
q1008 | parseChildInputpaths | train | function parseChildInputpaths(build) {
function parse(build) {
let inputpaths = [];
build.forEach(build => {
inputpaths = inputpaths.concat(build.inputpaths, build.builds ? parse(build.builds) : []);
});
return inputpaths;
}
build.childInputpaths = parse(build.builds);
} | javascript | {
"resource": ""
} |
q1009 | isAppServer | train | function isAppServer(inputpaths, serverConfig) {
// Test if 'p' is in 'dirs'
function contains(dirs, p) {
if (!Array.isArray(dirs)) dirs = [dirs];
return dirs.some(dir => {
return indir(dir, p);
});
}
return serverConfig != undefined && serverConfig.file != undefined && contains(inputpaths, serverConfig.file);
} | javascript | {
"resource": ""
} |
q1010 | contains | train | function contains(dirs, p) {
if (!Array.isArray(dirs)) dirs = [dirs];
return dirs.some(dir => {
return indir(dir, p);
});
} | javascript | {
"resource": ""
} |
q1011 | createTemplateValue | train | function createTemplateValue(start, end) {
var value = "";
while (start <= end) {
if (tokens[start].value) {
value += tokens[start].value;
} else if (tokens[start].type !== tt.template) {
value += tokens[start].type.label;
}
start++;
}
return value;
} | javascript | {
"resource": ""
} |
q1012 | replaceWithTemplateType | train | function replaceWithTemplateType(start, end) {
var templateToken = {
type: "Template",
value: createTemplateValue(start, end),
start: tokens[start].start,
end: tokens[end].end,
loc: {
start: tokens[start].loc.start,
end: tokens[end].loc.end
}
};
// put new token in place of old tokens
tokens.splice(start, end - start + 1, templateToken);
} | javascript | {
"resource": ""
} |
q1013 | _gpfBuildMimeTypeFromMappings | train | function _gpfBuildMimeTypeFromMappings (path, mappings) {
_gpfObjectForEach(mappings, function (extensions, key) {
var mimeType = path + key;
if (0 === extensions) {
_createMimeTypeExtensionMapping(mimeType, "." + key);
} else if ("string" === typeof extensions) {
extensions.split(",").forEach(function (extension) {
_createMimeTypeExtensionMapping(mimeType, "." + extension);
});
} else { // Assuming extensions is an object
_gpfBuildMimeTypeFromMappings(mimeType + "/", extensions);
}
});
} | javascript | {
"resource": ""
} |
q1014 | resolvePath | train | function resolvePath(filepath) {
filepath = filepath.replace(RE_TRAILING, '');
const cwd = process.cwd();
const npmPackage = filepath.includes('node_modules');
// Find nearest node_modules directory
if (npmPackage) {
const parts = filepath.split(path.sep);
let idx = parts.lastIndexOf('node_modules');
if (idx < parts.length - 1) idx += 2;
// Handle scoped
if (parts[idx - 1].charAt(0) == '@') idx++;
const dir = parts.slice(0, idx).join(path.sep);
// Installed packages must have manifest, otherwise continue
if (exists(path.join(dir, 'package.json'))) return dir;
}
// Find nearest directory with node_modules subdirectory
if (filepath.includes(cwd)) {
let depth = maxFileSystemDepth;
let dir = filepath;
let parent = '';
while (true) {
parent = path.dirname(dir);
// Stop if we hit max file system depth or root
// Convert to lowercase to fix problems on Windows
if (!--depth || parent.toLowerCase() === dir.toLowerCase()) {
break;
}
// Stop at nearest directory with node_modules or cwd
if (dir == cwd || exists(path.resolve(dir, 'node_modules'))) return dir;
// Walk
dir = parent;
}
}
// Return project directory if file isn't a project file
return cwd;
} | javascript | {
"resource": ""
} |
q1015 | resolveName | train | function resolveName(pkgpath) {
pkgpath = pkgpath.replace(RE_TRAILING, '');
const cwd = process.cwd();
const parts = pkgpath.split(path.sep);
const len = parts.length;
let idx = 1;
// Handle packages nested under root
if (!pkgpath.includes('node_modules') && cwd != pkgpath) {
// Increase by distance from root
idx += path.relative(cwd, pkgpath).split(path.sep).length;
// Handle scoped node_modules
} else if (parts[len - 2].charAt(0) == '@') {
idx = 2;
}
return parts.slice(len - idx).join(path.sep);
} | javascript | {
"resource": ""
} |
q1016 | resolveId | train | function resolveId(details, filepath) {
let id = '';
if ('string' == typeof filepath) {
// Only version if more than one package
const version = details.id.includes(versionDelimiter) ? versionDelimiter + details.version : '';
const versioned = (id, stripExtension) => {
// Strip extension
if (stripExtension) id = id.replace(path.extname(id), '');
return (process.platform == 'win32' ? id.replace(/\\/g, '/') : id) + version;
};
// Resolve aliases
id = alias.resolve(filepath, details.aliases);
// Ignore disabled (false)
id = id || filepath;
// Return if resolved id
if (!isFilepath(id)) return versioned(id, false);
// Resolve alias to id (also handles main => id)
id = alias.resolveReverse(id, details.aliases);
// Return if resolved id
if (!isFilepath(id)) return versioned(id, false);
// Resolve ids from project root if nested project package
const pkgpath = details.isNestedProjectPackage
? process.cwd()
: // Resolve ids from node_modules root if npm package
details.isNpmPackage ? details.dirname : details.pkgpath;
[...details.paths, pkgpath].some(sourcepath => {
if (filepath.includes(sourcepath)) {
id = path.relative(sourcepath, filepath);
return true;
}
});
return versioned(id, true);
}
return id;
} | javascript | {
"resource": ""
} |
q1017 | resolveNodeModules | train | function resolveNodeModules(pkgpath) {
let dir = pkgpath;
let dirs = [];
let depth = maxFileSystemDepth;
let parent;
let nodeModulespath;
while (true) {
parent = path.dirname(dir);
// Stop if we hit max file system depth or root
// Convert to lowercase to fix problems on Windows
if (!--depth || parent.toLowerCase() === dir.toLowerCase()) {
break;
}
nodeModulespath = path.resolve(dir, 'node_modules');
if (exists(nodeModulespath)) dirs.push(nodeModulespath);
// Walk
dir = parent;
}
return dirs;
} | javascript | {
"resource": ""
} |
q1018 | _gpfIsImplementedBy | train | function _gpfIsImplementedBy (inspectedObject, interfaceDefinition) {
var member,
memberReference,
memberValue,
memberType;
/*
* IMPORTANT note: we test the object itself (i.e. own members and the prototype).
* That's why the hasOwnProperty is skipped
*/
/*jslint forin:true*/
for (member in interfaceDefinition.prototype) {
if ("constructor" === member) { // Object
continue;
}
memberReference = interfaceDefinition.prototype[member];
memberValue = inspectedObject[member];
memberType = typeof memberValue;
if (typeof memberReference !== memberType) {
return false;
}
if ("function" === memberType && memberReference.length !== memberValue.length) {
return false;
}
}
return true;
} | javascript | {
"resource": ""
} |
q1019 | _wrapQueryInterface | train | function _wrapQueryInterface (orgQueryInterface) {
return function (interfaceDefinition) {
/*eslint-disable no-invalid-this*/
_gpfIgnore(interfaceDefinition);
var result = _queryInterface.apply(this, arguments);
if (null === result) {
result = orgQueryInterface.apply(this, arguments);
}
return result;
/*eslint-enable no-invalid-this*/
};
} | javascript | {
"resource": ""
} |
q1020 | generatePathString | train | function generatePathString(paths) {
let pathString = '';
if (!paths || !paths.length) return pathString;
if (paths.length > 1) {
pathString = paths.map(pathItem => filepathName(pathItem));
// Trim long lists
if (pathString.length > maxInputStringLength) {
const remainder = pathString.length - maxInputStringLength;
pathString = `${pathString
.slice(0, maxInputStringLength)
.join(', ')} ...and ${remainder} other${remainder > 1 ? 's' : ''}`;
} else {
pathString = pathString.join(', ');
}
} else {
pathString = filepathName(paths[0]);
}
return pathString;
} | javascript | {
"resource": ""
} |
q1021 | loadPluginsForType | train | function loadPluginsForType(type, options, version, compress) {
// Start with default if available
let plugins = type in allPlugins && allPlugins[type].default ? allPlugins[type].default.slice() : [];
// Add plugins based on version presets
plugins = version.reduce((plugins, preset) => {
let presetPlugins;
if ('string' == typeof preset) {
preset = preset.toLowerCase();
// Ignore generic
if (RE_GENERIC_VERSION.test(preset)) return plugins;
// Skip if babel version and type is postcss
if (type == 'postcss' && preset in allPlugins.babel) return plugins;
presetPlugins = allPlugins[type][preset];
// Try and parse with browserslist if no match
if (!presetPlugins) preset = { browsers: [preset] };
}
// Handle object ({ chrome: 5 }, { browsers: ['last 3'] })
if (!presetPlugins && 'string' != typeof preset) {
const key = Object.keys(preset)[0];
const value = preset[key];
if (key == 'browsers' && Array.isArray(value)) {
if (type == 'postcss') {
// Add Autoprefixer and pass-through
presetPlugins = [['autoprefixer', preset]];
} else if (type == 'babel') {
try {
// Add Babel plugins based on Autoprefixer-style config
presetPlugins = resolvePluginsForBrowsers(
browserslist(value).map(browser => {
const [name, version] = browser.split(' ');
return { [name]: version };
})
);
} catch (err) {
/* invalid browserslist value */
}
}
} else {
// See if concated key+value exists already
presetPlugins =
allPlugins[type][(key + value).toLowerCase()] || (type == 'babel' && resolvePluginsForBrowsers(preset));
}
}
if (!presetPlugins) warn(`unable to resolve plugins for ${strong(preset)} version`, 1);
return unique(plugins.concat(presetPlugins || []));
}, plugins);
// Add compression plugins
if (compress && type in allPlugins && allPlugins[type].compress) {
plugins.push(...allPlugins[type].compress);
}
// Add plugins defined in build (add before current plugins, but preserve order)
for (let i = options.plugins.length - 1; i >= 0; i--) {
const plugin = options.plugins[i];
const pluginName = Array.isArray(plugin) ? plugin[0] : plugin;
let exists = false;
plugins.some((existingPlugin, idx) => {
const existingPluginName = Array.isArray(existingPlugin) ? existingPlugin[0] : existingPlugin;
// Overwrite if exists
if (pluginName == existingPluginName) {
plugins[idx] = plugin;
exists = true;
}
return exists;
});
if (!exists) plugins.unshift(plugin);
}
options.plugins = plugins;
// Store hash of plugin names
options.fingerprint = md5(JSON.stringify(options));
// Install missing dependencies
dependencies.install(extractDependencyIds(options));
resolveDependencyPaths(options);
} | javascript | {
"resource": ""
} |
q1022 | extractDependencyIds | train | function extractDependencyIds(options) {
const dependencies = [];
function extract(items) {
// Invalid if not Array
if (Array.isArray(items)) {
items.reduce((dependencies, item) => {
// Items can be Array with depedency as first param
const dep = Array.isArray(item) ? item[0] : item;
// Only gather string references, not functions/modules
if ('string' == typeof dep) dependencies.push(dep);
return dependencies;
}, dependencies);
}
}
if (options.plugins) extract(options.plugins);
if (options.presets) extract(options.presets);
return dependencies;
} | javascript | {
"resource": ""
} |
q1023 | resolveDependencyPaths | train | function resolveDependencyPaths(options) {
function init(items) {
// Invalid if not Array
if (Array.isArray(items)) {
items.forEach((item, idx, items) => {
const isArray = Array.isArray(item);
const id = isArray ? item[0] : item;
// Ignore already resolved
if ('string' == typeof id) {
const filepath = dependencies.find(id);
if (!filepath) return warn(`unable to load plugin ${strong(id)}`, 1);
if (isArray) {
item[0] = require(filepath);
} else {
items[idx] = require(filepath);
}
}
});
}
}
if (options.plugins) init(options.plugins);
if (options.presets) init(options.presets);
} | javascript | {
"resource": ""
} |
q1024 | resolvePluginsForBrowsers | train | function resolvePluginsForBrowsers(browsers) {
const plugins = [];
if (!Array.isArray(browsers)) browsers = [browsers];
browsers.forEach(browser => {
const name = Object.keys(browser)[0];
const version = browser[name];
for (const pluginName in babelPluginsByEnvironmentVersion) {
if (
!babelPluginsByEnvironmentVersion[pluginName][name] ||
babelPluginsByEnvironmentVersion[pluginName][name] > version
) {
plugins.push(`babel-plugin-${pluginName}`);
}
}
});
return plugins;
} | javascript | {
"resource": ""
} |
q1025 | _send | train | function _send(sync, messages, metaConnect, extraPath) {
// We must be sure that the messages have a clientId.
// This is not guaranteed since the handshake may take time to return
// (and hence the clientId is not known yet) and the application
// may create other messages.
for (var i = 0; i < messages.length; ++i) {
var message = messages[i];
var messageId = message.id;
if (_clientId) {
message.clientId = _clientId;
}
message = _applyOutgoingExtensions(message);
if (message !== undefined && message !== null) {
// Extensions may have modified the message id, but we need to own it.
message.id = messageId;
messages[i] = message;
} else {
delete _callbacks[messageId];
messages.splice(i--, 1);
}
}
if (messages.length === 0) {
return;
}
var url = _cometd.getURL();
if (_config.appendMessageTypeToURL) {
// If url does not end with '/', then append it
if (!url.match(/\/$/)) {
url = url + '/';
}
if (extraPath) {
url = url + extraPath;
}
}
var envelope = {
url: url,
sync: sync,
messages: messages,
onSuccess: function(rcvdMessages) {
try {
_handleMessages.call(_cometd, rcvdMessages);
} catch (x) {
_cometd._info('Exception during handling of messages', x);
}
},
onFailure: function(conduit, messages, failure) {
try {
var transport = _cometd.getTransport();
failure.connectionType = transport ? transport.getType() : "unknown";
_handleFailure.call(_cometd, conduit, messages, failure);
} catch (x) {
_cometd._info('Exception during handling of failure', x);
}
}
};
_cometd._debug('Send', envelope);
_transport.send(envelope, metaConnect);
} | javascript | {
"resource": ""
} |
q1026 | _endBatch | train | function _endBatch() {
--_batch;
_cometd._debug('Ending batch, depth', _batch);
if (_batch < 0) {
throw 'Calls to startBatch() and endBatch() are not paired';
}
if (_batch === 0 && !_isDisconnected() && !_internalBatch) {
_flushBatch();
}
} | javascript | {
"resource": ""
} |
q1027 | _connect | train | function _connect() {
if (!_isDisconnected()) {
var bayeuxMessage = {
id: _nextMessageId(),
channel: '/meta/connect',
connectionType: _transport.getType()
};
// In case of reload or temporary loss of connection
// we want the next successful connect to return immediately
// instead of being held by the server, so that connect listeners
// can be notified that the connection has been re-established
if (!_connected) {
bayeuxMessage.advice = { timeout: 0 };
}
_setStatus('connecting');
_cometd._debug('Connect sent', bayeuxMessage);
_send(false, [bayeuxMessage], true, 'connect');
_setStatus('connected');
}
} | javascript | {
"resource": ""
} |
q1028 | _handshake | train | function _handshake(handshakeProps, handshakeCallback) {
if (_isFunction(handshakeProps)) {
handshakeCallback = handshakeProps;
handshakeProps = undefined;
}
_clientId = null;
_clearSubscriptions();
// Reset the transports if we're not retrying the handshake
if (_isDisconnected()) {
_transports.reset(true);
_updateAdvice(_config.advice);
} else {
// We are retrying the handshake, either because another handshake failed
// and we're backing off, or because the server timed us out and asks us to
// re-handshake: in both cases, make sure that if the handshake succeeds
// the next action is a connect.
_updateAdvice(_cometd._mixin(false, _advice, {reconnect: 'retry'}));
}
_batch = 0;
// Mark the start of an internal batch.
// This is needed because handshake and connect are async.
// It may happen that the application calls init() then subscribe()
// and the subscribe message is sent before the connect message, if
// the subscribe message is not held until the connect message is sent.
// So here we start a batch to hold temporarily any message until
// the connection is fully established.
_internalBatch = true;
// Save the properties provided by the user, so that
// we can reuse them during automatic re-handshake
_handshakeProps = handshakeProps;
_handshakeCallback = handshakeCallback;
var version = '1.0';
// Figure out the transports to send to the server
var url = _cometd.getURL();
var transportTypes = _transports.findTransportTypes(version, _crossDomain, url);
var bayeuxMessage = {
id: _nextMessageId(),
version: version,
minimumVersion: version,
channel: '/meta/handshake',
supportedConnectionTypes: transportTypes,
advice: {
timeout: _advice.timeout,
interval: _advice.interval
}
};
// Do not allow the user to override important fields.
var message = _cometd._mixin(false, {}, _handshakeProps, bayeuxMessage);
// Save the callback.
_cometd._putCallback(message.id, handshakeCallback);
// Pick up the first available transport as initial transport
// since we don't know if the server supports it
if (!_transport) {
_transport = _transports.negotiateTransport(transportTypes, version, _crossDomain, url);
if (!_transport) {
var failure = 'Could not find initial transport among: ' + _transports.getTransportTypes();
_cometd._warn(failure);
throw failure;
}
}
_cometd._debug('Initial transport is', _transport.getType());
// We started a batch to hold the application messages,
// so here we must bypass it and send immediately.
_setStatus('handshaking');
_cometd._debug('Handshake sent', message);
_send(false, [message], false, 'handshake');
} | javascript | {
"resource": ""
} |
q1029 | retro | train | function retro(content) {
// Lex incoming markdown file
var lexed = lex(content);
// Break it into sections
var newSections = sections.split(lexed)
.map(function(section) {
// Leave non quiz sections untouched
if(!isQuiz(section)) {
return section;
}
// Convert old section to new format
return retroSection(section);
});
// Bring sections back together into a list of lexed nodes
var newLexed = sections.join(newSections);
// Render back to markdown
return render(newLexed);
} | javascript | {
"resource": ""
} |
q1030 | _gpfEnumeratorEach | train | function _gpfEnumeratorEach (enumerator, callback, eventsHandler) {
var iEnumerator = _gpfI.query(enumerator, _gpfI.IEnumerator),
process;
function end (event) {
_gpfEventsFire.call(enumerator, event, {}, eventsHandler);
}
if (1 < callback.length) {
process = function (event) {
if (gpf.events.EVENT_CONTINUE === event.type) {
if (!iEnumerator.moveNext(process)) {
return;
}
} else if (gpf.events.EVENT_STOP === event.type) {
return end(gpf.events.EVENT_STOPPED);
} else if (gpf.events.EVENT_DATA !== event.type) {
return end(event.type);
}
callback(iEnumerator.current(), process);
};
if (iEnumerator.moveNext(process)) {
callback(iEnumerator.current(), process);
}
} else {
process = function (event) {
if (gpf.events.EVENT_DATA !== event.type) {
return end(event);
}
do {
callback(iEnumerator.current());
} while (iEnumerator.moveNext(process));
};
while (iEnumerator.moveNext(process)) {
callback(iEnumerator.current());
}
}
} | javascript | {
"resource": ""
} |
q1031 | _gpfArrayEnumerator | train | function _gpfArrayEnumerator (array) {
var pos = -1;
return {
reset: function () {
pos = -1;
},
moveNext: function (eventsHandler) {
var result;
++pos;
result = pos < array.length;
if (!result && eventsHandler) {
_gpfEventsFire.call(this, _GPF_EVENT_END_OF_DATA, {}, eventsHandler);
}
return result;
},
current: function () {
return array[pos];
}
};
} | javascript | {
"resource": ""
} |
q1032 | _buildEnumeratorOnObjectArray | train | function _buildEnumeratorOnObjectArray (object) {
var attributes = new _gpfA.Map(object).filter(_gpfA.EnumerableAttribute),
members = attributes.getMembers();
return _gpfArrayEnumerator(object[members[0]]);
} | javascript | {
"resource": ""
} |
q1033 | train | function (objPrototype) {
var me = this,
statics = _gpfA.AttrConstraintAttribute,
originalAlterPrototype = statics.originalAlterPrototype,
attributes = new _gpfA.Map(me);
// Get constraints set for THIS attribute
attributes.filter(_gpfAttrConstraint).forEach(function (constraintAttributes) {
constraintAttributes.forEach(function (attribute) {
attribute._check(me, objPrototype);
});
});
// OK, call _alterPrototype
me[originalAlterPrototype](objPrototype);
} | javascript | {
"resource": ""
} |
|
q1034 | render | train | function render(lexed) {
// Options to parser
var options = Object.create(kramed.defaults);
options.renderer = renderer();
if(!lexed.links) {
lexed.links = {};
}
return kramed.parser(lexed, options);
} | javascript | {
"resource": ""
} |
q1035 | _gpfSkipPad | train | function _gpfSkipPad (text, pad) {
var idx = 0;
while (idx < text.length && -1 !== pad.indexOf(text.charAt(idx))) {
++idx;
}
return idx;
} | javascript | {
"resource": ""
} |
q1036 | _gpfFromBaseANY | train | function _gpfFromBaseANY (base, text, pad) {
var baseLength = base.length,
result = 0,
idx = _gpfSkipPad(text, pad || base.charAt(0));
while (idx < text.length) {
result = baseLength * result + base.indexOf(text.charAt(idx++));
}
return result;
} | javascript | {
"resource": ""
} |
q1037 | _gpfPow2 | train | function _gpfPow2 (n) {
var result = _gpfPow2[n];
if (result) {
return result;
}
result = _gpfComputePow2(n);
_gpfPow2[n] = result;
return result;
} | javascript | {
"resource": ""
} |
q1038 | train | function (value, length, pad) {
return _gpfToBaseANY(_gpfB16, value, {
length: length,
pad: pad
});
} | javascript | {
"resource": ""
} |
|
q1039 | train | function (value, length, pad) {
return _gpfToBaseANY(_gpfB64, value, {
length: length,
pad: pad
});
} | javascript | {
"resource": ""
} |
|
q1040 | connectUser | train | async function connectUser(form) {
if (!form.login.value || !form.password.value) {
document.getElementById('login-errors').innerHTML += `<p>Login and password are required</p>`;
return;
}
await client.setCredentials({ login: form.login.value, password: form.password.value });
client
.connect()
.then(() => {
displayMessage('Login success', 'Welcome to wonderful service', 'is-success');
goTo('home');
})
.catch((e) => {
displayMessage(
'Login failed',
'Your account is not validated, have you clicked on the link in the email ?',
'is-warning'
);
});
} | javascript | {
"resource": ""
} |
q1041 | printWeatherForecast | train | function printWeatherForecast() {
return weather
.dailyForecast('Kiev')
.then(forecast => console.log('WEATHER FORECAST:', forecast))
.catch(error => console.error(error));
} | javascript | {
"resource": ""
} |
q1042 | _class | train | function _class (Constructor, members, Base) {
var ResultConstructor;
if (Base) {
ResultConstructor = function () {
Base.apply(this, arguments);
Constructor.apply(this, arguments);
};
ResultConstructor.prototype = new Base();
} else {
ResultConstructor = function () {
Constructor.apply(this, arguments);
};
}
if (members) {
Object.keys(members).forEach(function (memberName) {
ResultConstructor.prototype[memberName] = members[memberName];
});
}
return ResultConstructor;
} | javascript | {
"resource": ""
} |
q1043 | train | function (partStatistics) {
this.count += partStatistics.count;
this.tested += partStatistics.tested;
this.ignored += partStatistics.ignored;
} | javascript | {
"resource": ""
} |
|
q1044 | train | function (count, total, rounded) {
var scale;
if (rounded) {
scale = this._0digitsScale;
} else {
scale = this._2digitsScale;
}
return Math.floor(this._percentage * scale * count / total) / scale;
} | javascript | {
"resource": ""
} |
|
q1045 | train | function (numberOfCalls, branchDefinition) {
["if", "else"].forEach(function (label, index) {
++this.count;
this._testedOrIgnored(numberOfCalls[index], branchDefinition.locations[index]);
}, this);
} | javascript | {
"resource": ""
} |
|
q1046 | train | function (fileName) {
var result = new _File(fileName),
fileData = this._data[fileName];
[{
type: "statements",
data: "s",
map: "statementMap"
}, {
type: "functions",
data: "f",
map: "fnMap"
}, {
type: "branches",
data: "b",
map: "branchMap"
}].forEach(function (part) {
var map = fileData[part.map],
data = fileData[part.data],
statistics = result[part.type],
index = 1;
while (undefined !== data[index]) {
statistics.processCoverage(data[index], map[index]);
++index;
}
});
return result;
} | javascript | {
"resource": ""
} |
|
q1047 | train | function () {
this._files = {};
this._global = new _File();
Object.keys(this._data).forEach(function (fileName) {
var fileCoverage = this._computeFileCoverage(fileName);
this._files[fileCoverage.name] = fileCoverage;
this._global.statements.add(fileCoverage.statements);
this._global.functions.add(fileCoverage.functions);
this._global.branches.add(fileCoverage.branches);
}, this);
} | javascript | {
"resource": ""
} |
|
q1048 | find | train | function find(id) {
let filepath = '';
if ('string' == typeof id) {
try {
// Resolve relative to buddy package
filepath = require.resolve(id);
} catch (err) {
// Resolve relative to project package
filepath = resolve(path.resolve('package.json'), id);
}
}
return filepath;
} | javascript | {
"resource": ""
} |
q1049 | install | train | function install(ids) {
if (!ids || !ids.length) return;
const missingDependencies = ids.filter(id => find(id) == '');
if (missingDependencies.length) {
try {
const cmd = useNPM
? `npm --save-dev --save-exact install ${missingDependencies.join(' ')}`
: `yarn add --dev --exact ${missingDependencies.join(' ')}`;
print('installing the following missing dependencies:', 0);
missingDependencies.forEach(id => {
print(strong(id), 1);
});
exec(cmd);
} catch (err) {
error(err);
}
}
} | javascript | {
"resource": ""
} |
q1050 | _filter | train | function _filter (node, expr, resultSet) {
var
selectedNodes,
conditions,
type,
idx,
condition;
if (expr.and) {
conditions = expr.and;
type = 0;
} else if (expr.or) {
conditions = expr.or;
type = 1;
}
for (idx = 0; idx < conditions.length; ++idx) {
condition = conditions[idx];
if (condition.and || condition.or) {
selectedNodes = [];
_filter(node, condition, selectedNodes);
} else {
selectedNodes = _select(node, condition);
}
if (0 === type && selectedNodes.length === 0) {
return;
}
if (1 === type && selectedNodes.length !== 0) {
resultSet.push(node);
return;
}
}
if (0 === type) {
resultSet.push(node);
}
} | javascript | {
"resource": ""
} |
q1051 | _select | train | function _select (node, expr) {
var
resultSet,
nodeSet = [node];
while (expr) {
resultSet = [];
_test(nodeSet, expr, resultSet);
if (0 === resultSet.length) {
return [];
}
nodeSet = resultSet;
if (expr.filter) {
resultSet = [];
_each(nodeSet, _filter, expr.filter, resultSet);
if (0 === resultSet.length) {
return [];
}
nodeSet = resultSet;
}
expr = expr.then;
}
return resultSet;
} | javascript | {
"resource": ""
} |
q1052 | _gpfDefineCore | train | function _gpfDefineCore (name, Super, definition) {
var NewClass = _gpfDefineFactory(name, Super, definition);
_gpfDefineUpdateContext(name, NewClass);
return NewClass;
} | javascript | {
"resource": ""
} |
q1053 | _gpfDefineProcessParamsAndCallCore | train | function _gpfDefineProcessParamsAndCallCore (params, processFunction) {
processFunction("", Object, params);
return _gpfDefineCore.apply(null, params);
} | javascript | {
"resource": ""
} |
q1054 | parseLine | train | function parseLine(line) {
let args, mention, commandText;
if (new RegExp(`^@${forum.username}\\s\\S{3,}(\\s|$)`, 'i').test(line)) {
args = line.split(/\s+/);
args.shift();
commandText = args.shift();
mention = true;
} else if (/^!\w\S{2,}(\s|$)/.test(line)) {
args = line.split(/\s+/);
commandText = args.shift().substring(1);
mention = false;
}
if (commandText) {
return {
commandText: commandText,
command: commandText.toLowerCase(),
args: args,
line: line,
mention: mention
};
}
return null;
} | javascript | {
"resource": ""
} |
q1055 | onComplete | train | function onComplete(commands) {
const content = commands.commands.map((command) => command.replyText)
.filter((text) => (text || '').trim())
.join('\n\n---\n\n');
if (!content) {
return Promise.resolve();
}
return commands._replyFn(content);
} | javascript | {
"resource": ""
} |
q1056 | onError | train | function onError(reason, commands) {
if (typeof reason !== 'string' && typeof reason.message === 'string') {
reason = reason.message;
}
return commands._replyFn(`An unexpected error \`${reason}\` occured and your commands could not be processed!`);
} | javascript | {
"resource": ""
} |
q1057 | defaultHandler | train | function defaultHandler(command) {
debug(`executing default handler for unrecognized command ${command.commandText}`);
if (!command.mention) {
command.reply(`Command \`${command.command}\` is not recognized`);
}
return Promise.resolve();
} | javascript | {
"resource": ""
} |
q1058 | cmdHelp | train | function cmdHelp(command) {
let ext = '';
if (command.args && command.args.length > 0) {
ext = command.args.join(' ');
}
if (ext && helpTopics[ext]) {
const txt = `Help topic for \`${ext}\`\n\n${helpTopics[ext]}` +
'\n\nIssue the `help` command without any parameters to see all available commands';
command.reply(txt);
} else {
const help = `${getCommandHelps()}\n\n\\* Help topic available.\n\nIssue the \`help\` command with an ` +
'available help topic as a parameter to read additonal help';
command.reply(help);
}
return Promise.resolve();
} | javascript | {
"resource": ""
} |
q1059 | getCommandHelps | train | function getCommandHelps() {
const cmds = {},
topics = {},
result = ['Registered commands:'];
let keys = {};
Object.keys(handlers).map((key) => {
keys[key] = 1;
});
Object.keys(helpTopics).map((key) => {
keys[key] = 1;
});
Object.keys(keys).map((key) => {
if (handlers[key]) {
cmds[key] = handlers[key].help;
if (helpTopics[key]) {
cmds[key] += ' *';
}
} else {
topics[key] = 'Extended help topic';
}
});
keys = Object.keys(cmds);
keys.sort();
keys.forEach((cmd) => result.push(`${cmd}: ${cmds[cmd]}`));
keys = Object.keys(topics);
if (keys.length) {
result.push('');
result.push('Help Topics:');
keys.sort();
keys.forEach((topic) => result.push(`${topic}: ${topics[topic]}`));
}
return result.join('\n');
} | javascript | {
"resource": ""
} |
q1060 | checkAvailable | train | function checkAvailable(map, command, logType, logMsg) {
if (map[command]) {
const prefix = logType === 'error' ? 'ERROR' : 'WARNING';
forum.emit(logType, `${prefix}, ${command} is already registered: ${logMsg}`);
return false;
}
return true;
} | javascript | {
"resource": ""
} |
q1061 | threeParts | train | function threeParts(before, item1, defaultItem1, middle, item2, after) {
item2 = stringify(item2);
item1 = stringify(item1);
if (!item2) {
return '';
}
return before + (item1 || defaultItem1) + middle + item2 + after;
} | javascript | {
"resource": ""
} |
q1062 | train | function (state, char) {
gpf.interfaces.ignoreParameter(state);
gpf.interfaces.ignoreParameter(char);
gpf.Error.abstract();
// return -1;
} | javascript | {
"resource": ""
} |
|
q1063 | train | function (char, chars) {
var
first,
last;
if ("^" === char) {
this._exc = [];
} else if ("]" === char) {
if (this._inRange) {
gpf.Error.patternInvalidSyntax();
}
return true;
} else if ("-" === char) {
if (this._inRange || 0 === chars.length) {
gpf.Error.patternInvalidSyntax();
}
this._inRange = true;
} else {
if (this._inRange) {
first = chars[chars.length - 1].charCodeAt(0);
last = char.charCodeAt(0);
while (--last > first) {
chars.push(String.fromCharCode(last));
}
chars.push(char);
delete this._inRange;
} else {
// First char of a range
chars.push(char);
}
}
return false;
} | javascript | {
"resource": ""
} |
|
q1064 | train | function (pos) {
if (this._choice) {
if (undefined === pos) {
pos = this._items.length - 1;
}
return this._items[pos];
}
return this._items;
} | javascript | {
"resource": ""
} |
|
q1065 | train | function (char) {
var
parsedItem = this._parsedItem,
result;
if (parsedItem) {
result = parsedItem.parse(char);
if (bitTest(result, PatternItem.PARSE_END_OF_PATTERN)) {
parsedItem.finalize();
this._parsedItem = null;
// Remove the flag
result = bitClear(result,
PatternItem.PARSE_END_OF_PATTERN);
}
} else {
result = 0;
}
return result;
} | javascript | {
"resource": ""
} |
|
q1066 | train | function (char) {
var
parsedItem = this._lastItem();
if ("*" === char) {
parsedItem._min = 0;
parsedItem._max = 0;
} else if ("+" === char) {
parsedItem._max = 0;
} else if ("?" === char) {
parsedItem._min = 0;
}
return PatternItem.PARSE_PROCESSED;
} | javascript | {
"resource": ""
} |
|
q1067 | train | function (items) {
var
idx;
idx = items.length;
while (idx--) {
if (0 !== items[idx].min()) {
++idx;
break;
}
}
return idx;
} | javascript | {
"resource": ""
} |
|
q1068 | train | function (item, state) {
state.count = 0;
state.sub = {};
item.reset(state.sub);
} | javascript | {
"resource": ""
} |
|
q1069 | train | function (item, state, char) {
if (state.count < item.min() // Not enough match
// or at least two characters went through
|| state.length > state.matchingLength + 1) {
// Terminal error
return PatternItem.WRITE_NO_MATCH;
}
item = this._getItem(state, state.index + 1);
if (null === item) {
return PatternItem.WRITE_NO_MATCH;
}
++state.index;
this._reset(item, state);
return this.write(state, char); // Try with this one
} | javascript | {
"resource": ""
} |
|
q1070 | train | function (item, state) {
var
nextItem = this._getItem(state, state.index + 1),
optional;
if (this._choice && -1 < state.choice) {
optional = this._optionals[state.choice];
} else {
optional = this._optionals[0];
}
++state.count;
if (0 === item.max()) {
// Unlimited
this._reset(item, state);
if (null !== nextItem && optional > state.index) {
return PatternItem.WRITE_NEED_DATA;
} else {
// Last (or equivalent) so...
return PatternItem.WRITE_MATCH;
}
} else if (state.count === item.max()) {
if (null === nextItem) {
return PatternItem.WRITE_FINAL_MATCH;
}
++state.index;
this._reset(nextItem, state);
if (optional <= state.index) {
return PatternItem.WRITE_MATCH;
}
}
return PatternItem.WRITE_NEED_DATA;
} | javascript | {
"resource": ""
} |
|
q1071 | train | function (pattern) {
var
parser = new PatternParser();
parser.parse(pattern, null);
this._patternItem = parser.patternItem();
} | javascript | {
"resource": ""
} |
|
q1072 | _gpfNodeBuffer2JsArray | train | function _gpfNodeBuffer2JsArray (buffer) {
var result = [],
len = buffer.length,
idx;
for (idx = 0; idx < len; ++idx) {
result.push(buffer.readUInt8(idx));
}
return result;
} | javascript | {
"resource": ""
} |
q1073 | train | function (statusCode, text) {
var resp = this._response;
resp.writeHead(statusCode, {"Content-Type": "text/plain"});
resp.write([
"port : " + this._options.port,
"method : " + this._request.method,
"url : " + this._request.url,
"root : " + this._options.root,
"path : " + this._filePath,
"headers : "
+ JSON.stringify(this._request.headers, null, "\t\t"),
text
].join("\n"));
resp.end();
} | javascript | {
"resource": ""
} |
|
q1074 | train | function (filePath) {
var
me = this,
extName = _path.extname(filePath).toLowerCase(),
size,
stream;
_fs.stat(filePath, function (err, stats) {
var mimeType;
if (err) {
me._response.plain(500,
"Unable to access file (" + err + ")");
return;
}
if (stats.isDirectory()) {
me._response.plain(200, "Directory.");
return;
} else if (!stats.isFile()) {
me._response.plain(200, "Not a file.");
return;
}
size = stats.size;
mimeType = gpf.http.getMimeType(extName);
if (me._options.verbose) {
console.log("\tMime type : " + mimeType);
console.log("\tFile size : " + size);
}
me._response.writeHead(200, {
"content-type": mimeType,
"content-length": size
});
stream = _fs.createReadStream(filePath);
//stream.on("data", function (chunk) {
// if (!me._response.write(chunk)) {
// stream.pause();
// me._response.once("drain", function () {
// stream.resume();
// });
// }
//});
stream.on("end", function () {
if (me._options.verbose) {
console.log("\tEnd t+: "
+ ((new Date()) - me._startTimeStamp)
+ "ms");
}
me._response.statusCode = 200;
me._response.end();
});
stream.pipe(me._response);
});
} | javascript | {
"resource": ""
} |
|
q1075 | train | function (input, encoding) {
var module = _gpfEncodings[encoding];
if (undefined === module) {
gpf.Error.encodingNotSupported();
}
return new EncoderStream(module[0], input);
} | javascript | {
"resource": ""
} |
|
q1076 | _gpfPathMatchApply | train | function _gpfPathMatchApply (pathMatcher) {
/*jshint validthis:true*/
if (pathMatcher.match(this.parts)) {
this.result = !pathMatcher.negative;
return false; // Stop the main loop
}
return _gpfPathMatchAfterApplyNonMatching.call(this, pathMatcher);
} | javascript | {
"resource": ""
} |
q1077 | _gpfPathMatch | train | function _gpfPathMatch (pattern, path) {
var parts = _gpfPathDecompose(path),
matchers = _gpfPathMatchCompilePatterns(pattern),
scope = {
parts: parts
};
matchers.every(_gpfPathMatchApply, scope);
return scope.result;
} | javascript | {
"resource": ""
} |
q1078 | train | function (context) {
var parts = context.parts,
partsLen = parts.length,
startPos = context.startPos,
array = this.start,
len = array.length,
idx;
for (idx = 0; idx < len; ++idx) {
if (this._matchName(array[idx], parts[startPos])) {
if (++startPos >= partsLen) {
// Match if last part of the start and no end
if (idx === len - 1 && !this.end) {
return _GPF_PATHMATCH_OK;
}
return _GPF_PATHMATCH_KO;
}
} else {
return _GPF_PATHMATCH_KO;
}
}
context.startPos = startPos;
return _GPF_PATHMATCH_UNKNOWN;
} | javascript | {
"resource": ""
} |
|
q1079 | train | function (context) {
var parts = context.parts,
startPos = context.startPos,
endPos = parts.length - 1,
array = this.end,
len = array.length,
idx;
for (idx = 0; idx < len; ++idx) {
if (-1 < endPos && this._matchName(array[idx], parts[endPos])) {
if (endPos-- < startPos) {
return _GPF_PATHMATCH_KO;
}
} else {
return _GPF_PATHMATCH_KO;
}
}
return _GPF_PATHMATCH_UNKNOWN;
} | javascript | {
"resource": ""
} |
|
q1080 | train | function (parts) {
var result,
context = {
parts: parts,
startPos: 0
};
result = this._matchStart(context) || this._matchEnd(context);
return result !== _GPF_PATHMATCH_KO;
} | javascript | {
"resource": ""
} |
|
q1081 | renameRootDeclarations | train | function renameRootDeclarations(path, namespace) {
const { scope } = path;
const oldName = path.node.name;
const rootScope = scope.getProgramParent();
const isRootScope = scope === rootScope;
const newName = `${namespace}${oldName}`;
let binding = scope.getBinding(oldName);
if (binding) {
if (!path.isReferenced() && shouldRenameDeclaration(oldName, path, binding, rootScope)) {
path.node.name = newName;
if (!isRootScope) {
const declarationParent = getDeclarationParent(path);
// Function declaration defines own scope, so switch to parent
if (declarationParent.isFunctionDeclaration()) {
binding = declarationParent.scope.parent.getBinding(oldName);
}
}
// Handle references
if (binding.referenced) {
binding.referencePaths.forEach(path => {
path.node.name = newName;
});
}
}
}
} | javascript | {
"resource": ""
} |
q1082 | shouldRenameDeclaration | train | function shouldRenameDeclaration(name, path, binding, rootScope) {
const isRootScope = path.scope === rootScope;
const isGlobal = isRootScope && name in rootScope.globals;
const program = rootScope.path;
if (isGlobal) return false;
if (!isRootScope) {
const functionParent = path.getFunctionParent();
const declarationParent = getDeclarationParent(path);
// Bail if not a declaration or is property/key of object
if (!declarationParent || isPropertyOrKey(path)) return false;
if (declarationParent.isBlockScoped()) {
// Handle function declaration (which defines it's own scope)
if (declarationParent.isFunctionDeclaration()) {
return declarationParent.parentPath.scope === rootScope && declarationParent.node.id === path.node;
}
// Skip let/const in block scope
return false;
// Handle re-assignment of root bound declaration (ignore function expressions)
} else if (declarationParent.isAssignmentExpression() && !path.parentPath.isFunctionExpression()) {
const declarationBinding = declarationParent.scope.getBinding(name);
return declarationBinding ? declarationBinding.scope === rootScope : false;
// Skip if in function scope
} else if (functionParent !== program) {
return false;
}
}
// Skip if property or key of object
return !isPropertyOrKey(path);
} | javascript | {
"resource": ""
} |
q1083 | getDeclarationParent | train | function getDeclarationParent(path) {
do {
if (
path.isFunctionDeclaration() ||
path.isVariableDeclaration() ||
path.isClassDeclaration() ||
path.isAssignmentExpression()
) {
return path;
}
} while ((path = path.parentPath));
} | javascript | {
"resource": ""
} |
q1084 | isPropertyOrKey | train | function isPropertyOrKey(path) {
return path.parentPath.get('key') === path || path.parentPath.get('property') === path;
} | javascript | {
"resource": ""
} |
q1085 | transform | train | function transform(str, from, to) {
let out = '';
const escaped = '\\' + to;
for (let i = 0; i < str.length; i++) {
if (str[i] === to) {
out += escaped;
} else if (str[i] === from) {
out += to;
} else if (str[i] === '\\' && i + 1 < str.length && str[i + 1] === from) {
out += from;
i++;
} else {
out += str[i];
}
}
return out;
} | javascript | {
"resource": ""
} |
q1086 | keys | train | function keys(path, opts) {
let env = toUnderscore(path);
if (!opts.caseSensitive) {
env = env.toUpperCase();
return Object.keys(process.env).filter(key =>
key.toUpperCase().startsWith(env)
);
}
return Object.keys(process.env).filter(key => key.startsWith(env));
} | javascript | {
"resource": ""
} |
q1087 | get | train | function get(path, defaultValue, opts) {
let obj;
const args = [].slice.call(arguments);
path = args.shift();
if (typeof args[args.length - 1] === 'object') {
opts = args.pop();
} else {
opts = {};
}
defaultValue = args.pop();
keys(path, opts)
.sort((a, b) => a.length - b.length)
.forEach(key => {
let dotp = toDot(key, opts);
if (!opts.caseSensitive) {
dotp = dotp.toLowerCase();
}
const val = parse(process.env[key], opts);
if (dotp === '') {
obj = val;
} else {
if (typeof obj !== 'object') {
obj = {};
}
dotProp.set(obj, dotp, val);
}
});
let prefix = path;
if (!opts.caseSensitive) {
prefix = prefix.toLowerCase();
}
if (path === '') {
return obj;
}
return dotProp.get(obj, prefix, defaultValue);
} | javascript | {
"resource": ""
} |
q1088 | set | train | function set(path, value, opts) {
if (typeof opts === 'undefined') {
opts = {};
}
let env = toUnderscore(path);
if (!opts.caseSensitive) {
env = env.toUpperCase();
}
del(path, opts);
process.env[env] = stringify(value, opts);
} | javascript | {
"resource": ""
} |
q1089 | del | train | function del(path, opts) {
if (typeof opts === 'undefined') {
opts = {};
}
keys(path, opts).forEach(key => delete process.env[key]);
} | javascript | {
"resource": ""
} |
q1090 | copyFiles | train | function copyFiles (inSrc, outSrc, files) {
return new Promise((res, rej) => {
for (const file of files) {
copySync(`./${inSrc}/${file}`, `./${outSrc}/${file}`);
}
res();
});
} | javascript | {
"resource": ""
} |
q1091 | checkModule | train | function checkModule(pth, cb) {
checkStrider(pth, function(err, config){
if (err) return cb(err);
if (config){
config.dir = pth;
return cb(null, config);
}
checkPackageJson(pth, function(err, config){
if (err) return cb(err);
if (config){
config.dir = pth;
return cb(null, config);
}
return cb(null, false);
});
});
} | javascript | {
"resource": ""
} |
q1092 | readDirAbs | train | function readDirAbs(dir, cb) {
fs.readdir(dir, function(err, entries) {
if (err || !entries) {
return cb(err, null);
}
var items = [];
entries.forEach(function(entry) {
items.push(path.join(dir, entry));
});
return cb(null, items);
});
} | javascript | {
"resource": ""
} |
q1093 | readDirsParallel | train | function readDirsParallel(dirs, cb) {
var funcs = [];
dirs.forEach(function(dir) {
funcs.push(readDirAbs.bind(null, dir));
});
async.parallel(funcs, function(err, results) {
if (err) {
return cb(err, null);
}
// Flatten results and return
var flat = [].concat.apply([], results);
cb(null, flat);
}
);
} | javascript | {
"resource": ""
} |
q1094 | readDirs | train | function readDirs(dir, cb) {
// find top-level module dirs
if (Array.isArray(dir)) {
// dir is a list of paths
readDirsParallel(dir, cb);
} else {
// dir is a single path value
readDirAbs(dir, cb);
}
} | javascript | {
"resource": ""
} |
q1095 | factory | train | function factory(pkg, location) {
const isProd = process.env.NODE_ENV === "production";
return [
configure(pkg, location, "development", "module"),
isProd && configure(pkg, location, "development", "umd"),
isProd && configure(pkg, location, "production", "umd")
].filter(Boolean);
} | javascript | {
"resource": ""
} |
q1096 | train | function (dirs, done) {
var self = this;
utils.findExtensions(dirs, function (err, extensions) {
if (err) return done(err);
for (var i = 0; i < extensions.length; i++) {
extensions[i].type = extensions[i].type || 'basic';
extensions[i].id = extensions[i].id.toLowerCase();
if (RESERVED.indexOf(extensions[i].id) !== -1) {
return done(new Error('Extension id "' + extensions[i].id + '" is reserved. Your plugins are misconfigured.'));
}
if (self.ids[extensions[i].id]) {
// XXX should we die hard, ignore, or warn?
return done(new Error('Duplicate extension id! Your plugins are misconfigured.'));
}
self.ids[extensions[i].id] = true;
self.extensions[extensions[i].type][extensions[i].id] = extensions[i];
}
done();
});
} | javascript | {
"resource": ""
} |
|
q1097 | train | function( a, b, aParent, bParent, parentProp, compares, options ){
var bType = typeof b;
var hasAdditionalProp = false;
if(bType === 'object' || bType === 'function') {
var aCopy = assign({}, a);
if(options.deep === false) {
options.deep = -1;
}
// Check that everything in B is the same as whats in A, or
// isn't in A.
for (var prop in b) {
var compare = compares[prop] === undefined ? compares['*'] : compares[prop];
// run the comparison no matter what
var compareResult = loop(a[prop], b[prop], a, b, prop, compare, options );
// if there wasn't a prop (and we didn't run through a compare)
if(compareResult === h.ignoreType) {
// do nothing
} else if(!(prop in a) || options.performedDifference ) {
hasAdditionalProp = true;
} else if(!compareResult) {
return false;
}
delete aCopy[prop];
}
// go through aCopy props ... if there is no compare .. return false
for (prop in aCopy) {
if (compares[prop] === undefined || !loop(a[prop], undefined, a, b, prop, compares[prop], options) ) {
return false;
}
}
return hasAdditionalProp;
}
} | javascript | {
"resource": ""
} |
|
q1098 | train | function(a, b, aParent, bParent, prop, compares, options){
// if everything is the same OR doesn't have a property on the left or right (only)
// and union values
options.result = {};
options.performedUnion = 0;
options.checks = [
compareHelpers.unionComparesType,
addToResult(compareHelpers.equalBasicTypes, "equalBasicTypes"),
addToResult(compareHelpers.unionArrayLike, "unionArrayLike"),
addResultsToNewObject(compareHelpers.unionObject, "unionObject")
];
options.getUnions = [];
options["default"] = false;
var res = loop(a, b, aParent, bParent, prop, compares, options);
if(res === true) {
return options.result;
}
return false;
} | javascript | {
"resource": ""
} |
|
q1099 | train | function(depName, depLoad){
var parsed = baseHelpers.parseModuleName(depLoad.name);
var res;
if( parsed.packageName !== "can-util" ) {
res = baseNormalize.apply(this, arguments);
} else {
res = "set-"+parsed.packageName+"/"+parsed.modulePath
}
return res;
} | javascript | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.