.queue(function (assetGraph) {
expect(assetGraph, 'to contain assets', 'Png', 3);
expect(_.pluck(assetGraph.findAssets({isImage: true}), 'url').sort(), 'to equal', [
assetGraph.root + 'purplealpha24bit.pngquant=256.png',
assetGraph.root + 'redalpha24bit.png?irrelevant',
assetGraph.root + 'redalpha24bit.pngquant=128.png'
]);
// The first two CssImage relations should be in the same cssRule
var cssBackgroundImages = assetGraph.findRelations({type: 'CssImage'});
expect(cssBackgroundImages[0].cssRule, 'to equal', cssBackgroundImages[1].cssRule);
var rawSrcs = assetGraph.findRelations({type: 'CssImage'}).map(function (cssImageRelation) {
return cssImageRelation.to.rawSrc;
});
// Should look like PNGs:
expect(_.toArray(rawSrcs[0].slice(0, 4)), 'to equal', [0x89, 0x50, 0x4e, 0x47]);
expect(_.toArray(rawSrcs[1].slice(0, 4)), 'to equal', [0x89, 0x50, 0x4e, 0x47]);
expect(rawSrcs[1].length, 'to be less than', rawSrcs[0].length);
var cssBackgroundImages = assetGraph.findRelations({type: 'CssImage'});
expect(cssBackgroundImages[0].cssRule, 'to equal', cssBackgroundImages[1].cssRule);
})
execute: function(input) {
var validationRules = {
reference: {length: {min: 1,max: 20}},
date: {length: {min: 8,max: 8}},
amount: {length: {min: 1,max: 15}}
};
if (!cieUtils.validateInput(input,validationRules )) {
throw new Error('Longitud invalida');
}
var condensedInput = parseInput(input);
var acc = cieUtils.weightedReduce(_.toArray(condensedInput.reference).reverse(),[11,13,17,19,23]);
var acc_2 = ((acc % 97)+1)%10;
return condensedInput.reference + acc_2;
}
server.secure = function(router /*, and token1, token2, ...*/){
apiTokenMap[router.meta.entity] = apiTokenMap[router.meta.entity] || {};
var atm = apiTokenMap[router.meta.entity];
var tokens = _.toArray(arguments).slice(1).concat(['create', 'list', 'read', 'modify']);
_.each(tokens, function(t){
atm[t] = false;
});
//give router a token checker to be used when defining the routes (apis)
//e.g router.get('url..', router.token(...), function(req, res, next){...});
router.token = function(/*token1, token2, ...*/){
if(!profile.auth || !profile.auth.enabled) return function(req, res, next){next();};
var tokens = _.toArray(arguments);
return function(req, res, next){
if(req.session && req.session.username){
if(req.session.userspace === 'superadmin') return next();
//within the user & admin space, check api-access-token first
var pass = true;
var map = req.session['api-token-map'] && req.session['api-token-map'][router.meta.entity];
if(map){
for(var t in tokens){
if(!map[tokens[t]]) {
pass = false;
break;
}
}
}else
pass = false;
if(pass) {
if(req.session.userspace === 'user') req.mutex = true;
return next();
/////////////////////////////////////////////////////////////////////
//Don't forget to apply the space, mutex rule(s) in the guarded api//
/////////////////////////////////////////////////////////////////////
}
return res.status(403).json({error: 'Authorization'});
}else {
return res.status(401).json({error: 'Authentication'});
}
};
};
return router;
};
module.exports = function (/*[match...], [done]*/) {
var matchStrings = _.toArray(arguments);
var done = _.identity;
if (_.isFunction(_.last(matchStrings))) done = matchStrings.pop();
filteredBuckets(matchStrings, function (err, buckets) {
if (err) return done(err);
if (isConsole) {
console.log('Buckets:'.bold);
console.log(buckets.sort().join('\n'));
}
done(null, buckets);
});
};
compile: function(dsl) {
if (arguments.length > 1)
dsl = u_.toArray(arguments);
var root = treeFromDsl(dsl);
transform(this.options_, root);
var v0 = graphFromTree(root);
checkUniqueNumericalIds(v0);
if (this.options_.requireUniqueNames)
checkUniquenessOfNames(v0);
preOrder(v0, normalize);
return flow.create(root, v0, sortVertices(v0), this.options_);
}
PulsarApi.prototype.jobs = function(callback) {
var clientList = _.toArray(this._clientMap);
clientList.unshift(this._clientDefault);
var getClientJobs = function(client, callback) {
return client.jobs(callback);
};
return async.map(clientList, getClientJobs, function(results) {
var concatenator = function(all, items) {
return all.concat(items);
};
var jobs = _.reduce(results, concatenator, []);
return callback(jobs);
});
};
/**
* Extract stylesheets' hrefs from dom
* @param {Array} dom List of DOMs loaded by cheerio
* @param {Object} options Options, as passed to UnCSS
* @return {Array} Array of hrefs
*/
function extractStylesheets(dom, options) {
var media = _.union(['screen', 'all'], options.media),
stylesheets;
/* Match only specified media attributes, plus defaults */
media = 'link[rel="stylesheet"]:not(media),' + media.map(function (selector) {
return 'link[rel="stylesheet"]' + '[media="' + selector + '"]';
}).join(', ');
stylesheets = dom(media);
/* Stylesheets is not an array, but an object whose elements are indexes */
return _.toArray(stylesheets).map(function (x) {
return x.attribs.href;
});
}
function asyncSocketEvent(socket, event) {
var args = _.toArray(arguments).slice(1);
return new Promise(function(resolve, reject) {
args.push(function(err) {
if (err != null) return reject(err);
var args = _.toArray(arguments).slice(1),
len = args.length;
resolve(!len ? void 0 : len === 1 ? args[0] : args);
});
socket.emit.apply(socket, args);
});
}
function dispatch (/* arguments */) {
var funs = _.toArray(arguments);
var size = funs.length;
return function(target /*, args */) {
var ret = undefined;
var args = _.rest(arguments);
for (var funIndex = 0; funIndex < size; funIndex++) {
var fun = funs[funIndex];
ret = fun.apply(fun, construct(target, args));
if (existy(ret)) return ret;
}
return ret;
};
}
var definitionFn = function(done) {
console.log('Called keyword ' + name + ' definition with args', JSON.stringify(arguments));
console.log('Calling following keys ', JSON.stringify(keys));
// Save original args
var args = _.toArray(arguments)
var vars = _.last(args);
args = _.initial(args);
var keywordInfo = _.last(args);
args = _.initial(args);
keys.push({arguments: args});
debugger;
key.apply(null, keys).then(done);
}
AV.Query.or = function() {
var queries = _.toArray(arguments);
var className = null;
AV._arrayEach(queries, function(q) {
if (_.isNull(className)) {
className = q.className;
}
if (className !== q.className) {
throw "All queries must be for the same class";
}
});
var query = new AV.Query(className);
query._orQuery(queries);
return query;
};
(exports.rpush = function(){
var self = this;
var args = _.toArray(arguments);
var cb = args.pop();
var key = args.shift();
if (!this.data[key]) {
this.data[key] = {val: [], type: 'list'};
} else if (this.data[key].type != 'list') {
cb(new Error('wrong type'));
return;
}
_.each(args,function(arg) {
self.data[key].val.push(arg);
})
cb(null);
}).mutates = true;
q.on('connection', function(socket) {
var sockets = _und.toArray( io.nsps['/questions'].connected );
console.log(sockets.length);
socket.emit('questions', questions);
socket.emit('show', show);
socket.on('showscore', function (data) {
if ( data ) {
show = true;
} else {
show = false;
}
socket.broadcast.emit('show', data);
})
socket.on('loggedin', function (obj) {
socket.type = obj.type;
socket.sqiffer_id = obj.id;
db.getStreamScore( function (row) {
if (socket.type === 'user') {
try {
var score = _und.findWhere(row.new_val.score, {group: socket.sqiffer_id});
socket.emit('scores', score);
} catch (err) {}
} else {
socket.emit('scores', row);
}
});
})
socket.on('disconnect', function () {
var sockets = _und.toArray( io.nsps['/questions'].connected );
console.log(sockets.length);
})
return q;
});
g_participants: function(){
var users = _.reduce(_.toArray(arguments).join(':').split(';'), function(users, args){
args = args.split(':');
if(args[3] === "None") args[3] = "";
if(args[4] === "None") args[4] = "";
var user = makeUser(args[3], args[4], args[2], "", "");
user.sess = args[0];
user.time = parseFloat(args[1]);
if(!user.name && !user.alias) user.name = utils.getAnonName(user.id, user.time);
if(user.alias) user.alias = '#'+user.alias;
users[user.sess] = user;
return users;
},{});
return {
type: "g_participants",
users: users};
},
'keys must be unique even with different sources':function (){
var n1=orgParser.parseBigString(
"* Key test\nData Line1\nData Line2\n* Header 2\nData Line of header2\n* Header 3");
var n2=orgParser.parseBigString(
"* Key test\nData Line1\nData Line2\n* Header 2\nData Line of header2\n* Header 3");
keyCollection={};
//console.dir(n1);
//console.dir(n2);
_.each(n1,function(elem){
keyCollection[elem.key]=true;
});
_.each(n2,function(elem){
keyCollection[elem.key]=true;
});
assert.equal(_.toArray(keyCollection).length,(n1.length+n2.length));
},
exports.compile = function(){
var args = _.toArray(arguments),
source = args.shift(),
callback = args.pop(),
extname = path.extname(source).substring(1);
switch (args.length){
case 2:
var locals = args[1],
ext = args[0];
break;
case 1:
if (_.isObject(args[0])){
var locals = args[0],
ext = extname;
} else {
var ext = args[0];
}
break;
default:
var ext = extname;
break;
}
file.read(source, function(err, result){
if (err) throw err;
if (result){
if (render.hasOwnProperty(ext)){
var newCallback = output(render[ext].output, callback);
if (locals){
render[ext](source, result, locals, newCallback);
} else {
render[ext](source, result, newCallback);
}
} else {
callback(null, result);
}
} else {
callback(null);
}
});
};
/// #### functional.dispatch(*functions)
/// Returns a function taking one argument that will successively invokes
/// the given functions on the given argument until one returns a value.
///
/// __Parameters:__
/// - `functions`, functions.
///
/// __Return:__
/// - `Function`.
function dispatch() {
var funs = _.toArray(arguments);
var size = funs.length;
return function(target) {
var args = _.rest(arguments);
for (var index = 0; index < size; index++) {
var fun = funs[index];
var ret = fun.apply(this, construct(target, args));
if (!_.isUndefined(ret)) {
return ret;
}
}
};
}
'random test 3':function(){
// Given 1000 values the probability two launch give the same value is
// 1/10000 i.e. 0,01%
rList=[];
_.each(_.range(10000), function (fakeNumber){
rList.push(
new orgParser.Orgnode("*", "Test "+fakeNumber,
"", undefined, undefined,undefined));
});
var ofd=new orgParser.OrgQuery( rList );
var collector={};
_.each(_.range(2),function(){
var r=ofd.random();
collector[r.key]=r;
});
assert.equal(_.toArray(collector).length,2);
}
function orify (/* preds */) {
var preds = _.toArray(arguments);
return function(/* args */) {
var args = _.toArray(arguments);
var something = function(ps, truth) {
if (_.isEmpty(ps))
return truth;
else
return _.some(args, _.first(ps))
|| something(_.rest(ps), truth)
}
return something(preds, false);
};
}
module.exports.rewriteDestinationPathForEngine = function rewriteDestinationPathForEngine(/* path parts */) {
var config = CurrentConfig.get();
var destpath = _.toArray(arguments).join(path.sep);
var fileType = this.engineAndTypeFromFilepath(destpath).type;
// get the engine from config for the given type
var engine = config.engines[fileType];
// replace everything after the file type with the new
// engine extensions
var replaceTypeWithEngineRe = new RegExp(fileType + '\\S*$');
if (!fileType || !engine)
return destpath;
else
return destpath.replace(replaceTypeWithEngineRe, engine);
};
return function(event) {
var args = _.toArray(arguments);
switch (event) {
case 'changing':
this.trigger.apply(this, args);
break;
case 'saverequired':
this.needsSaved = true;
this.trigger.apply(this, args);
break;
case 'add':
case 'remove':
// annotate add and remove events with the field in which they occured
args[0] = event + ':' + field.name.toLowerCase();
this.trigger.apply(this, args);
break;
}};
function printChildren(data, label) {
var nodes, s;
data = _.toArray(data);
// map workspace.name => nodes.label for
// archy support.
nodes = _.map(data, function(d) {
return {'label': d['name']}
});
s = archy({
label: label.green,
nodes: nodes
}, " ");
print(s);
}
getPictures: function(albumId, isShallow) {
if (!this.pictures.hasOwnProperty(albumId)) {
throw new Error("No such album!");
}
var modifiedPictures = {};
_.each(this.pictures[albumId], function(picture, pictureId) {
modifiedPictures[pictureId] = {};
_.each(picture, function(value, key) {
if (key !== "data" || !isShallow) {
modifiedPictures[pictureId][key] = value;
}
});
});
return _.toArray(modifiedPictures);
},
logWithSpinner: function logWithSpinner(/* args */) {
var self = this;
var spinner = ['-', '\\', '|', '/'];
var message = _.toArray(arguments).join(' ');
var i = 0;
var timer = setInterval(function () {
self.singleLineLog(message + '... ' + spinner[i]);
(i === 3) ? i = 0 : i++;
}, 200);
return {
stop: function() {
clearInterval(timer);
console.log();
}
};
}
function addJoin () {
var args = _.toArray(arguments);
var type = args[0];
var table = args[1];
var conditions = args.slice(2).reduce(function (soFar, c) {
if (c) {
soFar.push(c.toString());
}
return soFar;
}, []);
conditions = _.map(conditions, function (c) {
return c.toString();
});
joins.push([type, table, 'ON'].concat(conditions.join(' AND ')).join(' '));
}
function oxfordJoin(array) {
if (array instanceof Array) {
} else {
array = _.toArray(array).map(function(item) {
return item.name;
});
}
var string = '';
if (array.length <= 1) {
string = array.join();
} else {
string = array.slice(0, -1).join(", ") + ", and " + array[array.length-1];
}
return string;
}
, getExternalsSource: function() {
var args = _.toArray(arguments)
, externalType = args.shift()
, externalsArray = _(args).filter(function(externals) {
return !!externals
})
if (!externalsArray.length) { return '' }
return _.chain(externalsArray)
.map(function(externals) { return externals.split(';') })
.reduce(function(memo, externals) { return memo.concat(externals) })
.map(function(external) {
return this.makeExternal(external, externalType)
}, this)
.value().join('')
}
var cleanExtend = function(dest, src) {
if (arguments[2] !== undefined) { // support multiple src args
return _.reduce(_.toArray(arguments), function(a, b) {
return cleanExtend(a, b); // can't use directly because there's a 3rd arg
}, dest);
}
for (var key in src) (function(key, value) {
if (isPrivate(key)) return;
if (value instanceof Function) return;
if (value instanceof ComponentBase) return;
if (value instanceof ModelBase) return;
dest[key] = value;
})(key, src[key]);
return dest;
};
assetGraph.eachAssetPostOrder(htmlAsset, function (relation) {
if (relation.type === 'HtmlStyle' || relation.type === 'CssImport') {
var relationMedia = ['all'];
if (relation.type === 'HtmlStyle') {
relationMedia = (relation.node.getAttribute('media') || 'all').split(',');
} else if (relation.type === 'CssImport' && relation.cssRule.media.length > 0) {
relationMedia = _.toArray(relation.cssRule.media);
}
if (includeMedia(relationMedia)) {
return true;
} else {
if (assetGraph.findRelations({to: relation.to}).length === 1) {
assetGraph.removeAsset(relation.to, true);
}
}
}
return false;
}, function (cssAsset, incomingRelation) {
(next = function() {
var args = _.toArray(arguments);
if (args.length || !methods.length) {
if (args[0] instanceof Error) {
if (_.isString(args[0].message)) args[0] = args[0].message;
else args[0] = args[0].toString();
}
return done.apply(self, args);
}
try {
methods.shift().call(self, payload, next);
} catch(e) {
next(e);
}
})();