| public AddAssemblyInfoFileName ( string fileName ) : void | ||
| fileName | string | |
| return | void | |
public Arguments ParseArguments(string[] commandLineArguments)
{
if (commandLineArguments.Length == 0)
{
return(new Arguments
{
TargetPath = System.Environment.CurrentDirectory,
});
}
var firstArgument = commandLineArguments.First();
if (firstArgument.IsHelp())
{
return(new Arguments
{
IsHelp = true,
});
}
if (firstArgument.IsInit())
{
return(new Arguments
{
TargetPath = System.Environment.CurrentDirectory,
Init = true,
});
}
var arguments = new Arguments();
AddAuthentication(arguments);
var switchesAndValues = CollectSwitchesAndValuesFromArguments(commandLineArguments, out var firstArgumentIsSwitch);
for (var i = 0; i < switchesAndValues.AllKeys.Length; i++)
{
var name = switchesAndValues.AllKeys[i];
var values = switchesAndValues.GetValues(name);
var value = values?.FirstOrDefault();
if (name.IsSwitch("version"))
{
EnsureArgumentValueCount(values);
arguments.IsVersion = true;
continue;
}
if (name.IsSwitch("l"))
{
EnsureArgumentValueCount(values);
arguments.LogFilePath = value;
continue;
}
if (name.IsSwitch("config"))
{
EnsureArgumentValueCount(values);
arguments.ConfigFile = value;
continue;
}
if (name.IsSwitch("targetpath"))
{
EnsureArgumentValueCount(values);
arguments.TargetPath = value;
continue;
}
if (name.IsSwitch("dynamicRepoLocation"))
{
EnsureArgumentValueCount(values);
arguments.DynamicRepositoryLocation = value;
continue;
}
if (name.IsSwitch("url"))
{
EnsureArgumentValueCount(values);
arguments.TargetUrl = value;
continue;
}
if (name.IsSwitch("b"))
{
EnsureArgumentValueCount(values);
arguments.TargetBranch = value;
continue;
}
if (name.IsSwitch("u"))
{
EnsureArgumentValueCount(values);
if (arguments.Authentication == null)
{
arguments.Authentication = new AuthenticationInfo();
}
arguments.Authentication.Username = value;
continue;
}
if (name.IsSwitch("p"))
{
EnsureArgumentValueCount(values);
if (arguments.Authentication == null)
{
arguments.Authentication = new AuthenticationInfo();
}
arguments.Authentication.Password = value;
continue;
}
if (name.IsSwitch("c"))
{
EnsureArgumentValueCount(values);
arguments.CommitId = value;
continue;
}
if (name.IsSwitch("exec"))
{
EnsureArgumentValueCount(values);
arguments.Exec = value;
continue;
}
if (name.IsSwitch("execargs"))
{
EnsureArgumentValueCount(values);
arguments.ExecArgs = value;
continue;
}
if (name.IsSwitch("proj"))
{
EnsureArgumentValueCount(values);
arguments.Proj = value;
continue;
}
if (name.IsSwitch("projargs"))
{
EnsureArgumentValueCount(values);
arguments.ProjArgs = value;
continue;
}
if (name.IsSwitch("diag"))
{
if (value == null || value.IsTrue())
{
arguments.Diag = true;
}
continue;
}
if (name.IsSwitch("updateAssemblyInfo"))
{
if (value.IsTrue())
{
arguments.UpdateAssemblyInfo = true;
}
else if (value.IsFalse())
{
arguments.UpdateAssemblyInfo = false;
}
else if (values != null && values.Length > 1)
{
arguments.UpdateAssemblyInfo = true;
foreach (var v in values)
{
arguments.AddAssemblyInfoFileName(v);
}
}
else if (!value.IsSwitchArgument())
{
arguments.UpdateAssemblyInfo = true;
arguments.AddAssemblyInfoFileName(value);
}
else
{
arguments.UpdateAssemblyInfo = true;
}
if (arguments.UpdateAssemblyInfoFileName.Count > 1 && arguments.EnsureAssemblyInfo)
{
throw new WarningException("Can't specify multiple assembly info files when using -ensureassemblyinfo switch, either use a single assembly info file or do not specify -ensureassemblyinfo and create assembly info files manually");
}
continue;
}
if (name.IsSwitch("assemblyversionformat"))
{
throw new WarningException("assemblyversionformat switch removed, use AssemblyVersioningScheme configuration value instead");
}
if (name.IsSwitch("v") || name.IsSwitch("showvariable"))
{
string versionVariable = null;
if (!string.IsNullOrWhiteSpace(value))
{
versionVariable = VersionVariables.AvailableVariables.SingleOrDefault(av => av.Equals(value.Replace("'", ""), StringComparison.CurrentCultureIgnoreCase));
}
if (versionVariable == null)
{
var messageFormat = "{0} requires a valid version variable. Available variables are:\n{1}";
var message = string.Format(messageFormat, name, string.Join(", ", VersionVariables.AvailableVariables.Select(x => string.Concat("'", x, "'"))));
throw new WarningException(message);
}
arguments.ShowVariable = versionVariable;
continue;
}
if (name.IsSwitch("showConfig"))
{
if (value.IsTrue())
{
arguments.ShowConfig = true;
}
else if (value.IsFalse())
{
arguments.UpdateAssemblyInfo = false;
}
else
{
arguments.ShowConfig = true;
}
continue;
}
if (name.IsSwitch("output"))
{
if (!Enum.TryParse(value, true, out OutputType outputType))
{
throw new WarningException($"Value '{value}' cannot be parsed as output type, please use 'json' or 'buildserver'");
}
arguments.Output = outputType;
continue;
}
if (name.IsSwitch("nofetch"))
{
arguments.NoFetch = true;
continue;
}
if (name.IsSwitch("nonormalize"))
{
arguments.NoNormalize = true;
continue;
}
if (name.IsSwitch("ensureassemblyinfo"))
{
if (value.IsTrue())
{
arguments.EnsureAssemblyInfo = true;
}
else if (value.IsFalse())
{
arguments.EnsureAssemblyInfo = false;
}
else
{
arguments.EnsureAssemblyInfo = true;
}
if (arguments.UpdateAssemblyInfoFileName.Count > 1 && arguments.EnsureAssemblyInfo)
{
throw new WarningException("Can't specify multiple assembly info files when using /ensureassemblyinfo switch, either use a single assembly info file or do not specify /ensureassemblyinfo and create assembly info files manually");
}
continue;
}
if (name.IsSwitch("overrideconfig"))
{
var keyValueOptions = (value ?? "").Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
if (keyValueOptions.Length == 0)
{
continue;
}
arguments.HasOverrideConfig = true;
arguments.OverrideConfig = new Config();
if (keyValueOptions.Length > 1)
{
throw new WarningException("Can't specify multiple /overrideconfig options: currently supported only 'tag-prefix' option");
}
// key=value
foreach (var keyValueOption in keyValueOptions)
{
var keyAndValue = keyValueOption.Split(new[] { '=' }, StringSplitOptions.RemoveEmptyEntries);
if (keyAndValue.Length != 2)
{
throw new WarningException($"Could not parse /overrideconfig option: {keyValueOption}. Ensure it is in format 'key=value'");
}
var optionKey = keyAndValue[0].ToLowerInvariant();
arguments.OverrideConfig.TagPrefix = optionKey switch
{
"tag-prefix" => keyAndValue[1],
_ => throw new WarningException($"Could not parse /overrideconfig option: {optionKey}. Currently supported only 'tag-prefix' option")
};
}
continue;
}
if (name.IsSwitch("nocache"))
{
arguments.NoCache = true;
continue;
}
if (name.IsSwitch("verbosity"))
{
// first try the old version
if (Enum.TryParse(value, true, out LogLevel logLevel))
{
arguments.Verbosity = LogExtensions.GetVerbosityForLevel(logLevel);
}
else if (!Enum.TryParse(value, true, out arguments.Verbosity))
{
throw new WarningException($"Could not parse Verbosity value '{value}'");
}
continue;
}
if (name.IsSwitch("updatewixversionfile"))
{
arguments.UpdateWixVersionFile = true;
continue;
}
var couldNotParseMessage = $"Could not parse command line parameter '{name}'.";
// If we've reached through all argument switches without a match, we can relatively safely assume that the first argument isn't a switch, but the target path.
if (i == 0)
{
if (name.StartsWith("/"))
{
if (Path.DirectorySeparatorChar == '/' && name.IsValidPath())
{
arguments.TargetPath = name;
continue;
}
}
else if (!name.IsSwitchArgument())
{
arguments.TargetPath = name;
continue;
}
couldNotParseMessage += " If it is the target path, make sure it exists.";
}
throw new WarningException(couldNotParseMessage);
}
if (arguments.TargetPath == null)
{
// If the first argument is a switch, it should already have been consumed in the above loop,
// or else a WarningException should have been thrown and we wouldn't end up here.
arguments.TargetPath = firstArgumentIsSwitch
? System.Environment.CurrentDirectory
: firstArgument;
}
return(arguments);
}
public static Arguments ParseArguments(List<string> commandLineArguments)
{
if (commandLineArguments.Count == 0)
{
return new Arguments
{
TargetPath = Environment.CurrentDirectory
};
}
var firstArgument = commandLineArguments.First();
if (firstArgument.IsHelp())
{
return new Arguments
{
IsHelp = true
};
}
if (firstArgument.IsInit())
{
return new Arguments
{
TargetPath = Environment.CurrentDirectory,
Init = true
};
}
var arguments = new Arguments();
bool firstArgumentIsSwitch;
var switchesAndValues = CollectSwitchesAndValuesFromArguments(commandLineArguments, out firstArgumentIsSwitch);
for (var i = 0; i < switchesAndValues.AllKeys.Length; i++)
{
var name = switchesAndValues.AllKeys[i];
var values = switchesAndValues.GetValues(name);
var value = values != null ? values.FirstOrDefault() : null;
if (name.IsSwitch("l"))
{
EnsureArgumentValueCount(values);
arguments.LogFilePath = value;
continue;
}
if (name.IsSwitch("targetpath"))
{
EnsureArgumentValueCount(values);
arguments.TargetPath = value;
continue;
}
if (name.IsSwitch("dynamicRepoLocation"))
{
EnsureArgumentValueCount(values);
arguments.DynamicRepositoryLocation = value;
continue;
}
if (name.IsSwitch("url"))
{
EnsureArgumentValueCount(values);
arguments.TargetUrl = value;
continue;
}
if (name.IsSwitch("b"))
{
EnsureArgumentValueCount(values);
arguments.TargetBranch = value;
continue;
}
if (name.IsSwitch("u"))
{
EnsureArgumentValueCount(values);
arguments.Authentication.Username = value;
continue;
}
if (name.IsSwitch("p"))
{
EnsureArgumentValueCount(values);
arguments.Authentication.Password = value;
continue;
}
if (name.IsSwitch("c"))
{
EnsureArgumentValueCount(values);
arguments.CommitId = value;
continue;
}
if (name.IsSwitch("exec"))
{
EnsureArgumentValueCount(values);
arguments.Exec = value;
continue;
}
if (name.IsSwitch("execargs"))
{
EnsureArgumentValueCount(values);
arguments.ExecArgs = value;
continue;
}
if (name.IsSwitch("proj"))
{
EnsureArgumentValueCount(values);
arguments.Proj = value;
continue;
}
if (name.IsSwitch("projargs"))
{
EnsureArgumentValueCount(values);
arguments.ProjArgs = value;
continue;
}
if (name.IsSwitch("updateAssemblyInfo"))
{
if (value.IsTrue())
{
arguments.UpdateAssemblyInfo = true;
}
else if (value.IsFalse())
{
arguments.UpdateAssemblyInfo = false;
}
else if (values != null && values.Length > 1)
{
arguments.UpdateAssemblyInfo = true;
foreach (var v in values)
{
arguments.AddAssemblyInfoFileName(v);
}
}
else if (!value.IsSwitchArgument())
{
arguments.UpdateAssemblyInfo = true;
arguments.AddAssemblyInfoFileName(value);
}
else
{
arguments.UpdateAssemblyInfo = true;
}
if (arguments.UpdateAssemblyInfoFileName.Count > 1 && arguments.EnsureAssemblyInfo)
{
throw new WarningException("Can't specify multiple assembly info files when using -ensureassemblyinfo switch, either use a single assembly info file or do not specify -ensureassemblyinfo and create assembly info files manually");
}
continue;
}
if (name.IsSwitch("assemblyversionformat"))
{
throw new WarningException("assemblyversionformat switch removed, use AssemblyVersioningScheme configuration value instead");
}
if (name.IsSwitch("v") || name.IsSwitch("showvariable"))
{
string versionVariable = null;
if (!string.IsNullOrWhiteSpace(value))
{
versionVariable = VersionVariables.AvailableVariables.SingleOrDefault(av => av.Equals(value.Replace("'", ""), StringComparison.CurrentCultureIgnoreCase));
}
if (versionVariable == null)
{
var messageFormat = "{0} requires a valid version variable. Available variables are:\n{1}";
var message = string.Format(messageFormat, name, String.Join(", ", VersionVariables.AvailableVariables.Select(x => string.Concat("'", x, "'"))));
throw new WarningException(message);
}
arguments.ShowVariable = versionVariable;
continue;
}
if (name.IsSwitch("showConfig"))
{
if (value.IsTrue())
{
arguments.ShowConfig = true;
}
else if (value.IsFalse())
{
arguments.UpdateAssemblyInfo = false;
}
else
{
arguments.ShowConfig = true;
}
continue;
}
if (name.IsSwitch("output"))
{
OutputType outputType;
if (!Enum.TryParse(value, true, out outputType))
{
throw new WarningException(string.Format("Value '{0}' cannot be parsed as output type, please use 'json' or 'buildserver'", value));
}
arguments.Output = outputType;
continue;
}
if (name.IsSwitch("nofetch"))
{
arguments.NoFetch = true;
continue;
}
if (name.IsSwitch("ensureassemblyinfo"))
{
if (value.IsTrue())
{
arguments.EnsureAssemblyInfo = true;
}
else if (value.IsFalse())
{
arguments.EnsureAssemblyInfo = false;
}
else
{
arguments.EnsureAssemblyInfo = true;
}
if (arguments.UpdateAssemblyInfoFileName.Count > 1 && arguments.EnsureAssemblyInfo)
{
throw new WarningException("Can't specify multiple assembly info files when using -ensureassemblyinfo switch, either use a single assembly info file or do not specify -ensureassemblyinfo and create assembly info files manually");
}
continue;
}
if (name.IsSwitch("overrideconfig"))
{
foreach (var item in value.Split(';'))
{
var configOverride = item.Split('=');
switch (configOverride[0])
{
case "tag-prefix":
if (1 < configOverride.Length)
{
arguments.OverrideConfig.TagPrefix = configOverride[1];
}
break;
}
}
continue;
}
var couldNotParseMessage = string.Format("Could not parse command line parameter '{0}'.", name);
// If we've reached through all argument switches without a match, we can relatively safely assume that the first argument isn't a switch, but the target path.
if (i == 0)
{
if (name.StartsWith("/"))
{
if (Path.DirectorySeparatorChar == '/' && name.IsValidPath())
{
arguments.TargetPath = name;
continue;
}
}
else if (!name.IsSwitchArgument())
{
arguments.TargetPath = name;
continue;
}
couldNotParseMessage += " If it is the target path, make sure it exists.";
}
throw new WarningException(couldNotParseMessage);
}
if (arguments.TargetPath == null)
{
// If the first argument is a switch, it should already have been consumed in the above loop,
// or else a WarningException should have been thrown and we wouldn't end up here.
arguments.TargetPath = firstArgumentIsSwitch
? Environment.CurrentDirectory
: firstArgument;
}
return arguments;
}
public static Arguments ParseArguments(List <string> commandLineArguments)
{
if (commandLineArguments.Count == 0)
{
return(new Arguments
{
TargetPath = Environment.CurrentDirectory
});
}
var firstArgument = commandLineArguments.First();
if (IsHelp(firstArgument))
{
return(new Arguments
{
IsHelp = true
});
}
if (IsInit(firstArgument))
{
return(new Arguments
{
TargetPath = Environment.CurrentDirectory,
Init = true
});
}
if (commandLineArguments.Count == 1 && !(commandLineArguments[0].StartsWith("-") ||
(commandLineArguments[0].StartsWith("/") && Path.DirectorySeparatorChar != '/')))
{
return(new Arguments
{
TargetPath = firstArgument
});
}
List <string> namedArguments;
var arguments = new Arguments();
if (firstArgument.StartsWith("-") || (firstArgument.StartsWith("/") && Path.DirectorySeparatorChar != '/'))
{
arguments.TargetPath = Environment.CurrentDirectory;
namedArguments = commandLineArguments;
}
else
{
arguments.TargetPath = firstArgument;
namedArguments = commandLineArguments.Skip(1).ToList();
}
var args = CollectSwitchesAndValuesFromArguments(namedArguments);
foreach (var name in args.AllKeys)
{
var values = args.GetValues(name);
string value = null;
if (values != null)
{
//Currently, no arguments use more than one value, so having multiple values is an input error.
//In the future, this exception can be removed to support multiple values for a switch.
// if (values.Length > 1) throw new WarningException(string.Format("Could not parse command line parameter '{0}'.", values[1]));
value = values.FirstOrDefault();
}
if (IsSwitch("l", name))
{
EnsureArgumentValueCount(values);
arguments.LogFilePath = value;
continue;
}
if (IsSwitch("targetpath", name))
{
EnsureArgumentValueCount(values);
arguments.TargetPath = value;
continue;
}
if (IsSwitch("dynamicRepoLocation", name))
{
EnsureArgumentValueCount(values);
arguments.DynamicRepositoryLocation = value;
continue;
}
if (IsSwitch("url", name))
{
EnsureArgumentValueCount(values);
arguments.TargetUrl = value;
continue;
}
if (IsSwitch("b", name))
{
EnsureArgumentValueCount(values);
arguments.TargetBranch = value;
continue;
}
if (IsSwitch("u", name))
{
EnsureArgumentValueCount(values);
arguments.Authentication.Username = value;
continue;
}
if (IsSwitch("p", name))
{
EnsureArgumentValueCount(values);
arguments.Authentication.Password = value;
continue;
}
if (IsSwitch("c", name))
{
EnsureArgumentValueCount(values);
arguments.CommitId = value;
continue;
}
if (IsSwitch("exec", name))
{
EnsureArgumentValueCount(values);
arguments.Exec = value;
continue;
}
if (IsSwitch("execargs", name))
{
EnsureArgumentValueCount(values);
arguments.ExecArgs = value;
continue;
}
if (IsSwitch("proj", name))
{
EnsureArgumentValueCount(values);
arguments.Proj = value;
continue;
}
if (IsSwitch("projargs", name))
{
EnsureArgumentValueCount(values);
arguments.ProjArgs = value;
continue;
}
if (IsSwitch("updateAssemblyInfo", name))
{
if (new[] { "1", "true" }.Contains(value, StringComparer.OrdinalIgnoreCase))
{
arguments.UpdateAssemblyInfo = true;
}
else if (new[] { "0", "false" }.Contains(value, StringComparer.OrdinalIgnoreCase))
{
arguments.UpdateAssemblyInfo = false;
}
else if (values != null && values.Length > 1)
{
arguments.UpdateAssemblyInfo = true;
foreach (var v in values)
{
arguments.AddAssemblyInfoFileName(v);
}
}
else if (!IsSwitchArgument(value))
{
arguments.UpdateAssemblyInfo = true;
arguments.AddAssemblyInfoFileName(value);
}
else
{
arguments.UpdateAssemblyInfo = true;
}
if (arguments.UpdateAssemblyInfoFileName.Count > 1 && arguments.EnsureAssemblyInfo)
{
throw new WarningException("Can't specify multiple assembly info files when using -ensureassemblyinfo switch, either use a single assembly info file or do not specify -ensureassemblyinfo and create assembly info files manually");
}
continue;
}
if (IsSwitch("assemblyversionformat", name))
{
throw new WarningException("assemblyversionformat switch removed, use AssemblyVersioningScheme configuration value instead");
}
if (IsSwitch("v", name) || IsSwitch("showvariable", name))
{
string versionVariable = null;
if (!string.IsNullOrWhiteSpace(value))
{
versionVariable = VersionVariables.AvailableVariables.SingleOrDefault(av => av.Equals(value.Replace("'", ""), StringComparison.CurrentCultureIgnoreCase));
}
if (versionVariable == null)
{
var messageFormat = "{0} requires a valid version variable. Available variables are:\n{1}";
var message = string.Format(messageFormat, name, String.Join(", ", VersionVariables.AvailableVariables.Select(x => string.Concat("'", x, "'"))));
throw new WarningException(message);
}
arguments.ShowVariable = versionVariable;
continue;
}
if (IsSwitch("showConfig", name))
{
if (new[] { "1", "true" }.Contains(value, StringComparer.OrdinalIgnoreCase))
{
arguments.ShowConfig = true;
}
else if (new[] { "0", "false" }.Contains(value, StringComparer.OrdinalIgnoreCase))
{
arguments.UpdateAssemblyInfo = false;
}
else
{
arguments.ShowConfig = true;
}
continue;
}
if (IsSwitch("output", name))
{
OutputType outputType;
if (!Enum.TryParse(value, true, out outputType))
{
throw new WarningException(string.Format("Value '{0}' cannot be parsed as output type, please use 'json' or 'buildserver'", value));
}
arguments.Output = outputType;
continue;
}
if (IsSwitch("nofetch", name))
{
arguments.NoFetch = true;
continue;
}
if (IsSwitch("ensureassemblyinfo", name))
{
if (new[] { "1", "true" }.Contains(value, StringComparer.OrdinalIgnoreCase))
{
arguments.EnsureAssemblyInfo = true;
}
else if (new[] { "0", "false" }.Contains(value, StringComparer.OrdinalIgnoreCase))
{
arguments.EnsureAssemblyInfo = false;
}
else
{
arguments.EnsureAssemblyInfo = true;
}
if (arguments.UpdateAssemblyInfoFileName.Count > 1 && arguments.EnsureAssemblyInfo)
{
throw new WarningException("Can't specify multiple assembly info files when using -ensureassemblyinfo switch, either use a single assembly info file or do not specify -ensureassemblyinfo and create assembly info files manually");
}
continue;
}
if (IsSwitch("overrideconfig", name))
{
foreach (var item in value.Split(';'))
{
var configOverride = item.Split('=');
switch (configOverride[0])
{
case "tag-prefix":
if (1 < configOverride.Length)
{
arguments.OverrideConfig.TagPrefix = configOverride[1];
}
break;
}
}
continue;
}
throw new WarningException(string.Format("Could not parse command line parameter '{0}'.", name));
}
return(arguments);
}
public static Arguments ParseArguments(List <string> commandLineArguments)
{
if (commandLineArguments.Count == 0)
{
return(new Arguments
{
TargetPath = Environment.CurrentDirectory
});
}
var firstArgument = commandLineArguments.First();
if (firstArgument.IsHelp())
{
return(new Arguments
{
IsHelp = true
});
}
if (firstArgument.IsInit())
{
return(new Arguments
{
TargetPath = Environment.CurrentDirectory,
Init = true
});
}
var arguments = new Arguments();
bool firstArgumentIsSwitch;
var switchesAndValues = CollectSwitchesAndValuesFromArguments(commandLineArguments, out firstArgumentIsSwitch);
for (var i = 0; i < switchesAndValues.AllKeys.Length; i++)
{
var name = switchesAndValues.AllKeys[i];
var values = switchesAndValues.GetValues(name);
var value = values != null?values.FirstOrDefault() : null;
if (name.IsSwitch("l"))
{
EnsureArgumentValueCount(values);
arguments.LogFilePath = value;
continue;
}
if (name.IsSwitch("targetpath"))
{
EnsureArgumentValueCount(values);
arguments.TargetPath = value;
continue;
}
if (name.IsSwitch("dynamicRepoLocation"))
{
EnsureArgumentValueCount(values);
arguments.DynamicRepositoryLocation = value;
continue;
}
if (name.IsSwitch("url"))
{
EnsureArgumentValueCount(values);
arguments.TargetUrl = value;
continue;
}
if (name.IsSwitch("b"))
{
EnsureArgumentValueCount(values);
arguments.TargetBranch = value;
continue;
}
if (name.IsSwitch("u"))
{
EnsureArgumentValueCount(values);
arguments.Authentication.Username = value;
continue;
}
if (name.IsSwitch("p"))
{
EnsureArgumentValueCount(values);
arguments.Authentication.Password = value;
continue;
}
if (name.IsSwitch("c"))
{
EnsureArgumentValueCount(values);
arguments.CommitId = value;
continue;
}
if (name.IsSwitch("exec"))
{
EnsureArgumentValueCount(values);
arguments.Exec = value;
continue;
}
if (name.IsSwitch("execargs"))
{
EnsureArgumentValueCount(values);
arguments.ExecArgs = value;
continue;
}
if (name.IsSwitch("proj"))
{
EnsureArgumentValueCount(values);
arguments.Proj = value;
continue;
}
if (name.IsSwitch("projargs"))
{
EnsureArgumentValueCount(values);
arguments.ProjArgs = value;
continue;
}
if (name.IsSwitch("updateAssemblyInfo"))
{
if (value.IsTrue())
{
arguments.UpdateAssemblyInfo = true;
}
else if (value.IsFalse())
{
arguments.UpdateAssemblyInfo = false;
}
else if (values != null && values.Length > 1)
{
arguments.UpdateAssemblyInfo = true;
foreach (var v in values)
{
arguments.AddAssemblyInfoFileName(v);
}
}
else if (!value.IsSwitchArgument())
{
arguments.UpdateAssemblyInfo = true;
arguments.AddAssemblyInfoFileName(value);
}
else
{
arguments.UpdateAssemblyInfo = true;
}
if (arguments.UpdateAssemblyInfoFileName.Count > 1 && arguments.EnsureAssemblyInfo)
{
throw new WarningException("Can't specify multiple assembly info files when using -ensureassemblyinfo switch, either use a single assembly info file or do not specify -ensureassemblyinfo and create assembly info files manually");
}
continue;
}
if (name.IsSwitch("assemblyversionformat"))
{
throw new WarningException("assemblyversionformat switch removed, use AssemblyVersioningScheme configuration value instead");
}
if (name.IsSwitch("v") || name.IsSwitch("showvariable"))
{
string versionVariable = null;
if (!string.IsNullOrWhiteSpace(value))
{
versionVariable = VersionVariables.AvailableVariables.SingleOrDefault(av => av.Equals(value.Replace("'", ""), StringComparison.CurrentCultureIgnoreCase));
}
if (versionVariable == null)
{
var messageFormat = "{0} requires a valid version variable. Available variables are:\n{1}";
var message = string.Format(messageFormat, name, String.Join(", ", VersionVariables.AvailableVariables.Select(x => string.Concat("'", x, "'"))));
throw new WarningException(message);
}
arguments.ShowVariable = versionVariable;
continue;
}
if (name.IsSwitch("showConfig"))
{
if (value.IsTrue())
{
arguments.ShowConfig = true;
}
else if (value.IsFalse())
{
arguments.UpdateAssemblyInfo = false;
}
else
{
arguments.ShowConfig = true;
}
continue;
}
if (name.IsSwitch("output"))
{
OutputType outputType;
if (!Enum.TryParse(value, true, out outputType))
{
throw new WarningException(string.Format("Value '{0}' cannot be parsed as output type, please use 'json' or 'buildserver'", value));
}
arguments.Output = outputType;
continue;
}
if (name.IsSwitch("nofetch"))
{
arguments.NoFetch = true;
continue;
}
if (name.IsSwitch("ensureassemblyinfo"))
{
if (value.IsTrue())
{
arguments.EnsureAssemblyInfo = true;
}
else if (value.IsFalse())
{
arguments.EnsureAssemblyInfo = false;
}
else
{
arguments.EnsureAssemblyInfo = true;
}
if (arguments.UpdateAssemblyInfoFileName.Count > 1 && arguments.EnsureAssemblyInfo)
{
throw new WarningException("Can't specify multiple assembly info files when using -ensureassemblyinfo switch, either use a single assembly info file or do not specify -ensureassemblyinfo and create assembly info files manually");
}
continue;
}
if (name.IsSwitch("overrideconfig"))
{
foreach (var item in value.Split(';'))
{
var configOverride = item.Split('=');
switch (configOverride[0])
{
case "tag-prefix":
if (1 < configOverride.Length)
{
arguments.OverrideConfig.TagPrefix = configOverride[1];
}
break;
}
}
continue;
}
var couldNotParseMessage = string.Format("Could not parse command line parameter '{0}'.", name);
// If we've reached through all argument switches without a match, we can relatively safely assume that the first argument isn't a switch, but the target path.
if (i == 0)
{
if (name.StartsWith("/"))
{
if (Path.DirectorySeparatorChar == '/' && name.IsValidPath())
{
arguments.TargetPath = name;
continue;
}
}
else if (!name.IsSwitchArgument())
{
arguments.TargetPath = name;
continue;
}
couldNotParseMessage += " If it is the target path, make sure it exists.";
}
throw new WarningException(couldNotParseMessage);
}
if (arguments.TargetPath == null)
{
// If the first argument is a switch, it should already have been consumed in the above loop,
// or else a WarningException should have been thrown and we wouldn't end up here.
arguments.TargetPath = firstArgumentIsSwitch
? Environment.CurrentDirectory
: firstArgument;
}
return(arguments);
}
public static Arguments ParseArguments(List<string> commandLineArguments)
{
if (commandLineArguments.Count == 0)
{
return new Arguments
{
TargetPath = Environment.CurrentDirectory
};
}
var firstArgument = commandLineArguments.First();
if (IsHelp(firstArgument))
{
return new Arguments
{
IsHelp = true
};
}
if (IsInit(firstArgument))
{
return new Arguments
{
TargetPath = Environment.CurrentDirectory,
Init = true
};
}
if (commandLineArguments.Count == 1 && !(commandLineArguments[0].StartsWith("-") ||
(commandLineArguments[0].StartsWith("/") && Path.DirectorySeparatorChar != '/')))
{
return new Arguments
{
TargetPath = firstArgument
};
}
List<string> namedArguments;
var arguments = new Arguments();
if (firstArgument.StartsWith("-") || (firstArgument.StartsWith("/") && Path.DirectorySeparatorChar != '/'))
{
arguments.TargetPath = Environment.CurrentDirectory;
namedArguments = commandLineArguments;
}
else
{
arguments.TargetPath = firstArgument;
namedArguments = commandLineArguments.Skip(1).ToList();
}
var args = CollectSwitchesAndValuesFromArguments(namedArguments);
foreach (var name in args.AllKeys)
{
var values = args.GetValues(name);
string value = null;
if (values != null)
{
//Currently, no arguments use more than one value, so having multiple values is an input error.
//In the future, this exception can be removed to support multiple values for a switch.
// if (values.Length > 1) throw new WarningException(string.Format("Could not parse command line parameter '{0}'.", values[1]));
value = values.FirstOrDefault();
}
if (IsSwitch("l", name))
{
EnsureArgumentValueCount(values);
arguments.LogFilePath = value;
continue;
}
if (IsSwitch("targetpath", name))
{
EnsureArgumentValueCount(values);
arguments.TargetPath = value;
continue;
}
if (IsSwitch("dynamicRepoLocation", name))
{
EnsureArgumentValueCount(values);
arguments.DynamicRepositoryLocation = value;
continue;
}
if (IsSwitch("url", name))
{
EnsureArgumentValueCount(values);
arguments.TargetUrl = value;
continue;
}
if (IsSwitch("b", name))
{
EnsureArgumentValueCount(values);
arguments.TargetBranch = value;
continue;
}
if (IsSwitch("u", name))
{
EnsureArgumentValueCount(values);
arguments.Authentication.Username = value;
continue;
}
if (IsSwitch("p", name))
{
EnsureArgumentValueCount(values);
arguments.Authentication.Password = value;
continue;
}
if (IsSwitch("c", name))
{
EnsureArgumentValueCount(values);
arguments.CommitId = value;
continue;
}
if (IsSwitch("exec", name))
{
EnsureArgumentValueCount(values);
arguments.Exec = value;
continue;
}
if (IsSwitch("execargs", name))
{
EnsureArgumentValueCount(values);
arguments.ExecArgs = value;
continue;
}
if (IsSwitch("proj", name))
{
EnsureArgumentValueCount(values);
arguments.Proj = value;
continue;
}
if (IsSwitch("projargs", name))
{
EnsureArgumentValueCount(values);
arguments.ProjArgs = value;
continue;
}
if (IsSwitch("updateAssemblyInfo", name))
{
if (new[] { "1", "true" }.Contains(value, StringComparer.OrdinalIgnoreCase))
{
arguments.UpdateAssemblyInfo = true;
}
else if (new[] { "0", "false" }.Contains(value, StringComparer.OrdinalIgnoreCase))
{
arguments.UpdateAssemblyInfo = false;
}
else if (values != null && values.Length > 1)
{
arguments.UpdateAssemblyInfo = true;
foreach(var v in values) arguments.AddAssemblyInfoFileName(v);
}
else if (!IsSwitchArgument(value))
{
arguments.UpdateAssemblyInfo = true;
arguments.AddAssemblyInfoFileName(value);
}
else
{
arguments.UpdateAssemblyInfo = true;
}
if (arguments.UpdateAssemblyInfoFileName.Count > 1 && arguments.EnsureAssemblyInfo)
{
throw new WarningException("Can't specify multiple assembly info files when using -ensureassemblyinfo switch, either use a single assembly info file or do not specify -ensureassemblyinfo and create assembly info files manually");
}
continue;
}
if (IsSwitch("assemblyversionformat", name))
{
throw new WarningException("assemblyversionformat switch removed, use AssemblyVersioningScheme configuration value instead");
}
if (IsSwitch("v", name) || IsSwitch("showvariable", name))
{
string versionVariable = null;
if (!string.IsNullOrWhiteSpace(value))
{
versionVariable = VersionVariables.AvailableVariables.SingleOrDefault(av => av.Equals(value.Replace("'", ""), StringComparison.CurrentCultureIgnoreCase));
}
if (versionVariable == null)
{
var messageFormat = "{0} requires a valid version variable. Available variables are:\n{1}";
var message = string.Format(messageFormat, name, String.Join(", ", VersionVariables.AvailableVariables.Select(x => string.Concat("'", x, "'"))));
throw new WarningException(message);
}
arguments.ShowVariable = versionVariable;
continue;
}
if (IsSwitch("showConfig", name))
{
if (new[] { "1", "true" }.Contains(value, StringComparer.OrdinalIgnoreCase))
{
arguments.ShowConfig = true;
}
else if (new[] { "0", "false" }.Contains(value, StringComparer.OrdinalIgnoreCase))
{
arguments.UpdateAssemblyInfo = false;
}
else
{
arguments.ShowConfig = true;
}
continue;
}
if (IsSwitch("output", name))
{
OutputType outputType;
if (!Enum.TryParse(value, true, out outputType))
{
throw new WarningException(string.Format("Value '{0}' cannot be parsed as output type, please use 'json' or 'buildserver'", value));
}
arguments.Output = outputType;
continue;
}
if (IsSwitch("nofetch", name))
{
arguments.NoFetch = true;
continue;
}
if (IsSwitch("ensureassemblyinfo", name))
{
if (new[] { "1", "true" }.Contains(value, StringComparer.OrdinalIgnoreCase))
{
arguments.EnsureAssemblyInfo = true;
}
else if (new[] { "0", "false" }.Contains(value, StringComparer.OrdinalIgnoreCase))
{
arguments.EnsureAssemblyInfo = false;
}
else
{
arguments.EnsureAssemblyInfo = true;
}
if (arguments.UpdateAssemblyInfoFileName.Count > 1 && arguments.EnsureAssemblyInfo)
{
throw new WarningException("Can't specify multiple assembly info files when using -ensureassemblyinfo switch, either use a single assembly info file or do not specify -ensureassemblyinfo and create assembly info files manually");
}
continue;
}
if (IsSwitch("overrideconfig", name))
{
foreach (var item in value.Split(';'))
{
var configOverride = item.Split('=');
switch (configOverride[0])
{
case "tag-prefix":
if (1 < configOverride.Length)
{
arguments.OverrideConfig.TagPrefix = configOverride[1];
}
break;
}
}
continue;
}
throw new WarningException(string.Format("Could not parse command line parameter '{0}'.", name));
}
return arguments;
}
