public string MergeTemplates(VersionParts incoming, VersionParts existing) { string result = ""; for (int i = 0; i < 4; i++) { //SafeLog("StampAssemblies: incoming[{0}]={1}", i, incoming.parts[i]); //SafeLog("StampAssemblies: existing[{0}]={1}", i, existing.parts[i]); if (incoming.parts[i] != "*") { result += incoming.parts[i] + "."; } else { if (existing.parts[i] == "*") { //SafeLog("StampAssemblies: existing.parts[i] == '*'"); result += "0."; } else { result += existing.parts[i] + "."; } } } return(result.TrimEnd(new char[] { '.' })); }
private string ExpandTemplate(string regexTemplate, string replaceTemplate, string whichVersion, string contents, VersionParts incomingVersion, VersionFormat format = VersionFormat.File) { try { var regex = new Regex(string.Format(regexTemplate, whichVersion)); var result = regex.Match(contents); if (result == Match.Empty) { return(contents); } var versionTemplateInFile = ParseVersionString(result.Groups[1].Value, format); var newVersion = MergeTemplates(incomingVersion, versionTemplateInFile); SafeLog("StampAssemblies: Merging existing {0} with incoming {1} to produce {2}.", versionTemplateInFile.ToString(), incomingVersion.ToString(), newVersion); return(regex.Replace(contents, string.Format(replaceTemplate, whichVersion, newVersion))); } catch (Exception e) { Log.LogError("Could not parse the {0} attribute, which should be something like 0.7.*.* or 1.0.0.0", whichVersion); Log.LogErrorFromException(e); throw; } }
public string GetModifiedContents(string contents, string incomingVersion, string incomingFileVersion) { var versionTemplateInFile = GetExistingAssemblyVersion(contents); var fileVersionTemplateInFile = GetExistingAssemblyFileVersion(contents); var versionTemplateInBuildScript = ParseVersionString(incomingVersion); VersionParts fileVersionTemplateInScript = null; fileVersionTemplateInScript = incomingFileVersion != null?ParseVersionString(incomingFileVersion) : versionTemplateInBuildScript; var newVersion = MergeTemplates(versionTemplateInBuildScript, versionTemplateInFile); var newFileVersion = MergeTemplates(fileVersionTemplateInScript, fileVersionTemplateInFile); SafeLog("StampAssemblies: Merging existing {0} with incoming {1} to produce {2}.", versionTemplateInFile.ToString(), incomingVersion, newVersion); SafeLog("StampAssemblies: Merging existing {0} with incoming {1} to produce {2}.", fileVersionTemplateInFile.ToString(), incomingFileVersion, newFileVersion); var replacement = string.Format( "[assembly: AssemblyVersion(\"{0}\")]", newVersion); contents = Regex.Replace(contents, @"\[assembly: AssemblyVersion\("".*""\)\]", replacement); replacement = string.Format( "[assembly: AssemblyFileVersion(\"{0}\")]", newFileVersion); contents = Regex.Replace(contents, @"\[assembly: AssemblyFileVersion\("".*""\)\]", replacement); return(contents); }
private string ModifyCodeAttributes(string contents, VersionParts version, VersionParts fileVersion, VersionParts infoVersion) { const string regexTemplate = @"\[assembly\: {0}\(""(.+)"""; const string replaceTemplate = @"[assembly: {0}(""{1}"""; contents = ExpandTemplate(regexTemplate, replaceTemplate, "AssemblyVersion", contents, version); contents = ExpandTemplate(regexTemplate, replaceTemplate, "AssemblyFileVersion", contents, fileVersion); contents = ExpandTemplate(regexTemplate, replaceTemplate, "AssemblyInformationalVersion", contents, infoVersion, VersionFormat.Info); return(contents); }
private string ModifyMSBuildProps(string contents, VersionParts version, VersionParts fileVersion, VersionParts infoVersion, VersionParts packageVersion) { const string regexTemplate = "<{0}>(.+)</{0}>"; const string replaceTemplate = "<{0}>{1}</{0}>"; contents = ExpandTemplate(regexTemplate, replaceTemplate, "AssemblyVersion", contents, version); contents = ExpandTemplate(regexTemplate, replaceTemplate, "FileVersion", contents, fileVersion); contents = ExpandTemplate(regexTemplate, replaceTemplate, "InformationalVersion", contents, infoVersion, VersionFormat.Info); contents = ExpandTemplate(regexTemplate, replaceTemplate, "Version", contents, packageVersion, VersionFormat.Semantic); return(contents); }
internal string GetModifiedContents(string contents, bool isCode, string versionStr, string fileVersionStr, string packageVersionStr) { // ENHANCE: add property for InformationalVersion VersionParts version = ParseVersionString(versionStr); VersionParts fileVersion = fileVersionStr != null?ParseVersionString(fileVersionStr) : version; VersionParts infoVersion = ParseVersionString(versionStr, VersionFormat.Info); VersionParts packageVersion = packageVersionStr != null ? ParseVersionString(packageVersionStr, VersionFormat.Semantic) : version; if (isCode) { return(ModifyCodeAttributes(contents, version, fileVersion, infoVersion)); } return(ModifyMSBuildProps(contents, version, fileVersion, infoVersion, packageVersion)); }
public string MergeTemplates(VersionParts incoming, VersionParts existing) { VersionParts result = new VersionParts { parts = (string[])existing.parts.Clone(), Prerelease = incoming.Prerelease ?? existing.Prerelease }; for (int i = 0; i < result.parts.Length; i++) { if (incoming.parts[i] != "*") { result.parts[i] = incoming.parts[i]; } else if (existing.parts[i] == "*") { result.parts[i] = "0"; } } return(result.ToString()); }
public VersionParts ParseVersionString(string contents) { var result = Regex.Match(contents, @"(.+)\.(.+)\.(.+)\.(.+)"); if (!result.Success) { //handle 1.0.* (I'm not good enough with regex to //overcome greediness and get a single pattern to work for both situations). result = Regex.Match(contents, @"(.+)\.(.+)\.(\*)"); } if (!result.Success) { //handle 0.0.12 result = Regex.Match(contents, @"(.+)\.(.+)\.(.+)"); } var v = new VersionParts(); v.parts[0] = result.Groups[1].Value; v.parts[1] = result.Groups[2].Value; v.parts[2] = result.Groups[3].Value; v.parts[3] = result.Groups[4].Value; for (int i = 0; i < 4; i++) { if (string.IsNullOrEmpty(v.parts[i])) { v.parts[i] = "*"; } } //can't propogate a hash code, though it's nice (for build server display purposes) //to send it through to us. So for now, we just strip it out. if (v.parts[3].IndexOfAny(new char[] { 'a', 'b', 'c', 'd', 'e', 'f' }) > -1) { v.parts[3] = "0"; } return(v); }
public VersionParts ParseVersionString(string contents, bool allowHashAsRevision = false) { var result = Regex.Match(contents, @"(.+)\.(.+)\.(.+)\.(.+)"); if (!result.Success) { //handle 1.0.* (I'm not good enough with regex to //overcome greediness and get a single pattern to work for both situations). result = Regex.Match(contents, @"(.+)\.(.+)\.(\*)"); } if (!result.Success) { //handle 0.0.12 result = Regex.Match(contents, @"(.+)\.(.+)\.(.+)"); } var v = new VersionParts(); v.parts[0] = result.Groups[1].Value; v.parts[1] = result.Groups[2].Value; v.parts[2] = result.Groups[3].Value; v.parts[3] = result.Groups[4].Value; for (int i = 0; i < 4; i++) { if (string.IsNullOrEmpty(v.parts[i])) { v.parts[i] = "*"; } } if (!allowHashAsRevision && v.parts[3].IndexOfAny(new char[] { 'a', 'b', 'c', 'd', 'e', 'f' }) > -1) { // zero out hash code which we can't have in numeric version numbers v.parts[3] = "0"; } return(v); }
private string ExpandTemplate(string whichAttribute, string contents, VersionParts incomingVersion, bool allowHashAsRevision) { try { var regex = new Regex(string.Format(@"\[assembly\: {0}\(""(.+)""", whichAttribute)); var result = regex.Match(contents); if (result == Match.Empty) return contents; var versionTemplateInFile = ParseVersionString(result.Groups[1].Value, allowHashAsRevision); var newVersion = MergeTemplates(incomingVersion, versionTemplateInFile); SafeLog("StampAssemblies: Merging existing {0} with incoming {1} to produce {2}.", versionTemplateInFile.ToString(), incomingVersion.ToString(), newVersion); return regex.Replace(contents, string.Format(@"[assembly: {0}(""{1}""", whichAttribute, newVersion)); } catch (Exception e) { Log.LogError("Could not parse the {0} attribute, which should be something like 0.7.*.* or 1.0.0.0", whichAttribute); Log.LogErrorFromException(e); throw e; } }
public string MergeTemplates(VersionParts incoming, VersionParts existing) { string result = ""; for (int i = 0; i < 4; i++) { //SafeLog("StampAssemblies: incoming[{0}]={1}", i, incoming.parts[i]); //SafeLog("StampAssemblies: existing[{0}]={1}", i, existing.parts[i]); if(incoming.parts[i] != "*") { result += incoming.parts[i] + "."; } else { if(existing.parts[i] == "*") { //SafeLog("StampAssemblies: existing.parts[i] == '*'"); result += "0."; } else { result += existing.parts[i] + "."; } } } return result.TrimEnd(new char[] {'.'}); }
private static VersionParts ParseVersionString(string contents, VersionFormat format) { VersionParts v; if (format == VersionFormat.Semantic) { Match result = Regex.Match(contents, @"([\d\*]+)\.([\d\*]+)\.([\d\*]+)(?:\-(.*))?"); v = new VersionParts { parts = new[] { result.Groups[1].Value, result.Groups[2].Value, result.Groups[3].Value }, Prerelease = result.Groups[4].Value }; } else { Match result = Regex.Match(contents, @"(.+)\.(.+)\.(.+)\.(.+)"); if (!result.Success) { //handle 1.0.* (I'm not good enough with regex to //overcome greediness and get a single pattern to work for both situations). result = Regex.Match(contents, @"(.+)\.(.+)\.(\*)"); } if (!result.Success) { //handle 0.0.12 result = Regex.Match(contents, @"(.+)\.(.+)\.(.+)"); } v = new VersionParts { parts = new[] { result.Groups[1].Value, result.Groups[2].Value, result.Groups[3].Value, result.Groups[4].Value } }; if (format == VersionFormat.File && v.parts.Length == 4 && v.parts[3].IndexOfAny(new[] { 'a', 'b', 'c', 'd', 'e', 'f' }) != -1) { // zero out hash code which we can't have in numeric version numbers v.parts[3] = "0"; } } for (int i = 0; i < v.parts.Length; i++) { if (string.IsNullOrEmpty(v.parts[i])) { v.parts[i] = "*"; } } return(v); }
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("/"))) { return(new Arguments { TargetPath = firstArgument }); } List <string> namedArguments; var arguments = new Arguments(); if (firstArgument.StartsWith("-") || firstArgument.StartsWith("/")) { 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)) { arguments.LogFilePath = value; continue; } if (IsSwitch("targetpath", name)) { arguments.TargetPath = value; continue; } if (IsSwitch("dynamicRepoLocation", name)) { arguments.DynamicRepositoryLocation = value; continue; } if (IsSwitch("url", name)) { arguments.TargetUrl = value; continue; } if (IsSwitch("b", name)) { arguments.TargetBranch = value; continue; } if (IsSwitch("u", name)) { arguments.Authentication.Username = value; continue; } if (IsSwitch("p", name)) { arguments.Authentication.Password = value; continue; } if (IsSwitch("c", name)) { arguments.CommitId = value; continue; } if (IsSwitch("exec", name)) { arguments.Exec = value; continue; } if (IsSwitch("execargs", name)) { arguments.ExecArgs = value; continue; } if (IsSwitch("proj", name)) { arguments.Proj = value; continue; } if (IsSwitch("projargs", name)) { arguments.ProjArgs = value; continue; } if (IsSwitch("updateAssemblyInfo", name)) { if (new[] { "1", "true" }.Contains(value)) { arguments.UpdateAssemblyInfo = true; } else if (new[] { "0", "false" }.Contains(value)) { arguments.UpdateAssemblyInfo = false; } else if (!IsSwitchArgument(value)) { arguments.UpdateAssemblyInfo = true; arguments.UpdateAssemblyInfoFileName = value; } else { arguments.UpdateAssemblyInfo = true; } continue; } if (IsSwitch("assemblyversionformat", name)) { throw new WarningException("assemblyversionformat switch removed, use AssemblyVersioningScheme configuration value instead"); } if ((IsSwitch("v", name)) && VersionParts.Contains(value.ToLower())) { arguments.ShowVariable = value.ToLower(); continue; } if (IsSwitch("showConfig", name)) { if (new[] { "1", "true" }.Contains(value)) { arguments.ShowConfig = true; } else if (new[] { "0", "false" }.Contains(value)) { 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; } throw new WarningException(string.Format("Could not parse command line parameter '{0}'.", name)); } return(arguments); }
public VersionParts ParseVersionString(string contents, bool allowHashAsRevision = false) { var result = Regex.Match(contents, @"(.+)\.(.+)\.(.+)\.(.+)"); if(!result.Success) { //handle 1.0.* (I'm not good enough with regex to //overcome greediness and get a single pattern to work for both situations). result = Regex.Match(contents, @"(.+)\.(.+)\.(\*)"); } if (!result.Success) { //handle 0.0.12 result = Regex.Match(contents, @"(.+)\.(.+)\.(.+)"); } var v = new VersionParts(); v.parts[0] = result.Groups[1].Value; v.parts[1] = result.Groups[2].Value; v.parts[2] = result.Groups[3].Value; v.parts[3] = result.Groups[4].Value; for (int i = 0; i < 4; i++) { if(string.IsNullOrEmpty(v.parts[i])) { v.parts[i] = "*"; } } if(!allowHashAsRevision && v.parts[3].IndexOfAny(new char[]{'a','b','c','d','e','f'}) >-1) { // zero out hash code which we can't have in numeric version numbers v.parts[3] = "0"; } return v; }
public VersionParts ParseVersionString(string contents) { var result = Regex.Match(contents, @"(.+)\.(.+)\.(.+)\.(.+)"); if(!result.Success) { //handle 1.0.* (I'm not good enough with regex to //overcome greediness and get a single pattern to work for both situations). result = Regex.Match(contents, @"(.+)\.(.+)\.(\*)"); } if (!result.Success) { //handle 0.0.12 result = Regex.Match(contents, @"(.+)\.(.+)\.(.+)"); } var v = new VersionParts(); v.parts[0] = result.Groups[1].Value; v.parts[1] = result.Groups[2].Value; v.parts[2] = result.Groups[3].Value; v.parts[3] = result.Groups[4].Value; for (int i = 0; i < 4; i++) { if(string.IsNullOrEmpty(v.parts[i])) { v.parts[i] = "*"; } } //can't propogate a hash code, though it's nice (for build server display purposes) //to send it through to us. So for now, we just strip it out. if(v.parts[3].IndexOfAny(new char[]{'a','b','c','d','e','f'}) >-1) { v.parts[3] = "0"; } return v; }
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("/"))) { return(new Arguments { TargetPath = firstArgument }); } List <string> namedArguments; var arguments = new Arguments(); if (firstArgument.StartsWith("-") || firstArgument.StartsWith("/")) { arguments.TargetPath = Environment.CurrentDirectory; namedArguments = commandLineArguments; } else { arguments.TargetPath = firstArgument; namedArguments = commandLineArguments.Skip(1).ToList(); } for (var index = 0; index < namedArguments.Count; index = index + 2) { var name = namedArguments[index]; var value = namedArguments.Count > index + 1 ? namedArguments[index + 1] : null; if (IsSwitch("l", name)) { arguments.LogFilePath = value; continue; } if (IsSwitch("targetpath", name)) { arguments.TargetPath = value; continue; } if (IsSwitch("url", name)) { arguments.TargetUrl = value; continue; } if (IsSwitch("b", name)) { arguments.TargetBranch = value; continue; } if (IsSwitch("u", name)) { arguments.Authentication.Username = value; continue; } if (IsSwitch("p", name)) { arguments.Authentication.Password = value; continue; } if (IsSwitch("c", name)) { arguments.CommitId = value; continue; } if (IsSwitch("exec", name)) { arguments.Exec = value; continue; } if (IsSwitch("execargs", name)) { arguments.ExecArgs = value; continue; } if (IsSwitch("proj", name)) { arguments.Proj = value; continue; } if (IsSwitch("projargs", name)) { arguments.ProjArgs = value; continue; } if (IsSwitch("updateAssemblyInfo", name)) { if (new[] { "1", "true" }.Contains(value)) { arguments.UpdateAssemblyInfo = true; } else if (new[] { "0", "false" }.Contains(value)) { arguments.UpdateAssemblyInfo = false; } else if (!IsSwitchArgument(value)) { arguments.UpdateAssemblyInfo = true; arguments.UpdateAssemblyInfoFileName = value; } else { arguments.UpdateAssemblyInfo = true; index--; } continue; } if (IsSwitch("assemblyversionformat", name)) { throw new WarningException("assemblyversionformat switch removed, use AssemblyVersioningScheme configuration value instead"); } if ((IsSwitch("v", name)) && VersionParts.Contains(value.ToLower())) { arguments.ShowVariable = value.ToLower(); continue; } if (IsSwitch("showConfig", name)) { if (new[] { "1", "true" }.Contains(value)) { arguments.ShowConfig = true; } else if (new[] { "0", "false" }.Contains(value)) { arguments.UpdateAssemblyInfo = false; } else { arguments.ShowConfig = true; index--; } 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; } 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 (IsHelp(firstArgument)) { return(new Arguments { IsHelp = true }); } if (commandLineArguments.Count == 1) { return(new Arguments { TargetPath = firstArgument }); } List <string> namedArguments; var arguments = new Arguments(); if (firstArgument.StartsWith("-") || firstArgument.StartsWith("/")) { arguments.TargetPath = Environment.CurrentDirectory; namedArguments = commandLineArguments; } else { arguments.TargetPath = firstArgument; namedArguments = commandLineArguments.Skip(1).ToList(); } EnsureArgumentsEvenCount(commandLineArguments, namedArguments); for (var index = 0; index < namedArguments.Count; index = index + 2) { var name = namedArguments[index]; var value = namedArguments[index + 1]; if (IsSwitch("l", name)) { arguments.LogFilePath = value; continue; } if (IsSwitch("url", name)) { arguments.TargetUrl = value; continue; } if (IsSwitch("b", name)) { arguments.TargetBranch = value; continue; } if (IsSwitch("u", name)) { arguments.Username = value; continue; } if (IsSwitch("p", name)) { arguments.Password = value; continue; } if ((IsSwitch("v", name)) && VersionParts.Contains(value.ToLower())) { arguments.VersionPart = value.ToLower(); continue; } if (IsSwitch("output", name)) { var outputType = OutputType.Json; if (!Enum.TryParse(value, true, out outputType)) { throw new ErrorException(string.Format("Value '{0}' cannot be parsed as output type, please use 'json' or 'buildserver'", value)); } arguments.Output = outputType; continue; } throw new ErrorException(string.Format("Could not parse command line parameter '{0}'.", name)); } return(arguments); }