private void EnsureProjectIsBuilt()
{
List <string> buildArgs = new List <string>();
buildArgs.Add("/nologo");
buildArgs.Add("/verbosity:quiet");
if (!string.IsNullOrWhiteSpace(Configuration))
{
buildArgs.Add($"/p:Configuration={Configuration}");
}
if (!string.IsNullOrWhiteSpace(Framework))
{
buildArgs.Add($"/p:TargetFramework={Framework}");
}
var buildResult = new MSBuildForwardingApp(buildArgs).Execute();
if (buildResult != 0)
{
Reporter.Error.WriteLine();
throw new GracefulException("The build failed. Please fix the build errors and run again.");
}
}
public void ItSetsEnvironmentalVariables(string envVarName)
{
var msbuildPath = "<msbuildpath>";
var startInfo = new MSBuildForwardingApp(new string[0], msbuildPath).GetProcessStartInfo();
startInfo.Environment.ContainsKey(envVarName).Should().BeTrue();
}
private void GetProjectDependencyGraph(string projectFilePath, string dgFilePath)
{
var args = new List <string>();
// Pass the project file path
args.Add(projectFilePath);
// Pass the task as generate restore Dependency Graph file
args.Add("/t:GenerateRestoreGraphFile");
// Pass Dependency Graph file output path
args.Add($"/p:RestoreGraphOutputPath=\"{dgFilePath}\"");
// Turn off recursive restore
args.Add($"/p:RestoreRecursive=false");
// Turn off restore for Dotnet cli tool references so that we do not generate extra dg specs
args.Add($"/p:RestoreDotnetCliToolReferences=false");
// Output should not include MSBuild version header
args.Add("/nologo");
var result = new MSBuildForwardingApp(args).Execute();
if (result != 0)
{
throw new GracefulException(string.Format(LocalizableStrings.CmdDGFileException, projectFilePath));
}
}
private void EnsureProjectIsBuilt()
{
List <string> buildArgs = new List <string>();
buildArgs.Add(Project);
buildArgs.Add("/nologo");
buildArgs.Add("/verbosity:quiet");
if (!string.IsNullOrWhiteSpace(Configuration))
{
buildArgs.Add($"/p:Configuration={Configuration}");
}
if (!string.IsNullOrWhiteSpace(Framework))
{
buildArgs.Add($"/p:TargetFramework={Framework}");
}
var buildResult = new MSBuildForwardingApp(buildArgs).Execute();
if (buildResult != 0)
{
Reporter.Error.WriteLine();
throw new GracefulException(LocalizableStrings.RunCommandException);
}
}
public static int Run(string[] args)
{
DebugHelper.HandleDebugSwitch(ref args);
CommandLineApplication app = new CommandLineApplication(throwOnUnexpectedArg: false);
app.Name = "dotnet publish";
app.FullName = ".NET Publisher";
app.Description = "Publisher for the .NET Platform";
app.AllowArgumentSeparator = true;
app.ArgumentSeparatorHelpText = HelpMessageStrings.MSBuildAdditionalArgsHelpText;
app.HelpOption("-h|--help");
CommandArgument projectArgument = app.Argument("<PROJECT>",
"The MSBuild project file to publish. If a project file is not specified, MSBuild searches the current" +
" working directory for a file that has a file extension that ends in `proj` and uses that file.");
CommandOption frameworkOption = app.Option(
"-f|--framework <FRAMEWORK>", "Target framework to publish for",
CommandOptionType.SingleValue);
CommandOption runtimeOption = app.Option(
"-r|--runtime <RUNTIME_IDENTIFIER>", "Target runtime to publish for. The default is to publish a portable application.",
CommandOptionType.SingleValue);
CommandOption outputOption = app.Option(
"-o|--output <OUTPUT_DIR>", "Path in which to publish the app",
CommandOptionType.SingleValue);
CommandOption configurationOption = app.Option(
"-c|--configuration <CONFIGURATION>", "Configuration under which to build",
CommandOptionType.SingleValue);
CommandOption versionSuffixOption = app.Option(
"--version-suffix <VERSION_SUFFIX>", "Defines the value for the $(VersionSuffix) property in the project",
CommandOptionType.SingleValue);
CommandOption verbosityOption = MSBuildForwardingApp.AddVerbosityOption(app);
app.OnExecute(() =>
{
var publish = new PublishCommand();
publish.ProjectPath = projectArgument.Value;
publish.Framework = frameworkOption.Value();
publish.Runtime = runtimeOption.Value();
publish.OutputPath = outputOption.Value();
publish.Configuration = configurationOption.Value();
publish.VersionSuffix = versionSuffixOption.Value();
publish.Verbosity = verbosityOption.Value();
publish.ExtraMSBuildArguments = app.RemainingArguments;
return(publish.Execute());
});
return(app.Execute(args));
}
public void ItSetsOrIgnoresTelemetrySessionId()
{
var msbuildPath = "<msbuildpath>";
var envVar = "DOTNET_CLI_TELEMETRY_SESSIONID";
var startInfo = new MSBuildForwardingApp(new string[0], msbuildPath)
.GetProcessStartInfo();
(startInfo.Environment[envVar] == null || int.TryParse(startInfo.Environment[envVar], out _))
.Should().BeTrue("DOTNET_CLI_TELEMETRY_SESSIONID should be null or current session id");
}
public static int Run(string[] args)
{
DebugHelper.HandleDebugSwitch(ref args);
CommandLineApplication app = new CommandLineApplication(throwOnUnexpectedArg: false);
app.Name = "dotnet publish";
app.FullName = LocalizableStrings.AppFullName;
app.Description = LocalizableStrings.AppDescription;
app.HandleRemainingArguments = true;
app.ArgumentSeparatorHelpText = HelpMessageStrings.MSBuildAdditionalArgsHelpText;
app.HelpOption("-h|--help");
CommandArgument projectArgument = app.Argument($"<{LocalizableStrings.ProjectArgument}>",
LocalizableStrings.ProjectArgDescription);
CommandOption frameworkOption = app.Option(
$"-f|--framework <{LocalizableStrings.FrameworkOption}>", LocalizableStrings.FrameworkOptionDescription,
CommandOptionType.SingleValue);
CommandOption runtimeOption = app.Option(
$"-r|--runtime <{LocalizableStrings.RuntimeOption}>", LocalizableStrings.RuntimeOptionDescription,
CommandOptionType.SingleValue);
CommandOption outputOption = app.Option(
$"-o|--output <{LocalizableStrings.OutputOption}>", LocalizableStrings.OutputOptionDescription,
CommandOptionType.SingleValue);
CommandOption configurationOption = app.Option(
$"-c|--configuration <{LocalizableStrings.ConfigurationOption}>", LocalizableStrings.ConfigurationOptionDescription,
CommandOptionType.SingleValue);
CommandOption versionSuffixOption = app.Option(
$"--version-suffix <{LocalizableStrings.VersionSuffixOption}>", LocalizableStrings.VersionSuffixOptionDescription,
CommandOptionType.SingleValue);
CommandOption verbosityOption = MSBuildForwardingApp.AddVerbosityOption(app);
app.OnExecute(() =>
{
var publish = new PublishCommand();
publish.ProjectPath = projectArgument.Value;
publish.Framework = frameworkOption.Value();
publish.Runtime = runtimeOption.Value();
publish.OutputPath = outputOption.Value();
publish.Configuration = configurationOption.Value();
publish.VersionSuffix = versionSuffixOption.Value();
publish.Verbosity = verbosityOption.Value();
publish.ExtraMSBuildArguments = app.RemainingArguments;
return(publish.Execute());
});
return(app.Execute(args));
}
private string[] GetArgsForMSBuild(Func <bool> sentinelExists, out Telemetry.Telemetry telemetry)
{
Telemetry.Telemetry.DisableForTests(); // reset static session id modified by telemetry constructor
telemetry = new Telemetry.Telemetry(new MockFirstTimeUseNoticeSentinel(sentinelExists));
MSBuildForwardingApp msBuildForwardingApp = new MSBuildForwardingApp(Enumerable.Empty <string>());
var forwardingAppWithoutLogging = msBuildForwardingApp
.GetType()
.GetField("_forwardingAppWithoutLogging", BindingFlags.Instance | BindingFlags.NonPublic)
?.GetValue(msBuildForwardingApp) as Cli.Utils.MSBuildForwardingAppWithoutLogging;
return(forwardingAppWithoutLogging?.GetAllArguments());
}
private string[] GetArgsForMSBuild(Func <bool> sentinelExists, out Telemetry telemetry)
{
telemetry = new Telemetry(new MockNuGetCacheSentinel(sentinelExists));
MSBuildForwardingApp msBuildForwardingApp = new MSBuildForwardingApp(Enumerable.Empty <string>());
FieldInfo forwardingAppFieldInfo = msBuildForwardingApp
.GetType()
.GetField("_forwardingApp", BindingFlags.Instance | BindingFlags.NonPublic);
ForwardingApp forwardingApp = forwardingAppFieldInfo?.GetValue(msBuildForwardingApp) as ForwardingApp;
FieldInfo allArgsFieldinfo = forwardingApp?
.GetType()
.GetField("_allArgs", BindingFlags.Instance | BindingFlags.NonPublic);
return(allArgsFieldinfo?.GetValue(forwardingApp) as string[]);
}
public void ItSetsOrIgnoresTelemetrySessionId()
{
var msbuildPath = "<msbuildpath>";
var envVar = "DOTNET_CLI_TELEMETRY_SESSIONID";
var startInfo = new MSBuildForwardingApp(new string[0], msbuildPath)
.GetProcessStartInfo();
string sessionId = startInfo.Environment[envVar];
Log.WriteLine("StartInfo DOTNET_CLI_TELEMETRY_SESSIONID: " + sessionId);
// Other in-process tests (GivenADotnetFirstTimeUseConfigurerWithStateSetup) use "test"
// for session ID, so ignore if they already set it
if (sessionId != "test")
{
(sessionId == null || Guid.TryParse(sessionId, out _))
.Should().BeTrue("DOTNET_CLI_TELEMETRY_SESSIONID should be null or current session id");
}
}
private void GetProjectDependencyGraph(string projectFilePath, string dgFilePath)
{
var args = new List <string>();
// Pass the project file path
args.Add(projectFilePath);
// Pass the task as generate restore Dependency Graph file
args.Add("/t:GenerateRestoreGraphFile");
// Pass Dependency Graph file output path
args.Add($"/p:RestoreGraphOutputPath=\"{dgFilePath}\"");
var result = new MSBuildForwardingApp(args).Execute();
if (result != 0)
{
throw new GracefulException(string.Format(LocalizableStrings.CmdDGFileException, projectFilePath));
}
}
private string[] GetArgsForMSBuild(Func <bool> sentinelExists, out Telemetry telemetry)
{
Telemetry.CurrentSessionId = null; // reset static session id modified by telemetry constructor
telemetry = new Telemetry(new MockNuGetCacheSentinel(sentinelExists));
MSBuildForwardingApp msBuildForwardingApp = new MSBuildForwardingApp(Enumerable.Empty <string>());
object forwardingAppWithoutLogging = msBuildForwardingApp
.GetType()
.GetField("_forwardingAppWithoutLogging", BindingFlags.Instance | BindingFlags.NonPublic)
?.GetValue(msBuildForwardingApp);
FieldInfo forwardingAppFieldInfo = forwardingAppWithoutLogging
.GetType()
.GetField("_forwardingApp", BindingFlags.Instance | BindingFlags.NonPublic);
object forwardingApp = forwardingAppFieldInfo?.GetValue(forwardingAppWithoutLogging);
FieldInfo allArgsFieldinfo = forwardingApp?
.GetType()
.GetField("_allArgs", BindingFlags.Instance | BindingFlags.NonPublic);
return(allArgsFieldinfo?.GetValue(forwardingApp) as string[]);
}
public static int Run(string[] args)
{
DebugHelper.HandleDebugSwitch(ref args);
CommandLineApplication app = new CommandLineApplication(throwOnUnexpectedArg: false)
{
Name = "dotnet clean",
FullName = LocalizableStrings.AppFullName,
Description = LocalizableStrings.AppDescription,
AllowArgumentSeparator = true,
ArgumentSeparatorHelpText = HelpMessageStrings.MSBuildAdditionalArgsHelpText
};
app.HelpOption("-h|--help");
CommandArgument projectArgument = app.Argument(
$"<{LocalizableStrings.CmdArgProject}>",
LocalizableStrings.CmdArgProjDescription);
CommandOption outputOption = app.Option(
$"-o|--output <{LocalizableStrings.CmdOutputDir}>",
LocalizableStrings.CmdOutputDirDescription,
CommandOptionType.SingleValue);
CommandOption frameworkOption = app.Option(
$"-f|--framework <{LocalizableStrings.CmdFramework}>",
LocalizableStrings.CmdFrameworkDescription,
CommandOptionType.SingleValue);
CommandOption configurationOption = app.Option(
$"-c|--configuration <{LocalizableStrings.CmdConfiguration}>",
LocalizableStrings.CmdConfigurationDescription,
CommandOptionType.SingleValue);
CommandOption verbosityOption = MSBuildForwardingApp.AddVerbosityOption(app);
app.OnExecute(() =>
{
List <string> msbuildArgs = new List <string>();
if (!string.IsNullOrEmpty(projectArgument.Value))
{
msbuildArgs.Add(projectArgument.Value);
}
msbuildArgs.Add("/t:Clean");
if (outputOption.HasValue())
{
msbuildArgs.Add($"/p:OutputPath={outputOption.Value()}");
}
if (frameworkOption.HasValue())
{
msbuildArgs.Add($"/p:TargetFramework={frameworkOption.Value()}");
}
if (configurationOption.HasValue())
{
msbuildArgs.Add($"/p:Configuration={configurationOption.Value()}");
}
if (verbosityOption.HasValue())
{
msbuildArgs.Add($"/verbosity:{verbosityOption.Value()}");
}
msbuildArgs.AddRange(app.RemainingArguments);
return(new MSBuildForwardingApp(msbuildArgs).Execute());
});
return(app.Execute(args));
}
public static int Run(string[] args)
{
DebugHelper.HandleDebugSwitch(ref args);
CommandLineApplication cmd = new CommandLineApplication(throwOnUnexpectedArg: false)
{
Name = "restore",
FullName = "restore",
Description = "restore for msbuild",
AllowArgumentSeparator = true,
ArgumentSeparatorHelpText = HelpMessageStrings.MSBuildAdditionalArgsHelpText
};
cmd.HelpOption("-h|--help");
var argRoot = cmd.Argument(
"[root]",
"Optional path to a project file or MSBuild arguments.",
multipleValues: true);
var sourceOption = cmd.Option(
"-s|--source <source>",
"Specifies a NuGet package source to use during the restore.",
CommandOptionType.MultipleValue);
var packagesOption = cmd.Option(
"--packages <packagesDirectory>",
"Directory to install packages in.",
CommandOptionType.SingleValue);
var disableParallelOption = cmd.Option(
"--disable-parallel",
"Disables restoring multiple projects in parallel.",
CommandOptionType.NoValue);
var configFileOption = cmd.Option(
"--configfile <file>",
"The NuGet configuration file to use.",
CommandOptionType.SingleValue);
var noCacheOption = cmd.Option(
"--no-cache",
"Do not cache packages and http requests.",
CommandOptionType.NoValue);
var ignoreFailedSourcesOption = cmd.Option(
"--ignore-failed-sources",
"Treat package source failures as warnings.",
CommandOptionType.NoValue);
var noDependenciesOption = cmd.Option(
"--no-dependencies",
"Set this flag to ignore project to project references and only restore the root project",
CommandOptionType.NoValue);
CommandOption verbosityOption = MSBuildForwardingApp.AddVerbosityOption(cmd);
cmd.OnExecute(() =>
{
var msbuildArgs = new List <string>()
{
"/NoLogo",
"/t:Restore",
"/ConsoleLoggerParameters:Verbosity=Minimal"
};
if (sourceOption.HasValue())
{
msbuildArgs.Add($"/p:RestoreSources={string.Join("%3B", sourceOption.Values)}");
}
if (packagesOption.HasValue())
{
msbuildArgs.Add($"/p:RestorePackagesPath={packagesOption.Value()}");
}
if (disableParallelOption.HasValue())
{
msbuildArgs.Add($"/p:RestoreDisableParallel=true");
}
if (configFileOption.HasValue())
{
msbuildArgs.Add($"/p:RestoreConfigFile={configFileOption.Value()}");
}
if (noCacheOption.HasValue())
{
msbuildArgs.Add($"/p:RestoreNoCache=true");
}
if (ignoreFailedSourcesOption.HasValue())
{
msbuildArgs.Add($"/p:RestoreIgnoreFailedSources=true");
}
if (noDependenciesOption.HasValue())
{
msbuildArgs.Add($"/p:RestoreRecursive=false");
}
if (verbosityOption.HasValue())
{
msbuildArgs.Add($"/verbosity:{verbosityOption.Value()}");
}
// Add in arguments
msbuildArgs.AddRange(argRoot.Values);
// Add remaining arguments that the parser did not understand
msbuildArgs.AddRange(cmd.RemainingArguments);
return(new MSBuildForwardingApp(msbuildArgs).Execute());
});
return(cmd.Execute(args));
}
public void ItDoesNotSetCurrentWorkingDirectory()
{
var msbuildPath = "<msbuildpath>";
var startInfo = new MSBuildForwardingApp(new string[0], msbuildPath)
.GetProcessStartInfo().WorkingDirectory.Should().Be("");
}
public static int Run(string[] args)
{
DebugHelper.HandleDebugSwitch(ref args);
CommandLineApplication cmd = new CommandLineApplication(throwOnUnexpectedArg: false)
{
Name = "pack",
FullName = LocalizableStrings.AppFullName,
Description = LocalizableStrings.AppDescription,
AllowArgumentSeparator = true,
ArgumentSeparatorHelpText = HelpMessageStrings.MSBuildAdditionalArgsHelpText
};
cmd.HelpOption("-h|--help");
var output = cmd.Option(
$"-o|--output <{LocalizableStrings.CmdOutputDir}>",
LocalizableStrings.CmdOutputDirDescription,
CommandOptionType.SingleValue);
var noBuild = cmd.Option(
"--no-build",
LocalizableStrings.CmdNoBuildOptionDescription,
CommandOptionType.NoValue);
var includeSymbols = cmd.Option(
"--include-symbols",
LocalizableStrings.CmdIncludeSymbolsDescription,
CommandOptionType.NoValue);
var includeSource = cmd.Option(
"--include-source",
LocalizableStrings.CmdIncludeSourceDescription,
CommandOptionType.NoValue);
var configuration = cmd.Option(
$"-c|--configuration <{LocalizableStrings.CmdConfig}>",
LocalizableStrings.CmdConfigDescription,
CommandOptionType.SingleValue);
var versionSuffix = cmd.Option(
$"--version-suffix <{LocalizableStrings.CmdVersionSuffix}>",
LocalizableStrings.CmdVersionSuffixDescription,
CommandOptionType.SingleValue);
var serviceable = cmd.Option(
"-s|--serviceable",
LocalizableStrings.CmdServiceableDescription,
CommandOptionType.NoValue);
var argRoot = cmd.Argument(
$"<{LocalizableStrings.CmdArgumentProject}>",
LocalizableStrings.CmdArgumentDescription,
multipleValues: true);
CommandOption verbosityOption = MSBuildForwardingApp.AddVerbosityOption(cmd);
cmd.OnExecute(() =>
{
var msbuildArgs = new List <string>()
{
"/t:pack"
};
if (noBuild.HasValue())
{
msbuildArgs.Add($"/p:NoBuild=true");
}
if (includeSymbols.HasValue())
{
msbuildArgs.Add($"/p:IncludeSymbols=true");
}
if (includeSource.HasValue())
{
msbuildArgs.Add($"/p:IncludeSource=true");
}
if (output.HasValue())
{
msbuildArgs.Add($"/p:PackageOutputPath={output.Value()}");
}
if (configuration.HasValue())
{
msbuildArgs.Add($"/p:Configuration={configuration.Value()}");
}
if (versionSuffix.HasValue())
{
msbuildArgs.Add($"/p:VersionSuffix={versionSuffix.Value()}");
}
if (serviceable.HasValue())
{
msbuildArgs.Add($"/p:Serviceable=true");
}
if (verbosityOption.HasValue())
{
msbuildArgs.Add($"/verbosity:{verbosityOption.Value()}");
}
msbuildArgs.AddRange(argRoot.Values);
msbuildArgs.AddRange(cmd.RemainingArguments);
return(new MSBuildForwardingApp(msbuildArgs).Execute());
});
return(cmd.Execute(args));
}
public static int Run(string[] args)
{
DebugHelper.HandleDebugSwitch(ref args);
CommandLineApplication app = new CommandLineApplication(throwOnUnexpectedArg: false);
app.Name = "dotnet build";
app.FullName = ".NET Builder";
app.Description = "Builder for the .NET Platform. Delegates to the MSBuild 'Build' target in the project file.";
app.AllowArgumentSeparator = true;
app.ArgumentSeparatorHelpText = HelpMessageStrings.MSBuildAdditionalArgsHelpText;
app.HelpOption("-h|--help");
CommandArgument projectArgument = app.Argument("<PROJECT>",
"The MSBuild project file to build. If a project file is not specified," +
" MSBuild searches the current working directory for a file that has a file extension that ends in `proj` and uses that file.");
CommandOption outputOption = app.Option("-o|--output <OUTPUT_DIR>", "Directory in which to place outputs", CommandOptionType.SingleValue);
CommandOption frameworkOption = app.Option("-f|--framework <FRAMEWORK>", "Compile a specific framework", CommandOptionType.SingleValue);
CommandOption runtimeOption = app.Option(
"-r|--runtime <RUNTIME_IDENTIFIER>", "Target runtime to build for. The default is to build a portable application.",
CommandOptionType.SingleValue);
CommandOption configurationOption = app.Option("-c|--configuration <CONFIGURATION>", "Configuration under which to build", CommandOptionType.SingleValue);
CommandOption versionSuffixOption = app.Option("--version-suffix <VERSION_SUFFIX>", "Defines the value for the $(VersionSuffix) property in the project", CommandOptionType.SingleValue);
CommandOption noIncrementalOption = app.Option("--no-incremental", "Set this flag to turn off incremental build", CommandOptionType.NoValue);
CommandOption noDependenciesOption = app.Option("--no-dependencies", "Set this flag to ignore project to project references and only build the root project", CommandOptionType.NoValue);
CommandOption verbosityOption = MSBuildForwardingApp.AddVerbosityOption(app);
app.OnExecute(() =>
{
List <string> msbuildArgs = new List <string>();
if (!string.IsNullOrEmpty(projectArgument.Value))
{
msbuildArgs.Add(projectArgument.Value);
}
if (noIncrementalOption.HasValue())
{
msbuildArgs.Add("/t:Rebuild");
}
else
{
msbuildArgs.Add("/t:Build");
}
if (outputOption.HasValue())
{
msbuildArgs.Add($"/p:OutputPath={outputOption.Value()}");
}
if (frameworkOption.HasValue())
{
msbuildArgs.Add($"/p:TargetFramework={frameworkOption.Value()}");
}
if (runtimeOption.HasValue())
{
msbuildArgs.Add($"/p:RuntimeIdentifier={runtimeOption.Value()}");
}
if (configurationOption.HasValue())
{
msbuildArgs.Add($"/p:Configuration={configurationOption.Value()}");
}
if (versionSuffixOption.HasValue())
{
msbuildArgs.Add($"/p:VersionSuffix={versionSuffixOption.Value()}");
}
if (noDependenciesOption.HasValue())
{
msbuildArgs.Add("/p:BuildProjectReferences=false");
}
if (verbosityOption.HasValue())
{
msbuildArgs.Add($"/verbosity:{verbosityOption.Value()}");
}
msbuildArgs.AddRange(app.RemainingArguments);
return(new MSBuildForwardingApp(msbuildArgs).Execute());
});
return(app.Execute(args));
}
public static int Run(string[] args)
{
DebugHelper.HandleDebugSwitch(ref args);
CommandLineApplication cmd = new CommandLineApplication(throwOnUnexpectedArg: false)
{
Name = "restore",
FullName = LocalizableStrings.AppFullName,
Description = LocalizableStrings.AppDescription,
HandleRemainingArguments = true,
ArgumentSeparatorHelpText = HelpMessageStrings.MSBuildAdditionalArgsHelpText
};
cmd.HelpOption("-h|--help");
var argRoot = cmd.Argument(
$"[{LocalizableStrings.CmdArgument}]",
LocalizableStrings.CmdArgumentDescription,
multipleValues: true);
var sourceOption = cmd.Option(
$"-s|--source <{LocalizableStrings.CmdSourceOption}>",
LocalizableStrings.CmdSourceOptionDescription,
CommandOptionType.MultipleValue);
var runtimeOption = cmd.Option(
$"-r|--runtime <{LocalizableStrings.CmdRuntimeOption}>",
LocalizableStrings.CmdRuntimeOptionDescription,
CommandOptionType.MultipleValue);
var packagesOption = cmd.Option(
$"--packages <{LocalizableStrings.CmdPackagesOption}>",
LocalizableStrings.CmdPackagesOptionDescription,
CommandOptionType.SingleValue);
var disableParallelOption = cmd.Option(
"--disable-parallel",
LocalizableStrings.CmdDisableParallelOptionDescription,
CommandOptionType.NoValue);
var configFileOption = cmd.Option(
$"--configfile <{LocalizableStrings.CmdConfigFileOption}>",
LocalizableStrings.CmdConfigFileOptionDescription,
CommandOptionType.SingleValue);
var noCacheOption = cmd.Option(
"--no-cache",
LocalizableStrings.CmdNoCacheOptionDescription,
CommandOptionType.NoValue);
var ignoreFailedSourcesOption = cmd.Option(
"--ignore-failed-sources",
LocalizableStrings.CmdIgnoreFailedSourcesOptionDescription,
CommandOptionType.NoValue);
var noDependenciesOption = cmd.Option(
"--no-dependencies",
LocalizableStrings.CmdNoDependenciesOptionDescription,
CommandOptionType.NoValue);
CommandOption verbosityOption = MSBuildForwardingApp.AddVerbosityOption(cmd);
cmd.OnExecute(() =>
{
var msbuildArgs = new List <string>()
{
"/NoLogo",
"/t:Restore",
"/ConsoleLoggerParameters:Verbosity=Minimal"
};
if (sourceOption.HasValue())
{
msbuildArgs.Add($"/p:RestoreSources={string.Join("%3B", sourceOption.Values)}");
}
if (runtimeOption.HasValue())
{
msbuildArgs.Add($"/p:RuntimeIdentifiers={string.Join("%3B", runtimeOption.Values)}");
}
if (packagesOption.HasValue())
{
msbuildArgs.Add($"/p:RestorePackagesPath={packagesOption.Value()}");
}
if (disableParallelOption.HasValue())
{
msbuildArgs.Add($"/p:RestoreDisableParallel=true");
}
if (configFileOption.HasValue())
{
msbuildArgs.Add($"/p:RestoreConfigFile={configFileOption.Value()}");
}
if (noCacheOption.HasValue())
{
msbuildArgs.Add($"/p:RestoreNoCache=true");
}
if (ignoreFailedSourcesOption.HasValue())
{
msbuildArgs.Add($"/p:RestoreIgnoreFailedSources=true");
}
if (noDependenciesOption.HasValue())
{
msbuildArgs.Add($"/p:RestoreRecursive=false");
}
if (verbosityOption.HasValue())
{
msbuildArgs.Add($"/verbosity:{verbosityOption.Value()}");
}
// Add in arguments
msbuildArgs.AddRange(argRoot.Values);
// Add remaining arguments that the parser did not understand
msbuildArgs.AddRange(cmd.RemainingArguments);
return(new MSBuildForwardingApp(msbuildArgs).Execute());
});
return(cmd.Execute(args));
}
public static int Run(string[] args)
{
DebugHelper.HandleDebugSwitch(ref args);
CommandLineApplication cmd = new CommandLineApplication(throwOnUnexpectedArg: false)
{
Name = "pack",
FullName = "pack",
Description = "pack for msbuild",
AllowArgumentSeparator = true,
ArgumentSeparatorHelpText = HelpMessageStrings.MSBuildAdditionalArgsHelpText
};
cmd.HelpOption("-h|--help");
var output = cmd.Option("-o|--output <OUTPUT_DIR>",
"Directory in which to place outputs",
CommandOptionType.SingleValue);
var noBuild = cmd.Option("--no-build",
"Do not build project before packing",
CommandOptionType.NoValue);
var includeSymbols = cmd.Option("--include-symbols",
"Include PDBs along with the DLLs in the output folder",
CommandOptionType.NoValue);
var includeSource = cmd.Option("--include-source",
"Include PDBs and source files. Source files go into the src folder in the resulting nuget package",
CommandOptionType.NoValue);
var configuration = cmd.Option("-c|--configuration <CONFIGURATION>",
"Configuration under which to build",
CommandOptionType.SingleValue);
var versionSuffix = cmd.Option("--version-suffix <VERSION_SUFFIX>",
"Defines what `*` should be replaced with in version field in project.json",
CommandOptionType.SingleValue);
var serviceable = cmd.Option("-s|--serviceable",
"Set the serviceable flag in the package",
CommandOptionType.NoValue);
var argRoot = cmd.Argument("<PROJECT>",
"The project to pack, defaults to the project file in the current directory. Can be a path to any project file",
multipleValues: true);
CommandOption verbosityOption = MSBuildForwardingApp.AddVerbosityOption(cmd);
cmd.OnExecute(() =>
{
var msbuildArgs = new List <string>()
{
"/t:pack"
};
if (noBuild.HasValue())
{
msbuildArgs.Add($"/p:NoBuild=true");
}
if (includeSymbols.HasValue())
{
msbuildArgs.Add($"/p:IncludeSymbols=true");
}
if (includeSource.HasValue())
{
msbuildArgs.Add($"/p:IncludeSource=true");
}
if (output.HasValue())
{
msbuildArgs.Add($"/p:PackageOutputPath={output.Value()}");
}
if (configuration.HasValue())
{
msbuildArgs.Add($"/p:Configuration={configuration.Value()}");
}
if (versionSuffix.HasValue())
{
msbuildArgs.Add($"/p:VersionSuffix={versionSuffix.Value()}");
}
if (serviceable.HasValue())
{
msbuildArgs.Add($"/p:Serviceable=true");
}
if (verbosityOption.HasValue())
{
msbuildArgs.Add($"/verbosity:{verbosityOption.Value()}");
}
msbuildArgs.AddRange(argRoot.Values);
msbuildArgs.AddRange(cmd.RemainingArguments);
return(new MSBuildForwardingApp(msbuildArgs).Execute());
});
return(cmd.Execute(args));
}
public static CacheCommand FromArgs(string[] args, string msbuildPath = null)
{
DebugHelper.HandleDebugSwitch(ref args);
var app = new CommandLineApplication(throwOnUnexpectedArg: false);
app.Name = "dotnet cache";
app.FullName = LocalizableStrings.AppFullName;
app.Description = LocalizableStrings.AppDescription;
app.AllowArgumentSeparator = true;
app.ArgumentSeparatorHelpText = HelpMessageStrings.MSBuildAdditionalArgsHelpText;
app.HelpOption("-h|--help");
CommandOption projectArgument = app.Option(
$"-e|--entries <{LocalizableStrings.ProjectEntries}>", LocalizableStrings.ProjectEntryDescription,
CommandOptionType.SingleValue);
CommandOption frameworkOption = app.Option(
$"-f|--framework <{LocalizableStrings.FrameworkOption}>", LocalizableStrings.FrameworkOptionDescription,
CommandOptionType.SingleValue);
CommandOption runtimeOption = app.Option(
$"-r|--runtime <{LocalizableStrings.RuntimeOption}>", LocalizableStrings.RuntimeOptionDescription,
CommandOptionType.SingleValue);
CommandOption outputOption = app.Option(
$"-o|--output <{LocalizableStrings.OutputOption}>", LocalizableStrings.OutputOptionDescription,
CommandOptionType.SingleValue);
CommandOption fxOption = app.Option(
$"--framework-version <{LocalizableStrings.FrameworkVersionOption}>", LocalizableStrings.FrameworkVersionOptionDescription,
CommandOptionType.SingleValue);
CommandOption skipOptimizationOption = app.Option(
$"--skip-optimization", LocalizableStrings.SkipOptimizationOptionDescription,
CommandOptionType.NoValue);
CommandOption workingDir = app.Option(
$"-w |--working-dir <{LocalizableStrings.IntermediateWorkingDirOption}>", LocalizableStrings.IntermediateWorkingDirOptionDescription,
CommandOptionType.SingleValue);
CommandOption preserveWorkingDir = app.Option(
$"--preserve-working-dir", LocalizableStrings.PreserveIntermediateWorkingDirOptionDescription,
CommandOptionType.NoValue);
CommandOption verbosityOption = MSBuildForwardingApp.AddVerbosityOption(app);
List <string> msbuildArgs = null;
app.OnExecute(() =>
{
msbuildArgs = new List <string>();
if (string.IsNullOrEmpty(projectArgument.Value()))
{
throw new InvalidOperationException(LocalizableStrings.SpecifyEntries);
}
msbuildArgs.Add("/t:ComposeCache");
msbuildArgs.Add(projectArgument.Value());
if (!string.IsNullOrEmpty(frameworkOption.Value()))
{
msbuildArgs.Add($"/p:TargetFramework={frameworkOption.Value()}");
}
if (!string.IsNullOrEmpty(runtimeOption.Value()))
{
msbuildArgs.Add($"/p:RuntimeIdentifier={runtimeOption.Value()}");
}
if (!string.IsNullOrEmpty(outputOption.Value()))
{
var outputPath = Path.GetFullPath(outputOption.Value());
msbuildArgs.Add($"/p:ComposeDir={outputPath}");
}
if (!string.IsNullOrEmpty(fxOption.Value()))
{
msbuildArgs.Add($"/p:FX_Version={fxOption.Value()}");
}
if (!string.IsNullOrEmpty(workingDir.Value()))
{
msbuildArgs.Add($"/p:ComposeWorkingDir={workingDir.Value()}");
}
if (skipOptimizationOption.HasValue())
{
msbuildArgs.Add($"/p:SkipOptimization={skipOptimizationOption.HasValue()}");
}
if (preserveWorkingDir.HasValue())
{
msbuildArgs.Add($"/p:PreserveComposeWorkingDir={preserveWorkingDir.HasValue()}");
}
if (!string.IsNullOrEmpty(verbosityOption.Value()))
{
msbuildArgs.Add($"/verbosity:{verbosityOption.Value()}");
}
msbuildArgs.AddRange(app.RemainingArguments);
return(0);
});
int exitCode = app.Execute(args);
if (msbuildArgs == null)
{
throw new CommandCreationException(exitCode);
}
return(new CacheCommand(msbuildArgs, msbuildPath));
}
public static int Run(string[] args)
{
DebugHelper.HandleDebugSwitch(ref args);
var cmd = new CommandLineApplication(throwOnUnexpectedArg: false)
{
Name = "dotnet test",
FullName = LocalizableStrings.AppFullName,
Description = LocalizableStrings.AppDescription,
HandleRemainingArguments = true,
ArgumentSeparatorHelpText = HelpMessageStrings.MSBuildAdditionalArgsHelpText
};
cmd.HelpOption("-h|--help");
var argRoot = cmd.Argument(
$"<{LocalizableStrings.CmdArgProject}>",
LocalizableStrings.CmdArgDescription,
multipleValues: false);
var settingOption = cmd.Option(
$"-s|--settings <{LocalizableStrings.CmdSettingsFile}>",
LocalizableStrings.CmdSettingsDescription,
CommandOptionType.SingleValue);
var listTestsOption = cmd.Option(
"-t|--list-tests",
LocalizableStrings.CmdListTestsDescription,
CommandOptionType.NoValue);
var testCaseFilterOption = cmd.Option(
$"--filter <{LocalizableStrings.CmdTestCaseFilterExpression}>",
LocalizableStrings.CmdTestCaseFilterDescription,
CommandOptionType.SingleValue);
var testAdapterPathOption = cmd.Option(
"-a|--test-adapter-path",
LocalizableStrings.CmdTestAdapterPathDescription,
CommandOptionType.SingleValue);
var loggerOption = cmd.Option(
$"-l|--logger <{LocalizableStrings.CmdLoggerOption}>",
LocalizableStrings.CmdLoggerDescription,
CommandOptionType.SingleValue);
var configurationOption = cmd.Option(
$"-c|--configuration <{LocalizableStrings.CmdConfiguration}>",
LocalizableStrings.CmdConfigDescription,
CommandOptionType.SingleValue);
var frameworkOption = cmd.Option(
$"-f|--framework <{LocalizableStrings.CmdFramework}>",
LocalizableStrings.CmdFrameworkDescription,
CommandOptionType.SingleValue);
var outputOption = cmd.Option(
$"-o|--output <{LocalizableStrings.CmdOutputDir}>",
LocalizableStrings.CmdOutputDescription,
CommandOptionType.SingleValue);
var diagOption = cmd.Option(
$"-d|--diag <{LocalizableStrings.CmdPathToLogFile}>",
LocalizableStrings.CmdPathTologFileDescription,
CommandOptionType.SingleValue);
var noBuildtOption = cmd.Option(
"--no-build",
LocalizableStrings.CmdNoBuildDescription,
CommandOptionType.NoValue);
CommandOption verbosityOption = MSBuildForwardingApp.AddVerbosityOption(cmd);
cmd.OnExecute(() =>
{
var msbuildArgs = new List <string>()
{
"/t:VSTest"
};
msbuildArgs.Add("/nologo");
if (settingOption.HasValue())
{
msbuildArgs.Add($"/p:VSTestSetting={settingOption.Value()}");
}
if (listTestsOption.HasValue())
{
msbuildArgs.Add($"/p:VSTestListTests=true");
}
if (testCaseFilterOption.HasValue())
{
msbuildArgs.Add($"/p:VSTestTestCaseFilter={testCaseFilterOption.Value()}");
}
if (testAdapterPathOption.HasValue())
{
msbuildArgs.Add($"/p:VSTestTestAdapterPath={testAdapterPathOption.Value()}");
}
if (loggerOption.HasValue())
{
msbuildArgs.Add($"/p:VSTestLogger={string.Join(";", loggerOption.Values)}");
}
if (configurationOption.HasValue())
{
msbuildArgs.Add($"/p:Configuration={configurationOption.Value()}");
}
if (frameworkOption.HasValue())
{
msbuildArgs.Add($"/p:TargetFramework={frameworkOption.Value()}");
}
if (outputOption.HasValue())
{
msbuildArgs.Add($"/p:OutputPath={outputOption.Value()}");
}
if (diagOption.HasValue())
{
msbuildArgs.Add($"/p:VSTestDiag={diagOption.Value()}");
}
if (noBuildtOption.HasValue())
{
msbuildArgs.Add($"/p:VSTestNoBuild=true");
}
if (verbosityOption.HasValue())
{
msbuildArgs.Add($"/verbosity:{verbosityOption.Value()}");
}
else
{
msbuildArgs.Add("/verbosity:quiet");
}
string defaultproject = GetSingleTestProjectToRunTestIfNotProvided(argRoot.Value, cmd.RemainingArguments);
if (!string.IsNullOrEmpty(defaultproject))
{
msbuildArgs.Add(defaultproject);
}
if (!string.IsNullOrEmpty(argRoot.Value))
{
msbuildArgs.Add(argRoot.Value);
}
// Add remaining arguments that the parser did not understand,
msbuildArgs.AddRange(cmd.RemainingArguments);
return(new MSBuildForwardingApp(msbuildArgs).Execute());
});
return(cmd.Execute(args));
}
public static int Run(string[] args)
{
DebugHelper.HandleDebugSwitch(ref args);
CommandLineApplication app = new CommandLineApplication(throwOnUnexpectedArg: false)
{
Name = "dotnet clean",
FullName = ".NET Clean Command",
Description = "Command to clean previously generated build outputs.",
AllowArgumentSeparator = true,
ArgumentSeparatorHelpText = HelpMessageStrings.MSBuildAdditionalArgsHelpText
};
app.HelpOption("-h|--help");
CommandArgument projectArgument = app.Argument("<PROJECT>",
"The MSBuild project file to build. If a project file is not specified," +
" MSBuild searches the current working directory for a file that has a file extension that ends in `proj` and uses that file.");
CommandOption outputOption = app.Option("-o|--output <OUTPUT_DIR>", "Directory in which the build outputs have been placed", CommandOptionType.SingleValue);
CommandOption frameworkOption = app.Option("-f|--framework <FRAMEWORK>", "Clean a specific framework", CommandOptionType.SingleValue);
CommandOption configurationOption = app.Option("-c|--configuration <CONFIGURATION>", "Clean a specific configuration", CommandOptionType.SingleValue);
CommandOption verbosityOption = MSBuildForwardingApp.AddVerbosityOption(app);
app.OnExecute(() =>
{
List <string> msbuildArgs = new List <string>();
if (!string.IsNullOrEmpty(projectArgument.Value))
{
msbuildArgs.Add(projectArgument.Value);
}
msbuildArgs.Add("/t:Clean");
if (outputOption.HasValue())
{
msbuildArgs.Add($"/p:OutputPath={outputOption.Value()}");
}
if (frameworkOption.HasValue())
{
msbuildArgs.Add($"/p:TargetFramework={frameworkOption.Value()}");
}
if (configurationOption.HasValue())
{
msbuildArgs.Add($"/p:Configuration={configurationOption.Value()}");
}
if (verbosityOption.HasValue())
{
msbuildArgs.Add($"/verbosity:{verbosityOption.Value()}");
}
msbuildArgs.AddRange(app.RemainingArguments);
return(new MSBuildForwardingApp(msbuildArgs).Execute());
});
return(app.Execute(args));
}
public BuildCommand(IEnumerable <string> msbuildArgs, string msbuildPath = null)
{
_forwardingApp = new MSBuildForwardingApp(msbuildArgs, msbuildPath);
}
public static int Run(string[] args)
{
DebugHelper.HandleDebugSwitch(ref args);
var cmd = new CommandLineApplication(throwOnUnexpectedArg: false)
{
Name = "dotnet test",
FullName = ".NET Test Driver",
Description = "Test Driver for the .NET Platform"
};
cmd.HelpOption("-h|--help");
var argRoot = cmd.Argument(
"<PROJECT>",
"The project to test, defaults to the current directory.",
multipleValues: false);
var settingOption = cmd.Option(
"-s|--settings <SettingsFile>",
"Settings to use when running tests.",
CommandOptionType.SingleValue);
var listTestsOption = cmd.Option(
"-lt|--listTests",
@"Lists discovered tests",
CommandOptionType.NoValue);
var testCaseFilterOption = cmd.Option(
"-tcf|--testCaseFilter <Expression>",
@"Run tests that match the given expression.
Examples:
--testCaseFilter:""Priority = 1""
--testCaseFilter: ""(FullyQualifiedName~Nightly | Name = MyTestMethod)""",
CommandOptionType.SingleValue);
var testAdapterPathOption = cmd.Option(
"-tap|--testAdapterPath",
@"Use custom adapters from the given path in the test run.
Example: --testAdapterPath:<pathToCustomAdapters>",
CommandOptionType.SingleValue);
var loggerOption = cmd.Option(
"-l|--logger <LoggerUri/FriendlyName>",
@"Specify a logger for test results.
Example: --logger:trx",
CommandOptionType.SingleValue);
var configurationOption = cmd.Option(
"-c|--configuration <configuration>",
@"Configuration under which to build, i.e. Debug/Release",
CommandOptionType.SingleValue);
var frameworkOption = cmd.Option(
"-f|--framework <FrameworkVersion>",
@"Looks for test binaries for a specific framework",
CommandOptionType.SingleValue);
var outputOption = cmd.Option(
"-o|--output <OutputDir>",
@"Directory in which to find the binaries to be run",
CommandOptionType.SingleValue);
var diagOption = cmd.Option(
"-d|--diag <PathToLogFile>",
@"Enable verbose logs for test platform.
Logs are written to the provided file.",
CommandOptionType.SingleValue);
var noBuildtOption = cmd.Option(
"--noBuild",
@"Do not build project before testing.",
CommandOptionType.NoValue);
CommandOption verbosityOption = MSBuildForwardingApp.AddVerbosityOption(cmd);
cmd.OnExecute(() =>
{
var msbuildArgs = new List <string>()
{
"/t:VSTest"
};
msbuildArgs.Add("/nologo");
if (settingOption.HasValue())
{
msbuildArgs.Add($"/p:VSTestSetting={settingOption.Value()}");
}
if (listTestsOption.HasValue())
{
msbuildArgs.Add($"/p:VSTestListTests=true");
}
if (testCaseFilterOption.HasValue())
{
msbuildArgs.Add($"/p:VSTestTestCaseFilter={testCaseFilterOption.Value()}");
}
if (testAdapterPathOption.HasValue())
{
msbuildArgs.Add($"/p:VSTestTestAdapterPath={testAdapterPathOption.Value()}");
}
if (loggerOption.HasValue())
{
msbuildArgs.Add($"/p:VSTestLogger={string.Join(";", loggerOption.Values)}");
}
if (configurationOption.HasValue())
{
msbuildArgs.Add($"/p:Configuration={configurationOption.Value()}");
}
if (frameworkOption.HasValue())
{
msbuildArgs.Add($"/p:TargetFramework={frameworkOption.Value()}");
}
if (outputOption.HasValue())
{
msbuildArgs.Add($"/p:OutputPath={outputOption.Value()}");
}
if (diagOption.HasValue())
{
msbuildArgs.Add($"/p:VSTestDiag={diagOption.Value()}");
}
if (noBuildtOption.HasValue())
{
msbuildArgs.Add($"/p:VSTestNoBuild=true");
}
if (verbosityOption.HasValue())
{
msbuildArgs.Add($"/verbosity:{verbosityOption.Value()}");
}
else
{
msbuildArgs.Add("/verbosity:quiet");
}
string defaultproject = GetSingleTestProjectToRunTestIfNotProvided(argRoot.Value, cmd.RemainingArguments);
if (!string.IsNullOrEmpty(defaultproject))
{
msbuildArgs.Add(defaultproject);
}
if (!string.IsNullOrEmpty(argRoot.Value))
{
msbuildArgs.Add(argRoot.Value);
}
// Add remaining arguments that the parser did not understand,
msbuildArgs.AddRange(cmd.RemainingArguments);
return(new MSBuildForwardingApp(msbuildArgs).Execute());
});
return(cmd.Execute(args));
}
public static int Run(string[] args)
{
DebugHelper.HandleDebugSwitch(ref args);
CommandLineApplication app = new CommandLineApplication(throwOnUnexpectedArg: false);
app.Name = "dotnet build";
app.FullName = LocalizableStrings.AppFullName;
app.Description = LocalizableStrings.AppDescription;
app.ArgumentSeparatorHelpText = HelpMessageStrings.MSBuildAdditionalArgsHelpText;
app.HandleRemainingArguments = true;
app.HelpOption("-h|--help");
CommandArgument projectArgument = app.Argument($"<{LocalizableStrings.ProjectArgumentValueName}>", LocalizableStrings.ProjectArgumentDescription);
CommandOption outputOption = app.Option($"-o|--output <{LocalizableStrings.OutputOptionName}>", LocalizableStrings.OutputOptionDescription, CommandOptionType.SingleValue);
CommandOption frameworkOption = app.Option($"-f|--framework <{LocalizableStrings.FrameworkOptionName}>", LocalizableStrings.FrameworkOptionDescription, CommandOptionType.SingleValue);
CommandOption runtimeOption = app.Option(
$"-r|--runtime <{LocalizableStrings.RuntimeOptionName}>", LocalizableStrings.RuntimeOptionDescription,
CommandOptionType.SingleValue);
CommandOption configurationOption = app.Option($"-c|--configuration <{LocalizableStrings.ConfigurationOptionName}>", LocalizableStrings.ConfigurationOptionDescription, CommandOptionType.SingleValue);
CommandOption versionSuffixOption = app.Option($"--version-suffix <{LocalizableStrings.VersionSuffixOptionName}>", LocalizableStrings.VersionSuffixOptionDescription, CommandOptionType.SingleValue);
CommandOption noIncrementalOption = app.Option("--no-incremental", LocalizableStrings.NoIncrementialOptionDescription, CommandOptionType.NoValue);
CommandOption noDependenciesOption = app.Option("--no-dependencies", LocalizableStrings.NoDependenciesOptionDescription, CommandOptionType.NoValue);
CommandOption verbosityOption = MSBuildForwardingApp.AddVerbosityOption(app);
app.OnExecute(() =>
{
List <string> msbuildArgs = new List <string>();
if (!string.IsNullOrEmpty(projectArgument.Value))
{
msbuildArgs.Add(projectArgument.Value);
}
if (noIncrementalOption.HasValue())
{
msbuildArgs.Add("/t:Rebuild");
}
else
{
msbuildArgs.Add("/t:Build");
}
if (outputOption.HasValue())
{
msbuildArgs.Add($"/p:OutputPath={outputOption.Value()}");
}
if (frameworkOption.HasValue())
{
msbuildArgs.Add($"/p:TargetFramework={frameworkOption.Value()}");
}
if (runtimeOption.HasValue())
{
msbuildArgs.Add($"/p:RuntimeIdentifier={runtimeOption.Value()}");
}
if (configurationOption.HasValue())
{
msbuildArgs.Add($"/p:Configuration={configurationOption.Value()}");
}
if (versionSuffixOption.HasValue())
{
msbuildArgs.Add($"/p:VersionSuffix={versionSuffixOption.Value()}");
}
if (noDependenciesOption.HasValue())
{
msbuildArgs.Add("/p:BuildProjectReferences=false");
}
if (verbosityOption.HasValue())
{
msbuildArgs.Add($"/verbosity:{verbosityOption.Value()}");
}
msbuildArgs.Add($"/clp:Summary");
msbuildArgs.AddRange(app.RemainingArguments);
return(new MSBuildForwardingApp(msbuildArgs).Execute());
});
return(app.Execute(args));
}
public static int Run(string[] args)
{
DebugHelper.HandleDebugSwitch(ref args);
var app = new CommandLineApplication(throwOnUnexpectedArg: false);
app.Name = "dotnet cache";
app.FullName = LocalizableStrings.AppFullName;
app.Description = LocalizableStrings.AppDescription;
app.AllowArgumentSeparator = true;
app.ArgumentSeparatorHelpText = HelpMessageStrings.MSBuildAdditionalArgsHelpText;
app.HelpOption("-h|--help");
CommandOption projectArgument = app.Option(
$"-e|--entries <{LocalizableStrings.ProjectEntries}>", LocalizableStrings.ProjectEntryDescription,
CommandOptionType.SingleValue);
CommandOption frameworkOption = app.Option(
$"-f|--framework <{LocalizableStrings.FrameworkOption}>", LocalizableStrings.FrameworkOptionDescription,
CommandOptionType.SingleValue);
CommandOption runtimeOption = app.Option(
$"-r|--runtime <{LocalizableStrings.RuntimeOption}>", LocalizableStrings.RuntimeOptionDescription,
CommandOptionType.SingleValue);
CommandOption outputOption = app.Option(
$"-o|--output <{LocalizableStrings.OutputOption}>", LocalizableStrings.OutputOptionDescription,
CommandOptionType.SingleValue);
CommandOption fxOption = app.Option(
$"--framework-version <{LocalizableStrings.FrameworkVersionOption}>", LocalizableStrings.FrameworkVersionOptionDescription,
CommandOptionType.SingleValue);
CommandOption skipOptimizationOption = app.Option(
$"--skip-optimization", LocalizableStrings.SkipOptimizationOptionDescription,
CommandOptionType.NoValue);
CommandOption workingDir = app.Option(
$"-w |--working-dir <{LocalizableStrings.IntermediateWorkingDirOption}>", LocalizableStrings.IntermediateWorkingDirOptionDescription,
CommandOptionType.SingleValue);
CommandOption preserveWorkingDir = app.Option(
$"--preserve-working-dir", LocalizableStrings.PreserveIntermediateWorkingDirOptionDescription,
CommandOptionType.NoValue);
CommandOption verbosityOption = MSBuildForwardingApp.AddVerbosityOption(app);
app.OnExecute(() =>
{
var cache = new CacheCommand();
cache.Framework = frameworkOption.Value();
cache.Runtime = runtimeOption.Value();
cache.OutputPath = outputOption.Value();
cache.FrameworkVersion = fxOption.Value();
cache.Verbosity = verbosityOption.Value();
cache.SkipOptimization = skipOptimizationOption.HasValue();
cache.IntermediateDir = workingDir.Value();
cache.PreserveIntermediateDir = preserveWorkingDir.HasValue();
cache.ExtraMSBuildArguments = app.RemainingArguments;
cache.ProjectArgument = projectArgument.Value();
return(cache.Execute());
});
return(app.Execute(args));
}
