_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q56200
|
createAnimationObject
|
train
|
function createAnimationObject(categoryName, fileName){
var animation,
inputFilepath = config.src + categoryName + '/' + fileName + '.css',
inputPlainFilepath = config.unprefixedSrc + categoryName + '/' + fileName + '.css',
outpuFilepath = config.dest + categoryName + '/' + 'db_'+ fileName + '.json',
currentFileSource,
currentFilePlainSource,
metadataObject;
// read the file
currentFileSource = grunt.file.read(inputFilepath);
currentFilePlainSource = grunt.file.read(inputPlainFilepath);
// extract relevant data
animation = parseString(currentFileSource);
// TODO: quitar los comentarios antes de guardarlo
if(animation.length > 0){
animation = animation[0];
animation.cssCode = new CleanCSS({
noAdvanced:false,
aggressiveMerging:false,
keepBreaks:true
}).minify(currentFileSource);
animation.plainCssCode = new CleanCSS({
noAdvanced:false,
aggressiveMerging:false,
keepBreaks:true
}).minify(currentFilePlainSource);
animation.cssCode = beautify_css(animation.cssCode, { indent_size: 2 });
animation.plainCssCode = beautify_css(animation.plainCssCode, { indent_size: 2 });
}
// write destiny
grunt.file.write(outpuFilepath, JSON.stringify(animation, null, 4));
}
|
javascript
|
{
"resource": ""
}
|
q56201
|
brackets
|
train
|
function brackets(pattern, options) {
const res = brackets.create(pattern, options);
return res.output;
}
|
javascript
|
{
"resource": ""
}
|
q56202
|
safeEval
|
train
|
function safeEval(src, parentContext){
var tree = prepareAst(src)
var context = Object.create(parentContext || {})
return finalValue(evaluateAst(tree, context))
}
|
javascript
|
{
"resource": ""
}
|
q56203
|
FunctionFactory
|
train
|
function FunctionFactory(parentContext){
var context = Object.create(parentContext || {})
return function Function() {
// normalize arguments array
var args = Array.prototype.slice.call(arguments)
var src = args.slice(-1)[0]
args = args.slice(0,-1)
if (typeof src === 'string'){
//HACK: esprima doesn't like returns outside functions
src = parse('function a(){ ' + src + '}').body[0].body
}
var tree = prepareAst(src)
return getFunction(tree, args, context)
}
}
|
javascript
|
{
"resource": ""
}
|
q56204
|
walkAll
|
train
|
function walkAll(nodes){
var result = undefined
for (var i=0;i<nodes.length;i++){
var childNode = nodes[i]
if (childNode.type === 'EmptyStatement') continue
result = walk(childNode)
if (result instanceof ReturnValue){
return result
}
}
return result
}
|
javascript
|
{
"resource": ""
}
|
q56205
|
setValue
|
train
|
function setValue(object, left, right, operator){
var name = null
if (left.type === 'Identifier'){
name = left.name
// handle parent context shadowing
object = objectForKey(object, name, primitives)
} else if (left.type === 'MemberExpression'){
if (left.computed){
name = walk(left.property)
} else {
name = left.property.name
}
object = walk(left.object)
}
// stop built in properties from being able to be changed
if (canSetProperty(object, name, primitives)){
switch(operator) {
case undefined: return object[name] = walk(right)
case '=': return object[name] = walk(right)
case '+=': return object[name] += walk(right)
case '-=': return object[name] -= walk(right)
case '++': return object[name]++
case '--': return object[name]--
}
}
}
|
javascript
|
{
"resource": ""
}
|
q56206
|
unsupportedExpression
|
train
|
function unsupportedExpression(node){
console.error(node)
var err = new Error('Unsupported expression: ' + node.type)
err.node = node
throw err
}
|
javascript
|
{
"resource": ""
}
|
q56207
|
objectForKey
|
train
|
function objectForKey(object, key, primitives){
var proto = primitives.getPrototypeOf(object)
if (!proto || hasOwnProperty(object, key)){
return object
} else {
return objectForKey(proto, key, primitives)
}
}
|
javascript
|
{
"resource": ""
}
|
q56208
|
canSetProperty
|
train
|
function canSetProperty(object, property, primitives){
if (property === '__proto__' || primitives.isPrimitive(object)){
return false
} else if (object != null){
if (hasOwnProperty(object, property)){
if (propertyIsEnumerable(object, property)){
return true
} else {
return false
}
} else {
return canSetProperty(primitives.getPrototypeOf(object), property, primitives)
}
} else {
return true
}
}
|
javascript
|
{
"resource": ""
}
|
q56209
|
get
|
train
|
function get(firebaseRef) {
return function(id, cb) {
firebaseRef.child(id).once('value').then(function(snapshot) {
cb(null, snapshot.val());
},
cb);
};
}
|
javascript
|
{
"resource": ""
}
|
q56210
|
save
|
train
|
function save(firebaseRef) {
return function(data, cb) {
var firebase_update = {};
firebase_update[data.id] = data;
firebaseRef.update(firebase_update).then(cb);
};
}
|
javascript
|
{
"resource": ""
}
|
q56211
|
all
|
train
|
function all(firebaseRef) {
return function(cb) {
firebaseRef.once('value').then(function success(records) {
var results = records.val();
if (!results) {
return cb(null, []);
}
var list = Object.keys(results).map(function(key) {
return results[key];
});
cb(null, list);
}, cb);
};
}
|
javascript
|
{
"resource": ""
}
|
q56212
|
train
|
function(selector, context) {
this.selector = selector;
if (typeof context == 'function') {
this.context = null;
this.asyncExecute(null, null, context);
}
else {
this.context = context;
}
this.instance = -1;
this.index = -1;
this.length = -1;
}
|
javascript
|
{
"resource": ""
}
|
|
q56213
|
train
|
function(url, callback) {
var self = this;
getPage(function(page) {
// Set the page size if it hasn't already been set.
if (!self.viewportSizeSet) {
self.viewportSizeSet = true;
page.set('viewportSize', {
width: self.config.width,
height: self.config.height
}, function (result) {
self.debug("Viewport set to: " + result.width + "x" + result.height);
});
}
// Set a custom user agent if it hasn't already been set.
if (self.config.userAgent && !self.userAgentSet) {
self.userAgentSet = true;
page.set('settings.userAgent', self.config.userAgent, function (result) {
self.debug("Useragent set to: " + result);
});
}
// Open the page.
self.debug('Navigating to ' + self.config.site + url);
page.open(self.config.site + url, function(status) {
if (status == 'fail') {
self.close();
throw new Error(status);
}
if (self.config.addJQuery) {
var loadJS = function() {
if (loading) {
setTimeout(loadJS, 100);
}
else {
page.includeJs(self.config.jQuery, callback);
}
}
loadJS();
}
else {
self.waitForPage(callback);
}
});
});
}
|
javascript
|
{
"resource": ""
}
|
|
q56214
|
train
|
function(callback, nowait) {
var self = this;
var loadWait = function() {
setTimeout(function() {
self.waitForPage(callback, true);
}, 100);
};
if (nowait) {
if (loading) {
loadWait();
}
else {
getPage(function(page) {
page.evaluate(function() {
return jQuery.isReady;
}, function(ready) {
if (ready) {
callback.call(self);
}
else {
loadWait();
}
});
});
}
}
else {
loadWait();
}
}
|
javascript
|
{
"resource": ""
}
|
|
q56215
|
train
|
function(element, callback, nowait) {
var self = this;
if (!nowait) {
this.waitForPage(function() {
self.waitForElement(element, callback, true);
});
}
else {
var loadWait = function() {
setTimeout(function() {
self.waitForElement(element, callback, true);
}, 100);
};
if (nowait) {
getPage(function(page) {
page.evaluate(function(element) {
var element = jQuery(element);
return ((element.length > 0) && element.is(':visible'));
}, function(found) {
if (found) {
self.debug('Element ' + element + ' found');
callback.call(self);
}
else {
loadWait();
}
}, element);
});
}
else {
loadWait();
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q56216
|
train
|
function(filename, done) {
this.debug('Capturing page at ' + filename);
getPage(function(page) {
page.render(filename, done);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q56217
|
train
|
function(selector, filename, done) {
this.debug('Upload ' + filename + ' to ' + selector);
getPage(function(page) {
page.uploadFile(selector, filename, done);
});
done();
}
|
javascript
|
{
"resource": ""
}
|
|
q56218
|
formatRuntime
|
train
|
function formatRuntime(raw) {
var hours, minutes;
if (!raw) {
return null;
}
hours = raw.match(/(\d+) h/);
minutes = raw.match(/(\d+) min/);
hours = hours ? hours[1] : 0;
minutes = minutes ? +minutes[1] : 0;
return (hours * 60) + minutes;
}
|
javascript
|
{
"resource": ""
}
|
q56219
|
formatList
|
train
|
function formatList(raw) {
var list;
if (!raw) {
return [];
}
list = raw.replace(/\(.+?\)/g, '').split(', ');
list = list.map(function (item) {
return item.trim();
});
return list;
}
|
javascript
|
{
"resource": ""
}
|
q56220
|
formatAwards
|
train
|
function formatAwards(raw) {
var wins, nominations;
if (!raw) {
return { wins: 0, nominations: 0, text: '' };
}
wins = raw.match(/(\d+) wins?/i);
nominations = raw.match(/(\d+) nominations?/i);
return {
wins: wins ? +wins[1] : 0,
nominations: nominations ? +nominations[1] : 0,
text: raw
};
}
|
javascript
|
{
"resource": ""
}
|
q56221
|
train
|
function(r, x) {
var r1 = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
var r2 = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
curve25519_sqrmodp(r1, x); // r1 = x^2
curve25519_mulasmall(r2, x, 486662); // r2 = Ax
curve25519_addmodp(r, r1, r2); // r = x^2 + Ax
curve25519_addmodp(r1, r, curve25519_one()); // r1 = x^2 + Ax + 1
curve25519_mulmodp(r, r1, x); // r = x^3 + Ax^2 + x
}
|
javascript
|
{
"resource": ""
}
|
|
q56222
|
train
|
function () {
this.rings.forEach(function (ringEl) {
var scale = ringEl.getComputedAttribute('scale');
ringEl.setAttribute('scale', {
x: scale.x * 1.06 + .05,
y: scale.y * 1.06 + .05,
z: scale.z
});
});
}
|
javascript
|
{
"resource": ""
}
|
|
q56223
|
getTokenDefault
|
train
|
function getTokenDefault(code, token, oauth2Client) {
return new Promise((resolve, reject) => {
const requestData = {
code,
token,
};
request({
url: 'https://us-central1-gas-include.cloudfunctions.net/getToken',
method: "POST",
json: true,
headers: {
"content-type": "application/json",
},
body: requestData,
}, (error, response, body) => {
const token = body;
if (error) {
reject(error);
} else if (response.statusCode === 200) {
resolve(token);
} else {
reject({
message: 'Failed to get a token for the default Oauth client.',
print: true,
});
}
});
});
}
|
javascript
|
{
"resource": ""
}
|
q56224
|
getTokenCustom
|
train
|
function getTokenCustom(code, oauth2Client) {
return new Promise((resolve, reject) => {
if (code) {
oauth2Client.getToken(code, (err, newToken) => {
if (err) {
reject(err);
return;
}
resolve(newToken);
return;
});
} else {
oauth2Client.refreshAccessToken((err, newToken) => {
if (err) {
reject(err);
}
resolve(newToken);
return;
});
}
});
}
|
javascript
|
{
"resource": ""
}
|
q56225
|
getScripts
|
train
|
function getScripts(auth, nameFilter, nextPageToken, allFiles) {
return new Promise((resolve, reject) => {
let query = '';
if (nameFilter) {
query = `mimeType='${constants.MIME_GAS}' and name contains '${nameFilter}'`;
} else {
query = `mimeType='${constants.MIME_GAS}'`;
}
const drive = google.drive('v3');
drive.files.list({
auth,
pageSize: 1000,
fields: 'nextPageToken, files(id, name, description, createdTime, modifiedTime)',
orderBy: 'name',
includeTeamDriveItems: true,
supportsTeamDrives: true,
q: query,
spaces: 'drive',
pageToken: nextPageToken,
}, (err, response) => {
if (err) {
triageGoogleError(err, 'listScriptFiles').then((triaged) => {
reject(triaged);
}).catch((notTriaged) => {
reject(notTriaged);
});
return;
}
const files = response.data.files;
allFiles = allFiles.concat(files);
// Need to get another page of results?
if (response.nextPageToken) {
getScripts(auth, nameFilter, response.nextPageToken, allFiles).then((allFiles) => {
resolve(allFiles);
}).catch((err) => {
reject(err);
});
return;
} else {
resolve(allFiles);
return;
}
});
});
}
|
javascript
|
{
"resource": ""
}
|
q56226
|
endDialog
|
train
|
function endDialog(success, config) {
if (success) {
createConfigFile(config);
console.log();
process.stdout.write('Succesfully configured gas');
checkbox.display('green');
process.exit(0);
} else {
console.log(`Only 'y' and 'n' are accepted inputs.`);
process.stdout.write('Failed to configure gas');
checkbox.display('red');
process.exit(1);
}
}
|
javascript
|
{
"resource": ""
}
|
q56227
|
importConfig
|
train
|
function importConfig(optionalPath) {
process.stdout.write(`Importing your config from '${optionalPath}'`);
let config;
try {
config = fs.readJsonSync(optionalPath, 'utf8');
} catch (err) {
checkbox.display('red');
process.stdout.write(`Can't seem to read '${optionalPath}'`);
checkbox.display('red');
process.exit(1);
}
fs.removeSync(tokenFile);
// Overwrite current config
createConfigFile(config);
checkbox.display('green');
}
|
javascript
|
{
"resource": ""
}
|
q56228
|
exportConfig
|
train
|
function exportConfig(optionalPath) {
// Read content of the global config file
let config = fs.readFileSync(configFile, 'utf8');
if (!config) {
config = '{}';
}
// Create file or print output
if (optionalPath) {
process.stdout.write(`Exporting your config to '${optionalPath}'`);
// Create a file in the specified location
const file = {
name: optionalPath,
source: config,
};
createFile(file);
checkbox.display('green');
} else {
console.log(config);
}
}
|
javascript
|
{
"resource": ""
}
|
q56229
|
enterConfig
|
train
|
function enterConfig() {
const config = {};
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout,
});
rl.question(`Do you want to use .gs as extension for your local code files instead of .js? [${'y'.green}/${'n'.red}]\n > `, (input) => {
if (input === 'y') {
config.extension = '.gs';
} else if (input !== 'n') {
endDialog(false);
rl.close();
}
rl.question(`Do you want to use a custom OAuth 2.0 client to authenticate with Google? [${'y'.green}/${'n'.red}]\n > `, (input) => {
if (input === 'y') {
config.client = {};
console.log();
rl.question(`Enter the 'Client ID' of your client \n > `, (input) => {
config.client.id = input;
rl.question(`Enter the 'Client secret' of your client\n > `, (input) => {
config.client.secret = input;
// Remove token file to force reauth
fs.removeSync(tokenFile);
endDialog(true, config);
rl.close();
});
});
} else if (input === 'n') {
endDialog(true, config);
rl.close();
} else {
endDialog(false);
rl.close();
}
});
});
}
|
javascript
|
{
"resource": ""
}
|
q56230
|
deleteRemote
|
train
|
function deleteRemote(auth, projectId, name) {
return new Promise((resolve, reject) => {
const drive = google.drive('v3');
const options = {
auth,
supportsTeamDrives: true,
fileId: projectId,
};
drive.files.delete(options, (err, result) => {
if (err) {
triageGoogleError(err, 'remoteDeleteProject').then((triaged) => {
reject(triaged);
}).catch((notTriaged) => {
reject(notTriaged);
});
} else {
resolve(result.data);
return;
}
return;
});
});
}
|
javascript
|
{
"resource": ""
}
|
q56231
|
queryProperties
|
train
|
function queryProperties(props, nodeTypeStack, childIndexStack = [], text) {
let stateId = 0
for (let i = 0, {length} = nodeTypeStack; i < length; i++) {
const nodeType = nodeTypeStack[i];
const state = props.states[stateId];
let found_transition = false;
for (const transition of state.transitions) {
if (
(transition.type === nodeType) &&
(transition.index == null || transition.index === childIndexStack[i]) &&
(transition.text == null || new RegExp(transition.text).test(text))
) {
stateId = transition.state_id;
found_transition = true;
break;
}
}
if (!found_transition) {
stateId = state.default_next_state_id
}
// console.log(
// nodeType, '->', stateId,
// props.property_sets[props.states[stateId].property_set_id]
// );
}
return props.property_sets[props.states[stateId].property_set_id]
}
|
javascript
|
{
"resource": ""
}
|
q56232
|
parseProperties
|
train
|
function parseProperties(source, baseDirectory) {
// Get the raw SCSS concrete syntax tree.
const rawTree = parseCSS(source);
removeWhitespace(rawTree);
// Convert the concrete syntax tree into a more convenient AST.
let schema
const rootRules = []
for (const rule of rawTree.value) {
if (rule.type === 'atrule') {
removeWhitespace(rule);
const [keyword, argument] = rule.value;
if (keyword.value === 'schema') {
schema = visitSchema(argument, baseDirectory)
} else if (keyword.value === 'import') {
rootRules.push(...visitImport(argument, baseDirectory))
}
} else {
rootRules.push(visitRule(rule, false))
}
}
// Flatten out any nested selectors.
const rules = []
for (const rootRule of rootRules) {
flattenRule(rootRule, rules, [[]]);
}
const validator = new Validator();
for (const rule of rules) {
// Validate each rule's properties against the schema.
for (const property in rule.properties) {
if (schema) {
const propertySchema = schema[property]
const value = rule.properties[property]
if (!propertySchema) {
throw new Error(`Property '${property}' is not present in the schema`);
}
const {errors} = validator.validate(value, propertySchema);
if (errors.length > 0) {
throw new Error(`Invalid value '${value}' for property '${property}'`)
}
}
}
rule.selectors = rule.selectors.map(applyPseudoClasses)
}
return rules;
}
|
javascript
|
{
"resource": ""
}
|
q56233
|
removeWhitespace
|
train
|
function removeWhitespace(node) {
node.value = node.value.filter(node => !isWhitespace(node))
}
|
javascript
|
{
"resource": ""
}
|
q56234
|
getExtensionFromFiletype
|
train
|
function getExtensionFromFiletype(filetype, codeExtensions) {
let extension;
if (filetype === 'HTML') {
extension = '.html';
} else if (filetype === 'JSON') {
extension = '.json';
} else {
extension = codeExtensions[0];
}
return extension;
}
|
javascript
|
{
"resource": ""
}
|
q56235
|
isPushable
|
train
|
function isPushable(extension, filename, codeExtensions, ignoreRegexes) {
const fullFilename = `${filename}${extension}`;
let ignored = false;
const filenameAndExtensionIsValid = (codeExtensions && codeExtensions.indexOf(extension) > -1 || extension === '.html' || (extension === '.json' && filename === 'appsscript'));
for (const regex of ignoreRegexes) {
if (fullFilename.match(regex)) {
ignored = true;
break;
}
}
return filenameAndExtensionIsValid && !ignored;
}
|
javascript
|
{
"resource": ""
}
|
q56236
|
get
|
train
|
function get(color) {
const symbols = getSymbols();
let result;
if (color === 'green') {
result = `[${symbols.check.green}]`;
} else if (color === 'red') {
result = `[${symbols.cross.red}]`;
} else if (color === 'yellow') {
result = `[${symbols.check.yellow}]`;
}
return result;
}
|
javascript
|
{
"resource": ""
}
|
q56237
|
createFile
|
train
|
function createFile(file) {
fs.ensureFileSync(file.name);
fs.writeFileSync(file.name, file.source);
return;
}
|
javascript
|
{
"resource": ""
}
|
q56238
|
getMetadata
|
train
|
async function getMetadata(auth, identifier) {
// Try to get info assuming identifier is an id
const metadata = await new Promise((resolve, reject) => {
const script = google.script('v1');
script.projects.get({
auth,
scriptId: identifier,
}, (err, result) => {
if (err) {
resolve(false);
} else {
resolve(result.data);
}
return;
});
});
if (metadata) {
return {
projectId: metadata.scriptId,
name: metadata.title,
createTime: metadata.createTime,
updateTime: metadata.updateTime,
creator: {
name: metadata.creator.name,
email: metadata.creator.email,
},
};
}
// Identifier did not match an id
const files = await getScripts(auth, identifier, null, []);
if (files.length === 0) { // 0 results
throw {
message: `No remote project with name or id '${identifier}' found ${checkbox.get('red')}\n` +
`Use 'gas get projects' to show all your remote Google Apps Script projects`,
print: true,
};
} else if (files.length === 1) { // 1 result
const result = files[0];
if (result.name === identifier) {
result.name = sanitize(result.name);
return {
projectId: result.id,
name: result.name,
createTime: result.createdTime,
updateTime: result.modifiedTime,
creator: {
name: '',
email: '',
},
};
} else {
// Check for exact match if exists
throw {
message: `No exact match with name or id '${identifier}' found ${checkbox.get('red')}\n` +
`Did you perhaps mean: '${result.name}'?`,
print: true,
};
}
} else { // More than 1 result
const exactMatches = [];
for (const match of files) {
if (match.name === identifier) {
exactMatches.push(match);
}
}
if (exactMatches.length === 0) { // 0 results
let message = `No project called '${identifier}' found ${checkbox.get('red')}\n`;
message += 'Did you mean one of these projects? :\n';
for (const file2 of files) {
message += `[${file2.id}] ${file2.name}\n`;
}
const err = {
message,
print: true,
};
} else if (exactMatches.length === 1) { // 1 result
exactMatches[0].name = sanitize(exactMatches[0].name);
return {
projectId: exactMatches[0].id,
name: exactMatches[0].name,
createTime: exactMatches[0].createdTime,
updateTime: exactMatches[0].lastModifiedAt,
creator: {
name: '',
email: '',
},
};
} else {
let message = `Multiple projects called '${identifier}' found ${checkbox.get('red')}\n`;
message += `Use 'gas rename <projectId> <newProjectName>' to rename script so they have a unique name or use the projectId as identifier\n\n`;
for (const exactMatch of exactMatches) {
message += `[${exactMatch.id}] ${exactMatch.name}\n`;
}
throw {
message,
print: true,
};
}
}
}
|
javascript
|
{
"resource": ""
}
|
q56239
|
Parser
|
train
|
function Parser(tokens, options) {
options = options || {};
if (!Array.isArray(tokens)) {
throw new Error('Expected tokens to be an Array but got "' + (typeof tokens) + '"');
}
if (typeof options !== 'object') {
throw new Error('Expected "options" to be an object but got "' + (typeof options) + '"');
}
this.tokens = new TokenStream(tokens);
this.filename = options.filename;
this.src = options.src;
this.inMixin = 0;
this.plugins = options.plugins || [];
}
|
javascript
|
{
"resource": ""
}
|
q56240
|
train
|
function(type){
if (this.peek().type === type) {
return this.advance();
} else {
this.error('INVALID_TOKEN', 'expected "' + type + '", but got "' + this.peek().type + '"', this.peek());
}
}
|
javascript
|
{
"resource": ""
}
|
|
q56241
|
train
|
function(){
var tok = this.expect('call');
var name = tok.val;
var args = tok.args;
var mixin = {
type: 'Mixin',
name: name,
args: args,
block: this.emptyBlock(tok.loc.start.line),
call: true,
attrs: [],
attributeBlocks: [],
line: tok.loc.start.line,
column: tok.loc.start.column,
filename: this.filename
};
this.tag(mixin);
if (mixin.code) {
mixin.block.nodes.push(mixin.code);
delete mixin.code;
}
if (mixin.block.nodes.length === 0) mixin.block = null;
return mixin;
}
|
javascript
|
{
"resource": ""
}
|
|
q56242
|
triageGoogleError
|
train
|
async function triageGoogleError(err, origin) {
// console.log(err);
const triaged = {
err,
origin,
print: true,
};
if (err && err.code === 401) {
triaged.message = `Your credentials appear to be invalid.\nRun 'gas auth -f' to re-authenticate.`;
triaged.extraInfo = `Invalid Credentials`;
} else if (err === `Error: invalid_grant`) {
triaged.message = `Your credentials appear to be invalid.\nRun 'gas auth -f' to re-authenticate.`;
triaged.extraInfo = `Invalid Grant`;
} else if (err && err.code === 403) {
triaged.message = err.message;
triaged.extraInfo = `Not allowed`;
} else if (err && err.code === 404) {
triaged.message = err.message;
triaged.extraInfo = `Not found`;
} else if (err && err.code === `ENOTFOUND`) {
triaged.message = `Can't seem to reach the Google servers.`;
triaged.extraInfo = `No connection`;
} else if (err && err.code === `ECONNRESET`) {
triaged.message = `Unexpected closed connection.`;
triaged.extraInfo = `Closed connection`;
} else if (err && err.code === 400 && origin === 'pushToRemote') {
const projectRoot = await findInProject('.', constants.META_DIR);
if (projectRoot.found) {
// Find syntax errors in all files
const files = getAllFiles(projectRoot.folder, '.', []);
const syntaxErrors = [];
for (const file of files) {
const extension = path.parse(file).ext;
if (extension === '.js' || extension === '.gs') {
const src = fs.readFileSync(path.join(projectRoot.folder, file));
const syntaxErr = check(src, file);
if (syntaxErr) {
syntaxErrors.push(syntaxErr);
}
}
}
// Create a message with a summary of found syntax errors
if (syntaxErrors.length > 0) {
let message = `The code you are trying to push appears to have 1 or more syntax error(s).`;
for (const err of syntaxErrors) {
message += `-------------------------------------------------------------------------------------------------\n`;
message += `${err}\n`;
}
triaged.extraInfo = `${syntaxErrors}`;
} else {
triaged.message = `Google doesn't accept the code you are trying to push. Try doublechecking for project structure errors.`;
triaged.extraInfo = `No syntax errors`;
}
} else {
triaged.message = `Google doesn't accept the code you are trying to push. Try doublechecking for project structure errors.`;
triaged.extraInfo = `No .gas folder found`;
}
} else if (err) {
triaged.message = (`gas returned an error: ${err}`);
triaged.extraInfo = `Not a known error`;
} else {
triaged.message = (`O-oh. Something seems to have gone wrong.`);
triaged.extraInfo = `No error passed to the function`;
}
return triaged;
}
|
javascript
|
{
"resource": ""
}
|
q56243
|
processSource
|
train
|
function processSource(code, dependencyList, depedencyName) {
// Replace function declarations
const packageName = dependencyList[depedencyName].packageName;
code = code.replace(/(\s*)function\s([A-z]*)\s*\(*/g, `$1function ${packageName}_$2(`);
// TODO replace function calls to dependencies
const dependencies = dependencyList[depedencyName].dependencies;
if (dependencies) {
for (const dependency of Reflect.ownKeys(dependencies)) {
const oldPrefix = dependencyList[dependency].packageName;
console.log(oldPrefix);
var re = new RegExp(`[ ]*${oldPrefix}_([A-z]*)[ ]*\\(`, "g");
code = code.replace(re, ` ${dependency}_$1(`);
}
}
return code;
}
|
javascript
|
{
"resource": ""
}
|
q56244
|
downloadDependencies
|
train
|
async function downloadDependencies(rootFolder, dependencyList) {
const includeFolder = path.join(rootFolder, constants.INCLUDE_DIR);
fs.removeSync(includeFolder);
const contentPath = path.join(includeFolder, 'content.json');
// Create new content.json
createFile({
name: contentPath,
source: JSON.stringify(dependencyList),
});
// Extensions
const extensions = eaft.getCodeExtensions();
// Download new dependencies
for (const dependency of Reflect.ownKeys(dependencyList)) {
const dependencies = dependencyList[dependency].dependencies;
const package = dependencyList[dependency].packageName;
const version = dependencyList[dependency].version;
const isRootDependency = dependencyList[dependency].isRootDependency;
// Use package name as dependency if it is a root dependency
let dependencyName;
if (isRootDependency) {
dependencyName = package;
} else {
dependencyName = dependency;
}
const packagePath = path.join(includeFolder, dependencyName);
// Get library code
url = `${constants.FIREBASE_DATABASE_URL}/package/${package}/version/${version}/code.json`;
const library = await request({
url,
method: "GET",
json: true,
headers: {
"content-type": "application/json",
},
});
// Write library files
for (const file of library.files) {
const extension = eaft.getExtensionFromFiletype(file.type, extensions);
const fileName = `${file.name}${extension}`;
const source = processSource(file.source, dependencyList, dependency);
createFile({
name: path.join(packagePath, fileName),
source,
});
}
}
}
|
javascript
|
{
"resource": ""
}
|
q56245
|
saveDependencies
|
train
|
async function saveDependencies(dependency, includeFile, projectRoot) {
let gasInclude = {};
if (includeFile.found) {
gasInclude = fs.readJsonSync(path.join(includeFile.folder, constants.INCLUDE_FILE));
} else if (projectRoot.found) {
includeFile.folder = projectRoot.folder;
} else {
includeFile.folder = '.';
}
if (!gasInclude.dependencies) {
gasInclude.dependencies = {};
}
const url = `${constants.FIREBASE_DATABASE_URL}/package/${dependency}/versions.json`;
const versions = await request({
url,
method: "GET",
json: true,
headers: {
"content-type": "application/json",
},
});
if (versions) {
// Get highest version
let maxVersion = '0.0.0';
for (const version of Reflect.ownKeys(versions)) {
const newVersion = version.replace(/_/g, '.');
if (semver.gt(newVersion, maxVersion)) {
maxVersion = newVersion;
}
}
gasInclude.dependencies[dependency] = `^${maxVersion}`;
createFile({
name: path.join(includeFile.folder, constants.INCLUDE_FILE),
source: JSON.stringify(gasInclude),
});
return includeFile.folder;
} else {
throw {
message: `Can't seem to find '${dependency}' in gas-include. Please double check your input.`,
print: true,
};
}
}
|
javascript
|
{
"resource": ""
}
|
q56246
|
train
|
function (locals) {
var stream = new ReadableStream();
// streaming will be set to false whenever there is back-pressure
var streaming = false;
function release() {
streaming = true;
}
// make sure _read is always implemented
stream._read = release;
// then-yield unwrap function
// which implements the backpressure pause mechanism
function unwrap(value) {
if (streaming) return value;
return new Promise(function (resolve) {
stream._read = function () {
release();
this._read = release;
resolve(value);
}
});
}
var template = fn(locals, runtime, {
push: function () {
for (var i = 0; i < arguments.length; i++)
if (!stream.push(arguments[i].toString())) streaming = false;
}
});
// call our function, setting `streaming` to `false` whenever
// the buffer is full and there is back-pressure
var result = ty.spawn(template, Promise.resolve, unwrap);
// once the function completes, we end the stream by pushing `null`
if (result)
result.then(stream.push.bind(stream, null), function (err) {
stream.emit('error', err);
stream.push(null);
});
else
stream.push(null);
return stream;
}
|
javascript
|
{
"resource": ""
}
|
|
q56247
|
unwrap
|
train
|
function unwrap(value) {
if (streaming) return value;
return new Promise(function (resolve) {
stream._read = function () {
release();
this._read = release;
resolve(value);
}
});
}
|
javascript
|
{
"resource": ""
}
|
q56248
|
enrouteHotReloadProxy
|
train
|
function enrouteHotReloadProxy(req, res, next) {
return reloadProxy({
basePath: opts.basePath,
method: method,
req: req,
res: res,
routeName: routeName,
sourceFile: sourceFile,
excludePath: opts.excludePath
}, next);
}
|
javascript
|
{
"resource": ""
}
|
q56249
|
reloadProxy
|
train
|
function reloadProxy(opts, cb) {
assert.object(opts, 'opts');
assert.string(opts.basePath, 'opts.basePath');
assert.optionalString(opts.excludePath, 'opts.excludePath');
assert.string(opts.method, 'opts.method');
assert.object(opts.req, 'opts.req');
assert.object(opts.res, 'opts.res');
assert.string(opts.routeName, 'opts.routeName');
assert.string(opts.sourceFile, 'opts.sourceFile');
assert.func(cb, 'cb');
var excludeFullpath = opts.basePath + '/' + opts.excludePath;
// clear require cache for code loaded from a specific base dir
Object.keys(require.cache).forEach(function (cacheKey) {
if (opts.excludePath && cacheKey.indexOf(excludeFullpath) !== -1) {
return;
} else if (cacheKey.indexOf(opts.basePath) !== -1) {
delete require.cache[cacheKey];
}
});
var handlers;
try {
handlers = require(opts.sourceFile);
} catch (e) {
var err = new verror.VError({
name: 'EnrouteRequireError',
cause: e,
info: {
file: opts.sourceFile,
route: opts.routeName,
method: opts.method
}
}, 'failed to require file, possible syntax error');
// now that the chain has failed, send back the require error.
return cb(err);
}
// if no require error, execute the handler chain. any errors that occur at
// runtime should be a runtime exception.
var handlerChain = compose(handlers);
return handlerChain(opts.req, opts.res, cb);
}
|
javascript
|
{
"resource": ""
}
|
q56250
|
downloadRemote
|
train
|
function downloadRemote(auth, projectId, dir, method) {
return new Promise((resolve, reject) => {
const gasDir = path.join('.', dir, constants.META_DIR);
if (method === 'clone' && fs.existsSync(path.join('.', dir))) {
reject({
message: `Oops, the directory '${dir}' seems to exist already.\nRemove this folder or use 'gas link' to link your project to the correct folder.`,
print: true,
});
return;
}
const file = {
name: path.join(gasDir, constants.META_ID),
source: projectId,
};
createFile(file);
const remote = path.join(gasDir, constants.META_REMOTE);
const script = google.script('v1');
script.projects.getContent({
auth,
scriptId: projectId,
}, (err, content) => {
if (err) {
fs.removeSync(remote);
triageGoogleError(err, 'downloadRemote').then((triaged) => {
reject(triaged);
}).catch((notTriaged) => {
reject(notTriaged);
});
} else {
createFile({
name: remote,
source: JSON.stringify(content.data),
});
resolve();
}
return;
});
});
}
|
javascript
|
{
"resource": ""
}
|
q56251
|
Client
|
train
|
function Client(opts) {
if (!(this instanceof Client)) {
return new Client(opts);
}
var options = {};
// If single connection provided, array-ify it
if (typeof opts === 'string') {
options.hosts = [opts];
opts = options;
} else if (typeof opts === 'undefined') {
opts = {};
} else if (_.isArray(opts)) {
options.hosts = opts;
opts = options;
}
_.defaults(opts, {
autodiscover: false,
bufferBeforeError: 1000,
disabled: false,
hosts: null,
reconnect: true,
onNetError: function onNetError(err) { console.error(err); },
queue: true,
netTimeout: 500,
backoffLimit: 10000,
maxValueSize: 1048576
});
// Iterate over options, assign each to this object
R.keys(opts).forEach(function(key) {
this[key] = opts[key];
}, this);
if (this.queue) {
this.buffer = new Immutable.List();
}
debug('Connect options', opts);
this.connect();
}
|
javascript
|
{
"resource": ""
}
|
q56252
|
getUserInfo
|
train
|
function getUserInfo(auth) {
return new Promise((resolve, reject) => {
const oauth2 = google.oauth2({
auth,
version: 'v2',
});
oauth2.userinfo.v2.me.get((err, res) => {
if (err) {
reject(err);
} else {
resolve(res.data);
}
return;
});
});
}
|
javascript
|
{
"resource": ""
}
|
q56253
|
authWithFirebase
|
train
|
async function authWithFirebase(auth) {
try {
const config = {
apiKey: constants.FIREBASE_DATABASE_PUBLIC_APIKEY,
databaseURL: constants.FIREBASE_DATABASE_URL,
};
if (!firebase.apps.length) {
firebase.initializeApp(config);
}
const credential = firebase.auth.GoogleAuthProvider.credential(auth.credentials.id_token);
await firebase.auth().signInAndRetrieveDataWithCredential(credential);
return true;
} catch (err) {
err.origin = 'authWithFirebase';
await error.log(err);
return false;
}
}
|
javascript
|
{
"resource": ""
}
|
q56254
|
setUserInfo
|
train
|
async function setUserInfo(auth) {
try {
const authenticated = await authWithFirebase(auth);
const token = await firebase.auth().currentUser.getIdToken();
const userId = firebase.auth().currentUser.uid;
const userInfo = await getUserInfo(auth);
userInfo.version = pjson.version;
userInfo.lastLogin = {
".sv": "timestamp",
};
const infoUrl = `${constants.FIREBASE_DATABASE_URL}/users/${userId}.json?auth=${token}`;
await request({
url: infoUrl,
method: "PATCH",
json: true,
headers: {
"content-type": "application/json",
},
body: userInfo,
});
return true;
} catch (err) {
err.origin = 'setUserInfo';
await error.log(err);
return false;
}
}
|
javascript
|
{
"resource": ""
}
|
q56255
|
publish
|
train
|
async function publish(auth, rootPath) {
// check if version does not exist yet
// check if user is allowed to publish
// check if version is larger than last version
// names cant contain _- etc, maybe just stick to lowercase letters?
// if projectKey, check that we can access the file?
package = fs.readJsonSync(path.join(rootPath, constants.INCLUDE_FILE));
code = fs.readJsonSync(path.join(rootPath, '.gas/publish.json'));
const versionUrl = package.version.replace(/\./g, '_');
// TODO
// console.log(semver.valid(package.version));
// console.log(versionUrl);
try {
const authenticated = await authWithFirebase(auth);
const token = await firebase.auth().currentUser.getIdToken();
const userId = firebase.auth().currentUser.uid;
let url;
let result;
// Set a packageName to active
url = `${constants.FIREBASE_DATABASE_URL}/packages/${package.name}.json?auth=${token}`;
result = await request({
url,
method: "PATCH",
json: true,
headers: {
"content-type": "application/json",
},
body: {
status: 'active',
},
});
// Patch users in a package
url = `${constants.FIREBASE_DATABASE_URL}/package/${package.name}/userIds/${userId}.json?auth=${token}`;
result = await request({
url,
method: "PATCH",
json: true,
headers: {
"content-type": "application/json",
},
body: {
status: 'active',
},
});
// Set version of a package to active
url = `${constants.FIREBASE_DATABASE_URL}/package/${package.name}/versions.json?auth=${token}`;
result = await request({
url,
method: "PATCH",
json: true,
headers: {
"content-type": "application/json",
},
body: {
[versionUrl]: true,
},
});
// Patch a version in a package
url = `${constants.FIREBASE_DATABASE_URL}/package/${package.name}/version/${versionUrl}.json?auth=${token}`;
result = await request({
url,
method: "PATCH",
json: true,
headers: {
"content-type": "application/json",
},
body: {
code,
dependencies: package.dependencies,
description: package.description,
homepage: package.homepage,
license: package.license,
readme: 'README.md',
repository: package.repository,
projectKey: package.projectKey,
timestamp: {
".sv": "timestamp",
},
userId,
},
});
return true;
} catch (err) {
err.origin = 'test';
await error.log(err);
return false;
}
}
|
javascript
|
{
"resource": ""
}
|
q56256
|
getId
|
train
|
function getId(rootFolder) {
return new Promise((resolve, reject) => {
const dir = path.join(rootFolder, constants.META_DIR, constants.META_ID);
fs.readFile(dir, 'utf8', (err, id) => {
if (err) {
reject(err);
return;
} else {
resolve(id);
return;
}
});
});
}
|
javascript
|
{
"resource": ""
}
|
q56257
|
renameRemote
|
train
|
function renameRemote(auth, projectId, name, newName) {
return new Promise((resolve, reject) => {
if (newName === name) {
resolve(false);
return;
}
const drive = google.drive('v3');
drive.files.update({
auth,
supportsTeamDrives: true,
fileId: projectId,
resource: {
name: newName,
},
}, (err, result) => {
if (err) {
triageGoogleError(err, 'remoteRenameProject').then((triaged) => {
reject(triaged);
}).catch((notTriaged) => {
reject(notTriaged);
});
} else {
resolve(true);
}
return;
});
});
}
|
javascript
|
{
"resource": ""
}
|
q56258
|
doAjaxRequest
|
train
|
function doAjaxRequest(type, url, opts) {
var params = {};
params.type = type;
params.url = url;
// don't just do a blind copy of params here. we want to restrict what can be used to avoid any jquery specific options.
params.data = opts.data;
params.contentType = opts.contentType;
params.dataType = opts.responseType;
params.success = opts.success;
params.error = opts.error;
params.global = opts.global;
params.async = opts.async;
logRequest(params);
var xhr = $.ajax(params);
return new neon.util.AjaxRequest(xhr);
}
|
javascript
|
{
"resource": ""
}
|
q56259
|
doPostBinary
|
train
|
function doPostBinary(binary, url, successCallback, errorCallback) {
var xhr = new XMLHttpRequest();
xhr.open('POST', url);
xhr.onload = function() {
if(xhr.status === 200) {
successCallback(xhr.response);
} else {
errorCallback(xhr.response);
}
hideDefaultSpinner();
};
showDefaultSpinner();
xhr.send(binary);
}
|
javascript
|
{
"resource": ""
}
|
q56260
|
saveState
|
train
|
function saveState(instanceId, stateObject, successCallback, errorCallback) {
var strObject = JSON.stringify(stateObject);
return neon.util.ajaxUtils.doPostJSON({
instanceId: instanceId,
state: strObject
}, neon.serviceUrl('widgetservice', 'savestate'), {
success: successCallback,
error: errorCallback,
global: false
});
}
|
javascript
|
{
"resource": ""
}
|
q56261
|
getSavedState
|
train
|
function getSavedState(id, successCallback) {
return neon.util.ajaxUtils.doGet(
neon.serviceUrl('widgetservice', 'restorestate/' + encodeURIComponent(id)), {
success: function(data) {
if(!data) {
return;
}
if(successCallback && typeof successCallback === 'function') {
successCallback(data);
}
},
error: function() {
//Do nothing, the state does not exist.
},
responseType: 'json'
}
);
}
|
javascript
|
{
"resource": ""
}
|
q56262
|
getPropertyKeys
|
train
|
function getPropertyKeys(successCallback, errorCallback) {
return neon.util.ajaxUtils.doGet(
neon.serviceUrl('propertyservice', '*'), {
success: successCallback,
error: errorCallback,
responseType: 'json'
}
);
}
|
javascript
|
{
"resource": ""
}
|
q56263
|
removeProperty
|
train
|
function removeProperty(key, successCallback, errorCallback) {
return neon.util.ajaxUtils.doDelete(
neon.serviceUrl('propertyservice', key), {
success: successCallback,
error: errorCallback,
responseType: 'json'
}
);
}
|
javascript
|
{
"resource": ""
}
|
q56264
|
setProperty
|
train
|
function setProperty(key, value, successCallback, errorCallback) {
return neon.util.ajaxUtils.doPost(
neon.serviceUrl('propertyservice', key), {
data: value,
contentType: 'text/plain',
success: successCallback,
error: errorCallback,
responseType: 'json'
}
);
}
|
javascript
|
{
"resource": ""
}
|
q56265
|
getInstanceId
|
train
|
function getInstanceId(qualifier, successCallback) {
// If the first argument is a function, assume that is the callback and that the caller
// wants the session id
if(typeof qualifier === 'function') {
successCallback = qualifier;
qualifier = null;
}
return neon.util.ajaxUtils.doGet(
neon.serviceUrl('widgetservice', 'instanceid', buildInstanceIdQueryString(qualifier)), {
success: function(instanceId) {
if(!instanceId) {
return;
}
if(successCallback && typeof successCallback === 'function') {
successCallback(instanceId);
}
},
error: function() {
}
}
);
}
|
javascript
|
{
"resource": ""
}
|
q56266
|
buildQualifierString
|
train
|
function buildQualifierString(qualifier) {
var fullQualifier = qualifier || '';
// when running in OWF, it is possible to have the same widget running multiple times so append
// the owf widget instanceid to the qualifier
if(neon.util.owfUtils.isRunningInOWF()) {
fullQualifier += OWF.getInstanceId();
}
return fullQualifier;
}
|
javascript
|
{
"resource": ""
}
|
q56267
|
addGitIgnore
|
train
|
function addGitIgnore(rootFolder) {
// If no .gitignore files exists, add one
const gitignore = path.join(rootFolder, '.gitignore');
if (!fs.existsSync(gitignore)) {
fs.writeFileSync(gitignore, gitignoreContent);
}
}
|
javascript
|
{
"resource": ""
}
|
q56268
|
addGasIgnore
|
train
|
function addGasIgnore(rootFolder) {
// If no .gitignore files exists, add one
const gasignore = path.join(rootFolder, constants.IGNORE_FILE);
if (!fs.existsSync(gasignore)) {
fs.writeFileSync(gasignore, gasignoreContent);
}
}
|
javascript
|
{
"resource": ""
}
|
q56269
|
getIgnoreRegexes
|
train
|
function getIgnoreRegexes(rootFolder) {
const gasignoreFilepath = path.join(rootFolder, constants.IGNORE_FILE);
let regexes = [];
if (fs.existsSync(gasignoreFilepath)) {
regexes = parse(fs.readFileSync(gasignoreFilepath));
}
return regexes;
}
|
javascript
|
{
"resource": ""
}
|
q56270
|
getAndWriteIncludedFile
|
train
|
function getAndWriteIncludedFile(file, includeDir) {
return new Promise((resolve, reject) => {
const fileName = file[0];
const fileURL = file[1];
const options = {
url: fileURL,
headers: {
'User-Agent': 'request',
},
};
request.get(options, (err, response, body) => {
if (!err && response.statusCode === 200) {
fs.writeFile(path.join(includeDir, fileName), body, (writeErr) => {
if (writeErr) {
resolve({
fileName,
successful: false,
});
} else {
resolve({
fileName,
successful: true,
});
}
return;
});
} else {
resolve({
fileName,
successful: false,
});
return;
}
});
});
}
|
javascript
|
{
"resource": ""
}
|
q56271
|
downloadIncludedFiles
|
train
|
function downloadIncludedFiles(included, dir) {
return new Promise((resolve, reject) => {
const includeDir = dir ? path.join('.', dir, constants.INCLUDE_DIR) : path.join('.', constants.INCLUDE_DIR);
// Create include folder if it doesn't exist yet
try {
if (!fs.existsSync(includeDir)) {
fs.mkdirSync(includeDir);
}
// Create list of filenames
const filenames = [];
for (const includeFile of included) {
filenames.push(includeFile[0]);
}
// Remove all files in includeDir not in includeFile
const allFiles = fs.readdirSync(includeDir);
const filesToDelete = [];
for (const file of allFiles) {
if (filenames.indexOf(file) < 0) {
filesToDelete.push(path.join(includeDir, file));
}
}
for (const fileToDelete of filesToDelete) {
fs.removeSync(fileToDelete);
}
// Download all the files
const promises = [];
for (const file of included) {
promises.push(getAndWriteIncludedFile(file, includeDir));
}
Promise.all(promises).then((values) => {
const failed = [];
const successful = [];
for (const value of values) {
if (value.successful) {
successful.push(value.fileName);
} else {
failed.push(value.fileName);
}
}
resolve({
failed,
successful,
});
});
} catch (err) {
reject(err);
return;
}
});
}
|
javascript
|
{
"resource": ""
}
|
q56272
|
displayProjectInfo
|
train
|
function displayProjectInfo(metadata) {
console.log(`NAME ${metadata.name}`);
console.log(`ID ${metadata.projectId}`);
console.log(`CREATED_AT ${metadata.createTime}`);
console.log(`LAST_MODIFIED_AT ${metadata.updateTime}`);
console.log(`CREATOR ${metadata.creator.name} - ${metadata.creator.email}`);
return;
}
|
javascript
|
{
"resource": ""
}
|
q56273
|
getFileJSON
|
train
|
function getFileJSON(rootFolder, file, fileName, extension, id) {
return new Promise((resolve, reject) => {
fs.stat(path.join(rootFolder, file), (err, stats) => {
if (err) {
reject();
return;
}
if (stats.isFile()) {
// Read local javascript file
fs.readFile(path.join(rootFolder, file), 'utf8', (err, source) => {
if (err) {
reject(err);
return;
}
const type = eaft.getFiletypeFromExtension(extension);
const fileJSON = {
name: fileName,
type,
source,
id,
};
resolve(fileJSON);
return;
});
} else {
reject();
return;
}
});
});
}
|
javascript
|
{
"resource": ""
}
|
q56274
|
local
|
train
|
function local(rootFolder) {
// Construct name to remote id map
const remote = path.join(rootFolder, constants.META_DIR, constants.META_REMOTE);
const remoteSource = fs.readJsonSync(remote, 'utf8');
const destination = constants.META_LOCAL;
return pack(rootFolder, destination);
}
|
javascript
|
{
"resource": ""
}
|
q56275
|
publish
|
train
|
function publish(rootFolder) {
// Read every local file and create a correct json file in .gas/${destination}
ignore.addGitIgnore(rootFolder);
ignore.addGasIgnore(rootFolder);
const destination = constants.META_PUBLISH;
return pack(rootFolder, destination);
}
|
javascript
|
{
"resource": ""
}
|
q56276
|
train
|
function (opts, cb) {
assert.object(opts, 'opts');
assert.func(cb, 'cb');
// asserts of other inputs done by parse and installRoutes respectively
vasync.pipeline({arg: {}, funcs: [
function parse(ctx, _cb) {
parser.parse(opts, function (err, config) {
ctx.config = config.validatedConfig;
ctx.basePath = config.basePath;
return _cb(err);
});
},
function installRoutes(ctx, _cb) {
install({
enroute: ctx.config,
server: opts.server,
basePath: ctx.basePath,
hotReload: opts.hotReload,
excludePath: opts.excludePath
}, function (err) {
return _cb(err);
});
}
]}, function (err, res) {
return cb(err);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q56277
|
remoteCreateProject
|
train
|
function remoteCreateProject(auth, name) {
return new Promise((resolve, reject) => {
const drive = google.drive('v3');
const options = {
auth,
resource: {
name,
mimeType: constants.MIME_GAS_JSON,
},
media: {
mimeType: constants.MIME_GAS_JSON,
body: JSON.stringify(files),
},
};
drive.files.create(options, (err, result) => {
if (err) {
triageGoogleError(err, 'remoteCreateProject').then((triaged) => {
reject(triaged);
}).catch((notTriaged) => {
reject(notTriaged);
});
} else {
resolve(result.data);
return;
}
return;
});
});
}
|
javascript
|
{
"resource": ""
}
|
q56278
|
train
|
function(block){
var escapePrettyMode = this.escapePrettyMode;
var pp = this.pp;
var ast = [];
// Pretty print multi-line text
if (pp && block.nodes.length > 1 && !escapePrettyMode &&
block.nodes[0].type === 'Text' && block.nodes[1].type === 'Text' ) {
push.apply(ast, this.prettyIndent(1, true));
}
for (var i = 0; i < block.nodes.length; ++i) {
// Pretty print text
if (pp && i > 0 && !escapePrettyMode &&
block.nodes[i].type === 'Text' && block.nodes[i-1].type === 'Text' &&
/\n$/.test(block.nodes[i - 1].val)) {
push.apply(ast,this.prettyIndent(1, false));
}
push.apply(ast, this.visit(block.nodes[i], block));
}
return ast;
}
|
javascript
|
{
"resource": ""
}
|
|
q56279
|
train
|
function(comment){
var ast = [];
if (!comment.buffer) return;
if (this.pp) push.apply(ast, this.prettyIndent(1, true));
push.apply(ast, this.buffer('<!--' + comment.val + '-->'));
return ast;
}
|
javascript
|
{
"resource": ""
}
|
|
q56280
|
train
|
function(attrs, buffer){
var res = compileAttrs(attrs, {
terse: this.terse,
format: buffer ? 'html' : 'object',
runtime: this.runtime.bind(this)
});
return res;
}
|
javascript
|
{
"resource": ""
}
|
|
q56281
|
createPackageFile
|
train
|
function createPackageFile(content) {
// todo in the rootfolder
createFile({
name: constants.INCLUDE_FILE,
source: `${JSON.stringify(content)}\n`,
});
}
|
javascript
|
{
"resource": ""
}
|
q56282
|
endDialog
|
train
|
function endDialog(success, content) {
if (success) {
createPackageFile(content);
process.stdout.write('Succesfully created gas-include.json');
checkbox.display('green');
process.exit(0);
} else {
process.stdout.write('Failed to create gas-include.json');
checkbox.display('red');
process.exit(1);
}
}
|
javascript
|
{
"resource": ""
}
|
q56283
|
findInProject
|
train
|
function findInProject(dir, name) {
return new Promise((resolve, reject) => {
const fullPath = process.cwd();
const pieces = fullPath.split(path.sep);
let folderCounter = 0;
let found = false;
let folder = dir;
while (folderCounter < pieces.length - 1 && !found) {
if (fs.existsSync(path.join(folder, name))) {
found = true;
} else {
folderCounter++;
folder = path.join('..', folder);
}
}
resolve({
found,
folder,
});
});
}
|
javascript
|
{
"resource": ""
}
|
q56284
|
unpackRemote
|
train
|
function unpackRemote(rootFolder, fileName) {
let foundSingleFile = false;
const local = path.join(rootFolder, constants.META_DIR, constants.META_LOCAL);
const remote = path.join(rootFolder, constants.META_DIR, constants.META_REMOTE);
// Read local files
const localFiles = getAllFiles(rootFolder, '.', []);
// Get valid extensions for code files
const extensions = eaft.getCodeExtensions();
// Get contents of .gasignore file
const ignoreRegexes = ignore.getIgnoreRegexes(rootFolder);
// Read remote.json
const data = fs.readFileSync(remote, 'utf8');
const result = JSON.parse(data);
// Create all javascript/html files from remote.json
const remoteFiles = [];
const remoteNames = [];
for (const file of result.files) {
const extension = eaft.getExtensionFromFiletype(file.type, extensions);
const remoteFileName = file.name + extension;
file.name = path.join(rootFolder, remoteFileName);
remoteNames.push(remoteFileName);
const included = file.name.substring(0, constants.INCLUDE_DIR.length + 1) === `${constants.INCLUDE_DIR}/`;
// What files do we need to create?
if (!fileName) {
remoteFiles.push(file);
} else if (fileName === remoteFileName) {
remoteFiles.push(file);
foundSingleFile = true;
}
}
// If we have not found our file
if (fileName && !foundSingleFile) {
console.log(`Can't seem to find the file '${fileName}' in this project`);
return;
}
// Write local.json
createFile({
name: local,
source: data,
});
// Sync create all necessary files
for (const remoteFile of remoteFiles) {
createFile(remoteFile);
}
// If there was no file specified to pull we will do a cleanup
if (!fileName) {
// Remove all .gs, .js, .html and appsscript.json files that were not in remote.json unless they are in .gasignore
const toDelete = [];
for (const localFileName of localFiles) {
const localExtension = path.parse(localFileName).ext;
const fileNameWithoutExtension = path.join(path.parse(localFileName).dir, path.parse(localFileName).name);
if (eaft.isPushable(localExtension, fileNameWithoutExtension, extensions, ignoreRegexes) &&
!remoteNames.includes(localFileName) && localFileName !== constants.INCLUDE_FILE) {
toDelete.push(path.join(rootFolder, localFileName));
}
}
// Delete files
for (const fileToDelete of toDelete) {
fs.removeSync(fileToDelete);
}
// Remove all empty folders
const allFolders = getAllFolders(rootFolder).sort().reverse();
for (const emptyFolder of allFolders) {
const files = fs.readdirSync(emptyFolder);
if (files.length === 0) {
fs.removeSync(emptyFolder);
} else if (files.length === 1 && files[0] === '.DS_Store') {
fs.removeSync(emptyFolder);
}
}
}
ignore.addGitIgnore(rootFolder);
ignore.addGasIgnore(rootFolder);
}
|
javascript
|
{
"resource": ""
}
|
q56285
|
recDependencies
|
train
|
async function recDependencies(dependencies, root) {
let url;
// TODO think about doing this in parallel using promises
for (const dependency of Reflect.ownKeys(dependencies)) {
const range = dependencies[dependency];
url = `${constants.FIREBASE_DATABASE_URL}/package/${dependency}/versions.json`;
const versions = await request({
url,
method: "GET",
json: true,
headers: {
"content-type": "application/json",
},
});
// Translate db versions to semver versions
const semverVersions = {};
for (const version of Reflect.ownKeys(versions)) {
semverVersions[version.replace(/_/g, '.')] = true;
}
const semverMatch = semver.maxSatisfying(Reflect.ownKeys(semverVersions), range);
const match = semverMatch.replace(/\./g, '_');
const versionKey = `${dependency}_${match}`;
// Set result
if (dependencies[dependency]) {
Reflect.deleteProperty(dependencies, dependency);
}
dependencies[versionKey] = true;
// check if in dependency list yet
if (!depencyList[versionKey]) {
// Resolve new dependencies
url = `${constants.FIREBASE_DATABASE_URL}/package/${dependency}/version/${match}/dependencies.json`;
const newDependencies = await request({
url,
method: "GET",
json: true,
headers: {
"content-type": "application/json",
},
});
// Add to dependencyList
depencyList[versionKey] = {};
// Resolve new dependencies
if (newDependencies) {
depencyList[versionKey].dependencies = await recDependencies(newDependencies);
}
}
if (root) {
depencyList[versionKey].isRootDependency = true;
}
depencyList[versionKey].packageName = dependency;
depencyList[versionKey].version = match;
}
return dependencies;
}
|
javascript
|
{
"resource": ""
}
|
q56286
|
resolveDependencies
|
train
|
async function resolveDependencies(rootFolder) {
const includeFile = path.join(rootFolder, constants.INCLUDE_FILE);
const includeJson = fs.readJsonSync(includeFile, 'utf8');
await recDependencies(includeJson.dependencies, true);
return depencyList;
}
|
javascript
|
{
"resource": ""
}
|
q56287
|
writeLocalJson
|
train
|
function writeLocalJson(source, rootFolder) {
// Write to local.json
const local = path.join(rootFolder, constants.META_DIR, constants.META_LOCAL);
const file = {
name: local,
source: JSON.stringify(source),
};
createFile(file);
}
|
javascript
|
{
"resource": ""
}
|
q56288
|
getAllFolders
|
train
|
function getAllFolders(dir, folderlist) {
const files = fs.readdirSync(dir);
folderlist = folderlist || [];
files.forEach((file) => {
if (fs.statSync(path.join(dir, file)).isDirectory()) {
folderlist = getAllFolders(path.join(dir, file), folderlist);
folderlist.push(path.join(dir, file));
}
});
return folderlist;
}
|
javascript
|
{
"resource": ""
}
|
q56289
|
format
|
train
|
function format(source) {
var fmtedCode = 'NotInitialized'
try {
fmtedCode = reason.printRE(reason.parseRE(source))
} catch (e) {
fmtedCode =
'line ' +
e.location.startLine +
', characters ' +
e.location.startLineStartChar +
'-' +
e.location.endLineEndChar +
', ' +
e.message +
'\n' +
source
}
return fmtedCode
}
|
javascript
|
{
"resource": ""
}
|
q56290
|
compile
|
train
|
function compile(
source,
filename = '',
includeModule = false,
debugMode = false,
) {
let res
let resName
let errors
try {
const [moduleName, bsCode, diagnosticErrors] = Retyped.compile(filename, source, debugMode)
const fmtCode = format(bsCode)
res = fmtCode
resName = moduleName
errors = diagnosticErrors
} catch (e) {
console.error(e)
throw new Error(`${e[0][0]}`)
}
if (res.includes('SYNTAX ERROR>')) {
throw new Error(res)
}
if (!includeModule) {
return res
} else {
return {
moduleName: resName,
bsCode: res,
diagnosticErrors: errors
}
}
}
|
javascript
|
{
"resource": ""
}
|
q56291
|
train
|
function (templateName, attributes, options) {
if (!this.$container) {
this.$container = this.createComponent(HtmlElement, {"class": this.$.containerClass, tagName: "div"});
this.$stage.addChild(this.$container);
}
if (!this.$templates[templateName]) {
console.warn("Couldn't find template " + templateName);
return null;
}
options = options || {};
var duration = options.hasOwnProperty("duration") ? options.duration : this.$.duration;
var notification = this.$templates[templateName].createInstance(attributes || {});
notification.bind('remove:dom', function () {
notification.destroy();
});
this.$container.addChild(notification);
var self = this;
notification.close = function () {
self.closeNotification(this);
};
this.$notifications.push(notification);
if (duration) {
setTimeout(function () {
self.closeNotification(notification);
}, duration * 1000);
}
return notification;
}
|
javascript
|
{
"resource": ""
}
|
|
q56292
|
train
|
function (to, createHistoryEntry, triggerRoute, force, callback) {
return this.history.navigate(to, createHistoryEntry, triggerRoute, force, callback);
}
|
javascript
|
{
"resource": ""
}
|
|
q56293
|
train
|
function (password, algorithm, salt) {
salt = salt || Crypto.randomBytes(128).toString("hex");
algorithm = algorithm || this.$.algorithm;
var hash = Crypto.createHash(this.$.algorithm);
hash.update(salt + password, "utf8");
return [algorithm, salt, hash.digest("hex")].join(this.$.delimiter);
}
|
javascript
|
{
"resource": ""
}
|
|
q56294
|
train
|
function (password, algorithm, salt) {
return {
hash: this.createHash(password, algorithm, salt),
loginAttempts: 0,
loginBlocked: null
}
}
|
javascript
|
{
"resource": ""
}
|
|
q56295
|
train
|
function (registrationRequest, cb) {
if (registrationRequest.$.password) {
var ret = {
providerUserId: registrationRequest.get(this.$.usernameField),
authenticationData: this.createAuthenticationData(registrationRequest.$.password)
};
cb(null, ret);
} else {
cb("No password set");
}
}
|
javascript
|
{
"resource": ""
}
|
|
q56296
|
train
|
function (registrationRequest, callback) {
this.fetchUser(registrationRequest, function (err, user) {
if (!err && user) {
err = RegistrationError.USER_ALREADY_EXISTS
}
callback(err);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q56297
|
train
|
function (authenticationRequest, callback) {
// create query to fetch the user
var query = this._createQueryForUser(authenticationRequest.get(this.$.usernameField));
var collection = this.$.dataSource.createCollection(this.$collectionClass).query(query);
collection.fetch({limit: 1}, function (err, users) {
var user;
if (!err && users.size()) {
user = users.at(0);
user.fetch(null, callback);
} else {
callback(err, null);
}
});
}
|
javascript
|
{
"resource": ""
}
|
|
q56298
|
train
|
function(key) {
var value = this.storage.get(key);
if (typeof value == 'undefined' || value == null || value == '') {
return value;
}
try {
return JSON.parse(value);
} catch(e) {
return value;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q56299
|
train
|
function(callback) {
var found = false;
this.each(function(key, value) {
if (callback(key, value)) {
found = [key, value];
return false;
}
});
return found;
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.