mirrors/dotnet-installer
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

move subcommands to new parser

Browse source
This commit is contained in:
Jon Sequeira 2017-03-10 16:43:44 -08:00
parent d3319adb59
commit a3f536c248
20 changed files with 307 additions and 395 deletions
Download patch file Download diff file Expand all files Collapse all files

7
src/Microsoft.DotNet.Cli.Utils/PathUtility.cs
View file

@ -313,9 +313,12 @@ namespace Microsoft.DotNet.Tools.Common
return Path.GetFullPath(path); return Path.GetFullPath(path);
} }
public static void EnsureAllPathsExist(List<string> paths, string pathDoesNotExistLocalizedFormatString) public static void EnsureAllPathsExist(
IReadOnlyCollection<string> paths,
string pathDoesNotExistLocalizedFormatString)
{ {
var notExisting = new List<string>(); var notExisting = new List<string>();
foreach (var p in paths) foreach (var p in paths)
{ {
if (!File.Exists(p)) if (!File.Exists(p))
@ -329,7 +332,7 @@ namespace Microsoft.DotNet.Tools.Common
throw new GracefulException( throw new GracefulException(
string.Join( string.Join(
Environment.NewLine, Environment.NewLine,
notExisting.Select((p) => string.Format(pathDoesNotExistLocalizedFormatString, p)))); notExisting.Select(p => string.Format(pathDoesNotExistLocalizedFormatString, p))));
} }
} }
} }

10
src/dotnet/CommandBase.cs Normal file
View file

@ -0,0 +1,10 @@
// Copyright (c) .NET Foundation and contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
namespace Microsoft.DotNet.Cli
{
public abstract class CommandBase
{
public abstract int Execute();
}
}

16
src/dotnet/DotNetSubCommandBase.cs
View file

@ -1,16 +0,0 @@
// Copyright (c) .NET Foundation and contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
using Microsoft.DotNet.Cli.CommandLine;
namespace Microsoft.DotNet.Cli
{
internal abstract class DotNetSubCommandBase : CommandLineApplication
{
internal DotNetSubCommandBase() : base(throwOnUnexpectedArg: false)
{
}
public abstract int Run(string fileOrDirectory);
}
}

49
src/dotnet/DotNetTopLevelCommandBase.cs
View file

