destinationFiles.map( function( filePath ) {
var fileType = filePath.split( "." ).pop().toLowerCase();
var output, generator;
// search for the correct generator by filetype
if ( fileType === 'scss' && options.useSassMaps) {
generator = generateSassMaps;
} else if ( mout.array.contains( fileExtensions.css, fileType ) ) {
generator = generateStyle;
} else if ( mout.array.contains( fileExtensions.js, fileType ) ) {
generator = options.amd ? generateAMD : generateJS;
} else {
grunt.log.warn( "Unknown filetype (" + fileType + ")." );
return false;
}
// generate and save output
output = generator.apply( null, [ srcConfig, fileType ] );
grunt.file.write( filePath, output );
grunt.log.ok( "File: " + filePath + " created." );
} );
Manager.prototype.configure = function (setup) {
var targetsHash = {};
this._conflicted = {};
// Targets - ignore those specified in ignoredDependencies
this._targets = mout.array.reject(setup.targets || [], function (target) {
return mout.array.contains(this._config.ignoredDependencies, target.name);
}, this);
this._targets.forEach(function (decEndpoint) {
decEndpoint.initialName = decEndpoint.name;
decEndpoint.dependants = mout.object.values(decEndpoint.dependants);
targetsHash[decEndpoint.name] = true;
// If the endpoint is marked as newly, make it unresolvable
decEndpoint.unresolvable = !!decEndpoint.newly;
});
// Resolved & installed
this._resolved = {};
this._installed = {};
mout.object.forOwn(setup.resolved, function (decEndpoint, name) {
decEndpoint.dependants = mout.object.values(decEndpoint.dependants);
this._resolved[name] = [decEndpoint];
this._installed[name] = decEndpoint.pkgMeta;
}, this);
// Installed
mout.object.mixIn(this._installed, setup.installed);
// Incompatibles
this._incompatibles = {};
setup.incompatibles = this._uniquify(setup.incompatibles || []);
setup.incompatibles.forEach(function (decEndpoint) {
var name = decEndpoint.name;
this._incompatibles[name] = this._incompatibles[name] || [];
this._incompatibles[name].push(decEndpoint);
decEndpoint.dependants = mout.object.values(decEndpoint.dependants);
// Mark as conflicted so that the resolution is not removed
this._conflicted[name] = true;
// If not a target/resolved, add as target
if (!targetsHash[name] && !this._resolved[name]) {
this._targets.push(decEndpoint);
}
}, this);
// Resolutions
this._resolutions = setup.resolutions || {};
// Uniquify targets
this._targets = this._uniquify(this._targets);
// Force-latest
this._forceLatest = !!setup.forceLatest;
return this;
};
var run = function (cmdString, action, logger, config) {
logger.action(action, cmdString);
//pass env + BOWER_PID so callees can identify a preinstall+postinstall from the same bower instance
var env = mout.object.mixIn({ 'BOWER_PID': process.pid }, process.env);
var args = shellquote.parse(cmdString, env);
var cmdName = args[0];
mout.array.remove(args, cmdName); //no rest() in mout
var options = {
cwd: config.cwd,
env: env
};
var promise = cmd(cmdName, args, options);
promise.progress(function (progress) {
progress.split('\n').forEach(function (line) {
if (line) {
logger.action(action, line);
}
});
});
return promise;
};
entries = entries.filter(function (entry) {
return !!mout.array.find(decEndpoints, function (decEndpoint) {
var entryPkgMeta = entry.pkgMeta;
// Check if name or source match the entry
if (decEndpoint.name !== entryPkgMeta.name &&
decEndpoint.source !== entryPkgMeta.name &&
decEndpoint.source !== entryPkgMeta._source
) {
return false;
}
// If target is a wildcard, simply return true
if (decEndpoint.target === '*') {
return true;
}
// If it's a semver target, compare using semver spec
if (semver.validRange(decEndpoint.target)) {
return semver.satisfies(entryPkgMeta.version, decEndpoint.target);
}
// Otherwise, compare against target/release
return decEndpoint.target === entryPkgMeta._target ||
decEndpoint.target === entryPkgMeta._release;
});
});
.spread(function(ConcreteResolver, versions){
// No versioned endpoints
if(ConcreteResolver === resolvers.Fs)
return noVersioned;
// Versioned endpoints
if(
ConcreteResolver === resolvers.GitRemote||
ConcreteResolver === resolvers.GitHub
) {
var lookup = { versions : {} };
mout.array.forEach(versions, function(version){
lookup.versions[version] = { hash: version};
});
return lookup;
}
return fail;
})
var filterStyleFiles = function(main){
return mout.array.filter(
mout.lang.toArray(main),
function(item){
return /\.css$/.test( item );
}
);
};
var orderByDependencies = function (packages, installed, json) {
var ordered = [];
installed = mout.object.keys(installed);
var depsSatisfied = function (packageName) {
return mout.array.difference(mout.object.keys(packages[packageName].dependencies), installed, ordered).length === 0;
};
var depsFromBowerJson = json && json.dependencies ? mout.object.keys(json.dependencies) : [];
var packageNames = mout.object.keys(packages);
//get the list of the packages that are specified in bower.json in that order
//its nice to maintain that order for users
var desiredOrder = mout.array.intersection(depsFromBowerJson, packageNames);
//then add to the end any remaining packages that werent in bower.json
desiredOrder = desiredOrder.concat(mout.array.difference(packageNames, desiredOrder));
//the desired order isn't necessarily a correct dependency specific order
//so we ensure that below
var resolvedOne = true;
while (resolvedOne) {
resolvedOne = false;
for (var i = 0; i < desiredOrder.length; i++) {
var packageName = desiredOrder[i];
if (depsSatisfied(packageName)) {
ordered.push(packageName);
mout.array.remove(desiredOrder, packageName);
//as soon as we resolve a package start the loop again
resolvedOne = true;
break;
}
}
if (!resolvedOne && desiredOrder.length > 0) {
//if we're here then some package(s) doesn't have all its deps satisified
//so lets just jam those names on the end
ordered = ordered.concat(desiredOrder);
}
}
return ordered;
};
.then(function (confirmed) {
// If the user decided to skip it, remove from the array so that it won't
// influence subsequent dependants
if (!confirmed) {
mout.array.remove(names, name);
} else {
packages[name] = decEndpoint.canonicalDir;
}
});
PackageAdapter.parseContributorsProperty = function(authors){
authors= mout.lang.toArray(authors);
if(authors.length > 1)
return mout.array.map(authors, resolvePeopleFields);
return;
};
names.forEach(function (name) {
// Prevent from infinite recursion when installing cyclic
// dependencies
if (!mout.array.contains(upperDeps, name)) {
data.dependencies[name] = this.toData(decEndpoint.dependencies[name],
extraKeys,
upperDeps.concat(decEndpoint.name));
}
}, this);