makeUrn: function (uri, params){ var urn = '', inner_params = {}, temp; if (uri.indexOf ('?') != -1) { urn = uri.split ('?') [0]; temp = uri.split ('?') [1]; if (temp.indexOf ('&') != -1) { temp = temp.split ('&'); _.each (temp, function (item){ inner_params [item.split ('=') [0]] = decodeURIComponent (item.split('=') [1]); }); } else { inner_params [temp.split('=') [0]] = decodeURIComponent (temp.split('=') [1]); } } else { urn = uri; } _.extend (inner_params, params); var tail = _.compact ( _.map (inner_params, function (value, name) { if (value) { return name + "=" + encodeURIComponent (value); } }) ).join ("&"); return tail ? (urn + '?' + tail) : urn; },
it('should not change protocol between patch versions', async () => { var shasum = crypto.createHash('sha1'); for (let [url, urlMapping] of _.toPairs(METHOD_MAP)) { shasum.update(url); for (let [method, methodMapping] of _.toPairs(urlMapping)) { shasum.update(method); if (methodMapping.command) shasum.update(methodMapping.command); if (methodMapping.payloadParams) { let allParams = _.flatten(methodMapping.payloadParams.required); if (methodMapping.payloadParams.optional) { allParams = allParams.concat(_.flatten(methodMapping.payloadParams.optional)); } for (let param of allParams) { shasum.update(param); } if (methodMapping.payloadParams.wrap) { shasum.update('skip'); shasum.update(methodMapping.payloadParams.wrap); } } } } var hash = shasum.digest('hex').substring(0, 8); // Modify the hash whenever the protocol has intentionally been modified. hash.should.equal('8c54fd6e'); });
attachments: function (doc) { if (!doc) return []; if (!doc._attachments) return []; return _.map (_.keys (doc._attachments), function (file) { var origin = doc.meta.last_updated_origin || doc.meta.origin; return '/' + _.map ([origin, doc._id, file], encodeURIComponent).join ('/'); }); },
allModules = (function(){ var fixSlashes = function(p){ return p.replace(new RegExp('\\\\','g'),'/');}, modules = _.flatten([scannedModules.js, options.extraModules || [], dynamicModules, scannedModules.text]) .map(fixSlashes) .filter(options.moduleFilter); return _.unique(modules); })(),
insertRequireModules = (function(){ if(typeof(options.require) === 'string' || _.isArray(options.require)){ return _.flatten([options.require]); } else if(options.require === true || (options.almond && options.require !== false)){ return [allModules[0]]; } return undefined; })(),
allModules = (function(){ var fixSlashes = function(p){ return p.replace(new RegExp('\\\\','g'),'/');}, modules = _.flatten([scannedModules.js, options.extraModules || [], dynamicModules, scannedModules.plugged]) .map(fixSlashes), include = _.filter(modules, options.moduleFilter), exclude = _.reject(modules, options.moduleFilter); return { include:_.unique(include), exclude:_.unique(exclude) }; })(),
_.each(input, (param) => { const decoded = decodeParams(param); if (_.isUndefined(decoded) === false) { if (_.has(obj, decoded.param)) { _.merge(obj[decoded.param], decoded.value); } else { obj[decoded.param] = decoded.value; } } });
uploadAttachments: function (model, eventFiles) { var meta = model.get ('meta'), origin = (meta.origin || meta.last_updated_origin), e = encodeURIComponent, baseUrl = '/' + _.map ([origin, model.id], e).join ('/'); var files = _.map (eventFiles, function (file) { return file; }); var _iterate = function () { var file; if (file = files.pop ()) { _uploadFile (file); } else { model.off ('change:_attachments', _iterate); } }; var _contentType = function (file) { return file.type; }; var _uploadFile = function (file) { var url = baseUrl + '/' + e (file.name) + '?rev=' + model.get ('_rev'); var xhr = new XMLHttpRequest (); xhr.open ('PUT', url); // TODO: Add better content-type detection xhr.setRequestHeader ('Content-Type', _contentType (file)); xhr.setRequestHeader ('Cookie', document.cookie); xhr.onreadystatechange = function (event) { console.log ('upload attachments result'); }; xhr.onerror = function () { console.error ('Failed to upload attachment', arguments); }; xhr.onabort = function () { console.log ('Attachment upload aborted', arguments); }; xhr.send (file); }; model.on ('change:_attachments', _iterate); _iterate (); },
scannedModules = (function(){ var stripExtension = function(p){ return p.substr(0, p.length - path.extname(p).length); }, expand = function(p){ return glob.sync(path.normalize(path.join(baseDir, p))); }, relativeToBaseDir = path.relative.bind(path, baseDir), jsFiles = _.unique( _.flatten([ mainFile, expand('/**/*.js') ])), jsModules = jsFiles.map(relativeToBaseDir).map(stripExtension), textFiles = _.flatten(_.map(options.textModuleExtensions, function(ext){return expand('/**/*'+ext);})), textModules = textFiles.map(relativeToBaseDir).map(function(m){ return 'text!' + m; }), scannedModules = {js: jsModules, text: textModules}; return scannedModules; })(),
//Write details of the given core to output. function logCore(core) { console.log('Core: ' + core.name + ' (' + core.id + ')'); console.log('\nFunctions: '); _.each(core.functions, function(fun) { console.log(' ' + fun); }); console.log('\nVariables: '); _.each(core.variables, function(type, varName) { console.log(' ' + varName); }); console.log('\nConnected: ' + core.connected); }
static merge(base, update) { if (!base) { return update; } if (!_.isArray(base)) { _.extend(base, update); } else { _.each(base, function(doc) { return _.extend(doc, update); }); } return base; }
scannedModules = (function(){ var stripExtension = function(p){ return p.substr(0, p.length - path.extname(p).length); }, expand = function(p){ return glob.sync(path.normalize(path.join(baseDir, p))); }, relativeToBaseDir = path.relative.bind(path, baseDir), jsFiles = (function() { var expandedJsFiles = _.flatten([ expand('/**/*.js') ]); return _.unique( mainFile ? [mainFile].concat(expandedJsFiles) : expandedJsFiles ); })(), jsModules = jsFiles.map(relativeToBaseDir).map(stripExtension), pluggedFiles = _.flatten( _.map( _.keys(options.pluginMap) , function(ext){return expand('/**/*'+ext);} ) ), pluggedModules = pluggedFiles.map(relativeToBaseDir).map(function(m){ return options.pluginMap[path.extname(m)] + '!' + m; }); return {js: jsModules, plugged: pluggedModules}; })(),
.then(result => { const pullRequest =result.repository.pullRequest; prInfo.head = pullRequest.headRefName; prInfo.head_sha = pullRequest.headRef.target.oid; prInfo.base = pullRequest.baseRefName; prInfo.base_sha = pullRequest.baseRef.target.oid; prInfo.contributors = pullRequest.participants.nodes.map((node) => node.login ); const edges = pullRequest.commits.edges; const fetchedCommits = edges.map((edge) => edge.node.commit ); const lastEdge = _.last(edges); prInfo.cursor = lastEdge ? lastEdge.cursor : null; prInfo.commits = _.union( prInfo.commits, fetchedCommits ); resolve(prInfo); });
_compile: function () { var source = this.source, compile = source.compile || []; _.each (source, function (value, index) { if (['start', 'stop', 'notify', 'filter'].indexOf (index) == -1) { if (compile.indexOf (index) == -1) { return; } } try { var fun = eval ('(' + value + ')'); this [index] = function () { try { return fun.apply (this, arguments); } catch (e) { console.error ('Failed to execute', source._id, index, e); } }; } catch (e) { console.error ('Failed to compile', source._id, index, e.message); } }, this); },
save: function (origin, app, data) { var arr = ['', origin]; if (app) { arr.push ('_design'); arr.push (app); arr.push ('_update'); arr.push (data.type); } if (data._id) { arr.push (data._id); } var options = { path: _.map (arr, e).join ('/'), method: data._id ? 'PUT' : 'POST', data: data }; // console.log (options.path); var deferred = Q.defer (); this.request (null, options, deferred.makeNodeResolver ()); return deferred.promise; }
it('should pass in envvar value if begins with a $', function () { const oldEnv = _.cloneDeep(process.env); process.env = { ENVVAR1: 'var1', ENVVAR2: 'var2', ENVVAR3: 'var3', ENVVAR1_VALUE: '$ENVVAR1', ENVVAR2_VALUE: '$ENVVAR2', ENVVAR3_VALUE: '$ENVVAR3', }; const obj = { envvar1: 'ENVVAR1_VALUE', envvar4: 'ENVVAR4_VALUE', child: { envvar2: 'ENVVAR2', }, }; expect(replaceEnvVars(obj)).to.be.eql({ envvar1: 'var1', child: { envvar2: 'var2', }, }); process.env = oldEnv; });
it('should replace with the environment variable if present', function () { const oldEnv = _.cloneDeep(process.env); process.env = { ENVVAR1: 'var1', ENVVAR2: 'var2', ENVVAR3: 'var3', }; const obj = { envvar1: 'ENVVAR1', envvar4: 'ENVVAR4', child: { envvar2: 'ENVVAR2', }, }; expect(replaceEnvVars(obj)).to.be.eql({ envvar1: 'var1', child: { envvar2: 'var2', }, }); process.env = oldEnv; });
db.sync({ force: true }).then(() => _.times(GROUPS, () => GroupModel.create({ name: faker.lorem.words(3), }).then(group => _.times(USERS_PER_GROUP, () => { const password = faker.internet.password(); return group.createUser({ email: faker.internet.email(), username: faker.internet.userName(), password, }).then((user) => { console.log( '{email, username, password}', `{${user.email}, ${user.username}, ${password}}` ); _.times(MESSAGES_PER_USER, () => MessageModel.create({ userId: user.id, groupId: group.id, text: faker.lorem.sentences(3), })); return user; }); })).then((userPromises) => { // make users friends with all users in the group Promise.all(userPromises).then((users) => { _.each(users, (current, i) => { _.each(users, (user, j) => { if (i !== j) { current.addFriend(user); } }); }); }); })));
const replaceEnvVars = (obj) => { _.each(obj, (envVar, key) => { if (_.isPlainObject(envVar)) { replaceEnvVars(envVar); } else { /* Check if envvar passed in - begins "$" recursive */ while (/^\$/.test(process.env[envVar])) { envVar = process.env[envVar] .replace(/^\$/, ''); } if (_.has(process.env, envVar)) { /* Replace the value with the envVar */ const tmp = process.env[envVar]; obj[key] = coerce(tmp); } else { /* No known envvar - delete it */ delete obj[key]; } } }); return obj; };
ipizza.provider = function (provider, opt) { if (provider instanceof Array) { return provider.forEach(ipizza.provider, opt) } opt = opt || {} if (typeof provider === 'string') opt.provider = provider else opt = provider if (opt.privateKey) { opt.privateKey = ipizza.file_(opt.privateKey) } if (opt.certificate) { opt.certificate = ipizza.file_(opt.certificate) } var p = providers[opt.provider] if (opt.alias) { p = providers[opt.alias] = providers[opt.alias] || {klass: p.klass, opt: {}} } if (!p) { ipizza.error_('provider setup', 'No such provider ' + opt.provider) } else { p.opt = _.extend(p.opt, opt) } }
function todos(state = [], action) { switch (action.type) { case COMPLETE_TODO: return _.map(state, function(t, index) { if (t.id !== action.id) { return t; } return Object.assign({}, t, { completed: !state.completed }); }); case ADD_TODO: let res = [ ...state, { id: count++, text: action.text, completed: false } ]; console.log(res); return res; default: return state } }
let run_query = function (doneVerb, funQ, config, done) { if (_.isFunction(config)) { done = config config = {} } let {host, user, password, database} = config const MYSQL_HOST = 'db' const MYSQL_USER = user || process.env.MYSQL_USER const MYSQL_PASSWORD = password || process.env.MYSQL_ROOT_PASSWORD || '' const MYSQL_DATABASE = database || process.env.MYSQL_DATABASE if (!MYSQL_HOST || !MYSQL_USER || !MYSQL_DATABASE) { console.error('Arguments or environmental variables incomplete.') process.exit(1) } let connection = mysql.createConnection({ host: MYSQL_HOST, user: MYSQL_USER, password: MYSQL_PASSWORD, multipleStatements: true }) let q = funQ(MYSQL_DATABASE) connection.connect() connection.query(q, (err, rows, fields) => { if (err) console.log('ERROR ========= :', err) && process.exit(123456) done(`Seed ${doneVerb} in database \`${MYSQL_DATABASE}\` on host '${MYSQL_HOST}' by user '${MYSQL_USER}'.`) }) connection.end() }
var fieldInfo = _.find(group.fields, function(itemInfo, pos){ var info = _.isString(itemInfo) ? {name: itemInfo, index: pos} : itemInfo; if (info.name == index){ position = info.index; return true; } });
var Daemon = function (daemons, source) { this.source = source; this.logger = new Logger ({ related: [source._id] }, _.bind (function (data) { var e = encodeURIComponent; data.type = 'urn:types/log'; var options = { path: '/' + e ('sys/logs') + '/_design/' + e ('urn:logs') + '/_update/' + e (data.type), method: 'POST', data: data }; this.request (null, options, function (error) { if (error) { console.error (error); } }); }, this)); this.hostname = require ('os').hostname (); this._daemons = daemons; this._compile (); };
constructor() { let config = Config.load_config(CONFIG_YML); this.src = path.resolve(config.root.src); this.dest = path.resolve(config.root.dest); this.compitability = config.compitability; this.raw = config; this._env = yargs.argv.env; _.each( config.tasks, (task, taskname) => { this[taskname] = _.reduce( task, (t, val, part) => { switch(part){ case 'src' : t[part] = path.join(this.src, val); break; case 'dest' : t[part] = path.join(this.dest, val); break; case 'config' : t[part] = path.resolve(val); break; case 'include' : t[part] = Config.resolve_include_array(val); break; default : t[part] = val } return t }, {} ) } ) }
this.getMyPoolTeamId = () => { const poolTeam = PoolTeams.findOne({ seasonId: this.getSeasonId(), userId: Meteor.userId(), }); return _.get(poolTeam, '_id'); };
'find: multiple comments by id': function(callback) { var ids = _.pluck(comments, 'id'); Comment.find(ids, function(err, results) { assert.equal(ids.length, results.length); callback(err, results) }) },
_stream: function (db, since) { if (db.streaming) { db.streamMore = true; return; } db.streaming = true; var callback = _.bind (function (error, result) { if (error) { console.error (error); this._endStream (db); return; } _.each (result.results, function (event) { this._dbEvent (db, event); }, this); this._endStream (db); }, this); var path = '/' + encodeURIComponent (db.name) + '/_changes?include_docs=true&since=' + since var options = { path: path }; this._request (null, options, callback); },
var _callback = _.bind (function (error, result) { if (error) { console.error ('Failed to reload daemons', error); return; } _.each (this.daemons, function (daemon) { daemon.stop (); }); this.daemons = _.map (result.rows, function (row) { var daemon = new Daemon (this, row.doc); daemon.start (); return daemon; }, this); }, this);
_.each(users, (current, i) => { _.each(users, (user, j) => { if (i !== j) { current.addFriend(user); } }); });