@ -3,12 +3,9 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.IO;
using System.Linq; using System.Linq;
using Microsoft.DotNet.Cli.CommandLine; using Microsoft.DotNet.Cli.CommandLine;
using Microsoft.DotNet.Cli.Utils; using Microsoft.DotNet.Cli.Utils;
using Microsoft.DotNet.Tools;
using Microsoft.DotNet.Tools.Common;
namespace Microsoft.DotNet.Cli namespace Microsoft.DotNet.Cli
{ {
@ -18,60 +15,34 @@ namespace Microsoft.DotNet.Cli
protected abstract string FullCommandNameLocalized { get; } protected abstract string FullCommandNameLocalized { get; }
protected abstract string ArgumentName { get; } protected abstract string ArgumentName { get; }
protected abstract string ArgumentDescriptionLocalized { get; } protected abstract string ArgumentDescriptionLocalized { get; }
internal abstract List<Func<DotNetSubCommandBase>> SubCommands { get; } internal abstract Dictionary<string, Func<AppliedOption, CommandBase>> SubCommands { get; }
public int RunCommand(string[] args) public int RunCommand(string[] args)
{ {
DebugHelper.HandleDebugSwitch(ref args); DebugHelper.HandleDebugSwitch(ref args);
CommandLineApplication command = new CommandLineApplication(throwOnUnexpectedArg: true) var parser = Parser.Instance;
{
Name = $"dotnet {CommandName}",
FullName = FullCommandNameLocalized,
};
command.HelpOption("-h|--help"); var result = parser.ParseFrom($"dotnet {CommandName}", args);
command.Argument(ArgumentName, ArgumentDescriptionLocalized); Reporter.Output.WriteLine(result.Diagram());
foreach (var subCommandCreator in SubCommands) result.ShowHelpIfRequested();
{
var subCommand = subCommandCreator();
command.AddCommand(subCommand);
subCommand.OnExecute(() => { var subcommandName = result.Command().Name;
try
{
if (!command.Arguments.Any())
{
throw new GracefulException(CommonLocalizableStrings.RequiredArgumentNotPassed, ArgumentDescriptionLocalized);
}
var projectOrDirectory = command.Arguments.First().Value; var create = SubCommands[subcommandName];
if (string.IsNullOrEmpty(projectOrDirectory))
{
projectOrDirectory = PathUtility.EnsureTrailingSlash(Directory.GetCurrentDirectory());
}
return subCommand.Run(projectOrDirectory); var command = create(result["dotnet"][CommandName]);
}
catch (GracefulException e)
{
Reporter.Error.WriteLine(e.Message.Red());
subCommand.ShowHelp();
return 1;
}
});
}
try try
{ {
return command.Execute(args); return command.Execute();
} }
catch (GracefulException e) catch (GracefulException e)
{ {
Reporter.Error.WriteLine(e.Message.Red()); Reporter.Error.WriteLine(e.Message.Red());
command.ShowHelp(); result.ShowHelp();
return 1; return 1;
} }
catch (CommandParsingException e) catch (CommandParsingException e)

4
src/dotnet/ParseResultExtensions.cs
View file

@ -14,11 +14,9 @@ namespace Microsoft.DotNet.Cli
public static void ShowHelpIfRequested(this ParseResult parseResult) public static void ShowHelpIfRequested(this ParseResult parseResult)
{ {
if (parseResult.HasOption("help")) if (parseResult.AppliedOptions.Any(o => o.HasOption("help")))
{ {
// NOTE: this is a temporary stage in refactoring toward the ClicCommandLineParser being used at the CLI entry point. // NOTE: this is a temporary stage in refactoring toward the ClicCommandLineParser being used at the CLI entry point.
throw new HelpException(parseResult.Command().HelpView()); throw new HelpException(parseResult.Command().HelpView());
} }
} }

2
src/dotnet/Program.cs
View file

@ -54,7 +54,7 @@ namespace Microsoft.DotNet.Cli
["test"] = TestCommand.Run, ["test"] = TestCommand.Run,
["vstest"] = VSTestCommand.Run, ["vstest"] = VSTestCommand.Run,
["complete"] = CompleteCommand.Run, ["complete"] = CompleteCommand.Run,
["parse"] = ParseCommand.Run, ["parse"] = ParseCommand.Run
}; };
public static int Main(string[] args) public static int Main(string[] args)

71
src/dotnet/commands/dotnet-add/AddCommandParser.cs
View file

@ -3,6 +3,7 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq;
using System.Net.Http; using System.Net.Http;
using System.Threading; using System.Threading;
using Microsoft.DotNet.Cli.CommandLine; using Microsoft.DotNet.Cli.CommandLine;
@ -13,36 +14,46 @@ namespace Microsoft.DotNet.Cli
internal static class AddCommandParser internal static class AddCommandParser
{ {
public static Command Add() => public static Command Add() =>
Create.Command("add", Create.Command(
".NET Add Command", "add",
Accept.ExactlyOneArgument.DefaultToCurrentDirectory(), ".NET Add Command",
Create.Command("package", Accept.ExactlyOneArgument
".NET Add Package reference Command", .DefaultToCurrentDirectory(),
Accept.ExactlyOneArgument Create.Command(
.WithSuggestionsFrom(QueryNuGet), CommonOptions.HelpOption(), "package",
Create.Option("-v|--version", ".NET Add Package reference Command",
"Version for the package to be added.", Accept.ExactlyOneArgument
Accept.ExactlyOneArgument .WithSuggestionsFrom(QueryNuGet), CommonOptions.HelpOption(),
.With(name: "VERSION")), Create.Option("-v|--version",
Create.Option("-f|--framework", "Version for the package to be added.",
"Add reference only when targetting a specific framework", Accept.ExactlyOneArgument
Accept.ExactlyOneArgument .With(name: "VERSION")
.With(name: "FRAMEWORK")), .ForwardAs(o => $"--version {o.Arguments.Single()}")),
Create.Option("-n|--no-restore ", Create.Option("-f|--framework",
"Add reference without performing restore preview and compatibility check."), "Add reference only when targetting a specific framework",
Create.Option("-s|--source", Accept.ExactlyOneArgument
"Use specific NuGet package sources to use during the restore."), .With(name: "FRAMEWORK")
Create.Option("--package-directory", .ForwardAs(o => $"--framework {o.Arguments.Single()}")),
"Restore the packages to this Directory .", Create.Option("-n|--no-restore ",
Accept.ExactlyOneArgument "Add reference without performing restore preview and compatibility check."),
.With(name: "PACKAGE_DIRECTORY"))), Create.Option("-s|--source",
Create.Command("reference", "Use specific NuGet package sources to use during the restore.",
"Command to add project to project reference", Accept.ExactlyOneArgument
Accept.OneOrMoreArguments, CommonOptions.HelpOption(), .With(name: "SOURCE")
Create.Option("-f|--framework", .ForwardAs(o => $"--source {o.Arguments.Single()}")),
"Add reference only when targetting a specific framework", Create.Option("--package-directory",
Accept.AnyOneOf(Suggest.TargetFrameworksFromProjectFile) "Restore the packages to this Directory .",
.With(name: "FRAMEWORK"))), CommonOptions.HelpOption()); Accept.ExactlyOneArgument
.With(name: "PACKAGE_DIRECTORY")
.ForwardAs(o => $"--package-directory {o.Arguments.Single()}"))),
Create.Command(
"reference",
"Command to add project to project reference",
Accept.OneOrMoreArguments, CommonOptions.HelpOption(),
Create.Option("-f|--framework",
"Add reference only when targetting a specific framework",
Accept.AnyOneOf(Suggest.TargetFrameworksFromProjectFile)
.With(name: "FRAMEWORK"))), CommonOptions.HelpOption());
public static IEnumerable<string> QueryNuGet(string match) public static IEnumerable<string> QueryNuGet(string match)
{ {

21
src/dotnet/commands/dotnet-add/Program.cs
View file

@ -3,7 +3,9 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq;
using Microsoft.DotNet.Cli; using Microsoft.DotNet.Cli;
using Microsoft.DotNet.Cli.CommandLine;
using Microsoft.DotNet.Cli.Utils; using Microsoft.DotNet.Cli.Utils;
using Microsoft.DotNet.Tools.Add.PackageReference; using Microsoft.DotNet.Tools.Add.PackageReference;
using Microsoft.DotNet.Tools.Add.ProjectToProjectReference; using Microsoft.DotNet.Tools.Add.ProjectToProjectReference;
@ -16,11 +18,22 @@ namespace Microsoft.DotNet.Tools.Add
protected override string FullCommandNameLocalized => LocalizableStrings.NetAddCommand; protected override string FullCommandNameLocalized => LocalizableStrings.NetAddCommand;
protected override string ArgumentName => Constants.ProjectArgumentName; protected override string ArgumentName => Constants.ProjectArgumentName;
protected override string ArgumentDescriptionLocalized => CommonLocalizableStrings.ArgumentsProjectDescription; protected override string ArgumentDescriptionLocalized => CommonLocalizableStrings.ArgumentsProjectDescription;
internal override List<Func<DotNetSubCommandBase>> SubCommands =>
new List<Func<DotNetSubCommandBase>> internal override Dictionary<string, Func<AppliedOption, CommandBase>> SubCommands =>
new Dictionary<string, Func<AppliedOption, CommandBase>>
{ {
AddProjectToProjectReferenceCommand.Create, {
AddPackageReferenceCommand.Create, "reference",
add => new AddProjectToProjectReferenceCommand(
add["reference"],
add.Value<string>())
},
{
"package",
add => new AddPackageReferenceCommand(
add["package"],
add.Value<string>())
}
}; };
public static int Run(string[] args) public static int Run(string[] args)

121
src/dotnet/commands/dotnet-add/dotnet-add-package/Program.cs
View file

@ -1,105 +1,65 @@
// Copyright (c) .NET Foundation and contributors. All rights reserved. // Copyright (c) .NET Foundation and contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information. // Licensed under the MIT license. See LICENSE file in the project root for full license information.
using Microsoft.Build.Evaluation; using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Microsoft.DotNet.Cli; using Microsoft.DotNet.Cli;
using Microsoft.DotNet.Cli.CommandLine; using Microsoft.DotNet.Cli.CommandLine;
using Microsoft.DotNet.Cli.Utils; using Microsoft.DotNet.Cli.Utils;
using Microsoft.DotNet.Tools.Common;
using Microsoft.DotNet.Tools.MSBuild; using Microsoft.DotNet.Tools.MSBuild;
using Microsoft.DotNet.Tools.NuGet; using Microsoft.DotNet.Tools.NuGet;
using NuGet.Frameworks;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
namespace Microsoft.DotNet.Tools.Add.PackageReference namespace Microsoft.DotNet.Tools.Add.PackageReference
{ {
internal class AddPackageReferenceCommand : DotNetSubCommandBase internal class AddPackageReferenceCommand : CommandBase
{ {
private CommandOption _versionOption; private readonly AppliedOption _appliedCommand;
private CommandOption _frameworkOption;
private CommandOption _noRestoreOption;
private CommandOption _sourceOption;
private CommandOption _packageDirectoryOption;
private CommandArgument _packageNameArgument;
public static DotNetSubCommandBase Create() private readonly string _packageId;
private readonly string _fileOrDirectory;
public AddPackageReferenceCommand(AppliedOption appliedCommand, string fileOrDirectory)
{ {
var command = new AddPackageReferenceCommand _appliedCommand = appliedCommand;
{ _fileOrDirectory = fileOrDirectory;
Name = "package", _packageId = appliedCommand.Value<string>();
FullName = LocalizableStrings.AppFullName,
Description = LocalizableStrings.AppDescription,
HandleRemainingArguments = false
};
command.HelpOption("-h|--help");
command._packageNameArgument = command.Argument( if ( string.IsNullOrWhiteSpace(_packageId) || _appliedCommand.Arguments.Count > 1)
$"<{LocalizableStrings.CmdPackage}>",
LocalizableStrings.CmdPackageDescription,
multipleValues: false);
command._versionOption = command.Option(
$"-v|--version <{LocalizableStrings.CmdVersion}>",
description: LocalizableStrings.CmdVersionDescription,
optionType: CommandOptionType.SingleValue);
command._frameworkOption = command.Option(
$"-f|--framework <{LocalizableStrings.CmdFramework}>",
LocalizableStrings.CmdFrameworkDescription,
CommandOptionType.SingleValue);
command._noRestoreOption = command.Option(
"-n|--no-restore ",
LocalizableStrings.CmdNoRestoreDescription,
CommandOptionType.NoValue);
command._sourceOption = command.Option(
$"-s|--source <{LocalizableStrings.CmdSource}>",
LocalizableStrings.CmdSourceDescription,
CommandOptionType.SingleValue);
command._packageDirectoryOption = command.Option(
$"--package-directory <{LocalizableStrings.CmdPackageDirectory}>",
LocalizableStrings.CmdPackageDirectoryDescription,
CommandOptionType.SingleValue);
return command;
}
public override int Run(string fileOrDirectory)
{
if (_packageNameArgument.Values.Count != 1 || string.IsNullOrWhiteSpace(_packageNameArgument.Value) || RemainingArguments.Count > 0)
{ {
throw new GracefulException(LocalizableStrings.SpecifyExactlyOnePackageReference); throw new GracefulException(LocalizableStrings.SpecifyExactlyOnePackageReference);
} }
}
public override int Execute()
{
var projectFilePath = string.Empty; var projectFilePath = string.Empty;
if (!File.Exists(fileOrDirectory)) if (!File.Exists(_fileOrDirectory))
{ {
projectFilePath = MsbuildProject.GetProjectFileFromDirectory(fileOrDirectory).FullName; projectFilePath = MsbuildProject.GetProjectFileFromDirectory(_fileOrDirectory).FullName;
} }
else else
{ {
projectFilePath = fileOrDirectory; projectFilePath = _fileOrDirectory;
} }
var tempDgFilePath = string.Empty; var tempDgFilePath = string.Empty;
if (!_noRestoreOption.HasValue()) if (!_appliedCommand.HasOption("no-restore"))
{ {
// Create a Dependency Graph file for the project // Create a Dependency Graph file for the project
tempDgFilePath = Path.GetTempFileName(); tempDgFilePath = Path.GetTempFileName();
GetProjectDependencyGraph(projectFilePath, tempDgFilePath); GetProjectDependencyGraph(projectFilePath, tempDgFilePath);
} }
var result = NuGetCommand.Run(TransformArgs(_packageNameArgument.Value, tempDgFilePath, projectFilePath)); var result = NuGetCommand.Run(
TransformArgs(
_packageId,
tempDgFilePath,
projectFilePath));
DisposeTemporaryFile(tempDgFilePath); DisposeTemporaryFile(tempDgFilePath);
return result; return result;
@ -136,7 +96,8 @@ namespace Microsoft.DotNet.Tools.Add.PackageReference
private string[] TransformArgs(string packageId, string tempDgFilePath, string projectFilePath) private string[] TransformArgs(string packageId, string tempDgFilePath, string projectFilePath)
{ {
var args = new List<string>(){ var args = new List<string>
{
"package", "package",
"add", "add",
"--package", "--package",
@ -145,27 +106,11 @@ namespace Microsoft.DotNet.Tools.Add.PackageReference
projectFilePath projectFilePath
}; };
if (_versionOption.HasValue()) args.AddRange(_appliedCommand
{ .OptionValuesToBeForwarded()
args.Add("--version"); .SelectMany(a => a.Split(' ')));
args.Add(_versionOption.Value());
} if (_appliedCommand.HasOption("no-restore"))
if (_sourceOption.HasValue())
{
args.Add("--source");
args.Add(_sourceOption.Value());
}
if (_frameworkOption.HasValue())
{
args.Add("--framework");
args.Add(_frameworkOption.Value());
}
if (_packageDirectoryOption.HasValue())
{
args.Add("--package-directory");
args.Add(_packageDirectoryOption.Value());
}
if (_noRestoreOption.HasValue())
{ {
args.Add("--no-restore"); args.Add("--no-restore");
} }

76
src/dotnet/commands/dotnet-add/dotnet-add-reference/Program.cs
View file

@ -1,59 +1,46 @@
// Copyright (c) .NET Foundation and contributors. All rights reserved. // Copyright (c) .NET Foundation and contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information. // Licensed under the MIT license. See LICENSE file in the project root for full license information.
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using Microsoft.Build.Evaluation; using Microsoft.Build.Evaluation;
using Microsoft.DotNet.Cli; using Microsoft.DotNet.Cli;
using Microsoft.DotNet.Cli.CommandLine; using Microsoft.DotNet.Cli.CommandLine;
using Microsoft.DotNet.Cli.Utils; using Microsoft.DotNet.Cli.Utils;
using Microsoft.DotNet.Tools.Common; using Microsoft.DotNet.Tools.Common;
using NuGet.Frameworks; using NuGet.Frameworks;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
namespace Microsoft.DotNet.Tools.Add.ProjectToProjectReference namespace Microsoft.DotNet.Tools.Add.ProjectToProjectReference
{ {
internal class AddProjectToProjectReferenceCommand : DotNetSubCommandBase internal class AddProjectToProjectReferenceCommand : CommandBase
{ {
private CommandOption _frameworkOption; private readonly AppliedOption _appliedCommand;
private readonly string _fileOrDirectory;
public static DotNetSubCommandBase Create() public AddProjectToProjectReferenceCommand(AppliedOption appliedCommand, string fileOrDirectory)
{ {
var command = new AddProjectToProjectReferenceCommand() if (appliedCommand == null)
{ {
Name = "reference", throw new ArgumentNullException(nameof(appliedCommand));
FullName = LocalizableStrings.AppFullName, }
Description = LocalizableStrings.AppDescription, _appliedCommand = appliedCommand;
HandleRemainingArguments = true, _fileOrDirectory = fileOrDirectory;
ArgumentSeparatorHelpText = LocalizableStrings.AppHelpText,
};
command.HelpOption("-h|--help");
command._frameworkOption = command.Option(
$"-f|--framework <{CommonLocalizableStrings.CmdFramework}>",
LocalizableStrings.CmdFrameworkDescription,
CommandOptionType.SingleValue);
return command;
} }
public override int Run(string fileOrDirectory) public override int Execute()
{ {
var projects = new ProjectCollection(); var projects = new ProjectCollection();
MsbuildProject msbuildProj = MsbuildProject.FromFileOrDirectory(projects, fileOrDirectory); MsbuildProject msbuildProj = MsbuildProject.FromFileOrDirectory(projects, _fileOrDirectory);
if (RemainingArguments.Count == 0) var frameworkString = _appliedCommand["framework"].Value<string>();
{
throw new GracefulException(CommonLocalizableStrings.SpecifyAtLeastOneReferenceToAdd);
}
string frameworkString = _frameworkOption.Value(); PathUtility.EnsureAllPathsExist(_appliedCommand.Arguments, CommonLocalizableStrings.ReferenceDoesNotExist);
PathUtility.EnsureAllPathsExist(RemainingArguments, CommonLocalizableStrings.ReferenceDoesNotExist); List<MsbuildProject> refs = _appliedCommand.Arguments
List<MsbuildProject> refs = RemainingArguments .Select((r) => MsbuildProject.FromFile(projects, r))
.Select((r) => MsbuildProject.FromFile(projects, r)) .ToList();
.ToList();
if (frameworkString == null) if (frameworkString == null)
{ {
@ -64,8 +51,8 @@ namespace Microsoft.DotNet.Tools.Add.ProjectToProjectReference
if (!@ref.CanWorkOnFramework(tfm)) if (!@ref.CanWorkOnFramework(tfm))
{ {
Reporter.Error.Write(GetProjectNotCompatibleWithFrameworksDisplayString( Reporter.Error.Write(GetProjectNotCompatibleWithFrameworksDisplayString(
@ref, @ref,
msbuildProj.GetTargetFrameworks().Select((fx) => fx.GetShortFolderName()))); msbuildProj.GetTargetFrameworks().Select((fx) => fx.GetShortFolderName())));
return 1; return 1;
} }
} }
@ -77,9 +64,9 @@ namespace Microsoft.DotNet.Tools.Add.ProjectToProjectReference
if (!msbuildProj.IsTargetingFramework(framework)) if (!msbuildProj.IsTargetingFramework(framework))
{ {
Reporter.Error.WriteLine(string.Format( Reporter.Error.WriteLine(string.Format(
CommonLocalizableStrings.ProjectDoesNotTargetFramework, CommonLocalizableStrings.ProjectDoesNotTargetFramework,
msbuildProj.ProjectRootElement.FullPath, msbuildProj.ProjectRootElement.FullPath,
frameworkString)); frameworkString));
return 1; return 1;
} }
@ -88,18 +75,19 @@ namespace Microsoft.DotNet.Tools.Add.ProjectToProjectReference
if (!@ref.CanWorkOnFramework(framework)) if (!@ref.CanWorkOnFramework(framework))
{ {
Reporter.Error.Write(GetProjectNotCompatibleWithFrameworksDisplayString( Reporter.Error.Write(GetProjectNotCompatibleWithFrameworksDisplayString(
@ref, @ref,
new string[] { frameworkString })); new string[] { frameworkString }));
return 1; return 1;
} }
} }
} }
var relativePathReferences = RemainingArguments.Select((r) => var relativePathReferences = _appliedCommand.Arguments.Select((r) =>
PathUtility.GetRelativePath(msbuildProj.ProjectDirectory, Path.GetFullPath(r))).ToList(); PathUtility.GetRelativePath(msbuildProj.ProjectDirectory, Path.GetFullPath(r)))
.ToList();
int numberOfAddedReferences = msbuildProj.AddProjectToProjectReferences( int numberOfAddedReferences = msbuildProj.AddProjectToProjectReferences(
_frameworkOption.Value(), frameworkString,
relativePathReferences); relativePathReferences);
if (numberOfAddedReferences != 0) if (numberOfAddedReferences != 0)

3
src/dotnet/commands/dotnet-complete/CompleteCommandParser.cs
View file

@ -15,6 +15,7 @@ namespace Microsoft.DotNet.Cli
.With(name: "path"), .With(name: "path"),
Create.Option("--position", "", Create.Option("--position", "",
Accept.ExactlyOneArgument Accept.ExactlyOneArgument
.With(name: "command"))); .With(name: "command")
.MaterializeAs(o => int.Parse(o.Arguments.Single()))));
} }
} }

8
src/dotnet/commands/dotnet-list/Program.cs
View file

@ -4,6 +4,7 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using Microsoft.DotNet.Cli; using Microsoft.DotNet.Cli;
using Microsoft.DotNet.Cli.CommandLine;
using Microsoft.DotNet.Cli.Utils; using Microsoft.DotNet.Cli.Utils;
using Microsoft.DotNet.Tools.List.ProjectToProjectReferences; using Microsoft.DotNet.Tools.List.ProjectToProjectReferences;
@ -15,10 +16,11 @@ namespace Microsoft.DotNet.Tools.List
protected override string FullCommandNameLocalized => LocalizableStrings.NetListCommand; protected override string FullCommandNameLocalized => LocalizableStrings.NetListCommand;
protected override string ArgumentName => Constants.ProjectArgumentName; protected override string ArgumentName => Constants.ProjectArgumentName;
protected override string ArgumentDescriptionLocalized => CommonLocalizableStrings.ArgumentsProjectDescription; protected override string ArgumentDescriptionLocalized => CommonLocalizableStrings.ArgumentsProjectDescription;
internal override List<Func<DotNetSubCommandBase>> SubCommands =>
new List<Func<DotNetSubCommandBase>> internal override Dictionary<string, Func<AppliedOption, CommandBase>> SubCommands =>
new Dictionary<string, Func<AppliedOption, CommandBase>>
{ {
ListProjectToProjectReferencesCommand.Create, { "list", o => new ListProjectToProjectReferencesCommand(o) }
}; };
public static int Run(string[] args) public static int Run(string[] args)

32
src/dotnet/commands/dotnet-list/dotnet-list-reference/Program.cs
View file

@ -1,40 +1,40 @@
// Copyright (c) .NET Foundation and contributors. All rights reserved. // Copyright (c) .NET Foundation and contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information. // Licensed under the MIT license. See LICENSE file in the project root for full license information.
using System;
using System.Linq;
using Microsoft.Build.Evaluation; using Microsoft.Build.Evaluation;
using Microsoft.DotNet.Cli; using Microsoft.DotNet.Cli;
using Microsoft.DotNet.Cli.CommandLine;
using Microsoft.DotNet.Cli.Utils; using Microsoft.DotNet.Cli.Utils;
using System.Linq;
namespace Microsoft.DotNet.Tools.List.ProjectToProjectReferences namespace Microsoft.DotNet.Tools.List.ProjectToProjectReferences
{ {
internal class ListProjectToProjectReferencesCommand : DotNetSubCommandBase internal class ListProjectToProjectReferencesCommand : CommandBase
{ {
public static DotNetSubCommandBase Create() private readonly string _fileOrDirectory;
public ListProjectToProjectReferencesCommand(AppliedOption appliedCommand)
{ {
var command = new ListProjectToProjectReferencesCommand() if (appliedCommand == null)
{ {
Name = "reference", throw new ArgumentNullException(nameof(appliedCommand));
FullName = LocalizableStrings.AppFullName, }
Description = LocalizableStrings.AppDescription,
};
command.HelpOption("-h|--help"); _fileOrDirectory = appliedCommand.Arguments.Single();
return command;
} }
public override int Run(string fileOrDirectory) public override int Execute()
{ {
var msbuildProj = MsbuildProject.FromFileOrDirectory(new ProjectCollection(), fileOrDirectory); var msbuildProj = MsbuildProject.FromFileOrDirectory(new ProjectCollection(), _fileOrDirectory);
var p2ps = msbuildProj.GetProjectToProjectReferences(); var p2ps = msbuildProj.GetProjectToProjectReferences();
if (!p2ps.Any()) if (!p2ps.Any())
{ {
Reporter.Output.WriteLine(string.Format( Reporter.Output.WriteLine(string.Format(
CommonLocalizableStrings.NoReferencesFound, CommonLocalizableStrings.NoReferencesFound,
CommonLocalizableStrings.P2P, CommonLocalizableStrings.P2P,
fileOrDirectory)); _fileOrDirectory));
return 0; return 0;
} }

10
src/dotnet/commands/dotnet-remove/Program.cs
View file

@ -4,6 +4,7 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using Microsoft.DotNet.Cli; using Microsoft.DotNet.Cli;
using Microsoft.DotNet.Cli.CommandLine;
using Microsoft.DotNet.Cli.Utils; using Microsoft.DotNet.Cli.Utils;
using Microsoft.DotNet.Tools.Remove.PackageReference; using Microsoft.DotNet.Tools.Remove.PackageReference;
using Microsoft.DotNet.Tools.Remove.ProjectToProjectReference; using Microsoft.DotNet.Tools.Remove.ProjectToProjectReference;
@ -16,11 +17,12 @@ namespace Microsoft.DotNet.Tools.Remove
protected override string FullCommandNameLocalized => LocalizableStrings.NetRemoveCommand; protected override string FullCommandNameLocalized => LocalizableStrings.NetRemoveCommand;
protected override string ArgumentName => Constants.ProjectArgumentName; protected override string ArgumentName => Constants.ProjectArgumentName;
protected override string ArgumentDescriptionLocalized => CommonLocalizableStrings.ArgumentsProjectDescription; protected override string ArgumentDescriptionLocalized => CommonLocalizableStrings.ArgumentsProjectDescription;
internal override List<Func<DotNetSubCommandBase>> SubCommands =>
new List<Func<DotNetSubCommandBase>> internal override Dictionary<string, Func<AppliedOption, CommandBase>> SubCommands =>
new Dictionary<string, Func<AppliedOption, CommandBase>>
{ {
RemoveProjectToProjectReferenceCommand.Create, { "reference", o => new RemoveProjectToProjectReferenceCommand(o) },
RemovePackageReferenceCommand.Create { "package", o => new RemovePackageReferenceCommand(o) }
}; };
public static int Run(string[] args) public static int Run(string[] args)

56
src/dotnet/commands/dotnet-remove/dotnet-remove-package/Program.cs
View file

@ -1,61 +1,50 @@
// Copyright (c) .NET Foundation and contributors. All rights reserved. // Copyright (c) .NET Foundation and contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information. // Licensed under the MIT license. See LICENSE file in the project root for full license information.
using Microsoft.Build.Evaluation; using System;
using System.IO;
using System.Linq;
using Microsoft.DotNet.Cli; using Microsoft.DotNet.Cli;
using Microsoft.DotNet.Cli.CommandLine; using Microsoft.DotNet.Cli.CommandLine;
using Microsoft.DotNet.Cli.Utils; using Microsoft.DotNet.Cli.Utils;
using Microsoft.DotNet.Tools.Common;
using Microsoft.DotNet.Tools.MSBuild;
using Microsoft.DotNet.Tools.NuGet; using Microsoft.DotNet.Tools.NuGet;
using NuGet.Frameworks;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
namespace Microsoft.DotNet.Tools.Remove.PackageReference namespace Microsoft.DotNet.Tools.Remove.PackageReference
{ {
internal class RemovePackageReferenceCommand : DotNetSubCommandBase internal class RemovePackageReferenceCommand : CommandBase
{ {
private readonly AppliedOption _appliedCommand;
private readonly string _fileOrDirectory;
public static DotNetSubCommandBase Create() public RemovePackageReferenceCommand(AppliedOption appliedCommand)
{ {
var command = new RemovePackageReferenceCommand if (appliedCommand == null)
{ {
Name = "package", throw new ArgumentNullException(nameof(appliedCommand));
FullName = LocalizableStrings.AppFullName, }
Description = LocalizableStrings.AppDescription, if (_appliedCommand.Arguments.Count != 1)
HandleRemainingArguments = true,
ArgumentSeparatorHelpText = LocalizableStrings.AppHelpText,
};
command.HelpOption("-h|--help");
return command;
}
public override int Run(string fileOrDirectory)
{
if (RemainingArguments.Count != 1)
{ {
throw new GracefulException(LocalizableStrings.SpecifyExactlyOnePackageReference); throw new GracefulException(LocalizableStrings.SpecifyExactlyOnePackageReference);
} }
_appliedCommand = appliedCommand;
_fileOrDirectory = appliedCommand.Arguments.Single();
}
public override int Execute()
{
var projectFilePath = string.Empty; var projectFilePath = string.Empty;
if (!File.Exists(fileOrDirectory)) if (!File.Exists(_fileOrDirectory))
{ {
projectFilePath = MsbuildProject.GetProjectFileFromDirectory(fileOrDirectory).FullName; projectFilePath = MsbuildProject.GetProjectFileFromDirectory(_fileOrDirectory).FullName;
} }
else else
{ {
projectFilePath = fileOrDirectory; projectFilePath = _fileOrDirectory;
} }
var packageToRemove = RemainingArguments.First(); var packageToRemove = _appliedCommand.Arguments.Single();
var result = NuGetCommand.Run(TransformArgs(packageToRemove, projectFilePath)); var result = NuGetCommand.Run(TransformArgs(packageToRemove, projectFilePath));
return result; return result;
@ -63,7 +52,8 @@ namespace Microsoft.DotNet.Tools.Remove.PackageReference
private string[] TransformArgs(string packageId, string projectFilePath) private string[] TransformArgs(string packageId, string projectFilePath)
{ {
return new string[]{ return new string[]
{
"package", "package",
"remove", "remove",
"--package", "--package",

46
src/dotnet/commands/dotnet-remove/dotnet-remove-reference/Program.cs
View file

@ -1,6 +1,8 @@
// Copyright (c) .NET Foundation and contributors. All rights reserved. // Copyright (c) .NET Foundation and contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information. // Licensed under the MIT license. See LICENSE file in the project root for full license information.
using System;
using System.Linq;
using Microsoft.Build.Evaluation; using Microsoft.Build.Evaluation;
using Microsoft.DotNet.Cli; using Microsoft.DotNet.Cli;
using Microsoft.DotNet.Cli.CommandLine; using Microsoft.DotNet.Cli.CommandLine;
@ -8,42 +10,34 @@ using Microsoft.DotNet.Cli.Utils;
namespace Microsoft.DotNet.Tools.Remove.ProjectToProjectReference namespace Microsoft.DotNet.Tools.Remove.ProjectToProjectReference
{ {
internal class RemoveProjectToProjectReferenceCommand : DotNetSubCommandBase internal class RemoveProjectToProjectReferenceCommand : CommandBase
{ {
private CommandOption _frameworkOption; private readonly AppliedOption _appliedCommand;
private readonly string _fileOrDirectory;
public static DotNetSubCommandBase Create() public RemoveProjectToProjectReferenceCommand(AppliedOption appliedCommand)
{ {
var command = new RemoveProjectToProjectReferenceCommand() if (appliedCommand == null)
{ {
Name = "reference", throw new ArgumentNullException(nameof(appliedCommand));
FullName = LocalizableStrings.AppFullName, }
Description = LocalizableStrings.AppDescription,
HandleRemainingArguments = true,
ArgumentSeparatorHelpText = LocalizableStrings.AppHelpText,
};
command.HelpOption("-h|--help"); if (_appliedCommand.Arguments.Count == 0)
command._frameworkOption = command.Option(
$"-f|--framework <{CommonLocalizableStrings.CmdFramework}>",
LocalizableStrings.CmdFrameworkDescription,
CommandOptionType.SingleValue);
return command;
}
public override int Run(string fileOrDirectory)
{
var msbuildProj = MsbuildProject.FromFileOrDirectory(new ProjectCollection(), fileOrDirectory);
if (RemainingArguments.Count == 0)
{ {
throw new GracefulException(CommonLocalizableStrings.SpecifyAtLeastOneReferenceToRemove); throw new GracefulException(CommonLocalizableStrings.SpecifyAtLeastOneReferenceToRemove);
} }
_appliedCommand = appliedCommand;
_fileOrDirectory = appliedCommand.Arguments.Single();
}
public override int Execute()
{
var msbuildProj = MsbuildProject.FromFileOrDirectory(new ProjectCollection(), _fileOrDirectory);
int numberOfRemovedReferences = msbuildProj.RemoveProjectToProjectReferences( int numberOfRemovedReferences = msbuildProj.RemoveProjectToProjectReferences(
_frameworkOption.Value(), _appliedCommand["framework"].Value<string>(),
RemainingArguments); _appliedCommand.Arguments);
if (numberOfRemovedReferences != 0) if (numberOfRemovedReferences != 0)
{ {

12
src/dotnet/commands/dotnet-sln/Program.cs
View file

@ -4,6 +4,7 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using Microsoft.DotNet.Cli; using Microsoft.DotNet.Cli;
using Microsoft.DotNet.Cli.CommandLine;
using Microsoft.DotNet.Cli.Utils; using Microsoft.DotNet.Cli.Utils;
using Microsoft.DotNet.Tools.Sln.Add; using Microsoft.DotNet.Tools.Sln.Add;
using Microsoft.DotNet.Tools.Sln.List; using Microsoft.DotNet.Tools.Sln.List;
@ -17,12 +18,13 @@ namespace Microsoft.DotNet.Tools.Sln
protected override string FullCommandNameLocalized => LocalizableStrings.AppFullName; protected override string FullCommandNameLocalized => LocalizableStrings.AppFullName;
protected override string ArgumentName => Constants.SolutionArgumentName; protected override string ArgumentName => Constants.SolutionArgumentName;
protected override string ArgumentDescriptionLocalized => CommonLocalizableStrings.ArgumentsSolutionDescription; protected override string ArgumentDescriptionLocalized => CommonLocalizableStrings.ArgumentsSolutionDescription;
internal override List<Func<DotNetSubCommandBase>> SubCommands =>
new List<Func<DotNetSubCommandBase>> internal override Dictionary<string, Func<AppliedOption, CommandBase>> SubCommands =>
new Dictionary<string, Func<AppliedOption, CommandBase>>
{ {
AddProjectToSolutionCommand.Create, { "add", o => new AddProjectToSolutionCommand(o) },
ListProjectsInSolutionCommand.Create, { "list", o => new ListProjectsInSolutionCommand(o) },
RemoveProjectFromSolutionCommand.Create { "remove", o => new RemoveProjectFromSolutionCommand(o) }
}; };
public static int Run(string[] args) public static int Run(string[] args)

47
src/dotnet/commands/dotnet-sln/add/Program.cs
View file

@ -1,49 +1,50 @@
// Copyright (c) .NET Foundation and contributors. All rights reserved. // Copyright (c) .NET Foundation and contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information. // Licensed under the MIT license. See LICENSE file in the project root for full license information.
using System;
using System.IO;
using System.Linq;
using Microsoft.DotNet.Cli; using Microsoft.DotNet.Cli;
using Microsoft.DotNet.Cli.CommandLine;
using Microsoft.DotNet.Cli.Sln.Internal; using Microsoft.DotNet.Cli.Sln.Internal;
using Microsoft.DotNet.Cli.Utils; using Microsoft.DotNet.Cli.Utils;
using Microsoft.DotNet.Tools.Common; using Microsoft.DotNet.Tools.Common;
using Microsoft.DotNet.Tools.Sln;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
namespace Microsoft.DotNet.Tools.Sln.Add namespace Microsoft.DotNet.Tools.Sln.Add
{ {
internal class AddProjectToSolutionCommand : DotNetSubCommandBase internal class AddProjectToSolutionCommand : CommandBase
{ {
public static DotNetSubCommandBase Create() private readonly AppliedOption _appliedCommand;
private readonly string _fileOrDirectory;
public AddProjectToSolutionCommand(AppliedOption appliedCommand)
{ {
var command = new AddProjectToSolutionCommand() if (appliedCommand == null)
{ {
Name = "add", throw new ArgumentNullException(nameof(appliedCommand));
FullName = LocalizableStrings.AddAppFullName, }
Description = LocalizableStrings.AddSubcommandHelpText, _appliedCommand = appliedCommand;
HandleRemainingArguments = true,
ArgumentSeparatorHelpText = LocalizableStrings.AddSubcommandHelpText,
};
command.HelpOption("-h|--help"); _fileOrDirectory = appliedCommand.Arguments.Single();
return command;
} }
public override int Run(string fileOrDirectory) public override int Execute()
{ {
SlnFile slnFile = SlnFileFactory.CreateFromFileOrDirectory(fileOrDirectory); SlnFile slnFile = SlnFileFactory.CreateFromFileOrDirectory(_fileOrDirectory);
if (RemainingArguments.Count == 0) if (_appliedCommand.Arguments.Count == 0)
{ {
throw new GracefulException(CommonLocalizableStrings.SpecifyAtLeastOneProjectToAdd); throw new GracefulException(CommonLocalizableStrings.SpecifyAtLeastOneProjectToAdd);
} }
PathUtility.EnsureAllPathsExist(RemainingArguments, CommonLocalizableStrings.ProjectDoesNotExist); PathUtility.EnsureAllPathsExist(_appliedCommand.Arguments, CommonLocalizableStrings.ProjectDoesNotExist);
var fullProjectPaths = RemainingArguments.Select((p) => Path.GetFullPath(p)).ToList();
var fullProjectPaths = _appliedCommand.Arguments
.Select(Path.GetFullPath)
.ToList();
var preAddProjectCount = slnFile.Projects.Count;
int preAddProjectCount = slnFile.Projects.Count;
foreach (var fullProjectPath in fullProjectPaths) foreach (var fullProjectPath in fullProjectPaths)
{ {
slnFile.AddProject(fullProjectPath); slnFile.AddProject(fullProjectPath);

27
src/dotnet/commands/dotnet-sln/list/Program.cs
View file

@ -1,33 +1,32 @@
// Copyright (c) .NET Foundation and contributors. All rights reserved. // Copyright (c) .NET Foundation and contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information. // Licensed under the MIT license. See LICENSE file in the project root for full license information.
using System;
using System.Linq;
using Microsoft.DotNet.Cli; using Microsoft.DotNet.Cli;
using Microsoft.DotNet.Cli.CommandLine;
using Microsoft.DotNet.Cli.Sln.Internal; using Microsoft.DotNet.Cli.Sln.Internal;
using Microsoft.DotNet.Cli.Utils; using Microsoft.DotNet.Cli.Utils;
using Microsoft.DotNet.Tools.Common; using Microsoft.DotNet.Tools.Common;
using Microsoft.DotNet.Tools.Sln;
namespace Microsoft.DotNet.Tools.Sln.List namespace Microsoft.DotNet.Tools.Sln.List
{ {
internal class ListProjectsInSolutionCommand : DotNetSubCommandBase internal class ListProjectsInSolutionCommand : CommandBase
{ {
public static DotNetSubCommandBase Create() private readonly string _fileOrDirectory;
public ListProjectsInSolutionCommand(AppliedOption appliedCommand)
{ {
var command = new ListProjectsInSolutionCommand() if (appliedCommand == null)
{ {
Name = "list", throw new ArgumentNullException(nameof(appliedCommand));
FullName = LocalizableStrings.ListAppFullName, }
Description = LocalizableStrings.ListSubcommandHelpText, _fileOrDirectory = appliedCommand.Arguments.Single();
};
command.HelpOption("-h|--help");
return command;
} }
public override int Run(string fileOrDirectory) public override int Execute()
{ {
SlnFile slnFile = SlnFileFactory.CreateFromFileOrDirectory(fileOrDirectory); SlnFile slnFile = SlnFileFactory.CreateFromFileOrDirectory(_fileOrDirectory);
if (slnFile.Projects.Count == 0) if (slnFile.Projects.Count == 0)
{ {
Reporter.Output.WriteLine(CommonLocalizableStrings.NoProjectsFound); Reporter.Output.WriteLine(CommonLocalizableStrings.NoProjectsFound);

54
src/dotnet/commands/dotnet-sln/remove/Program.cs
View file

@ -1,49 +1,47 @@
// Copyright (c) .NET Foundation and contributors. All rights reserved. // Copyright (c) .NET Foundation and contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information. // Licensed under the MIT license. See LICENSE file in the project root for full license information.
using System;
using System.IO;
using System.Linq;
using Microsoft.DotNet.Cli; using Microsoft.DotNet.Cli;
using Microsoft.DotNet.Cli.CommandLine;
using Microsoft.DotNet.Cli.Sln.Internal; using Microsoft.DotNet.Cli.Sln.Internal;
using Microsoft.DotNet.Cli.Utils; using Microsoft.DotNet.Cli.Utils;
using Microsoft.DotNet.Tools.Common; using Microsoft.DotNet.Tools.Common;
using Microsoft.DotNet.Tools.Sln;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
namespace Microsoft.DotNet.Tools.Sln.Remove namespace Microsoft.DotNet.Tools.Sln.Remove
{ {
internal class RemoveProjectFromSolutionCommand : DotNetSubCommandBase internal class RemoveProjectFromSolutionCommand : CommandBase
{ {
public static DotNetSubCommandBase Create() private readonly AppliedOption _appliedCommand;
private readonly string _fileOrDirectory;
public RemoveProjectFromSolutionCommand(AppliedOption appliedCommand)
{ {
var command = new RemoveProjectFromSolutionCommand() if (appliedCommand == null)
{ {
Name = "remove", throw new ArgumentNullException(nameof(appliedCommand));
FullName = LocalizableStrings.RemoveAppFullName, }
Description = LocalizableStrings.RemoveSubcommandHelpText,
HandleRemainingArguments = true,
ArgumentSeparatorHelpText = LocalizableStrings.RemoveSubcommandHelpText,
};
command.HelpOption("-h|--help"); if (_appliedCommand.Arguments.Count == 0)
return command;
}
public override int Run(string fileOrDirectory)
{
SlnFile slnFile = SlnFileFactory.CreateFromFileOrDirectory(fileOrDirectory);
if (RemainingArguments.Count == 0)
{ {
throw new GracefulException(CommonLocalizableStrings.SpecifyAtLeastOneProjectToRemove); throw new GracefulException(CommonLocalizableStrings.SpecifyAtLeastOneProjectToRemove);
} }
var relativeProjectPaths = RemainingArguments.Select((p) => _appliedCommand = appliedCommand;
PathUtility.GetRelativePath( _fileOrDirectory = appliedCommand.Arguments.Single();
PathUtility.EnsureTrailingSlash(slnFile.BaseDirectory), }
Path.GetFullPath(p))).ToList();
public override int Execute()
{
SlnFile slnFile = SlnFileFactory.CreateFromFileOrDirectory(_fileOrDirectory);
var relativeProjectPaths = _appliedCommand.Arguments.Select(p =>
PathUtility.GetRelativePath(
PathUtility.EnsureTrailingSlash(slnFile.BaseDirectory),
Path.GetFullPath(p)))
.ToList();
bool slnChanged = false; bool slnChanged = false;
foreach (var path in relativeProjectPaths) foreach (var path in relativeProjectPaths)