public void BuildArguments(ICakeContext context, ProcessArgumentBuilder builder)
{
if (NoGraphics)
{
builder.Append("-nographics");
}
builder.Append(PlatformTarget == UnityPlatformTarget.x64 ? "-buildWindows64Player" : "-buildWindowsPlayer");
builder.AppendQuoted(_outputPath.MakeAbsolute(context.Environment).FullPath);
}
/// <summary>
/// Appends the specified secret text to the argument builder.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="switch">The switch preceding the text.</param>
/// <param name="separator">The separator between the switch and argument</param>
/// <param name="argument">The secret argument to be appended.</param>
/// <returns>The same <see cref="ProcessArgumentBuilder"/> instance so that multiple calls can be chained.</returns>
public static ProcessArgumentBuilder AppendSwitchSecret(this ProcessArgumentBuilder builder, string @switch, string separator, IProcessArgument argument)
{
builder?.Append(new SwitchArgument(@switch, new SecretArgument(argument), separator));
return(builder);
}
/// <summary>
/// Appends the specified secret text to the argument builder.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="argument">The secret argument to be appended.</param>
/// <returns>The same <see cref="ProcessArgumentBuilder"/> instance so that multiple calls can be chained.</returns>
public static ProcessArgumentBuilder AppendSecret(this ProcessArgumentBuilder builder, IProcessArgument argument)
{
builder?.Append(new SecretArgument(argument));
return(builder);
}
/// <summary>
/// Quotes and appends the specified argument to the argument builder.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="argument">The argument to be quoted and appended.</param>
/// <returns>The same <see cref="ProcessArgumentBuilder"/> instance so that multiple calls can be chained.</returns>
public static ProcessArgumentBuilder AppendQuoted(this ProcessArgumentBuilder builder, IProcessArgument argument)
{
builder?.Append(new QuotedArgument(argument));
return(builder);
}
/// <summary>
/// Quotes and appends the specified text to the argument builder.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="text">The text to be quoted and appended.</param>
/// <returns>The same <see cref="ProcessArgumentBuilder"/> instance so that multiple calls can be chained.</returns>
public static ProcessArgumentBuilder?AppendQuoted(this ProcessArgumentBuilder builder, string text)
{
builder?.Append(new QuotedArgument(new TextArgument(text)));
return(builder);
}
private ProcessArgumentBuilder GetArguments(IEnumerable <FilePath> assemblyPaths, NUnitSettings settings)
{
var builder = new ProcessArgumentBuilder();
// Add the assemblies to build.
foreach (var assemblyPath in assemblyPaths)
{
builder.AppendQuoted(assemblyPath.MakeAbsolute(_environment).FullPath);
}
if (settings.Framework != null)
{
builder.AppendQuoted("-framework:" + settings.Framework);
}
if (settings.Include != null)
{
builder.AppendQuoted("-include:" + settings.Include);
}
if (settings.Exclude != null)
{
builder.AppendQuoted("-exclude:" + settings.Exclude);
}
if (settings.Timeout.HasValue)
{
builder.Append("-timeout:" + settings.Timeout.Value);
}
// No shadow copy?
if (!settings.ShadowCopy)
{
builder.Append("-noshadow");
}
if (settings.NoLogo)
{
builder.Append("-nologo");
}
if (settings.NoThread)
{
builder.Append("-nothread");
}
if (settings.StopOnError)
{
builder.Append("-stoponerror");
}
if (settings.Trace != null)
{
builder.Append("-trace:" + settings.Trace);
}
if (settings.OutputFile != null)
{
builder.AppendQuoted(string.Format(CultureInfo.InvariantCulture, "-output:{0}", settings.OutputFile.MakeAbsolute(_environment).FullPath));
}
if (settings.ErrorOutputFile != null)
{
builder.AppendQuoted(string.Format(CultureInfo.InvariantCulture, "-err:{0}", settings.ErrorOutputFile.MakeAbsolute(_environment).FullPath));
}
if (settings.ResultsFile != null && settings.NoResults)
{
throw new ArgumentException(
GetToolName() + ": You can't specify both a results file and set NoResults to true.");
}
if (settings.ResultsFile != null)
{
builder.AppendQuoted(
string.Format(
CultureInfo.InvariantCulture,
"-result:{0}", settings.ResultsFile.MakeAbsolute(_environment).FullPath));
}
else if (settings.NoResults)
{
builder.AppendQuoted("-noresult");
}
// don't include the default value
if (settings.Process != NUnitProcessOption.Single)
{
builder.AppendQuoted("-process:" + settings.Process);
}
if (settings.UseSingleThreadedApartment)
{
builder.AppendQuoted("-apartment:STA");
}
if (settings.AppDomainUsage != NUnitAppDomainUsage.Default)
{
builder.AppendQuoted("-domain:" + settings.AppDomainUsage);
}
return(builder);
}
private ProcessArgumentBuilder GetArguments(FilePath packageFilePath, ChocolateyPushSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("push");
builder.AppendQuoted(packageFilePath.MakeAbsolute(_environment).FullPath);
if (settings.Source != null)
{
builder.Append("-s");
builder.AppendQuoted(settings.Source);
}
if (settings.Timeout != null)
{
builder.Append("-t");
builder.Append(Convert.ToInt32(settings.Timeout.Value.TotalSeconds).ToString(CultureInfo.InvariantCulture));
}
if (settings.ApiKey != null)
{
builder.Append("-k");
builder.AppendSecret(settings.ApiKey);
}
// Debug
if (settings.Debug)
{
builder.Append("-d");
}
// Verbose
if (settings.Verbose)
{
builder.Append("-v");
}
// Always say yes, so as to not show interactive prompt
builder.Append("-y");
// Force
if (settings.Force)
{
builder.Append("-f");
}
// Noop
if (settings.Noop)
{
builder.Append("--noop");
}
// Limit Output
if (settings.LimitOutput)
{
builder.Append("-r");
}
// Execution Timeout
if (settings.ExecutionTimeout != 0)
{
builder.Append("--execution-timeout");
builder.AppendQuoted(settings.ExecutionTimeout.ToString(CultureInfo.InvariantCulture));
}
// Cache Location
if (!string.IsNullOrWhiteSpace(settings.CacheLocation))
{
builder.Append("-c");
builder.AppendQuoted(settings.CacheLocation);
}
// Allow Unofficial
if (settings.AllowUnofficial)
{
builder.Append("--allowunofficial");
}
return(builder);
}
private ProcessArgumentBuilder GetArguments(string name, string value, ChocolateyConfigSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("config");
builder.Append("set");
builder.Append("--name");
builder.AppendQuoted(name);
builder.Append("--value");
builder.AppendQuoted(value);
// Debug
if (settings.Debug)
{
builder.Append("-d");
}
// Verbose
if (settings.Verbose)
{
builder.Append("-v");
}
// Always say yes, so as to not show interactive prompt
builder.Append("-y");
// Force
if (settings.Force)
{
builder.Append("-f");
}
// Noop
if (settings.Noop)
{
builder.Append("--noop");
}
// Limit Output
if (settings.LimitOutput)
{
builder.Append("-r");
}
// Execution Timeout
if (settings.ExecutionTimeout != 0)
{
builder.Append("--execution-timeout");
builder.AppendQuoted(settings.ExecutionTimeout.ToString(CultureInfo.InvariantCulture));
}
// Cache Location
if (!string.IsNullOrWhiteSpace(settings.CacheLocation))
{
builder.Append("-c");
builder.AppendQuoted(settings.CacheLocation);
}
// Allow Unofficial
if (settings.AllowUnofficial)
{
builder.Append("--allowunofficial");
}
return(builder);
}
private ProcessArgumentBuilder GetArguments(FilePath solution, MSBuildSettings settings)
{
var builder = new ProcessArgumentBuilder();
// Set the maximum number of processors?
if (settings.MaxCpuCount != null)
{
builder.Append(settings.MaxCpuCount > 0 ? string.Concat("/m:", settings.MaxCpuCount) : "/m");
}
// Set the detailed summary flag.
if (settings.DetailedSummary.GetValueOrDefault())
{
builder.Append("/ds");
}
// Set the no console logger flag.
if (settings.NoConsoleLogger.GetValueOrDefault())
{
builder.Append("/noconlog");
}
// Set the verbosity.
builder.Append(string.Format(CultureInfo.InvariantCulture, "/v:{0}", GetVerbosityName(settings.Verbosity)));
if (settings.NodeReuse != null)
{
builder.Append(string.Concat("/nr:", settings.NodeReuse.Value ? "true" : "false"));
}
// Got a specific configuration in mind?
if (!string.IsNullOrWhiteSpace(settings.Configuration))
{
// Add the configuration as a property.
builder.AppendSwitch("/p:Configuration", "=", settings.Configuration);
}
// Build for a specific platform?
if (settings.PlatformTarget.HasValue)
{
var platform = settings.PlatformTarget.Value;
bool isSolution = string.Equals(solution.GetExtension(), ".sln", StringComparison.OrdinalIgnoreCase);
builder.Append(string.Concat("/p:Platform=", GetPlatformName(platform, isSolution)));
}
// Got any properties?
if (settings.Properties.Count > 0)
{
foreach (var property in GetPropertyArguments(settings.Properties))
{
builder.Append(property);
}
}
// Got any targets?
if (settings.Targets.Count > 0)
{
var targets = string.Join(";", settings.Targets);
builder.Append(string.Concat("/target:", targets));
}
else
{
// Use default target.
builder.Append("/target:Build");
}
if (settings.Loggers.Count > 0)
{
foreach (var logger in settings.Loggers)
{
var argument = GetLoggerArgument(logger);
builder.Append(argument);
}
}
// Got any file loggers?
if (settings.FileLoggers.Count > 0)
{
var arguments = settings.FileLoggers.Select((logger, index) =>
{
return(GetLoggerArgument(index, logger));
});
foreach (var argument in arguments)
{
builder.Append(argument);
}
}
// Add the solution as the last parameter.
builder.Append(solution.MakeAbsolute(_environment).FullPath);
return(builder);
}
private static void AppendMSBuildSwitch(this ProcessArgumentBuilder builder, string @switch)
=> builder.Append($"/{@switch}");
/// <summary>
/// Adds MSBuild arguments
/// </summary>
/// <param name="builder">Argument builder.</param>
/// <param name="settings">MSBuild settings to add.</param>
/// <param name="environment">The environment.</param>
/// <exception cref="InvalidOperationException">Throws if 10 or more file loggers specified.</exception>
public static void AppendMSBuildSettings(this ProcessArgumentBuilder builder, DotNetCoreMSBuildSettings settings, ICakeEnvironment environment)
{
// Got any targets?
if (settings.Targets.Any())
{
if (settings.Targets.All(string.IsNullOrWhiteSpace))
{
throw new ArgumentException("Specify the name of the target", nameof(settings.Targets));
}
builder.AppendMSBuildSwitch("target", string.Join(";", settings.Targets));
}
// Got any properties?
foreach (var property in settings.Properties)
{
if (property.Value == null || property.Value.All(string.IsNullOrWhiteSpace))
{
throw new ArgumentException("A property must have at least one non-empty value", nameof(settings.Properties));
}
foreach (var value in property.Value)
{
if (string.IsNullOrWhiteSpace(value))
{
continue;
}
builder.AppendMSBuildSwitch("property", $"{property.Key}={value.EscapeMSBuildPropertySpecialCharacters()}");
}
}
// Set the maximum number of processors?
if (settings.MaxCpuCount.HasValue)
{
builder.AppendMSBuildSwitchWithOptionalValue("maxcpucount", settings.MaxCpuCount.Value, maxCpuCount => maxCpuCount > 0);
}
// use different version of msbuild?
if (settings.ToolVersion.HasValue)
{
builder.AppendMSBuildSwitch("toolsversion", GetToolVersionValue(settings.ToolVersion.Value));
}
// configure console logger?
if (!settings.DisableConsoleLogger && settings.ConsoleLoggerSettings != null)
{
var arguments = GetLoggerSettings(settings.ConsoleLoggerSettings);
if (arguments.Any())
{
builder.AppendMSBuildSwitch("consoleloggerparameters", arguments);
}
}
// disable console logger?
if (settings.DisableConsoleLogger)
{
builder.AppendMSBuildSwitch("noconsolelogger");
}
// Got any file loggers?
if (settings.FileLoggers.Any())
{
if (settings.FileLoggers.Count >= 10)
{
throw new InvalidOperationException("Too Many FileLoggers");
}
var arguments = settings
.FileLoggers
.Select((logger, index) => GetLoggerArgument(index, logger, environment))
.Where(arg => !string.IsNullOrEmpty(arg));
foreach (var argument in arguments)
{
builder.Append(argument);
}
}
// Use binary logging?
if (settings.BinaryLogger != null && settings.BinaryLogger.Enabled)
{
string binaryOptions = null;
if (!string.IsNullOrEmpty(settings.BinaryLogger.FileName))
{
binaryOptions = settings.BinaryLogger.FileName;
}
if (settings.BinaryLogger.Imports != MSBuildBinaryLoggerImports.Unspecified)
{
if (!string.IsNullOrEmpty(binaryOptions))
{
binaryOptions += ";";
}
binaryOptions = binaryOptions + "ProjectImports=" + settings.BinaryLogger.Imports;
}
builder.AppendMSBuildSwitchWithOptionalValueIfNotEmpty("binarylogger", binaryOptions);
}
// Got any distributed loggers?
foreach (var distributedLogger in settings.DistributedLoggers)
{
builder.AppendMSBuildSwitch("distributedlogger", $"{GetLoggerValue(distributedLogger.CentralLogger)}*{GetLoggerValue(distributedLogger.ForwardingLogger)}");
}
// use a file logger for each node?
if (settings.DistributedFileLogger)
{
builder.AppendMSBuildSwitch("distributedfilelogger");
}
// Got any loggers?
foreach (var logger in settings.Loggers)
{
builder.AppendMSBuildSwitch("logger", GetLoggerValue(logger));
}
var showWarningsAsError = settings.TreatAllWarningsAs == MSBuildTreatAllWarningsAs.Error || settings.WarningCodesAsError.Any();
var showWarningsAsMessages = settings.TreatAllWarningsAs == MSBuildTreatAllWarningsAs.Message || settings.WarningCodesAsMessage.Any();
// Treat all or some warnings as errors?
if (showWarningsAsError)
{
builder.AppendMSBuildSwitchWithOptionalValueIfNotEmpty("warnaserror", GetWarningCodes(settings.TreatAllWarningsAs == MSBuildTreatAllWarningsAs.Error, settings.WarningCodesAsError));
}
// Treat all or some warnings as messages?
if (showWarningsAsMessages)
{
builder.AppendMSBuildSwitchWithOptionalValueIfNotEmpty("warnasmessage", GetWarningCodes(settings.TreatAllWarningsAs == MSBuildTreatAllWarningsAs.Message, settings.WarningCodesAsMessage));
}
// set project file extensions to ignore when searching for project file
if (settings.IgnoreProjectExtensions.Any())
{
builder.AppendMSBuildSwitch("ignoreprojectextensions", string.Join(",", settings.IgnoreProjectExtensions));
}
// detailed summary?
if (settings.DetailedSummary)
{
builder.AppendMSBuildSwitch("detailedsummary");
}
// Include response files?
foreach (var responseFile in settings.ResponseFiles)
{
builder.AppendSwitchQuoted("@", string.Empty, responseFile.MakeAbsolute(environment).FullPath);
}
// exclude auto response files?
if (settings.ExcludeAutoResponseFiles)
{
builder.AppendMSBuildSwitch("noautoresponse");
}
// don't output MSBuild logo?
if (settings.NoLogo)
{
builder.AppendMSBuildSwitch("nologo");
}
}
private ProcessArgumentBuilder GetArguments(IEnumerable <FilePath> assemblyPaths, NUnit3Settings settings)
{
var builder = new ProcessArgumentBuilder();
// Add the assemblies to build.
foreach (var assemblyPath in assemblyPaths)
{
builder.AppendQuoted(assemblyPath.MakeAbsolute(_environment).FullPath);
}
if (settings.Test != null)
{
builder.Append("--test=" + settings.Test);
}
if (settings.TestList != null)
{
builder.AppendQuoted(string.Format(CultureInfo.InvariantCulture, "--testlist={0}", settings.TestList.MakeAbsolute(_environment).FullPath));
}
if (settings.Where != null)
{
builder.Append("--where \"" + settings.Where + "\"");
}
if (settings.Timeout.HasValue)
{
builder.Append("--timeout=" + settings.Timeout.Value);
}
if (settings.Seed.HasValue)
{
builder.Append("--seed=" + settings.Seed.Value);
}
if (settings.Workers.HasValue)
{
builder.Append("--workers=" + settings.Workers.Value);
}
if (settings.StopOnError)
{
builder.Append("--stoponerror");
}
if (settings.SkipNonTestAssemblies)
{
builder.Append("--skipnontestassemblies");
}
if (settings.Work != null)
{
builder.AppendQuoted(string.Format(CultureInfo.InvariantCulture, "--work={0}", settings.Work.MakeAbsolute(_environment).FullPath));
}
if (settings.OutputFile != null)
{
builder.AppendQuoted(string.Format(CultureInfo.InvariantCulture, "--out={0}", settings.OutputFile.MakeAbsolute(_environment).FullPath));
}
#pragma warning disable 0618
if (settings.ErrorOutputFile != null)
{
builder.AppendQuoted(string.Format(CultureInfo.InvariantCulture, "--err={0}", settings.ErrorOutputFile.MakeAbsolute(_environment).FullPath));
}
if (settings.Full)
{
builder.Append("--full");
}
#pragma warning restore 0618
if (HasResults(settings) && settings.NoResults)
{
throw new ArgumentException(
GetToolName() + ": You can't specify both a results file and set NoResults to true.");
}
if (HasResults(settings))
{
foreach (var result in settings.Results)
{
var resultString = new StringBuilder(result.FileName.MakeAbsolute(_environment).FullPath);
if (result.Format != null)
{
resultString.AppendFormat(";format={0}", result.Format);
}
if (result.Transform != null)
{
resultString.AppendFormat(";transform={0}", result.Transform.MakeAbsolute(_environment).FullPath);
}
builder.AppendQuoted(string.Format(CultureInfo.InvariantCulture, "--result={0}", resultString));
}
}
else if (settings.NoResults)
{
builder.AppendQuoted("--noresult");
}
if (settings.Labels != NUnit3Labels.Off)
{
builder.Append("--labels=" + settings.Labels);
}
if (settings.TeamCity)
{
builder.Append("--teamcity");
}
if (settings.NoHeader)
{
builder.Append("--noheader");
}
if (settings.NoColor)
{
builder.Append("--nocolor");
}
#pragma warning disable 0618
if (settings.Verbose)
{
builder.Append("--verbose");
}
#pragma warning restore 0618
if (settings.Configuration != null)
{
builder.AppendQuoted("--config=" + settings.Configuration);
}
if (settings.Framework != null)
{
builder.AppendQuoted("--framework=" + settings.Framework);
}
if (settings.X86)
{
builder.Append("--x86");
}
if (settings.DisposeRunners)
{
builder.Append("--dispose-runners");
}
if (settings.ShadowCopy)
{
builder.Append("--shadowcopy");
}
if (settings.Agents.HasValue)
{
builder.Append("--agents=" + settings.Agents.Value);
}
// don't include the default value
if (settings.Process != NUnit3ProcessOption.Multiple)
{
builder.Append("--process=" + settings.Process);
}
if (settings.AppDomainUsage != NUnit3AppDomainUsage.Default)
{
builder.Append("--domain=" + settings.AppDomainUsage);
}
if (settings.TraceLevel.HasValue)
{
builder.Append("--trace=" + settings.TraceLevel.Value.GetArgumentValue());
}
if (settings.ConfigFile != null)
{
builder.AppendQuoted(string.Format(CultureInfo.InvariantCulture, "--configfile={0}", settings.ConfigFile.MakeAbsolute(_environment).FullPath));
}
if (settings.Params != null && settings.Params.Count > 0)
{
foreach (var param in settings.Params)
{
builder.AppendQuoted(string.Format(CultureInfo.InvariantCulture, "--params={0}={1}", param.Key, param.Value));
}
}
return(builder);
}
private ProcessArgumentBuilder GetArguments(string userName, string password, string owner, string repository, GitReleaseManagerCreateSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("create");
builder.Append("-u");
builder.AppendQuoted(userName);
builder.Append("-p");
builder.AppendQuotedSecret(password);
builder.Append("-o");
builder.AppendQuoted(owner);
builder.Append("-r");
builder.AppendQuoted(repository);
// Milestone
if (!string.IsNullOrWhiteSpace(settings.Milestone))
{
builder.Append("-m");
builder.AppendQuoted(settings.Milestone);
}
// Name
if (!string.IsNullOrWhiteSpace(settings.Name))
{
builder.Append("-n");
builder.AppendQuoted(settings.Name);
}
// Input File Path
if (settings.InputFilePath != null)
{
builder.Append("-i");
builder.AppendQuoted(settings.InputFilePath.MakeAbsolute(_environment).FullPath);
}
// Prerelease?
if (settings.Prerelease)
{
builder.Append("-pre");
}
// Assets
if (!string.IsNullOrWhiteSpace(settings.Assets))
{
builder.Append("-a");
builder.AppendQuoted(settings.Assets);
}
// Target Commitish
if (!string.IsNullOrWhiteSpace(settings.TargetCommitish))
{
builder.Append("-c");
builder.AppendQuoted(settings.TargetCommitish);
}
// Target Directory
if (settings.TargetDirectory != null)
{
builder.Append("-d");
builder.AppendQuoted(settings.TargetDirectory.MakeAbsolute(_environment).FullPath);
}
// Log File Path
if (settings.LogFilePath != null)
{
builder.Append("-l");
builder.AppendQuoted(settings.LogFilePath.MakeAbsolute(_environment).FullPath);
}
return(builder);
}
private ProcessArgumentBuilder GetArguments(string packageId, ChocolateyUpgradeSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("upgrade");
builder.Append(packageId);
// Debug
if (settings.Debug)
{
builder.Append("-d");
}
// Verbose
if (settings.Verbose)
{
builder.Append("-v");
}
// Accept License
if (settings.AcceptLicense)
{
builder.Append("--acceptLicense");
}
// Always say yes, so as to not show interactive prompt
builder.Append("-y");
// Force
if (settings.Force)
{
builder.Append("-f");
}
// Noop
if (settings.Noop)
{
builder.Append("--noop");
}
// Limit Output
if (settings.LimitOutput)
{
builder.Append("-r");
}
// Execution Timeout
if (settings.ExecutionTimeout != 0)
{
builder.Append("--execution-timeout");
builder.Append(settings.ExecutionTimeout.ToString(CultureInfo.InvariantCulture));
}
// Cache Location
if (!string.IsNullOrWhiteSpace(settings.CacheLocation))
{
builder.Append("-c");
builder.Append(settings.CacheLocation);
}
// Allow Unofficial
if (settings.AllowUnofficial)
{
builder.Append("--allowunofficial");
}
// Package source
if (!string.IsNullOrWhiteSpace(settings.Source))
{
builder.Append("-s");
builder.Append(settings.Source);
}
// Version
if (settings.Version != null)
{
builder.Append("--version");
builder.Append(settings.Version);
}
// Prerelease
if (settings.Prerelease)
{
builder.Append("--pre");
}
// Forcex86
if (settings.Forcex86)
{
builder.Append("--x86");
}
// Install Arguments
if (!string.IsNullOrWhiteSpace(settings.InstallArguments))
{
builder.Append("--ia");
builder.Append(settings.InstallArguments);
}
// OverrideArguments
if (settings.OverrideArguments)
{
builder.Append("-o");
}
// NotSilent
if (settings.NotSilent)
{
builder.Append("--notSilent");
}
// Package Parameters
if (!string.IsNullOrWhiteSpace(settings.PackageParameters))
{
builder.Append("--params");
builder.Append(settings.PackageParameters);
}
// Allow Downgrade
if (settings.AllowDowngrade)
{
builder.Append("--allowdowngrade");
}
// Side by side installation
if (settings.SideBySide)
{
builder.Append("-m");
}
// Ignore Dependencies
if (settings.IgnoreDependencies)
{
builder.Append("-i");
}
// Skip PowerShell
if (settings.SkipPowerShell)
{
builder.Append("-n");
}
// Fail on Unfound
if (settings.FailOnUnfound)
{
builder.Append("--failonunfound");
}
// Fail on Not Installed
if (settings.FailOnNotInstalled)
{
builder.Append("--failonnotinstalled");
}
// User
if (!string.IsNullOrWhiteSpace(settings.User))
{
builder.Append("-u");
builder.Append(settings.User);
}
// Password
if (!string.IsNullOrWhiteSpace(settings.Password))
{
builder.Append("-p");
builder.Append(settings.Password);
}
// Ignore Checksums
if (settings.IgnoreChecksums)
{
builder.Append("--ignorechecksums");
}
return(builder);
}
public void Run(FilePath apkFile, string apiKey, string devicesHash, string userEmail, DirectoryPath uitestAssemblies, TestCloudSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("submit");
builder.AppendQuoted(apkFile.MakeAbsolute(_cakeEnvironment).FullPath);
builder.AppendQuotedSecret(apiKey);
if (settings.Keystore != null)
{
builder.Append("keystore");
builder.AppendQuoted(settings.Keystore.MakeAbsolute(_cakeEnvironment).FullPath);
builder.AppendQuoted(settings.KeystorePassword);
builder.AppendQuoted(settings.KeystoreAlias);
builder.AppendQuoted(settings.KeystoreAliasPassword);
}
builder.Append("--devices " + devicesHash);
builder.Append("--series " + settings.Series);
builder.Append("--locale");
builder.AppendQuoted(settings.Locale);
builder.Append("--user");
builder.AppendQuoted(userEmail);
builder.Append("--assembly-dir");
builder.AppendQuoted(uitestAssemblies.MakeAbsolute(_cakeEnvironment).FullPath);
if (settings.NUnitXmlFile != null)
{
builder.Append("--nunit-xml");
builder.AppendQuoted(settings.NUnitXmlFile.MakeAbsolute(_cakeEnvironment).FullPath);
}
if (settings.Dsym != null)
{
builder.Append("--dsym");
builder.AppendQuoted(settings.Dsym.MakeAbsolute(_cakeEnvironment).FullPath);
}
if (settings.Categories != null)
{
foreach (var cat in settings.Categories)
{
builder.Append("--category");
builder.AppendQuoted(cat);
}
}
if (!string.IsNullOrEmpty(settings.Fixture))
{
builder.Append("--fixture");
builder.AppendQuoted(settings.Fixture);
}
if (!string.IsNullOrEmpty(settings.AppName))
{
builder.Append("--app-name");
builder.AppendQuoted(settings.AppName);
}
if (settings.TestChunk)
{
builder.Append("--test-chunk");
}
if (settings.TestFixture)
{
builder.Append("--test-fixture");
}
Run(settings, builder);
}
private ProcessArgumentBuilder GetArguments(DirectoryPath repositoryRootPath, GitLinkSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.AppendQuoted(repositoryRootPath.MakeAbsolute(_environment).FullPath);
if (!string.IsNullOrWhiteSpace(settings.RepositoryUrl))
{
builder.Append("-u");
builder.AppendQuoted(settings.RepositoryUrl);
}
if (!string.IsNullOrWhiteSpace(settings.SolutionFileName))
{
builder.Append("-f");
builder.AppendQuoted(settings.SolutionFileName);
}
if (!string.IsNullOrWhiteSpace(settings.Configuration))
{
builder.Append("-c");
builder.AppendQuoted(settings.Configuration);
}
if (!string.IsNullOrWhiteSpace(settings.Platform))
{
builder.Append("-p");
builder.AppendQuoted(settings.Platform);
}
if (!string.IsNullOrWhiteSpace(settings.Branch))
{
builder.Append("-b");
builder.AppendQuoted(settings.Branch);
}
if (settings.LogFilePath != null)
{
builder.Append("-l");
builder.AppendQuoted(settings.LogFilePath.MakeAbsolute(_environment).FullPath);
}
if (!string.IsNullOrWhiteSpace(settings.ShaHash))
{
builder.Append("-s");
builder.AppendQuoted(settings.ShaHash);
}
if (settings.PdbDirectoryPath != null)
{
builder.Append("-d");
builder.AppendQuoted(settings.PdbDirectoryPath.MakeAbsolute(_environment).FullPath);
}
if (settings.UsePowerShell)
{
builder.Append("-powershell");
}
if (settings.ErrorsAsWarnings)
{
builder.Append("-errorsaswarnings");
}
if (settings.SkipVerify)
{
builder.Append("-skipverify");
}
if (settings.IsDebug)
{
builder.Append("-debug");
}
return(builder);
}
private ProcessArgumentBuilder GetArguments(IReadOnlyList <FilePath> assemblyPaths, XUnit2Settings settings)
{
var builder = new ProcessArgumentBuilder();
// Add the assemblies to test.
foreach (var assembly in assemblyPaths)
{
builder.Append(assembly.MakeAbsolute(_environment).FullPath);
}
// No shadow copy?
if (!settings.ShadowCopy)
{
builder.Append("-noshadow");
}
// No app domain?
if (settings.NoAppDomain)
{
builder.Append("-noappdomain");
}
// Generate NUnit Style XML report?
if (settings.NUnitReport)
{
var reportFileName = XUnitRunnerUtilities.GetReportFileName(assemblyPaths);
var assemblyFilename = reportFileName.AppendExtension(".xml");
var outputPath = settings.OutputDirectory.MakeAbsolute(_environment).GetFilePath(assemblyFilename);
builder.Append("-nunit");
builder.Append(outputPath.FullPath);
}
// Generate HTML report?
if (settings.HtmlReport)
{
var reportFileName = XUnitRunnerUtilities.GetReportFileName(assemblyPaths);
var assemblyFilename = reportFileName.AppendExtension(".html");
var outputPath = settings.OutputDirectory.MakeAbsolute(_environment).GetFilePath(assemblyFilename);
builder.Append("-html");
builder.Append(outputPath.FullPath);
}
// Generate XML report?
if (settings.XmlReport || settings.XmlReportV1)
{
var reportFileName = XUnitRunnerUtilities.GetReportFileName(assemblyPaths);
var assemblyFilename = reportFileName.AppendExtension(".xml");
var outputPath = settings.OutputDirectory.MakeAbsolute(_environment).GetFilePath(assemblyFilename);
builder.Append(settings.XmlReportV1 ? "-xmlv1" : "-xml");
builder.Append(outputPath.FullPath);
}
// parallelize test execution?
if (settings.Parallelism != ParallelismOption.None)
{
builder.Append("-parallel " + settings.Parallelism.ToString().ToLowerInvariant());
}
// max thread count for collection parallelization
if (settings.MaxThreads.HasValue)
{
if (settings.MaxThreads.Value == 0)
{
builder.Append("-maxthreads unlimited");
}
else
{
builder.Append("-maxthreads " + settings.MaxThreads.Value);
}
}
foreach (var trait in settings.TraitsToInclude
.SelectMany(pair => pair.Value.Select(v => new { Name = pair.Key, Value = v })))
{
builder.Append("-trait \"{0}={1}\"", trait.Name, trait.Value);
}
foreach (var trait in settings.TraitsToExclude
.SelectMany(pair => pair.Value.Select(v => new { Name = pair.Key, Value = v })))
{
builder.Append("-notrait \"{0}={1}\"", trait.Name, trait.Value);
}
return(builder);
}
public ProcessArgumentBuilder Get()
{
AppendCommonArguments();
AppendArgumentIfNotNull("releaseNumber", _settings.ReleaseNumber);
AppendArgumentIfNotNull("defaultpackageversion", _settings.DefaultPackageVersion);
AppendPackages(_settings, _builder);
AppendArgumentIfNotNull("packagesFolder", _settings.PackagesFolder);
AppendArgumentIfNotNull("releasenotes", _settings.ReleaseNotes);
AppendArgumentIfNotNull("releasenotesfile", _settings.ReleaseNotesFile);
if (_settings.IgnoreExisting)
{
_builder.Append("--ignoreexisting");
}
return(_builder);
}
private ProcessArgumentBuilder GetArguments(FilePath targetFilePath, NuGetRestoreSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("restore");
builder.AppendQuoted(targetFilePath.MakeAbsolute(_environment).FullPath);
// RequireConsent?
if (settings.RequireConsent)
{
builder.Append("-RequireConsent");
}
// Packages Directory.
if (settings.PackagesDirectory != null)
{
builder.Append("-PackagesDirectory");
builder.AppendQuoted(settings.PackagesDirectory.MakeAbsolute(_environment).FullPath);
}
// List of package sources.
if (settings.Source != null && settings.Source.Count > 0)
{
builder.Append("-Source");
builder.AppendQuoted(string.Join(";", settings.Source));
}
// List of package fallback sources.
if (settings.FallbackSource != null && settings.FallbackSource.Count > 0)
{
builder.Append("-FallbackSource");
builder.AppendQuoted(string.Join(";", settings.FallbackSource));
}
// No Cache?
if (settings.NoCache)
{
builder.Append("-NoCache");
}
// Disable Parallel Processing?
if (settings.DisableParallelProcessing)
{
builder.Append("-DisableParallelProcessing");
}
// Verbosity?
if (settings.Verbosity.HasValue)
{
builder.Append("-Verbosity");
builder.Append(settings.Verbosity.Value.ToString().ToLowerInvariant());
}
// Configuration file.
if (settings.ConfigFile != null)
{
builder.Append("-ConfigFile");
builder.AppendQuoted(settings.ConfigFile.MakeAbsolute(_environment).FullPath);
}
// MSBuildVersion?
if (settings.MSBuildVersion.HasValue)
{
builder.Append("-MSBuildVersion");
builder.Append(settings.MSBuildVersion.Value.ToString("D"));
}
builder.Append("-NonInteractive");
return(builder);
}
private static ProcessArgumentBuilder ProcessArguments(
ICakeContext cakeContext,
ProcessArgumentBuilder builder,
FilePath project,
XUnit2Settings settings)
{
// No shadow copy?
if (!settings.ShadowCopy)
{
throw new CakeException("-noshadow is not supported in .netcoreapp");
}
// No app domain?
if (settings.NoAppDomain)
{
throw new CakeException("-noappdomain is not supported in .netcoreapp");
}
if (settings.OutputDirectory == null &&
(settings.HtmlReport || settings.NUnitReport || settings.XmlReport))
{
throw new CakeException("OutputDirectory must not be null");
}
// Generate NUnit Style XML report?
if (settings.NUnitReport)
{
var reportFileName = new FilePath(project.GetDirectory().GetDirectoryName());
var assemblyFilename = reportFileName.AppendExtension(".xml");
var outputPath = settings.OutputDirectory.MakeAbsolute(cakeContext.Environment)
.GetFilePath(assemblyFilename);
builder.Append("-nunit");
builder.AppendQuoted(outputPath.FullPath);
}
// Generate HTML report?
if (settings.HtmlReport)
{
var reportFileName = new FilePath(project.GetDirectory().GetDirectoryName());
var assemblyFilename = reportFileName.AppendExtension(".html");
var outputPath = settings.OutputDirectory.MakeAbsolute(cakeContext.Environment)
.GetFilePath(assemblyFilename);
builder.Append("-html");
builder.AppendQuoted(outputPath.FullPath);
}
if (settings.XmlReportV1)
{
throw new CakeException("-xmlv1 is not supported in .netcoreapp");
}
// Generate XML report?
if (settings.XmlReport)
{
var reportFileName = new FilePath(project.GetDirectory().GetDirectoryName());
var assemblyFilename = reportFileName.AppendExtension(".xml");
var outputPath = settings.OutputDirectory.MakeAbsolute(cakeContext.Environment)
.GetFilePath(assemblyFilename);
builder.Append("-xml");
builder.AppendQuoted(outputPath.FullPath);
}
// parallelize test execution?
if (settings.Parallelism != null && settings.Parallelism != ParallelismOption.None)
{
builder.Append($"-parallel {settings.Parallelism.ToString().ToLowerInvariant()}");
}
// max thread count for collection parallelization
if (settings.MaxThreads.HasValue)
{
if (settings.MaxThreads.Value == 0)
{
builder.Append("-maxthreads unlimited");
}
else
{
builder.Append($"-maxthreads {settings.MaxThreads.Value}");
}
}
foreach (var trait in settings.TraitsToInclude
.SelectMany(pair => pair.Value.Select(v => new { Name = pair.Key, Value = v })))
{
builder.Append("-trait \"{0}={1}\"", trait.Name, trait.Value);
}
foreach (var trait in settings.TraitsToExclude
.SelectMany(pair => pair.Value.Select(v => new { Name = pair.Key, Value = v })))
{
builder.Append($"-notrait \"{trait.Name}={trait.Value}\"");
}
return(builder);
}
/// <summary>
/// Adds common arguments to the process builder.
/// </summary>
/// <param name="settings">The settings.</param>
/// <param name="builder">The process argument builder.</param>
/// <returns>The process argument builder.</returns>
protected ProcessArgumentBuilder AddCommonArguments(ChocolateySettings settings, ProcessArgumentBuilder builder)
{
// Debug
if (settings.Debug)
{
builder.Append("-d");
}
// Verbose
if (settings.Verbose)
{
builder.Append("-v");
}
// Accept License
if (settings.AcceptLicense)
{
builder.Append("--acceptLicense");
}
// Always say yes, so as to not show interactive prompt
builder.Append("-y");
// Force
if (settings.Force)
{
builder.Append("-f");
}
// Noop
if (settings.Noop)
{
builder.Append("--noop");
}
// Limit Output
if (settings.LimitOutput)
{
builder.Append("-r");
}
// Execution Timeout
if (settings.ExecutionTimeout != 0)
{
builder.Append("--execution-timeout");
builder.AppendQuoted(settings.ExecutionTimeout.ToString(CultureInfo.InvariantCulture));
}
// Cache Location
if (!string.IsNullOrWhiteSpace(settings.CacheLocation))
{
builder.Append("-c");
builder.AppendQuoted(settings.CacheLocation);
}
// Allow Unofficial
if (settings.AllowUnofficial)
{
builder.Append("--allowunofficial");
}
// Package source
if (!string.IsNullOrWhiteSpace(settings.Source))
{
builder.Append("-s");
builder.AppendQuoted(settings.Source);
}
// Version
if (settings.Version != null)
{
builder.Append("--version");
builder.AppendQuoted(settings.Version);
}
// OverrideArguments
if (settings.OverrideArguments)
{
builder.Append("-o");
}
// NotSilent
if (settings.NotSilent)
{
builder.Append("--notSilent");
}
// Package Parameters
if (!string.IsNullOrWhiteSpace(settings.PackageParameters))
{
builder.Append("--params");
builder.AppendQuoted(settings.PackageParameters);
}
// Side by side installation
if (settings.SideBySide)
{
builder.Append("-m");
}
// Skip PowerShell
if (settings.SkipPowerShell)
{
builder.Append("-n");
}
return(builder);
}
private ProcessArgumentBuilder GetArguments(IEnumerable <FilePath> assemblyPaths, VSTestSettings settings)
{
var builder = new ProcessArgumentBuilder();
// Add the assembly to build.
foreach (var assemblyPath in assemblyPaths)
{
builder.Append(assemblyPath.MakeAbsolute(_environment).FullPath);
}
if (settings.SettingsFile != null)
{
builder.AppendSwitch("/Settings", ":", settings.SettingsFile.MakeAbsolute(_environment).FullPath);
}
if (settings.Parallel)
{
builder.Append("/Parallel");
}
if (settings.EnableCodeCoverage)
{
builder.Append("/EnableCodeCoverage");
}
if (settings.InIsolation)
{
builder.Append("/InIsolation");
}
if (settings.UseVsixExtensions != null)
{
builder.AppendSwitch("/UseVsixExtensions", ":", settings.UseVsixExtensions.Value ? "true" : "false");
}
if (settings.TestAdapterPath != null)
{
builder.AppendSwitch("/TestAdapterPath", ":", settings.TestAdapterPath.MakeAbsolute(_environment).FullPath);
}
if (settings.PlatformArchitecture != VSTestPlatform.Default)
{
builder.AppendSwitch("/Platform", ":", settings.PlatformArchitecture.ToString());
}
if (settings.FrameworkVersion != VSTestFrameworkVersion.Default)
{
builder.AppendSwitch("/Framework", ":", settings.FrameworkVersion.ToString().Replace("NET", "Framework"));
}
if (settings.TestCaseFilter != null)
{
builder.AppendSwitch("/TestCaseFilter", ":", settings.TestCaseFilter);
}
if (settings.Diag != null)
{
builder.AppendSwitch("/Diag", ":", settings.Diag.MakeAbsolute(_environment).FullPath);
}
if (!string.IsNullOrEmpty(settings.Logger))
{
builder.Append("/Logger:{0}", settings.Logger.Trim());
}
return(builder);
}
/// <summary>
/// Evaluates the settings and writes them to <paramref name="args"/>.
/// </summary>
/// <param name="args">The argument builder into which the settings should be written.</param>
internal void Evaluate(ProcessArgumentBuilder args)
{
args.Append(Command);
AppendNpmSettings(args);
EvaluateCore(args);
}
private ProcessArgumentBuilder GetArguments(FilePath solution, MSBuildSettings settings)
{
var builder = new ProcessArgumentBuilder();
// Set the maximum number of processors?
if (settings.MaxCpuCount != null)
{
builder.Append(settings.MaxCpuCount > 0 ? string.Concat("/m:", settings.MaxCpuCount) : "/m");
}
// Set the detailed summary flag.
if (settings.DetailedSummary.GetValueOrDefault())
{
builder.Append("/ds");
}
// Set the no console logger flag.
if (settings.NoConsoleLogger.GetValueOrDefault())
{
builder.Append("/noconlog");
}
// Set the verbosity.
builder.Append(string.Format(CultureInfo.InvariantCulture, "/v:{0}", settings.Verbosity.GetMSBuildVerbosityName()));
if (settings.NodeReuse != null)
{
builder.Append(string.Concat("/nr:", settings.NodeReuse.Value ? "true" : "false"));
}
// Got a specific configuration in mind?
if (!string.IsNullOrWhiteSpace(settings.Configuration))
{
// Add the configuration as a property.
builder.AppendSwitchQuoted("/p:Configuration", "=", settings.Configuration);
}
// Build for a specific platform?
if (settings.PlatformTarget.HasValue)
{
var platform = settings.PlatformTarget.Value;
bool isSolution = string.Equals(solution.GetExtension(), ".sln", StringComparison.OrdinalIgnoreCase);
builder.Append(string.Concat("/p:Platform=", GetPlatformName(platform, isSolution)));
}
// Got any properties?
if (settings.Properties.Count > 0)
{
foreach (var property in GetPropertyArguments(settings.Properties))
{
builder.Append(property);
}
}
// Got any targets?
if (settings.Targets.Count > 0)
{
var targets = string.Join(";", settings.Targets);
builder.Append(string.Concat("/target:", targets));
}
else
{
// Use default target.
builder.Append("/target:Build");
}
if (settings.Loggers.Count > 0)
{
foreach (var logger in settings.Loggers)
{
var argument = GetLoggerArgument(logger);
builder.Append(argument);
}
}
// Got any file loggers?
if (settings.FileLoggers.Count > 0)
{
var arguments = settings.FileLoggers.Select((logger, index) => GetLoggerArgument(index, logger));
foreach (var argument in arguments)
{
builder.Append(argument);
}
}
// Use binary logging?
if (settings.BinaryLogger != null && settings.BinaryLogger.Enabled)
{
string binaryOptions = null;
if (!string.IsNullOrEmpty(settings.BinaryLogger.FileName))
{
binaryOptions = settings.BinaryLogger.FileName;
}
if (settings.BinaryLogger.Imports != MSBuildBinaryLogImports.Unspecified)
{
if (!string.IsNullOrEmpty(binaryOptions))
{
binaryOptions = binaryOptions + ";";
}
binaryOptions = binaryOptions + "ProjectImports=" + settings.BinaryLogger.Imports;
}
if (string.IsNullOrEmpty(binaryOptions))
{
builder.Append("/bl");
}
else
{
builder.Append("/bl:" + binaryOptions);
}
}
// Treat errors as warníngs?
if (settings.WarningsAsErrorCodes.Any())
{
var codes = string.Join(";", settings.WarningsAsErrorCodes);
builder.Append($"/warnaserror:{codes.Quote()}");
}
else if (settings.WarningsAsError)
{
builder.Append("/warnaserror");
}
// Any warnings to NOT treat as errors?
if (settings.WarningsAsMessageCodes.Any())
{
var codes = string.Join(";", settings.WarningsAsMessageCodes);
builder.Append($"/warnasmessage:{codes.Quote()}");
}
// Invoke restore target before any other target?
if (settings.Restore)
{
builder.Append("/restore");
}
// Add the solution as the last parameter.
builder.AppendQuoted(solution.MakeAbsolute(_environment).FullPath);
return(builder);
}
private ProcessArgumentBuilder GetArguments(FilePath filePath, NuGetPackSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("pack");
// Version
if (!string.IsNullOrWhiteSpace(settings.Version))
{
builder.Append("-Version");
builder.AppendQuoted(settings.Version);
}
// Base path
if (settings.BasePath != null)
{
builder.Append("-BasePath");
builder.AppendQuoted(settings.BasePath.MakeAbsolute(_environment).FullPath);
}
// Output directory
if (settings.OutputDirectory != null)
{
builder.Append("-OutputDirectory");
builder.AppendQuoted(settings.OutputDirectory.MakeAbsolute(_environment).FullPath);
}
// Nuspec file
builder.AppendQuoted(filePath.MakeAbsolute(_environment).FullPath);
// No package analysis?
if (settings.NoPackageAnalysis)
{
builder.Append("-NoPackageAnalysis");
}
// IncludeReferencedProjects?
if (settings.IncludeReferencedProjects)
{
builder.Append("-IncludeReferencedProjects");
}
// Symbols?
if (settings.Symbols)
{
builder.Append("-Symbols");
}
// Verbosity
if (settings.Verbosity != null)
{
builder.Append("-Verbosity");
builder.Append(settings.Verbosity.Value.ToString().ToLowerInvariant());
}
// MSBuildVersion?
if (settings.MSBuildVersion.HasValue)
{
builder.Append("-MSBuildVersion");
builder.Append(settings.MSBuildVersion.Value.ToString("D"));
}
// Properties
if (settings.Properties != null && settings.Properties.Count > 0)
{
if (settings.Properties.Values.Any(string.IsNullOrWhiteSpace))
{
throw new CakeException("Properties values can not be null or empty.");
}
if (settings.Properties.Keys.Any(string.IsNullOrWhiteSpace))
{
throw new CakeException("Properties keys can not be null or empty.");
}
builder.Append("-Properties");
builder.AppendQuoted(string.Join(";",
settings.Properties.Select(property => string.Concat(property.Key, "=", property.Value))));
}
return(builder);
}
public void Build(XCodeBuildSettings settings)
{
var builder = new ProcessArgumentBuilder();
if (settings.Verbose)
{
builder.Append("-verbose");
}
if (settings.CheckFirstLaunchStatus)
{
builder.Append("-checkFirstLaunchStatus");
}
if (!string.IsNullOrEmpty(settings.Project))
{
builder.Append(string.Format("-project \"{0}\"", settings.Project));
}
if (!string.IsNullOrEmpty(settings.Target))
{
builder.Append(string.Format("-target \"{0}\"", settings.Target));
}
if (settings.AllTargets)
{
builder.Append("-alltargets");
}
if (settings.Workspace != null)
{
builder.Append("-workspace " + GetQuotedAbsolute(settings.Workspace));
}
if (!string.IsNullOrEmpty(settings.Scheme))
{
builder.Append(string.Format("-scheme \"{0}\"", settings.Scheme));
}
if (!string.IsNullOrEmpty(settings.Configuration))
{
builder.Append(string.Format("-configuration \"{0}\"", settings.Configuration));
}
if (settings.XcConfig != null)
{
builder.Append("-xcconfig " + GetQuotedAbsolute(settings.XcConfig));
}
if (!string.IsNullOrEmpty(settings.Arch))
{
builder.Append(string.Format("-arch \"{0}\"", settings.Arch));
}
if (!string.IsNullOrEmpty(settings.Sdk))
{
builder.Append(string.Format("-sdk \"{0}\"", settings.Sdk));
}
if (!string.IsNullOrEmpty(settings.Toolchain))
{
builder.Append(string.Format("-toolchain \"{0}\"", settings.Toolchain));
}
if (settings.Destination != null && settings.Destination.Count > 0)
{
builder.Append("-destination " +
string.Join(",", settings.Destination.Select(kvp => string.Format("{0}={1}", kvp.Key, kvp.Value))));
if (settings.DestinationTimeout.HasValue)
{
builder.Append("-destination-timeout " + settings.DestinationTimeout.Value);
}
}
if (settings.ParallelizeTargets)
{
builder.Append("-parallelizeTargets");
}
if (settings.Jobs.HasValue)
{
builder.Append("-jobs " + settings.Jobs.Value);
}
if (settings.DryRun)
{
builder.Append("-dry-run");
}
if (settings.ResultBundlePath != null)
{
builder.Append("-resultBundlePath " + GetQuotedAbsolute(settings.ResultBundlePath));
}
if (settings.DerivedDataPath != null)
{
builder.Append("-derivedDataPath " + GetQuotedAbsolute(settings.DerivedDataPath));
}
if (settings.ArchivePath != null)
{
builder.Append("-archivePath " + GetQuotedAbsolute(settings.ArchivePath));
}
if (settings.ExportArchive)
{
builder.Append("-exportArchive");
}
if (settings.ExportFormat.HasValue)
{
builder.Append("-exportFormat " + settings.ExportFormat.Value.ToString().ToLowerInvariant());
}
if (settings.ExportPath != null)
{
builder.Append("-exportPath " + GetQuotedAbsolute(settings.ExportPath));
}
if (settings.ExportOptionsPlist != null)
{
builder.Append("-exportOptionsPlist " + GetQuotedAbsolute(settings.ExportOptionsPlist));
}
if (!string.IsNullOrEmpty(settings.ExportProvisioningProfile))
{
builder.Append("-exportProvisioningProfile " + settings.ExportProvisioningProfile);
}
if (!string.IsNullOrEmpty(settings.ExportSigningIdentity))
{
builder.Append("-exportSigningIdentity " + settings.ExportSigningIdentity);
}
if (!string.IsNullOrEmpty(settings.ExportInstallerIdentity))
{
builder.Append("-exportInstallerIdentity " + settings.ExportInstallerIdentity);
}
if (settings.ExportWithOriginalSigningIdentity)
{
builder.Append("-exportWithOriginalSigningIdentity");
}
if (settings.SkipUnavailableActions)
{
builder.Append("-skipUnavailableActions");
}
if (settings.ExportLocalizations)
{
builder.Append("-exportLocalizations");
}
if (settings.LocalizationPath != null)
{
builder.Append("-localizationPath " + GetQuotedAbsolute(settings.LocalizationPath));
}
if (!string.IsNullOrEmpty(settings.ExportLanguage))
{
builder.Append("-exportLanguage " + settings.ExportLanguage);
}
if (settings.Archive)
{
builder.Append("archive");
}
else
{
builder.Append("build");
}
if (settings.Clean)
{
builder.Append("clean");
}
if (settings.BuildSettings != null && settings.BuildSettings.Count > 0)
{
builder.Append(string.Join(" ", settings.BuildSettings.Select(kvp => string.Format("{0}={1}", kvp.Key, kvp.Value))));
}
Run(settings, builder, settings.ToolPath);
}
/// <summary>
/// Appends the specified secret text to the argument builder.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="text">The secret text to be appended.</param>
/// <returns>The same <see cref="ProcessArgumentBuilder"/> instance so that multiple calls can be chained.</returns>
public static ProcessArgumentBuilder AppendSecret(this ProcessArgumentBuilder builder, string text)
{
builder?.Append(new SecretArgument(new TextArgument(text)));
return(builder);
}
private ProcessArgumentBuilder GetArguments(FilePath[] absoluteAssemblyPaths, SignToolSignSettings settings)
{
foreach (var path in absoluteAssemblyPaths)
{
if (!_fileSystem.Exist(path))
{
const string format = "{0}: The assembly '{1}' does not exist.";
var message = string.Format(CultureInfo.InvariantCulture, format, GetToolName(), path.FullPath);
throw new CakeException(message);
}
}
var builder = new ProcessArgumentBuilder();
// SIGN Command.
builder.Append("SIGN");
// SHA-256.
if (settings.DigestAlgorithm == SignToolDigestAlgorithm.Sha256)
{
builder.Append("/fd sha256");
}
// TimeStamp.
if (settings.TimeStampUri != null)
{
if (settings.TimeStampDigestAlgorithm == SignToolDigestAlgorithm.Sha256)
{
// If Sha256 use RFC 3161 timestamp server.
builder.Append("/tr");
builder.AppendQuoted(settings.TimeStampUri.AbsoluteUri);
builder.Append("/td sha256");
}
else
{
// Otherwise use SHA-1 Authenticode timestamp server
builder.Append("/t");
builder.AppendQuoted(settings.TimeStampUri.AbsoluteUri);
}
}
if (settings.CertPath == null && string.IsNullOrEmpty(settings.CertThumbprint) && string.IsNullOrEmpty(settings.CertSubjectName))
{
const string format = "{0}: One of Certificate path, Certificate thumbprint or Certificate subject name is required but neither are specified.";
var message = string.Format(CultureInfo.InvariantCulture, format, GetToolName());
throw new CakeException(message);
}
if (settings.CertPath != null && !string.IsNullOrEmpty(settings.CertThumbprint))
{
const string format = "{0}: Certificate path and Certificate thumbprint cannot be specified together.";
var message = string.Format(CultureInfo.InvariantCulture, format, GetToolName());
throw new CakeException(message);
}
if (settings.CertPath != null && !string.IsNullOrEmpty(settings.CertSubjectName))
{
const string format = "{0}: Certificate path and Certificate subject name cannot be specified together.";
var message = string.Format(CultureInfo.InvariantCulture, format, GetToolName());
throw new CakeException(message);
}
if (!string.IsNullOrEmpty(settings.CertThumbprint) && !string.IsNullOrEmpty(settings.Password))
{
const string format = "{0}: Certificate thumbprint and Password cannot be specified together.";
var message = string.Format(CultureInfo.InvariantCulture, format, GetToolName());
throw new CakeException(message);
}
if (!string.IsNullOrEmpty(settings.CertSubjectName) && !string.IsNullOrEmpty(settings.Password))
{
const string format = "{0}: Certificate subject name and Password cannot be specified together.";
var message = string.Format(CultureInfo.InvariantCulture, format, GetToolName());
throw new CakeException(message);
}
if (settings.CertPath != null)
{
// Make certificate path absolute.
settings.CertPath = settings.CertPath.IsRelative
? settings.CertPath.MakeAbsolute(_environment)
: settings.CertPath;
if (!_fileSystem.Exist(settings.CertPath))
{
const string format = "{0}: The certificate '{1}' does not exist.";
var message = string.Format(CultureInfo.InvariantCulture, format, GetToolName(), settings.CertPath.FullPath);
throw new CakeException(message);
}
// Path to PFX Certificate.
builder.Append("/f");
builder.AppendQuoted(settings.CertPath.MakeAbsolute(_environment).FullPath);
// PFX Password.
if (!string.IsNullOrEmpty(settings.Password))
{
builder.Append("/p");
builder.AppendSecret(settings.Password);
}
}
if (settings.AdditionalCertPath != null)
{
// Make additional certificate path absolute.
settings.AdditionalCertPath = settings.AdditionalCertPath.IsRelative
? settings.AdditionalCertPath.MakeAbsolute(_environment)
: settings.AdditionalCertPath;
if (!_fileSystem.Exist(settings.AdditionalCertPath))
{
const string format = "{0}: The additional certificate '{1}' does not exist.";
var message = string.Format(CultureInfo.InvariantCulture, format, GetToolName(), settings.AdditionalCertPath.FullPath);
throw new CakeException(message);
}
// Path to additional certificate.
builder.Append("/ac");
builder.AppendQuoted(settings.AdditionalCertPath.MakeAbsolute(_environment).FullPath);
}
// Certificate thumbprint.
if (!string.IsNullOrEmpty(settings.CertThumbprint))
{
builder.Append("/sha1");
builder.AppendQuoted(settings.CertThumbprint);
}
if (!string.IsNullOrEmpty(settings.CertSubjectName))
{
builder.Append("/n");
builder.AppendQuoted(settings.CertSubjectName);
}
// Signed content description.
if (!string.IsNullOrEmpty(settings.Description))
{
builder.Append("/d");
builder.AppendQuoted(settings.Description);
}
// Signed content expanded description URL.
if (settings.DescriptionUri != null)
{
builder.Append("/du");
builder.AppendQuoted(settings.DescriptionUri.AbsoluteUri);
}
// Append signature.
if (settings.AppendSignature)
{
builder.Append("/as");
}
// use machine store when requested
if (settings.UseMachineStore)
{
builder.Append("/sm");
}
// open a specific certificate store
if (!string.IsNullOrWhiteSpace(settings.StoreName))
{
builder.Append("/s");
builder.AppendQuoted(settings.StoreName);
}
// Target Assemblies to sign.
foreach (var path in absoluteAssemblyPaths)
{
builder.AppendQuoted(path.FullPath);
}
return(builder);
}
/// <summary>
/// Appends the specified switch to the argument builder.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="switch">The switch preceding the text.</param>
/// <param name="separator">The separator between the switch and argument.</param>
/// <param name="text">The text to be appended.</param>
/// <returns>The same <see cref="ProcessArgumentBuilder"/> instance so that multiple calls can be chained.</returns>
public static ProcessArgumentBuilder AppendSwitch(this ProcessArgumentBuilder builder, string @switch, string separator, string text)
{
builder?.Append(new SwitchArgument(@switch, new TextArgument(text), separator));
return(builder);
}
private ProcessArgumentBuilder GetArguments(FilePath path, DNURestoreSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("restore");
// Specific project path?
if (path != null)
{
builder.AppendQuoted(path.MakeAbsolute(_environment).FullPath);
}
// List of package sources
if (settings.Sources != null && settings.Sources.Count > 0)
{
foreach (var source in settings.Sources)
{
builder.Append("--source");
builder.AppendQuoted(source);
}
}
// List of fallback package sources
if (settings.FallbackSources != null && settings.FallbackSources.Count > 0)
{
foreach (var fallbacksource in settings.FallbackSources)
{
builder.Append("--fallbacksource");
builder.AppendQuoted(fallbacksource);
}
}
// Proxy
if (settings.Proxy != null)
{
builder.Append("--proxy");
builder.AppendQuoted(settings.Proxy);
}
// No Cache?
if (settings.NoCache)
{
builder.Append("--no-cache");
}
// Packages
if (settings.Packages != null)
{
builder.Append("--packages");
builder.AppendQuoted(settings.Packages.MakeAbsolute(_environment).FullPath);
}
// Ignore failed sources?
if (settings.IgnoreFailedSources)
{
builder.Append("--ignore-failed-sources");
}
// Quiet?
if (settings.Quiet)
{
builder.Append("--quiet");
}
// Parallel?
if (settings.Parallel)
{
builder.Append("--parallel");
}
// Locked?
if (settings.Locked.HasValue)
{
switch (settings.Locked)
{
case DNULocked.Lock:
builder.Append("--lock");
break;
case DNULocked.Unlock:
builder.Append("--unlock");
break;
}
}
// List of runtime identifiers
if (settings.Runtimes != null && settings.Runtimes.Count > 0)
{
foreach (var runtime in settings.Runtimes)
{
builder.Append("--runtime");
builder.AppendQuoted(runtime);
}
}
return(builder);
}
/// <summary>
/// Appends the specified text to the argument builder.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="text">The text to be appended.</param>
/// <param name="renderer">The renderer which handles quoting and escaping.</param>
/// <returns>The same <see cref="ProcessArgumentBuilder"/> instance so that multiple calls can be chained.</returns>
public static ProcessArgumentBuilder Append(this ProcessArgumentBuilder builder, string text, IProcessArgumentRenderer renderer)
{
builder?.Append(new TextArgument(text, renderer));
return(builder);
}
private ProcessArgumentBuilder GetInstallArguments(TopshelfSettings settings)
{
ProcessArgumentBuilder builder = new ProcessArgumentBuilder();
if ((settings != null) && (settings.Arguments != null))
{
builder = settings.Arguments;
}
builder.Append(new TextArgument("install"));
if (settings != null)
{
if (!string.IsNullOrWhiteSpace(settings.Username))
{
builder.Append(new TextArgument("-username"));
builder.Append(new QuotedArgument(new TextArgument(settings.Username)));
}
if (!string.IsNullOrWhiteSpace(settings.Password))
{
builder.Append(new TextArgument("-password"));
builder.Append(new QuotedArgument(new TextArgument(settings.Password)));
}
if (!string.IsNullOrWhiteSpace(settings.Instance))
{
builder.Append(new TextArgument("-instance"));
builder.Append(new QuotedArgument(new TextArgument(settings.Instance)));
}
builder.Append(settings.Autostart
? new TextArgument("--autostart")
: new TextArgument("--manual"));
if (settings.Disabled)
builder.Append(new TextArgument("--disabled"));
if (settings.Delayed)
builder.Append(new TextArgument("--delayed"));
if (settings.LocalSystem)
builder.Append(new TextArgument("--localsystem"));
if (settings.LocalService)
builder.Append(new TextArgument("--localservice"));
if (settings.NetworkService)
builder.Append(new TextArgument("--networkservice"));
if (!string.IsNullOrWhiteSpace(settings.ServiceName))
{
builder.Append(new TextArgument("--servicename"));
builder.Append(new QuotedArgument(new TextArgument(settings.Description)));
}
if (!string.IsNullOrWhiteSpace(settings.Description))
{
builder.Append(new TextArgument("--description"));
builder.Append(new QuotedArgument(new TextArgument(settings.Description)));
}
if (!string.IsNullOrWhiteSpace(settings.DisplayName))
{
builder.Append(new TextArgument("--displayname"));
builder.Append(new QuotedArgument(new TextArgument(settings.DisplayName)));
}
}
return builder;
}
