public bool Process(ILogger logger, IEnumerable<string> args, MetaProjectPersistence metaProject, ComponentsList components, string packagesOutputDirectory)
{
var nugetNamePattern = args.FirstOrDefault();
if (nugetNamePattern == null || nugetNamePattern.StartsWith("-") || nugetNamePattern.EndsWith("\"")) {
logger.Error("No nuget pattern specified");
return true;
}
var nugetComponent = components.FindComponent<INugetSpec>(nugetNamePattern);
if (nugetComponent == null)
return true;
logger.Info("== Nuget to add: {0}", nugetComponent);
var componentNamePattern = args.LastOrDefault();
if (componentNamePattern == null || componentNamePattern.StartsWith("-") || componentNamePattern.EndsWith("\"")) {
logger.Error("No component pattern specified");
return true;
}
var specificComponent = components.FindComponent<IProject>(componentNamePattern);
if (specificComponent == null)
return true;
logger.Info("== Component to reference nuget: {0}", specificComponent);
if (specificComponent == nugetComponent) {
logger.Error("Nuget can't be added to itself");
return true;
}
specificComponent.AddNuget(logger, nugetComponent, components, packagesOutputDirectory);
return true;
}
public bool Process(ILogger logger, IEnumerable<string> args, MetaProjectPersistence metaProject, ComponentsList components, string packagesOutputDirectory)
{
var destination = args.ParseStringParameter("to", metaProject.LastPublishedTo);
if (string.IsNullOrWhiteSpace(destination))
return true;
if (!Directory.Exists(destination)) {
logger.Error("Could not find destination folder: '{0}'", destination);
return true;
}
metaProject.LastPublishedTo = destination;
var componentNamePattern = args.FirstOrDefault(s => !s.StartsWith("-")) ?? ".*";
var list = components.FilterBy(componentNamePattern, nugets: true);
var listIsOk = true;
foreach (var component in list)
if (component is INugetSpec)
if (!BuildHelper.PackageExists(component as INugetSpec, packagesOutputDirectory)) {
listIsOk = false;
logger.ErrorDetail("There is no built package for nuget '{0}'", component.Name);
}
if (listIsOk)
foreach (var component in list)
if (component is INugetSpec)
BuildHelper.CopyIfNew(logger, component as INugetSpec, packagesOutputDirectory, destination);
return true;
}
public bool Process(ILogger logger, IEnumerable<string> args, MetaProjectPersistence metaProject, ComponentsList components, string packagesOutputDirectory)
{
// BIG TODO: reengineer command parsing
var componentNamePattern = args.LastOrDefault();
if (componentNamePattern == null || componentNamePattern.StartsWith("-") || componentNamePattern.EndsWith("\"")) {
logger.Error("No component pattern specified");
return true;
}
string tags = args.ParseStringParameter("tags");
string licenseUrl = args.ParseStringParameter("licenseUrl");
string projectUrl = args.ParseStringParameter("projectUrl");
string iconUrl = args.ParseStringParameter("iconUrl");
string copyright = args.ParseStringParameter("copyright");
bool requireLicenseAcceptance = args.Contains("-r");
if (licenseUrl == null && requireLicenseAcceptance) {
logger.Error("Requiring license acceptance demands a license url");
return true;
}
var specificComponent = components.FindComponent<IProject>(componentNamePattern, c => c.CanBecomeNugget);
if (specificComponent == null)
return true;
if (specificComponent.PromoteToNuget(logger, packagesOutputDirectory, tags,
licenseUrl, projectUrl, iconUrl, copyright, requireLicenseAcceptance) != null)
ScanCommand.Rescan(logger, metaProject, components);
return true;
}
public bool Process(ILogger logger, IEnumerable<string> args, MetaProjectPersistence metaProject, ComponentsList components, string packagesOutputDirectory)
{
logger.Info("Directories that will be scanned:");
using (logger.Block)
foreach (var dir in metaProject.ListOfDirectories)
logger.Info(dir);
logger.Info("Directories that won't be scanned:");
using (logger.Block)
foreach (var dir in metaProject.ListOfExcludedDirectories)
logger.Info(dir);
Rescan(logger, metaProject, components);
return true;
}
public bool Process(ILogger logger, IEnumerable<string> args, MetaProjectPersistence metaProject, ComponentsList components, string packagesOutputDirectory)
{
var pattern = args.FirstOrDefault(s => !s.StartsWith("-"));
bool full = args.Contains("-full") || args.Contains("-f");
bool nugets = args.Contains("-nugets") || args.Contains("-n");
bool orphans = args.Contains("-orphans");
bool solutions = args.Contains("-solutions") || args.Contains("-s");
bool orderByTreeDepth = args.Contains("-orderbytree") || args.Contains("-o");
bool groupByType = (args.Contains("-groupbytype") || args.Contains("-g")) && !nugets;
var i = 0;
if (solutions) {
logger.Info("=========== [Solutions]");
foreach (var solution in components.Solutions) {
logger.Info("[{0:0000}] {1}", ++i, solution.ToString());
if (full)
using (logger.Block) {
int j = 0;
foreach (var project in solution.Projects.OrderBy(p => p.Name)) {
var component = components.FindMatchingComponent(project);
if (component == null)
logger.Info("[{0:0000}] Missing project '{1}'", ++j, project.Name);
else
logger.Info("[{0:0000}] {1}", ++j, component.ToString());
}
}
}
} else {
if (string.IsNullOrWhiteSpace(pattern)) {
logger.Info("Listing all {0}...", nugets ? "nugets" : "components");
} else {
logger.Info("Listing {1} filtered by '{0}' ...", pattern, nugets ? "nugets" : "components");
pattern = pattern.ToLowerInvariant();
}
if (orphans)
logger.Info("-- only orphan projects");
if (orderByTreeDepth)
logger.Info("-- ordered by dependents components tree depth (most referenced first)");
if (groupByType)
logger.Info("-- grouped by type");
var lastGroup = "";
foreach (var component in components.FilterBy(pattern, nugets, orderByTreeDepth, groupByType, orphans)) {
if (groupByType && component.Type != lastGroup) {
lastGroup = component.Type;
logger.Info("=========== [{0}]", lastGroup);
}
logger.Info("[{0:0000}] {1}", ++i, (full ? component.ToLongString() : component.ToString()));
}
}
return true;
}
public bool Process(ILogger logger, IEnumerable<string> args, MetaProjectPersistence metaProject, ComponentsList components, string packagesOutputDirectory)
{
UpdatePackagesCommand.UpdateDependencies(logger, components, packagesOutputDirectory);
var componentNamePattern = args.FirstOrDefault(s => !s.StartsWith("-"));
if (!string.IsNullOrWhiteSpace(componentNamePattern)) {
var rootComponent = components.FindComponent<IVersionable>(componentNamePattern);
if (rootComponent == null)
return true;
BuildHelper.BuildChain(logger, rootComponent, packagesOutputDirectory, rootComponent.DependentProjects);
} else {
foreach (var rootComponent in GetPendingForPublishingComponents(logger, components, packagesOutputDirectory))
BuildHelper.BuildChain(logger, rootComponent, packagesOutputDirectory, rootComponent.DependentProjects);
}
return true;
}
static void Main(string[] args)
{
Console.WriteLine("NugetCracker {0}\nSee https://github.com/monoman/NugetCracker\n", Version.ToString(3));
using (_metaProjectPersistence = new MetaProjectPersistence(args.GetMetaProjectFilePath())) {
Console.WriteLine("Using {0}", _metaProjectPersistence.FilePath);
_components = new ComponentsList();
if (!args.TakeWhile(s => s.ToLowerInvariant() != "-c").Any(s => s.ToLowerInvariant() == "-noscan"))
ProcessCommand(new string[] { "scan" });
var inlineCommand = args.SkipWhile(s => s.ToLowerInvariant() != "-c").Skip(1);
if (inlineCommand.Count() > 0) {
ProcessCommand(inlineCommand);
Console.WriteLine("Done!");
} else
InteractiveLoop();
}
}
public bool Process(ILogger logger, IEnumerable<string> args, MetaProjectPersistence metaProject, ComponentsList components, string packagesOutputDirectory)
{
bool foundOne = false;
var partToBump = ParsePartToBump(logger, args);
bool noBuild = args.Where(s => s.StartsWith("-n")).Count() > 0;
foreach (var componentNamePattern in args.Where(s => !s.StartsWith("-"))) {
foundOne = true;
var specificComponent = components.FindComponent<IVersionable>(componentNamePattern);
if (specificComponent == null)
return true;
BumpVersion(logger, specificComponent, partToBump, packagesOutputDirectory, noBuild);
}
if (!foundOne) {
logger.Error("No component pattern specified");
return true;
}
return true;
}
public bool Process(ILogger logger, IEnumerable<string> args, MetaProjectPersistence metaProject, ComponentsList components, string packagesOutputDirectory)
{
var relativePath = string.Join(" ", args.Where(s => !s.StartsWith("-")));
if (string.IsNullOrWhiteSpace(relativePath)) {
logger.Error("No relativePath provided");
return true;
}
bool force = args.Any(s => s.Length > 1 && "-force".StartsWith(s.ToLowerInvariant()));
var path = metaProject.ToAbsolutePath(relativePath);
if (!Directory.Exists(path)) {
logger.Error("The path '{0}' doesn't exist", path);
return true;
}
if (!force) {
Console.Write("Exclude directory '{0}' and all subfolders from scanning? [y/N]", path);
var answer = Console.ReadLine().Trim().ToLowerInvariant();
if (answer != "y")
return true;
}
metaProject.AddExcludedDirectory(path);
components.Prune(path);
logger.Info("Directory '{0}' excluded from scanning", relativePath);
return true;
}
public static void Rescan(ILogger logger, MetaProjectPersistence metaProject, ComponentsList components)
{
components.Clear();
int scannedDirsCount = 0;
foreach (string dir in metaProject.ListOfDirectories) {
string path = metaProject.ToAbsolutePath(dir);
logger.Info("Scanning '{0}' > '{1}'", dir, path);
components.Scan(metaProject, path, _factories, s =>
{
logger.Debug(s);
scannedDirsCount++;
});
}
logger.Info("Scanned {0} directories", scannedDirsCount);
logger.Info("Found {0} component{1}", components.Count, components.Count > 1 ? "s" : "");
logger.Info("Found {0} solution{1}", components.Solutions.Count, components.Solutions.Count > 1 ? "s" : "");
logger.Info("Sorting...");
components.SortByName();
logger.Info("Finding dependents...");
components.FindDependents();
logger.Info("Matching solutions to projects...");
components.MatchSolutionsToProjects();
return;
}
