_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q1100
|
concatUnique
|
train
|
function concatUnique(aItems, bItems, algebra) {
var idTree = {};
var aSet;
// IE 9 and 10 don't have Set.
if(typeof Set !== "undefined") {
aSet = new Set(); // jshint ignore:line
}
aItems.forEach(function(item) {
var keyNode = idTree;
if(aSet) {
aSet.add(item);
}
each(algebra.clauses.id, function(prop) {
var propVal = getProp(item, prop);
if(keyNode && typeof propVal !== "undefined") {
keyNode = keyNode[propVal] = keyNode[propVal] || {};
} else {
keyNode = undefined;
}
});
});
return aItems.concat(bItems.filter(function(item) {
var keyNode = idTree;
if(aSet && aSet.has(item)) {
return false;
}
// IE9/10 case
if(!aSet && aItems.indexOf(item) > -1) {
return false;
}
each(algebra.clauses.id, function(prop) {
keyNode = keyNode && keyNode[getProp(item, prop)];
});
return keyNode === idTree || !keyNode;
}));
}
|
javascript
|
{
"resource": ""
}
|
q1101
|
train
|
function(){
var clauses = this.clauses = {
where: {},
order: {},
paginate: {},
id: {}
};
this.translators = {
where: new Translate("where", {
fromSet: function(set, setRemainder){
return setRemainder;
},
toSet: function(set, wheres){
return assign(set, wheres);
}
})
};
var self = this;
each(arguments, function(arg) {
if(arg) {
if(arg instanceof Translate) {
self.translators[arg.clause] = arg;
} else {
assign(clauses[arg.constructor.type || 'where'], arg);
}
}
});
}
|
javascript
|
{
"resource": ""
}
|
|
q1102
|
train
|
function(aClauses, bClauses) {
var self = this;
var differentTypes = [];
each(clause.TYPES, function(type) {
if( !self.evaluateOperator(compare.equal, aClauses[type], bClauses[type], {isProperties: true},{isProperties:true}) ) {
differentTypes.push(type);
}
});
return differentTypes;
}
|
javascript
|
{
"resource": ""
}
|
|
q1103
|
train
|
function(set, clause, result, useSet) {
if(result && typeof result === "object" && useSet !== false) {
if( this.translators[clause] ) {
set = this.translators.where.toSet(set, result);
} else {
set = assign(set, result);
}
return true;
}
else if(result) {
return useSet === undefined ? undefined : false;
}
else {
return false;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q1104
|
train
|
function(operator, a, b, aOptions, bOptions, evaluateOptions) {
aOptions = aOptions || {};
bOptions = bOptions || {};
evaluateOptions = assign({
evaluateWhere: operator,
evaluatePaginate: operator,
evaluateOrder: operator,
shouldEvaluatePaginate: function(aClauseProps, bClauseProps) {
return aClauseProps.enabled.paginate || bClauseProps.enabled.paginate;
},
shouldEvaluateOrder: function(aClauseProps, bClauseProps) {
return aClauseProps.enabled.order && compare.equal(aClauseProps.order, bClauseProps.order, undefined, undefined, undefined,{},{});
}
/* aClauseProps.enabled.order || bClauseProps.enabled.order */
}, evaluateOptions||{});
var aClauseProps = this.getClauseProperties(a, aOptions),
bClauseProps = this.getClauseProperties(b, bOptions),
set = {},
useSet;
var result = evaluateOptions.evaluateWhere(aClauseProps.where, bClauseProps.where,
undefined, undefined, undefined, this.clauses.where, {});
useSet = this.updateSet(set, "where", result, useSet);
// if success, and either has paginate props
if(result && evaluateOptions.shouldEvaluatePaginate(aClauseProps,bClauseProps) ) {
// if they have an order, it has to be true for paginate to be valid
// this isn't true if a < b, a is paginated, and b is not.
if( evaluateOptions.shouldEvaluateOrder(aClauseProps,bClauseProps)) {
result = evaluateOptions.evaluateOrder(aClauseProps.order, bClauseProps.order, undefined,
undefined, undefined, {}, {});
useSet = this.updateSet(set, "order", result, useSet);
}
if(result) {
result = evaluateOptions.evaluatePaginate(aClauseProps.paginate, bClauseProps.paginate,
undefined, undefined, undefined, this.clauses.paginate, {});
useSet = this.updateSet(set, "paginate", result, useSet);
}
}
// if orders are the same keep order!
else if( result && evaluateOptions.shouldEvaluateOrder(aClauseProps,bClauseProps) ) {
result = operator(aClauseProps.order, bClauseProps.order, undefined,
undefined, undefined, {}, {});
useSet = this.updateSet(set, "order", result, useSet);
}
// not checking order here makes it mean that different orders represent the same set?
return result && useSet ? set : result;
}
|
javascript
|
{
"resource": ""
}
|
|
q1105
|
train
|
function(setA, setB, property1, property2){
// p for param
// v for value
var numProps = numericProperties(setA, setB, property1, property2);
var sAv1 = numProps.sAv1,
sAv2 = numProps.sAv2,
sBv1 = numProps.sBv1,
sBv2 = numProps.sBv2,
count = sAv2 - sAv1 + 1;
var after = {
difference: [sBv2+1, sAv2],
intersection: [sAv1,sBv2],
union: [sBv1, sAv2],
count: count,
meta: "after"
};
var before = {
difference: [sAv1, sBv1-1],
intersection: [sBv1,sAv2],
union: [sAv1, sBv2],
count: count,
meta: "before"
};
// if the sets are equal
if(sAv1 === sBv1 && sAv2 === sBv2) {
return {
intersection: [sAv1,sAv2],
union: [sAv1,sAv2],
count: count,
meta: "equal"
};
}
// A starts at B but A ends later
else if( sAv1 === sBv1 && sBv2 < sAv2 ) {
return after;
}
// A end at B but A starts earlier
else if( sAv2 === sBv2 && sBv1 > sAv1 ) {
return before;
}
// B contains A
else if( within(sAv1, [sBv1, sBv2]) && within(sAv2, [sBv1, sBv2]) ) {
return {
intersection: [sAv1,sAv2],
union: [sBv1, sBv2],
count: count,
meta: "subset"
};
}
// A contains B
else if( within(sBv1, [sAv1, sAv2]) && within(sBv2, [sAv1, sAv2]) ) {
return {
intersection: [sBv1,sBv2],
// there is a difference in what A has
difference: [null, null],
union: [sAv1, sAv2],
count: count,
meta: "superset"
};
}
// setA starts earlier and overlaps setB
else if(sAv1 < sBv1 && within(sAv2, [sBv1, sBv2]) ) {
return before;
}
// setB starts earlier and overlaps setA
else if(sBv1 < sAv1 && within(sBv2, [sAv1, sAv2]) ) {
return after;
}
// side by side ... nothing intersection
else if(sAv2 === sBv1-1) {
return {
difference: [sAv1,sAv2],
union: [sAv1, sBv2],
count: count,
meta: "disjoint-before"
};
}
else if(sBv2 === sAv1 - 1) {
return {
difference: [sAv1,sAv2],
union: [sBv1, sAv2],
count: count,
meta: "disjoint-after"
};
}
if(!isNaN(count)) {
return {
count: count,
meta: "disjoint"
};
}
}
|
javascript
|
{
"resource": ""
}
|
|
q1106
|
getThreshold
|
train
|
function getThreshold(fromStep, toStep, now)
{
let threshold
// Allows custom thresholds when moving
// from a specific step to a specific step.
if (fromStep && (fromStep.id || fromStep.unit)) {
threshold = toStep[`threshold_for_${fromStep.id || fromStep.unit}`]
}
// If no custom threshold is set for this transition
// then use the usual threshold for the next step.
if (threshold === undefined) {
threshold = toStep.threshold
}
// Convert threshold to a number.
if (typeof threshold === 'function') {
threshold = threshold(now)
}
// Throw if no threshold is found.
if (fromStep && typeof threshold !== 'number') {
// Babel transforms `typeof` into some "branches"
// so istanbul will show this as "branch not covered".
/* istanbul ignore next */
const type = typeof threshold
throw new Error(`Each step of a gradation must have a threshold defined except for the first one. Got "${threshold}", ${type}. Step: ${JSON.stringify(toStep)}`)
}
return threshold
}
|
javascript
|
{
"resource": ""
}
|
q1107
|
getAllowedSteps
|
train
|
function getAllowedSteps(gradation, units)
{
return gradation.filter(({ unit }) => {
// If this step has a `unit` defined
// then this `unit` must be in the list of `units` allowed.
if (unit) {
return units.indexOf(unit) >= 0
}
// A gradation step is not required to specify a `unit`.
// E.g. for Twitter gradation it specifies `format()` instead.
return true
})
}
|
javascript
|
{
"resource": ""
}
|
q1108
|
getTimeIntervalMeasurementUnits
|
train
|
function getTimeIntervalMeasurementUnits(localeData, restrictedSetOfUnits)
{
// All available time interval measurement units.
let units = Object.keys(localeData)
// If only a specific set of available
// time measurement units can be used.
if (restrictedSetOfUnits) {
// Reduce available time interval measurement units
// based on user's preferences.
units = restrictedSetOfUnits.filter(_ => units.indexOf(_) >= 0)
}
// Stock `Intl.RelativeTimeFormat` locale data doesn't have "now" units.
// So either "now" is present in extended locale data
// or it's taken from ".second.current".
if ((!restrictedSetOfUnits || restrictedSetOfUnits.indexOf('now') >= 0) &&
units.indexOf('now') < 0) {
if (localeData.second.current) {
units.unshift('now')
}
}
return units
}
|
javascript
|
{
"resource": ""
}
|
q1109
|
toggle
|
train
|
function toggle(element, animation, callbackFn) {
var nowVisible = element.style.display != 'none' || element.offsetLeft > 0;
// create clone for reference
var clone = element.cloneNode(true);
var cleanup = function() {
element.removeAttribute('data-animated');
element.setAttribute('style', clone.getAttribute('style'));
element.style.display = nowVisible ? 'none' : '';
if( callbackFn ) { callbackFn(); }
};
// store attribute so everyone knows we're animating this element
element.setAttribute('data-animated', "true");
// toggle element visiblity right away if we're making something visible
if( ! nowVisible ) {
element.style.display = '';
}
var hiddenStyles, visibleStyles;
// animate properties
if( animation === 'slide' ) {
hiddenStyles = initObjectProperties(["height", "borderTopWidth", "borderBottomWidth", "paddingTop", "paddingBottom"], 0);
visibleStyles = {};
if( ! nowVisible ) {
var computedStyles = window.getComputedStyle(element);
visibleStyles = copyObjectProperties(["height", "borderTopWidth", "borderBottomWidth", "paddingTop", "paddingBottom"], computedStyles);
// in some browsers, getComputedStyle returns "auto" value. this falls back to getBoundingClientRect() in those browsers since we need an actual height.
if(!isFinite(visibleStyles.height)) {
var clientRect = element.getBoundingClientRect();
visibleStyles.height = clientRect.height;
}
css(element, hiddenStyles);
}
// don't show a scrollbar during animation
element.style.overflowY = 'hidden';
animate(element, nowVisible ? hiddenStyles : visibleStyles, cleanup);
} else {
hiddenStyles = { opacity: 0 };
visibleStyles = { opacity: 1 };
if( ! nowVisible ) {
css(element, hiddenStyles);
}
animate(element, nowVisible ? hiddenStyles : visibleStyles, cleanup);
}
}
|
javascript
|
{
"resource": ""
}
|
q1110
|
nest
|
train
|
function nest (str, refs, escape) {
var res = [], match
var a = 0
while (match = re.exec(str)) {
if (a++ > 10e3) throw Error('Circular references in parenthesis')
res.push(str.slice(0, match.index))
res.push(nest(refs[match[1]], refs))
str = str.slice(match.index + match[0].length)
}
res.push(str)
return res
}
|
javascript
|
{
"resource": ""
}
|
q1111
|
loadData
|
train
|
function loadData() {
var data = fs.readFileSync(__dirname + '/zip_codes.csv', 'utf8');
var lines = data.split('\r\n');
var trie = {};
lines.forEach(function(line) {
var parts = line.split(',');
var zip = parts[0], city = parts[1], state = parts[2];
var node = trie;
for (var i = 0; i < zip.length; i++) {
var num = zip[i];
var pos = node[num];
if (pos == null)
node = node[num] = (i === zip.length - 1) ? [city, state] : {};
else
node = node[num];
}
});
return trie;
}
|
javascript
|
{
"resource": ""
}
|
q1112
|
setupStyleguide
|
train
|
function setupStyleguide(options) {
let cwd = !!options && !!options.cwd ? options.cwd : process.cwd()
success('Styleguide.new:', 'initialize styleguide ...')
return new Styleguide()
.initialize(cwd)
.then(function (styleguide) {
success('Styleguide.new:', 'initialize finished')
if (!options || !options.prepare) {
success('Styleguide.prepare:', 'preparing the styleguide target ...')
return styleguide.prepare()
} else {
return Promise.resolve(styleguide)
}
})
}
|
javascript
|
{
"resource": ""
}
|
q1113
|
resolveStyleguide
|
train
|
function resolveStyleguide(options) {
return setupStyleguide(options)
.then(function (styleguide) {
success('Styleguide.read:', 'start reading ...')
return styleguide.read()
})
.then(function (styleguide) {
success('Styleguide.read:', 'finished reading')
return Promise.resolve(styleguide)
})
}
|
javascript
|
{
"resource": ""
}
|
q1114
|
build
|
train
|
function build(options) {
options = Object.assign({}, options)
return resolveStyleguide(options)
.then(function (styleguide) {
success('Styleguide.write:', 'start writing ...')
return styleguide.write()
})
.then(function (styleguide) {
success('Styleguide.write:', 'finished writing')
return styleguide
})
.catch(function (e) {
error('Cli.build', 'failed to build Styleguide', e)
throw (e)
})
}
|
javascript
|
{
"resource": ""
}
|
q1115
|
createExport
|
train
|
function createExport(options) {
options = Object.assign({}, options, { prepare: false })
/** we need no styleguide preparation, like asset copying etc. */
return resolveStyleguide(options)
.then(function (styleguide) {
return styleguide.exportStyleguide()
})
.catch(function (e) {
error('Cli.createExport', 'failed to build Styleguide', e)
throw (e)
})
/** create static styleguide structure */
}
|
javascript
|
{
"resource": ""
}
|
q1116
|
train
|
function (config, mockSrc, defaultScenario, filenames,
scenarioName) {
// read mock data files for this scenario
var scenario = filenames.map(function (filename) {
var filepath = fs.realpathSync(path.join(mockSrc, filename));
return {
scenarioName: scenarioName,
filename: filename,
scenario: require(filepath)
};
});
return scenario;
}
|
javascript
|
{
"resource": ""
}
|
|
q1117
|
train
|
function (config, mockSrc) {
var mockManifestPath = path.join(process.cwd(), mockSrc,
mockManifestFilename),
// read manifest JSON by require'ing it
mockManifest = require(mockManifestPath),
// read files for default scenario first, so we can merge it into other
// scenarios later
defaultScenario = readScenario(config, mockSrc, [],
mockManifest._default, '_default');
// read files for each scenario
return _.mapValues(mockManifest, function (filenames, scenarioName) {
return readScenario(config, mockSrc, defaultScenario, filenames,
scenarioName);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q1118
|
train
|
function (data, pluginNames) {
logger('runPlugins input', data);
var plugins = pluginNames.map(function (pn) { return pluginRegistry[pn]; }),
applyPlugin = function (oldData, plugin) { return plugin(oldData); };
// Use reduce to apply all the plugins to the data
var output = plugins.reduce(applyPlugin, data);
logger('runPlugins output', output);
return output;
}
|
javascript
|
{
"resource": ""
}
|
|
q1119
|
train
|
function (dataWithContext) {
return _.mapValues(dataWithContext, function (scenario) {
return scenario.map(function (response) {
return response.scenario;
});
});
}
|
javascript
|
{
"resource": ""
}
|
|
q1120
|
train
|
function (config, mockSrc) {
var dataWithContext = readMockManifest(config, mockSrc);
// log('readScenarioData config', config);
if (config.plugins) {
dataWithContext = runPlugins(dataWithContext, config.plugins);
}
return removeContext(dataWithContext);
}
|
javascript
|
{
"resource": ""
}
|
|
q1121
|
train
|
function (templatePath, path, data, name) {
var templateString = fs.readFileSync(templatePath);
// generate scenarioData.js contents by inserting data into template
var templateData = {scenarioData: data};
templateData.scenarioDataName = name || '';
var output = _.template(templateString)(templateData);
mkdirp.sync(getDirName(path));
fs.writeFileSync(path, output);
}
|
javascript
|
{
"resource": ""
}
|
|
q1122
|
train
|
function () {
config.multipleFiles = config.multipleFiles || false;
var defaultTemplate = singleFileDefaultTemplate;
if (config.multipleFiles) {
defaultTemplate = multipleFilesDefaultTemplate;
}
config.template = config.template || defaultTemplate;
var mockSrc = _.isArray(config.src) ? _.first(config.src) : config.src;
logger('mock source', mockSrc);
logger('dest', config.dest);
logger('template', config.template);
logger('multipleFiles', config.multipleFiles);
logger('plugins', config.plugins);
// read all scenario data from manifest/JSON files
var scenarioData = readScenarioData(config, mockSrc);
logger('scenarioData', scenarioData);
var scenarioModuleFilename = config.dest,
scenarioString;
if (!config.multipleFiles) {
// stringify all scenario files into a single Angular module
scenarioString = JSON.stringify(scenarioData);
writeScenarioModule(config.template, scenarioModuleFilename,
scenarioString);
} else {
fs.mkdirSync(config.dest);
// stringify each scenario file into it's own Angular module
for (var scenarioName in scenarioData) {
if (scenarioData.hasOwnProperty(scenarioName)) {
scenarioModuleFilename = config.dest + '/' + scenarioName +
'.js';
scenarioString = JSON.stringify(scenarioData[scenarioName]);
writeScenarioModule(config.template, scenarioModuleFilename,
scenarioString, scenarioName);
}
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q1123
|
accessor
|
train
|
function accessor(k) {
Popup.prototype[k] = function(v) {
if (typeof v == "undefined") return this["_" + k];
this["_" + k] = v;
return this;
};
}
|
javascript
|
{
"resource": ""
}
|
q1124
|
compile
|
train
|
function compile(pos) {
var values = []
if (!pos) {
return null
}
values = [[pos.line || 1, pos.column || 1].join(':')]
if ('offset' in pos) {
values.push(String(pos.offset || 0))
}
return values
}
|
javascript
|
{
"resource": ""
}
|
q1125
|
stringify
|
train
|
function stringify(start, end) {
var values = []
var positions = []
var offsets = []
add(start)
add(end)
if (positions.length !== 0) {
values.push(positions.join('-'))
}
if (offsets.length !== 0) {
values.push(offsets.join('-'))
}
return values.join(', ')
// Add a position.
function add(position) {
var tuple = compile(position)
if (tuple) {
positions.push(tuple[0])
if (tuple[1]) {
offsets.push(tuple[1])
}
}
}
}
|
javascript
|
{
"resource": ""
}
|
q1126
|
add
|
train
|
function add(position) {
var tuple = compile(position)
if (tuple) {
positions.push(tuple[0])
if (tuple[1]) {
offsets.push(tuple[1])
}
}
}
|
javascript
|
{
"resource": ""
}
|
q1127
|
formatNode
|
train
|
function formatNode(node) {
var log = node.type
var location = node.position || {}
var position = stringify(location.start, location.end)
var key
var values = []
var value
if (node.children) {
log += dim('[') + yellow(node.children.length) + dim(']')
} else if (typeof node.value === 'string') {
log += dim(': ') + green(JSON.stringify(node.value))
}
if (position) {
log += ' (' + position + ')'
}
for (key in node) {
value = node[key]
if (
ignore.indexOf(key) !== -1 ||
value === null ||
value === undefined ||
(typeof value === 'object' && isEmpty(value))
) {
continue
}
values.push('[' + key + '=' + JSON.stringify(value) + ']')
}
if (values.length !== 0) {
log += ' ' + values.join('')
}
return log
}
|
javascript
|
{
"resource": ""
}
|
q1128
|
execList
|
train
|
function execList(options) {
const deferred = Q.defer();
const json = options.json !== false;
const offline = options.offline !== false;
const cwd = options.cwd || process.cwd();
const config = {json, offline, cwd};
bower.commands.list(undefined, config)
.on('end', (conf) => {
deferred.resolve(flatten(conf));
})
.on('error', (error) => {
deferred.reject(error);
});
return deferred.promise;
}
|
javascript
|
{
"resource": ""
}
|
q1129
|
errMessageFormat
|
train
|
function errMessageFormat (showDiff, pos, title, msg, stack) {
if (showDiff) {
return format.red(' ' + pos + ') ' + title + ':\n' + msg) + format.gray('\n' + stack + '\n')
}
return format.red(' ' + pos + ') ' + title + ':\n') +
format.white(' ' + msg) +
format.white('\n' + stack + '\n')
}
|
javascript
|
{
"resource": ""
}
|
q1130
|
unifiedDiff
|
train
|
function unifiedDiff (err) {
let indent = ' '
function cleanUp (line) {
if (line[0] === '+') {
return indent + format.colorLines('green', line)
}
if (line[0] === '-') {
return indent + format.colorLines('red', line)
}
if (line.match(/@@/)) {
return null
}
if (line.match(/\\ No newline/)) {
return null
}
if (line.trim().length) {
line = format.colorLines('white', line)
}
return indent + line
}
function notBlank (line) {
return typeof line !== 'undefined' && line !== null
}
let msg = diff.createPatch('string', err.actual, err.expected)
let lines = msg.split('\n').splice(4)
let diffResult = lines.map(cleanUp).filter(notBlank).join('\n')
if (!diffResult.trim().length) {
msg = diff.createPatch(
'string',
stringify(Object.keys(err._actual || err.actual).sort()),
stringify(Object.keys(err._expected || err.expected).sort())
)
lines = msg.split('\n').splice(4)
diffResult = format.red(' object keys not match: \n') + lines.map(cleanUp).filter(notBlank).join('\n')
}
return '\n ' +
format.colorLines('green', '+ expected') + ' ' +
format.colorLines('red', '- actual') +
'\n\n' +
diffResult
}
|
javascript
|
{
"resource": ""
}
|
q1131
|
unwrapReturns
|
train
|
function unwrapReturns(ast, src, result) {
const charArray = src.split('');
const state = {
hasReturn: false,
source(node) {
return src.slice(node.start, node.end);
},
replace(node, str) {
charArray.fill('', node.start, node.end);
charArray[node.start] = str;
}
};
walk(ast, unwrapReturnsVisitors, state);
return {
before: state.hasReturn ? `var ${result} = ` : '',
body: charArray.join(''),
after: state.hasReturn ? `;if (${result}) return ${result}.value` : ''
};
}
|
javascript
|
{
"resource": ""
}
|
q1132
|
checkPageViewsCriteria
|
train
|
function checkPageViewsCriteria() {
// don't bother if another box is currently open
if( isAnyBoxVisible() ) {
return;
}
boxes.forEach(function(box) {
if( ! box.mayAutoShow() ) {
return;
}
if( box.config.trigger.method === 'pageviews' && pageViews >= box.config.trigger.value ) {
box.trigger();
}
});
}
|
javascript
|
{
"resource": ""
}
|
q1133
|
checkTimeCriteria
|
train
|
function checkTimeCriteria() {
// don't bother if another box is currently open
if( isAnyBoxVisible() ) {
return;
}
boxes.forEach(function(box) {
if( ! box.mayAutoShow() ) {
return;
}
// check "time on site" trigger
if (box.config.trigger.method === 'time_on_site' && siteTimer.time >= box.config.trigger.value) {
box.trigger();
}
// check "time on page" trigger
if (box.config.trigger.method === 'time_on_page' && pageTimer.time >= box.config.trigger.value) {
box.trigger();
}
});
}
|
javascript
|
{
"resource": ""
}
|
q1134
|
checkHeightCriteria
|
train
|
function checkHeightCriteria() {
var scrollY = scrollElement.hasOwnProperty('pageYOffset') ? scrollElement.pageYOffset : scrollElement.scrollTop;
scrollY = scrollY + window.innerHeight * 0.9;
boxes.forEach(function(box) {
if( ! box.mayAutoShow() || box.triggerHeight <= 0 ) {
return;
}
if( scrollY > box.triggerHeight ) {
// don't bother if another box is currently open
if( isAnyBoxVisible() ) {
return;
}
// trigger box
box.trigger();
}
// if box may auto-hide and scrollY is less than triggerHeight (with small margin of error), hide box
if( box.mayRehide() && scrollY < ( box.triggerHeight - 5 ) ) {
box.hide();
}
});
}
|
javascript
|
{
"resource": ""
}
|
q1135
|
Refs
|
train
|
function Refs(a, b) {
if (!(this instanceof Refs)) {
return new Refs(a, b);
}
// link
a.inverse = b;
b.inverse = a;
this.props = {};
this.props[a.name] = a;
this.props[b.name] = b;
}
|
javascript
|
{
"resource": ""
}
|
q1136
|
train
|
function(element, event, callback, capturePhase) {
if (!element.id) element.id = $.uuid()
if (!ChuiEventCache.elements[element.id]) {
ChuiEventCache.elements[element.id] = []
}
ChuiEventCache.elements[element.id].push({
event: event,
callback: callback
})
element.addEventListener(event, callback, capturePhase)
}
|
javascript
|
{
"resource": ""
}
|
|
q1137
|
train
|
function(element, event, callback) {
const eventStack = ChuiEventCache.elements[element.id]
if (!eventStack) return
let deleteOrder = []
if (!event) {
deleteOrder = []
eventStack.forEach(function(evt, idx) {
element.removeEventListener(evt.event, evt.callback, evt.capturePhase)
deleteOrder.push(idx)
})
deleteFromEventStack(deleteOrder, eventStack)
} else if (!!event && !callback) {
deleteOrder = []
eventStack.forEach(function(evt, idx) {
if (evt.event === event) {
element.removeEventListener(evt.event, evt.callback, evt.capturePhase)
deleteOrder.push(idx)
}
})
deleteFromEventStack(deleteOrder, eventStack)
} else if (callback) {
deleteOrder = []
eventStack.forEach(function(evt, idx) {
if (callback === evt.callback) {
element.removeEventListener(evt.event, evt.callback, evt.capturePhase)
deleteOrder.push(idx)
}
})
deleteFromEventStack(deleteOrder, eventStack)
}
}
|
javascript
|
{
"resource": ""
}
|
|
q1138
|
train
|
function(element, selector, event, callback, capturePhase) {
const delegateElement = $(element).array[0]
$(element).forEach(function(ctx) {
$(ctx).on(event, function(e) {
let target = e.target
if (e.target.nodeType === 3) {
target = e.target.parentNode
}
$(ctx).find(selector).forEach(function(delegateElement) {
if (delegateElement === target) {
callback.call(delegateElement, e)
} else {
try {
const ancestor = $(target).closest(selector)
if (delegateElement === ancestor.array[0]) {
callback.call(delegateElement, e)
}
} catch (err) {}
}
})
}, capturePhase)
})
}
|
javascript
|
{
"resource": ""
}
|
|
q1139
|
getName
|
train
|
function getName () {
const pathname = url.parse(parts[parts.length - 1]).pathname;
return pathname ? pathname.replace('/', '') : pathname;
}
|
javascript
|
{
"resource": ""
}
|
q1140
|
getOptionsObject
|
train
|
function getOptionsObject () {
if (parts.length > 1) {
// Options should be appended to the last hosts querystring
return qs.parse(url.parse(parts[parts.length - 1]).query);
}
return {};
}
|
javascript
|
{
"resource": ""
}
|
q1141
|
getAuthenticationObject
|
train
|
function getAuthenticationObject () {
const authString = url.parse(parts[0]).auth;
if (authString) {
return {
source: getName(),
user: authString.split(':')[0],
pass: authString.split(':')[1]
};
} else {
return {};
}
}
|
javascript
|
{
"resource": ""
}
|
q1142
|
train
|
function (metadata) {
var key;
if (metadata) {
this.name = metadata.name;
this.size = metadata.size || 0;
this.mime = metadata.mime || '';
this.isPublic = metadata.isPublic || false;
this.tags = metadata.tags || [];
this.content = metadata.content;
this.contentType = metadata.contentType || BlobMetadata.CONTENT_TYPES.OBJECT;
if (this.contentType === BlobMetadata.CONTENT_TYPES.COMPLEX) {
for (key in this.content) {
if (this.content.hasOwnProperty(key)) {
if (BlobConfig.hashRegex.test(this.content[key].content) === false) {
throw new Error('BlobMetadata is malformed: hash \'' + this.content[key].content +
'\'is invalid');
}
}
}
}
} else {
throw new Error('metadata parameter is not defined');
}
}
|
javascript
|
{
"resource": ""
}
|
|
q1143
|
train
|
function (parameters) {
parameters = parameters || {};
if (parameters.logger) {
this.logger = parameters.logger;
} else {
/*eslint-disable no-console*/
var doLog = function () {
console.log.apply(console, arguments);
};
this.logger = {
debug: doLog,
log: doLog,
info: doLog,
warn: doLog,
error: doLog
};
console.warn('Since v1.3.0 ExecutorClient requires a logger, falling back on console.log.');
/*eslint-enable no-console*/
}
this.logger.debug('ctor', {metadata: parameters});
this.isNodeJS = (typeof window === 'undefined') && (typeof process === 'object');
this.isNodeWebkit = (typeof window === 'object') && (typeof process === 'object');
//console.log(isNode);
if (this.isNodeJS) {
this.logger.debug('Running under node');
this.server = '127.0.0.1';
this.httpsecure = false;
}
this.server = parameters.server || this.server;
this.serverPort = parameters.serverPort || this.serverPort;
this.httpsecure = (parameters.httpsecure !== undefined) ? parameters.httpsecure : this.httpsecure;
if (this.isNodeJS) {
this.http = this.httpsecure ? require('https') : require('http');
}
this.origin = '';
if (this.httpsecure !== undefined && this.server && this.serverPort) {
this.origin = (this.httpsecure ? 'https://' : 'http://') + this.server + ':' + this.serverPort;
}
if (parameters && typeof parameters.relativeUrl === 'string') {
this.relativeUrl = parameters.relativeUrl;
} else if (typeof WebGMEGlobal !== 'undefined' && WebGMEGlobal.gmeConfig &&
typeof WebGMEGlobal.gmeConfig.client.mountedPath === 'string') {
this.relativeUrl = WebGMEGlobal.gmeConfig.client.mountedPath + '/rest/executor/';
} else {
this.relativeUrl = '/rest/executor/';
}
this.executorUrl = this.origin + this.relativeUrl;
// TODO: TOKEN???
// TODO: any ways to ask for this or get it from the configuration?
if (parameters.executorNonce) {
this.executorNonce = parameters.executorNonce;
}
this.logger.debug('origin', this.origin);
this.logger.debug('executorUrl', this.executorUrl);
}
|
javascript
|
{
"resource": ""
}
|
|
q1144
|
expandKeys
|
train
|
function expandKeys(object) {
var hasFlattenedKeys = _.some(object, function(val, key) {
return key.split('.').length > 1;
});
if (!hasFlattenedKeys) return object;
return _.reduce(object, function(payload, value, key) {
var path = key.split('.');
if (path.length === 1) {
var obj = {};
obj[key] = value;
payload = deepExtend(payload, obj);
return payload;
}
var subKey = path.pop();
var localObj = payload;
while (path.length) {
var subPath = path.shift();
localObj = localObj[subPath] = localObj[subPath] || {};
}
localObj[subKey] = object[key];
return payload;
}, {});
}
|
javascript
|
{
"resource": ""
}
|
q1145
|
deepExtend
|
train
|
function deepExtend(target, source) {
_.each(source, function(value, key) {
if (_.has(target, key) && isObject(target[key]) && isObject(source[key])) {
deepExtend(target[key], source[key]);
} else {
target[key] = source[key];
}
});
return target;
}
|
javascript
|
{
"resource": ""
}
|
q1146
|
query
|
train
|
function query(value, field, expression) {
if (!expression) {
return value;
}
var expressionQuery = {};
expressionQuery[expression] = value;
return expressionQuery;
}
|
javascript
|
{
"resource": ""
}
|
q1147
|
train
|
function() {
var distDir = this.readConfig('distDir');
var packedDirName = this.readConfig('packedDirName');
var archivePath = this.readConfig('archivePath');
if (packedDirName) {
packedDirName = path.join(archivePath, packedDirName);
this.log('moving ' + distDir + ' to ' + packedDirName);
this.distDir = packedDirName;
return move(distDir, packedDirName);
}
return RSVP.resolve();
}
|
javascript
|
{
"resource": ""
}
|
|
q1148
|
checkChain
|
train
|
function checkChain(value, chain, baton, callback) {
var funs = chain.validators.map(function(i) {
return i.func;
});
function _reduce(memo, validator, callback) {
validator(memo, baton, function(err, result) {
var message;
if (err) {
if (err.hasOwnProperty(message)) {
message = err.message;
} else {
message = err;
}
callback(message);
} else {
callback(null, result);
}
});
}
async.reduce(funs, value, _reduce, callback);
}
|
javascript
|
{
"resource": ""
}
|
q1149
|
chainHelp
|
train
|
function chainHelp(chain) {
return chain.validators.map(function(e) {
return e.help;
})
.filter(function(e) {
return e;
});
}
|
javascript
|
{
"resource": ""
}
|
q1150
|
train
|
function() {
if (! (this instanceof Chain)) {
return new Chain();
}
this.validators = [];
this.target = null;
this.isOptional = false;
this.isImmutable = false;
this.isUpdateRequired = false;
this._validatorCount = 0;
this._numItemsValidator = null;
}
|
javascript
|
{
"resource": ""
}
|
|
q1151
|
train
|
function(schema, /* optional */ baton) {
if (! (this instanceof Valve)) {
return new Valve(schema, baton);
}
this.schema = schema;
this.baton = baton;
}
|
javascript
|
{
"resource": ""
}
|
|
q1152
|
createDitcherInstance
|
train
|
function createDitcherInstance(mongoUrl, callback) {
// Default config used by ditcher if no connection string
// is provided
var config = {
database: {
host: process.env.MONGODB_HOST || '127.0.0.1',
port: process.env.FH_LOCAL_DB_PORT || 27017,
name: 'FH_LOCAL'
}
};
if (mongoUrl) {
try {
config = utils.parseMongoConnectionURL(mongoUrl);
} catch(e) {
return callback(e);
}
}
var versString = (mongoUrl) ? "db per app" : "shared db";
var ditcher = new fhditcher.Ditcher(config, logger, versString, function () {
return callback(null, ditcher);
});
}
|
javascript
|
{
"resource": ""
}
|
q1153
|
train
|
function(next) {
logger.log("DeregisterImage:", images);
if (shell.isArg("-dry-run", options)) return next();
lib.forEachSeries(images, function(img, next2) {
aws.ec2DeregisterImage(img.imageId, { snapshots: 1 }, next2);
}, next);
}
|
javascript
|
{
"resource": ""
}
|
|
q1154
|
makeRequest
|
train
|
function makeRequest(capturedError) {
req(app)
.get('/bundle.js')
.expect(500)
.end(function(err, res) {
if (err) {
done(err);
}
assert.ok(capturedError, 'expected error in onerror');
assert.equal(res.text, capturedError.stack);
done();
});
}
|
javascript
|
{
"resource": ""
}
|
q1155
|
train
|
function(userIds) {
return new Promise((resolve, reject) => {
this._start()
.uri('/api/user/bulk')
.urlParameter('userId', userIds)
.delete()
.go(this._responseHandler(resolve, reject));
});
}
|
javascript
|
{
"resource": ""
}
|
|
q1156
|
train
|
function(userId, applicationId, callerIPAddress) {
return new Promise((resolve, reject) => {
this._start()
.uri('/api/login')
.urlSegment(userId)
.urlSegment(applicationId)
.urlParameter('ipAddress', callerIPAddress)
.put()
.go(this._responseHandler(resolve, reject));
});
}
|
javascript
|
{
"resource": ""
}
|
|
q1157
|
train
|
function(global, refreshToken) {
return new Promise((resolve, reject) => {
this._start()
.uri('/api/logout')
.urlParameter('global', global)
.urlParameter('refreshToken', refreshToken)
.post()
.go(this._responseHandler(resolve, reject));
});
}
|
javascript
|
{
"resource": ""
}
|
|
q1158
|
train
|
function(applicationId, start, end) {
return new Promise((resolve, reject) => {
this._start()
.uri('/api/report/daily-active-user')
.urlParameter('applicationId', applicationId)
.urlParameter('start', start)
.urlParameter('end', end)
.get()
.go(this._responseHandler(resolve, reject));
});
}
|
javascript
|
{
"resource": ""
}
|
|
q1159
|
train
|
function(userId) {
return new Promise((resolve, reject) => {
this._start()
.uri('/api/user')
.urlSegment(userId)
.get()
.go(this._responseHandler(resolve, reject));
});
}
|
javascript
|
{
"resource": ""
}
|
|
q1160
|
train
|
function(userId, offset, limit) {
return new Promise((resolve, reject) => {
this._start()
.uri('/api/report/user-login')
.urlParameter('userId', userId)
.urlParameter('offset', offset)
.urlParameter('limit', limit)
.get()
.go(this._responseHandler(resolve, reject));
});
}
|
javascript
|
{
"resource": ""
}
|
|
q1161
|
train
|
function(token, userId, applicationId) {
return new Promise((resolve, reject) => {
this._start()
.uri('/api/jwt/refresh')
.urlParameter('token', token)
.urlParameter('userId', userId)
.urlParameter('applicationId', applicationId)
.delete()
.go(this._responseHandler(resolve, reject));
});
}
|
javascript
|
{
"resource": ""
}
|
|
q1162
|
train
|
function(request) {
return new Promise((resolve, reject) => {
this._start()
.uri('/api/system/audit-log/search')
.setJSONBody(request)
.post()
.go(this._responseHandler(resolve, reject));
});
}
|
javascript
|
{
"resource": ""
}
|
|
q1163
|
train
|
function(verificationId) {
return new Promise((resolve, reject) => {
this._start()
.uri('/api/user/verify-email')
.urlSegment(verificationId)
.post()
.go(this._responseHandler(resolve, reject));
});
}
|
javascript
|
{
"resource": ""
}
|
|
q1164
|
train
|
function(version) {
var command = 'node_modules/.bin/bower uninstall ember && node_modules/.bin/bower install ember#' + version;
grunt.log.writeln('Running bower install', command);
try {
var resultBower = execSync(command);
grunt.log.writeln(resultBower);
} catch (e) {
grunt.fail.warn(e);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q1165
|
train
|
function(nodeUnitTaskName) {
grunt.registerTask(nodeUnitTaskName, 'Nodeunit sync runner', function() {
try {
var result = execSync('node_modules/.bin/nodeunit --reporter="minimal"', { encoding: 'utf8' });
grunt.log.writeln(result);
} catch (e) {
grunt.fail.warn(e);
}
});
}
|
javascript
|
{
"resource": ""
}
|
|
q1166
|
matchObj
|
train
|
function matchObj(obj, line) {
for (const p in obj) if (obj[p] && obj[p].test(line)) return p;
return "";
}
|
javascript
|
{
"resource": ""
}
|
q1167
|
processRow
|
train
|
function processRow(row) {
if (!row) row = {};
for (var i = 0; i < hooks.length; i++) {
if (hooks[i].call(row, req, row) === true) return false;
}
return true;
}
|
javascript
|
{
"resource": ""
}
|
q1168
|
updateTaxis
|
train
|
function updateTaxis()
{
var ids = [ "11", "22", "33" ];
var statuses = [ "avail", "busy", "scheduled" ];
var bbox = bkutils.geoBoundingBox(center[0], center[1], 2); // within 2 km from the center
var latitude = lib.randomNum(bbox[0], bbox[2], 5);
var longitude = lib.randomNum(bbox[1], bbox[3], 5);
var id = ids[lib.randomInt(0, ids.length - 1)];
var status = statuses[lib.randomInt(0, statuses.length - 1)];
db.put("taxi", { id: id, status: status, latitude: latitude, longitude: longitude });
}
|
javascript
|
{
"resource": ""
}
|
q1169
|
mergeSubResource
|
train
|
function mergeSubResource(attrNode, subResourceConfig, context) {
// Merge options from sub-resource to parent (order is irrelevant here):
Object.keys(subResourceConfig).forEach(optionName => {
if (optionName === 'attributes') {
if (!attrNode.attributes) attrNode.attributes = {};
} else if (optionName === 'dataSources') {
const newDataSources = Object.assign({}, subResourceConfig.dataSources);
if (attrNode.dataSources) {
Object.keys(attrNode.dataSources).forEach(dataSourceName => {
if (newDataSources[dataSourceName]) {
if (attrNode.dataSources[dataSourceName].inherit) {
if (attrNode.dataSources[dataSourceName].inherit === 'inherit') {
newDataSources[dataSourceName] = Object.assign(
{},
newDataSources[dataSourceName],
attrNode.dataSources[dataSourceName]
);
} else if (attrNode.dataSources[dataSourceName].inherit === 'replace') {
newDataSources[dataSourceName] = attrNode.dataSources[dataSourceName];
}
} else {
throw new ImplementationError(
`Cannot overwrite DataSource "${dataSourceName}"` +
` in "${context.attrPath.join('.')}" (maybe use "inherit"?)`
);
}
} else {
newDataSources[dataSourceName] = attrNode.dataSources[dataSourceName];
}
});
}
attrNode.dataSources = newDataSources;
} else if (typeof subResourceConfig[optionName] === 'object') {
attrNode[optionName] = cloneDeep(subResourceConfig[optionName]);
} else if (!(optionName in attrNode)) {
attrNode[optionName] = subResourceConfig[optionName];
}
});
attrNode._origNodes = attrNode._origNodes || [];
attrNode._origNodes.push(subResourceConfig);
}
|
javascript
|
{
"resource": ""
}
|
q1170
|
getAttribute
|
train
|
function getAttribute(path, attrNode, context) {
path.forEach((attributeName, i) => {
if (!(attrNode.attributes && attrNode.attributes[attributeName])) {
if (attrNode._origNodes) {
let subAttrNode = null;
attrNode._origNodes.forEach((origNode, inheritDepth) => {
if (!origNode || !origNode.attributes || !origNode.attributes[attributeName]) return;
let origSubAttrNode = origNode.attributes[attributeName];
if (subAttrNode) {
if (subAttrNode.inherit === 'inherit') {
// just add/merge options from sub-resource below
} else if (subAttrNode.inherit === 'replace') {
return; // just ignore options from sub-resource
} else {
let attrPath = context.attrPath.join('.');
throw new ImplementationError(
`Cannot overwrite attribute "${attributeName}" in "${attrPath}" (maybe use "inherit"?)`
);
}
} else {
subAttrNode = {};
}
Object.keys(origSubAttrNode).forEach(optionName => {
if (subAttrNode.hasOwnProperty(optionName)) return; // for inherit
if (optionName === 'attributes') {
subAttrNode[optionName] = {};
} else if (optionName === 'dataSources') {
// DataSources are handled/cloned later in resolveResourceTree():
subAttrNode[optionName] = origSubAttrNode[optionName];
} else if (typeof origSubAttrNode[optionName] === 'object') {
subAttrNode[optionName] = cloneDeep(origSubAttrNode[optionName]);
} else {
subAttrNode[optionName] = origSubAttrNode[optionName];
}
});
// keep the inherit-depth (array length) from parent:
subAttrNode._origNodes = subAttrNode._origNodes || Array(attrNode._origNodes.length);
subAttrNode._origNodes[inheritDepth] = origSubAttrNode;
attrNode.attributes[attributeName] = subAttrNode;
});
}
if (!(attrNode.attributes && attrNode.attributes[attributeName])) {
throw new RequestError(
'Unknown attribute ' + `"${context.attrPath.concat(path.slice(0, i + 1)).join('.')}"`
);
}
}
attrNode = attrNode.attributes[attributeName];
if (attrNode.resource) {
const subContext = Object.assign({}, context);
subContext.attrPath = subContext.attrPath.concat(path.slice(0, i + 1));
resolveIncludes(attrNode, subContext);
}
});
return attrNode;
}
|
javascript
|
{
"resource": ""
}
|
q1171
|
resolveDataSourceAttributes
|
train
|
function resolveDataSourceAttributes(resourceTree, dataSources, primaryName) {
Object.keys(dataSources).forEach(dataSourceName => {
const dataSource = dataSources[dataSourceName];
dataSource.attributes = [];
dataSource.attributeOptions = {};
});
resourceTree.attributes.forEach(function resolveAttribute(attrInfo) {
let selectedDataSources;
if (attrInfo.fromDataSource === '#same-group') {
return attrInfo.attributes.forEach(resolveAttribute); // handle key-groups as flat
}
if (attrInfo.fromDataSource === '#all-selected') {
attrInfo.attrNode.selectedDataSource = primaryName;
selectedDataSources = [];
Object.keys(dataSources).forEach(dataSourceName => {
if (dataSources[dataSourceName].joinParentKey) return;
selectedDataSources.push(dataSourceName);
});
} else if (attrInfo.fromDataSource === '#current-primary') {
attrInfo.attrNode.selectedDataSource = primaryName;
selectedDataSources = [attrInfo.attrNode.selectedDataSource];
} else if (attrInfo.fromDataSource) {
attrInfo.attrNode.selectedDataSource = attrInfo.fromDataSource;
selectedDataSources = [attrInfo.attrNode.selectedDataSource];
} else {
attrInfo.attrNode.selectedDataSource = Object.keys(attrInfo.dataSourceMap).find(
dataSourceName => dataSources[dataSourceName]
);
if (!attrInfo.attrNode.selectedDataSource) {
throw new ImplementationError(
'No proper DataSource selected for attribute ' +
'(this should not happen - bug in request-resolver in Flora core)'
);
}
selectedDataSources = [attrInfo.attrNode.selectedDataSource];
}
selectedDataSources.forEach(selectedDataSourceName => {
const attribute = attrInfo.dataSourceMap[selectedDataSourceName];
dataSources[selectedDataSourceName].attributes.push(attribute);
dataSources[selectedDataSourceName].attributeOptions[attribute] = _.pick(attrInfo.attrNode, [
'type',
'storedType',
'multiValued',
'delimiter'
]);
});
return null;
});
Object.keys(dataSources).forEach(dataSourceName => {
dataSources[dataSourceName].attributes = _.uniq(dataSources[dataSourceName].attributes);
});
}
|
javascript
|
{
"resource": ""
}
|
q1172
|
train
|
function () {
var _this = this;
console.info('INFO: creating tunnel to %s', this.proxyHost);
this._tunnel = childProcess.spawn('ssh', this._buildSSHArgs());
var cleanup = function () {
_this._tunnel.stderr.removeAllListeners('data');
};
this._tunnel.stderr.on('data', function (data) {
if (/success/.test(data)) {
cleanup();
return _this._resolveTunnel();
}
if (/failed/.test(data)) {
cleanup();
return _this._rejectTunnel();
}
});
this._tunnel.on('exit', function (code, signal) {
_this.emit('exit', code, signal);
});
this._tunnel.on('close', function (code, signal) {
_this.emit('close', code, signal);
return _this._closeTunnel(code);
});
this._tunnel.on('error', function () {
return _this._rejectTunnel();
});
return _this._tunnelDeferred.promise.timeout(this._connectTimeout);
}
|
javascript
|
{
"resource": ""
}
|
|
q1173
|
train
|
function () {
if (!this._tunnel) {
return q();
}
var _this = this;
this._tunnel.kill('SIGTERM');
return this._closeDeferred.promise.timeout(3000).fail(function () {
_this._tunnel.kill('SIGKILL');
return _this._closeTunnel(-1);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q1174
|
train
|
function(next) {
core.allowPackages.forEach(function(pkg) {
try {
var mod = path.dirname(require.resolve(pkg)).replace(/\/lib$/, "");
core.packages[pkg] = { path: mod };
if (lib.statSync(mod + "/etc").isDirectory()) {
core.packages[pkg].etc = 1;
var cfg = lib.readFileSync(mod + "/etc/config");
if (cfg) {
config = cfg + "\n" + config;
core.packages[pkg].config = 1;
core.parseConfig(cfg, 1);
}
}
["modules","locales","views","web"].forEach(function(x) {
if (lib.statSync(mod + "/" + x).isDirectory()) {
core.path[x].unshift(mod + "/" + x);
core.packages[pkg][x] = 1;
}
});
logger.debug("init:", "npm package:", pkg, core.packages[pkg]);
} catch(e) {
logger.error("init:", "npm package:", pkg, e);
}
});
next();
}
|
javascript
|
{
"resource": ""
}
|
|
q1175
|
train
|
function(next) {
if (options.noModules) return next();
var opts = {
denyModules: options.denyModules || core.denyModules[core.role] || core.denyModules[""],
allowModules: options.allowModules || core.allowModules[core.role] || core.allowModules[""],
stopOnError: options.stopOnError || core.stopOnError,
};
var modules = path.resolve(__dirname, "../modules");
core.loadModules(modules, opts);
core.path.modules.forEach(function(mod) {
if (modules == path.resolve(mod)) return;
core.loadModules(mod, opts);
});
next();
}
|
javascript
|
{
"resource": ""
}
|
|
q1176
|
train
|
function(next) {
var files = [];
if (core.appPackage && core.packages[core.appPackage]) files.push(core.packages[core.appPackage].path);
files.push(core.home, core.path.etc + "/..", __dirname + "/..");
for (var i in files) {
var pkg = lib.readFileSync(files[i] + "/package.json", { json: 1, logger: "error", missingok: 1 });
logger.debug("init:", files[i] + "/package.json", pkg.name, pkg.version);
if (!core.appName && pkg.name) core.appName = pkg.name;
if (!core.appVersion && pkg.version) core.appVersion = pkg.version;
if (!core.appDescr && pkg.description) core.appDescr = pkg.description;
if (!core.version && pkg.name == "backendjs") core.version = pkg.version;
}
if (!core.appName) core.appName = core.name;
if (!core.appVersion) core.appVersion = core.version;
// Use the app name as salt for consistentcy
if (!core.salt) core.salt = lib.salt = core.appName;
next();
}
|
javascript
|
{
"resource": ""
}
|
|
q1177
|
train
|
function(next) {
if (options.noDns || core.noDns) return next();
core.loadDnsConfig(options, next);
}
|
javascript
|
{
"resource": ""
}
|
|
q1178
|
train
|
function(next) {
try { process.umask(core.umask); } catch(e) { logger.error("umask:", core.umask, e) }
// Create all subfolders with permissions, run it before initializing db which may create files in the spool folder
if (!cluster.isWorker && !core.worker) {
Object.keys(core.path).forEach(function(p) {
var paths = Array.isArray(core.path[p]) ? core.path[p] : [core.path[p]];
paths.forEach(function(x) {
if (!x || path.isAbsolute(x)) return;
lib.mkdirSync(x);
lib.chownSync(this.uid, this.gid, x);
});
});
}
next();
}
|
javascript
|
{
"resource": ""
}
|
|
q1179
|
train
|
function(next) {
if (options.noDb || core.noDb) return next();
db.init(options, next);
}
|
javascript
|
{
"resource": ""
}
|
|
q1180
|
train
|
function(next) {
if (options.noDb || core.noDb) return next();
db.initConfig(options, next);
}
|
javascript
|
{
"resource": ""
}
|
|
q1181
|
train
|
function(next) {
if (!cluster.isWorker && !core.worker && process.getuid() == 0) {
lib.findFileSync(core.path.spool).forEach(function(p) { lib.chownSync(core.uid, core.gid, p); });
}
next();
}
|
javascript
|
{
"resource": ""
}
|
|
q1182
|
train
|
function(next) {
if (options.noConfigure || core.noConfigure) return next();
core.runMethods("configureModule", options, next);
}
|
javascript
|
{
"resource": ""
}
|
|
q1183
|
updateVersion2gitTag
|
train
|
function updateVersion2gitTag(pkg) {
let tag = child_process.execSync('git describe --tag').toString().trim();
pkg.version = tag;
}
|
javascript
|
{
"resource": ""
}
|
q1184
|
train
|
function(t, utc, lang, tz) {
return zeropad(utc ? t.getUTCMinutes() : t.getMinutes())
}
|
javascript
|
{
"resource": ""
}
|
|
q1185
|
_parse
|
train
|
function _parse(type, obj, options)
{
if (!obj) return _checkResult(type, lib.newError("empty " + type), obj, options);
try {
obj = _parseResult(type, obj, options);
} catch(err) {
obj = _checkResult(type, err, obj, options);
}
return obj;
}
|
javascript
|
{
"resource": ""
}
|
q1186
|
_checkResult
|
train
|
function _checkResult(type, err, obj, options)
{
if (options) {
if (options.logger) logger.logger(options.logger, 'parse:', type, options, lib.traceError(err), obj);
if (options.datatype == "object" || options.datatype == "obj") return {};
if (options.datatype == "list") return [];
if (options.datatype == "str") return "";
}
return null;
}
|
javascript
|
{
"resource": ""
}
|
q1187
|
getConfig
|
train
|
function getConfig(fpath, defaults) {
var path = require('path');
var dpath = path.dirname(path.resolve(fpath));
function parentpath(fromdir, pattern) {
var pp = require('parentpath'),
cwd = process.cwd();
try {
process.chdir(fromdir);
return pp.sync(pattern);
} catch (e) {
return null;
} finally {
process.chdir(cwd);
}
}
function fromNpm() {
var config;
var dir = parentpath(dpath, 'package.json');
if (dir) {
try {
config = require(dir + '/package.json')[MJS_NPM];
config.__origin__ = dir + '/package.json';
} catch (e) {
}
}
return config;
}
function fromResourceFile() {
var candidates = [
parentpath(path, MJS_RC),
process.env.HOME, process.env.USERPROFILE, process.env.HOMEPATH, process.env.HOMEDRIVE + process.env.HOMEPATH
];
var config;
for (var i = 0; i < candidates.length; i++) {
var candidate = candidates[i] + '/' + MJS_RC;
if (fs.existsSync(candidate)) {
try {
config = JSON.parse(fs.readFileSync(candidate));
config.__origin__ = candidate;
break;
} catch (e) {
showHelpAndExit('Unable to read config from "' + candidate + '": ' + e.message, 1);
}
}
}
return config;
}
var config = fromNpm() || fromResourceFile() || {};
// Make sure we apply defaults to missing values
Object.keys(defaults).filter(function (k) {
return config[k] == null
}).forEach(function (k) {
config[k] = defaults[k];
});
return config;
}
|
javascript
|
{
"resource": ""
}
|
q1188
|
walk
|
train
|
function walk(configDirectory, resourceName, resources) {
resourceName = resourceName || '';
resources = resources || {};
fs.readdirSync(path.join(configDirectory, resourceName)).forEach(fileName => {
const subResourceName = (resourceName !== '' ? resourceName + '/' : '') + fileName;
const absoluteFilePath = path.join(configDirectory, subResourceName);
const stat = fs.statSync(absoluteFilePath);
if (stat && stat.isDirectory()) {
walk(configDirectory, subResourceName, resources);
} else if (resourceName !== '') {
if (fileName.startsWith('config.')) {
if (!resources[resourceName]) resources[resourceName] = {};
resources[resourceName].configFile = absoluteFilePath;
}
if (fileName === 'index.js') {
if (!resources[resourceName]) resources[resourceName] = {};
resources[resourceName].instanceFile = absoluteFilePath;
}
}
});
return resources;
}
|
javascript
|
{
"resource": ""
}
|
q1189
|
Client
|
train
|
function Client(options) {
this.accessID = options.accessID;
this.accessKey = options.accessKey;
this.signatureMethod = options.signatureMethod || 'HmacSHA1';
this.signatureVersion = options.signatureVersion || '1';
this.APIVersion = options.APIVersion || '2013-05-10';
this.APIHost = options.APIHost || 'http://ots.aliyuncs.com';
// protocol: 'http:'
// hostname: 'service.ots.aliyun.com'
// port: undefined
this.APIHostInfo = urlparse(this.APIHost);
this.requestAgent = options.agent || null;
this.requestTimeout = options.requestTimeout || 5000;
var dnsCacheTime = options.dnsCacheTime || 10000;
this.dns = CacheDNS.create({cacheTime: dnsCacheTime});
this.vip = options.vip;
}
|
javascript
|
{
"resource": ""
}
|
q1190
|
getDataSource
|
train
|
function getDataSource(node) {
const config = Object.assign({}, copyXmlAttributes(node));
if (node.childNodes.length) {
// parse datasource options
for (let i = 0; i < node.childNodes.length; ++i) {
const childNode = node.childNodes.item(i);
if (childNode.nodeType === TEXT_NODE && childNode.textContent.trim().length > 0) {
throw new ImplementationError(`dataSource contains useless text: "${childNode.textContent.trim()}"`);
}
if (
childNode.nodeType === ELEMENT_NODE &&
childNode.namespaceURI === 'urn:flora:options' &&
childNode.localName === 'option'
) {
if (childNode.attributes.length !== 1)
throw new Error('flora:option element requires a name attribute');
const attr = childNode.attributes.item(0);
if (attr.localName !== 'name') throw new Error('flora:option element requires a name attribute');
if (config[attr.value]) throw new Error(`Data source option "${attr.value}" already defined`);
config[attr.value] = childNode.textContent.trim();
}
}
}
const name = config.name ? config.name : 'primary';
if (config.name) delete config.name;
return { name, config };
}
|
javascript
|
{
"resource": ""
}
|
q1191
|
parse
|
train
|
function parse(node) {
const cfg = Object.assign({}, copyXmlAttributes(node));
for (let i = 0, l = node.childNodes.length; i < l; ++i) {
const el = node.childNodes.item(i);
if (el.nodeType === ELEMENT_NODE) {
if (!el.namespaceURI) {
// attribute elements
if (!cfg.attributes) cfg.attributes = {};
cfg.attributes[el.localName] = el.childNodes.length ? parse(el) : copyXmlAttributes(el);
} else if (el.namespaceURI === 'urn:flora:options') {
// flora specific elements
if (el.localName === 'dataSource') {
const dataSource = getDataSource(el);
if (!cfg.dataSources) cfg.dataSources = {};
if (cfg.dataSources[dataSource.name]) {
throw new Error(`Data source "${dataSource.name}" already defined`);
}
cfg.dataSources[dataSource.name] = dataSource.config;
}
if (el.localName === 'subFilter') {
if (!cfg.subFilters) cfg.subFilters = [];
cfg.subFilters.push(copyXmlAttributes(el));
}
}
} else if (el.nodeType === TEXT_NODE && el.textContent.trim().length > 0) {
throw new ImplementationError(`Config contains unnecessary text: "${el.textContent.trim()}"`);
}
}
return cfg;
}
|
javascript
|
{
"resource": ""
}
|
q1192
|
getAttribute
|
train
|
function getAttribute(path, attrNode) {
path.forEach(attrName => {
if (!(attrNode.attributes && attrNode.attributes[attrName])) {
throw new ImplementationError(`Result-Builder: Unknown attribute "${path.join('.')}"`);
}
attrNode = attrNode.attributes[attrName];
});
return attrNode;
}
|
javascript
|
{
"resource": ""
}
|
q1193
|
preprocessRawResults
|
train
|
function preprocessRawResults(rawResults, resolvedConfig) {
rawResults.forEach((rawResult, resultId) => {
if (!rawResult.attributePath) return; // e.g. sub-filter results don't need indexing
// link resultIds into attribute tree (per DataSource):
const attrNode = getAttribute(rawResult.attributePath, resolvedConfig);
attrNode.dataSources[rawResult.dataSourceName].resultId = resultId;
// index rows by childKey if available
// (top-level result has no childKey and does not need to be indexed):
if (rawResult.childKey) {
const keyAttr = rawResult.childKey.length === 1 ? rawResult.childKey[0] : null;
rawResult.indexedData = {};
rawResult.data.forEach((row, i) => {
function dereferenceKeyAttr(keyAttrib) {
const keyVal = row[keyAttrib];
if (keyVal === undefined) {
const attrPath =
rawResult.attributePath.length > 0 ? rawResult.attributePath.join('.') : '{root}';
throw new DataError(
`Result-row ${i} of "${attrPath}" (DataSource "${
rawResult.dataSourceName
}") misses child key attribute "${keyAttr}"`
);
}
return keyVal;
}
const key = keyAttr
? '' + dereferenceKeyAttr(keyAttr) // speed up non-composite keys
: rawResult.childKey.map(dereferenceKeyAttr).join(keySeparator);
if (!rawResult.uniqueChildKey) {
if (!rawResult.indexedData[key]) rawResult.indexedData[key] = [];
rawResult.indexedData[key].push(row);
} else {
if (rawResult.indexedData[key]) {
const attrPath =
rawResult.attributePath.length > 0 ? rawResult.attributePath.join('.') : '{root}';
throw new DataError(
`Result-row ${i} of "${attrPath}" (DataSource "${
rawResult.dataSourceName
}") has duplicate child key "${key}"`
);
}
rawResult.indexedData[key] = row;
}
});
}
});
}
|
javascript
|
{
"resource": ""
}
|
q1194
|
parseNode
|
train
|
function parseNode(attrNode, parsers, context) {
const attrNames = Object.keys(attrNode);
const errorContext = context.errorContext;
Object.keys(parsers).forEach(attrName => {
const parser = parsers[attrName];
context.errorContext = ` (option "${attrName}"${errorContext})`;
removeValue(attrNames, attrName);
if (attrName in attrNode && parser !== null) {
attrNode[attrName] = parser(attrNode[attrName], context);
}
});
context.errorContext = errorContext;
if (attrNames.length > 0) {
throw new ImplementationError(`Invalid option "${attrNames.join(', ')}"${context.errorContext}`);
}
}
|
javascript
|
{
"resource": ""
}
|
q1195
|
checkIdentifier
|
train
|
function checkIdentifier(str, context) {
if (!/^[a-zA-Z_][a-zA-Z_0-9]*$/.test(str)) {
throw new ImplementationError(`Invalid identifier "${str}"${context.errorContext}`);
}
return str;
}
|
javascript
|
{
"resource": ""
}
|
q1196
|
parseAttributePath
|
train
|
function parseAttributePath(attrPath, context) {
const parsed = attrPath.split('.');
parsed.forEach(item => checkIdentifier(item, context));
return parsed;
}
|
javascript
|
{
"resource": ""
}
|
q1197
|
parsePrimaryKey
|
train
|
function parsePrimaryKey(attrPathList, context) {
return attrPathList.split(',').map(attrPath => parseAttributePath(attrPath, context));
}
|
javascript
|
{
"resource": ""
}
|
q1198
|
checkWhitelist
|
train
|
function checkWhitelist(str, whitelist, context) {
if (whitelist.indexOf(str) === -1) {
throw new ImplementationError(
'Invalid "' + str + '" (allowed: ' + whitelist.join(', ') + ')' + context.errorContext
);
}
return str;
}
|
javascript
|
{
"resource": ""
}
|
q1199
|
parseList
|
train
|
function parseList(list, whitelist, context) {
const parsed = list.split(',');
parsed.forEach(item => checkWhitelist(item, whitelist, context));
return parsed;
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.