pluck: function() {
var args = sliced(arguments);
var cb = args.pop();
var fields = _.uniq(_.compact(_.flatten(args)));
var relation = this;
// TODO: handle associations
relation.setSelectValues(fields);
this.model.query(relation.toSQL(), function(err, result) {
if (err) { cb(err); return; }
var columns = result.rows.map(function(row) {
return fields.reduce(function(items, field) {
return items.concat(row[field]);
}, []);
});
if (fields.length === 1) {
columns = columns.map(function(column) { return column[0]; });
}
cb(null, columns);
});
},
Logger.prototype.bind = function () {
var args = _.flatten(arguments);
var context0 = this.context;
var i;
var l = context0.length;
var name;
var context = new Array(l);
for (i = 0; i < l; i += 1) {
context[i] = context0[i];
}
l = args.length;
for (i = 0; i < l; i += 1) {
name = args[i];
if (duck.isLogger(name)) {
context = context.concat(name.context);
} else {
context.push(name);
}
}
return new Logger(this.logging, context);
};
function processTranslations(translations) {
function processPiece(base, piece) {
return _.map(piece, function(value, key) {
var localBase = base ? base + '.' + key : key;
return _.isPlainObject(value) ? processPiece(localBase, value) : localBase;
});
}
return _.uniq(_.flatten(processPiece(null, translations.translation), true)).sort();
}
function sortFiles(priorities, paths) {
var priorityGlobs = joinPaths(priorities);
var priorityPaths = [];
matchGlobOnPaths(priorityGlobs, paths, function(matches, path, globIndex) {
if (matches) {
priorityPaths[globIndex] = priorityPaths[globIndex] || [];
priorityPaths[globIndex].push(path);
}
});
var flattenedPriorityPaths = _.flatten(priorityPaths);
return _.union(flattenedPriorityPaths, paths);
}
Cached.prototype.getRequiresFromFiles = function (file_sources) {
function readRequire(source) {
var requires = [];
astRequireParser(source, function(require) {
requires.push(require);
});
return requires;
}
var self = this;
return _.uniq(_.flatten(_.map(file_sources, function (source, file) {
return self._requires_cache[file] = self._requires_cache[file] || _.uniq(readRequire(source));
})));
};
}, function(err, result) {
if (err) return callback(err);
var flatResults = _.flatten(result);
flatResults = ignoreIgnoreds(assetConfig.ignore[options.env], flatResults);
flatResults = sortFiles(assetConfig.priorities, flatResults);
var finalAssets = {};
var extensionRegex = /\.([0-9a-z]+$)/i;
_.each(flatResults, function(path) {
var extension = extensionRegex.exec(path)[1];
finalAssets[extension] = finalAssets[extension] || [];
finalAssets[extension].push(path.replace(options.assetPrefix, '/'));
});
return finished(finalAssets);
});
// call java with given flags
function callJava(jarFile, flags, useFlagFile) {
// tiered compilation makes java load faster
var realFlags = ['-XX:+TieredCompilation', '-jar', jarFile];
// use flag file?
if (useFlagFile) {
// generate temporary flag file
var flagFilePath = sync(_.flatten(flags).join(' '), TEMP_FLAG_FILE);
// flag file is used to shorten command line
realFlags.push('--flagfile=' + flagFilePath);
} else {
// just add flags as is
realFlags = realFlags.concat(flags);
}
return spawn('java', realFlags, {cwd: __dirname});
}
async.parallel(roots.map(curry2(dir.files)), function (err, sourceMatrix) {
// if there was an error, throw it further
if (err) return callback(err);
// concatenate separate lists of file names from different roots
var sourceList = _.flatten(sourceMatrix, true);
// in case one root is inside another
sourceList = _.uniq(sourceList);
// in case some source files are inside roots
sourceList = _.difference(sourceList, jsSources);
// delete all non-js files
sourceList = _.filter(sourceList, curry2(hasExtension)('js'));
// add source file paths (for temporary files) into the mix
sourceList = sourceList.concat(saved.js);
// return it
callback(null, sourceList);
});
Model.mixin = function() {
var mixins = _.flatten(sliced(arguments));
for (var i in mixins) {
var mixin = mixins[i];
mixin(this);
if (_.isFunction(mixin.mixedIn)) {
mixin.mixedIn(this);
}
if (_.isFunction(mixin.inherited)) {
this.inheritFunctions.push(mixin.inherited);
}
}
};
_findWithIDs: function() {
var ids = sliced(arguments);
var cb = ids.pop();
if (!this.pk) {
cb(new Error(this.model.name + ' has no primary key defined'));
}
ids = _.uniq(_.compact(_.flatten(ids)));
switch (ids.length) {
case 0:
cb(new Error('could not find ' + this.model.name + ' without an ID'));
break;
case 1:
this._findOne(ids[0], cb);
break;
default:
this._findSome(ids, cb);
break;
}
},
.then(function(sprites) {
return VOW.all(_.flatten(sprites).map(function(sprite) {
return sprite.write();
}));
})