/// <summary>
/// Moves selected item up or down.
/// </summary>
/// <param name="direction"></param>
private void MoveSelectedItem(MoveDirection direction)
{
Debug.Assert(m_checkedListBoxVersions.SelectedItems.Count == 1);
int index = m_checkedListBoxVersions.SelectedIndex;
bool isChecked = m_checkedListBoxVersions.GetItemChecked(index);
AssemblyVersionType avt = (AssemblyVersionType)m_checkedListBoxVersions.Items[index];
m_checkedListBoxVersions.Items.RemoveAt(index);
int newIndex = index;
switch (direction)
{
case MoveDirection.Down:
newIndex++;
break;
case MoveDirection.Up:
newIndex--;
break;
default:
Debug.Assert(false, "Not supported MoveDirection");
break;
}
m_checkedListBoxVersions.Items.Insert(newIndex, avt);
m_checkedListBoxVersions.SetItemChecked(newIndex, isChecked);
m_checkedListBoxVersions.SelectedIndex = newIndex;
}
public void SetUpdated(ProjectInfo projectInfo, AssemblyVersionType versionType, string newVersion)
{
Debug.Assert(Contains(projectInfo));
this[projectInfo].UpdateState = UpdateState.Updated;
this[projectInfo][versionType].UpdateState = UpdateState.Updated;
this[projectInfo][versionType].Version = newVersion;
}
/// <summary>
/// Extracts version string from resource file content.
/// </summary>
/// <param name="versionType">
/// Version type to search. Can be AssemblyFileVersion or
/// AssemblyInformationalVersion, corresponding to FILEVERSION and
/// PRODUCTVERSION respectively.
/// </param>
/// <returns>
/// Version string found.
/// </returns>
protected override string GetVersionString(AssemblyVersionType versionType)
{
Debug.Assert(versionType != AssemblyVersionType.AssemblyVersion && versionType != AssemblyVersionType.All);
// if VS_VERSION_INFO header not found, there is no valid version
Regex regex = new Regex(VersionInfoHeaderLine, RegexOptions.Multiline);
Match match = regex.Match(m_fileContent);
if (!match.Success)
{
return("");
}
int offset = match.Index + match.Length;
string pattern = "";
switch (versionType)
{
case AssemblyVersionType.AssemblyFileVersion:
pattern = StartOfLine + FileVersionCaps + OneOrMoreWhitespacePattern + VersionPattern;
break;
case AssemblyVersionType.AssemblyInformationalVersion:
pattern = StartOfLine + ProductVersionCaps + OneOrMoreWhitespacePattern + VersionPattern;
break;
default:
Debug.Assert(false, string.Format("Illegal versionName: {0}", versionType.ToString()));
break;
}
regex = new Regex(pattern, RegexOptions.Multiline);
match = regex.Match(m_fileContent, offset);
Debug.Assert(match.Value.Length > 0);
return(match.Value);
}
/// <summary>
/// Determines if one of <c>AssemblyVersionType</c> assembly infos
/// should be updated.
/// </summary>
/// <param name="projectInfo">
/// <c>ProjectInfo</c> for the project that is considered.
/// </param>
/// <param name="assemblyVersionType">
/// <c>AssemblyVersionType</c> for which version update is determined.
/// </param>
/// <param name="highestProjectVersion">
/// Highest <c>ProjectVersion</c> used as a reference for update.
/// </param>
/// <returns>
/// <c>true</c> if version should be incremented.
/// </returns>
private bool ShouldUpdateOneOfAssemblyVersionTypes(ProjectInfo projectInfo, AssemblyVersionType assemblyVersionType, ProjectVersion highestProjectVersion)
{
Debug.Assert(assemblyVersionType == AssemblyVersionType.AssemblyVersion || assemblyVersionType == AssemblyVersionType.AssemblyFileVersion || assemblyVersionType == AssemblyVersionType.AssemblyInformationalVersion);
// first check if corresponding assembly version type exists at all
if (projectInfo.CurrentAssemblyVersions[assemblyVersionType] == ProjectVersion.Empty)
{
return(false);
}
// else, depending on settings
switch (m_numberingOptions.BatchCommandIncrementScheme)
{
case (BatchCommandIncrementScheme.IncrementModifiedIndependently):
return(projectInfo.IsMarkedForUpdate(assemblyVersionType));
case (BatchCommandIncrementScheme.IncrementAllIndependently):
return(true);
case (BatchCommandIncrementScheme.IncrementModifiedOnlyAndSynchronize):
int resetBuildAndRevisionValues = (int)m_numberingOptions.ResetBuildAndRevisionTo;
return(projectInfo.Modified || ProjectVersion.ApplyVersionPattern(highestProjectVersion.ToString(), projectInfo.CurrentAssemblyVersions[assemblyVersionType].ToString(), resetBuildAndRevisionValues) != projectInfo.CurrentAssemblyVersions[assemblyVersionType].ToString());//projectInfo.CurrentAssemblyVersions[assemblyVersionType] < highestProjectVersion;
case (BatchCommandIncrementScheme.IncrementAllAndSynchronize):
int buildAndRevisionResetValue = (int)m_numberingOptions.ResetBuildAndRevisionTo;
return(ProjectVersion.ApplyVersionPattern(highestProjectVersion.ToString(), projectInfo.CurrentAssemblyVersions[assemblyVersionType].ToString(), buildAndRevisionResetValue) != projectInfo.CurrentAssemblyVersions[assemblyVersionType].ToString()); // projectInfo.CurrentAssemblyVersions[assemblyVersionType] < highestProjectVersion;
}
Debug.Assert(false, "Not supported option");
return(false);
}
public void AssemblyVersionFormatAndTypeTest(AssemblyVersionType type, string format, string expected)
{
LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@"
<nlog>
<targets><target name='debug' type='Debug' layout='${message:withException=true}|${assembly-version:type=" + type.ToString().ToLower() + @":format=" + format + @"}' /></targets>
<rules><logger name='*' minlevel='Debug' writeTo='debug' /></rules>
</nlog>");
var logger = LogManager.GetLogger("SomeLogger");
var compiledAssembly = TestAssembly.Value;
var testLoggerType = compiledAssembly.GetType("LogTester.LoggerTest");
var logMethod = testLoggerType.GetMethod("TestLog");
var testLoggerInstance = Activator.CreateInstance(testLoggerType);
logMethod.Invoke(testLoggerInstance, new object[] { logger, compiledAssembly });
var lastMessage = GetDebugLastMessage("debug");
var messageParts = lastMessage.Split('|');
var logMessage = messageParts[0];
var logVersion = messageParts[1];
if (logMessage.StartsWith("Skip:"))
{
_testOutputHelper.WriteLine(logMessage);
}
else
{
Assert.StartsWith("Pass:", logMessage);
Assert.Equal(expected, logVersion);
}
}
protected override string GetVersionString(AssemblyVersionType versionType)
{
Debug.Assert(versionType != AssemblyVersionType.AssemblyVersion && versionType != AssemblyVersionType.All);
int pos = GetMatchPosition(ProductVersionLinePattern, 0);
Regex regex = new Regex(VersionPattern);
return(regex.Match(m_fileContent, pos + 1).Value);
}
public ProjectVersion this[AssemblyVersionType type] {
get {
Debug.Assert(type != AssemblyVersionType.All);
return((ProjectVersion)m_versions[type]);
}
set {
Debug.Assert(type != AssemblyVersionType.All);
m_versions[type] = value;
}
}
protected void SetVersionString(AssemblyVersionType versionType, string newVersion)
{
string entireAttributeString = GetVersionString(versionType);
Debug.Assert(entireAttributeString.Length > 0);
Regex regex = new Regex(QuotesEnclosedPattern);
string newVersionString = regex.Replace(entireAttributeString, string.Format(CultureInfo.CurrentCulture, "\"{0}\"", newVersion), 1);
Debug.Assert(newVersionString.Length > 0);
m_fileContent = m_fileContent.Replace(entireAttributeString, newVersionString);
Debug.Assert(m_fileContent.IndexOf(newVersionString) != -1);
}
public override void SaveVersion(AssemblyVersionType typeToSave, string newVersion)
{
Debug.Assert(typeToSave == AssemblyVersionType.AssemblyInformationalVersion);
int pos = GetMatchPosition(ProductVersionLinePattern, 0);
Regex regex = new Regex(VersionPattern);
m_fileContent = regex.Replace(m_fileContent, newVersion, 1, pos + 1);
if (ConfigurationPersister.Instance.Configuration.NumberingOptions.GeneratePackageAndProductCodes)
{
ModifyPackageAndProductCodes();
}
FileUtil.SaveTextFile(Filename, m_fileContent, m_encoding);
}
/// <summary>
/// Saves version to corresponding files.
/// </summary>
/// <param name="newVersion">
/// New version string to be saved.
/// </param>
/// <param name="numberingOptions">
/// Numbering options.
/// </param>
public bool Save(AssemblyVersionType versionTypeToSave, string newVersion)
{
foreach (VersionStream vs in m_versionStreams)
{
try {
vs.SaveVersion(versionTypeToSave, newVersion);
}
catch (Exception) {
MessageBox.Show(s_txtCannotSaveFile + Environment.NewLine + vs.Filename, s_txtSaveErrorTitle);
return(false);
}
}
return(true);
}
public void Increment(AssemblyVersionType typeToIncrement, NumberingOptions numberingOptions)
{
if ((typeToIncrement & AssemblyVersionType.AssemblyVersion) != 0)
{
this[AssemblyVersionType.AssemblyVersion].Increment(numberingOptions);
}
if ((typeToIncrement & AssemblyVersionType.AssemblyFileVersion) != 0)
{
this[AssemblyVersionType.AssemblyFileVersion].Increment(numberingOptions);
}
if ((typeToIncrement & AssemblyVersionType.AssemblyInformationalVersion) != 0)
{
this[AssemblyVersionType.AssemblyInformationalVersion].Increment(numberingOptions);
}
}
/// <summary>
/// Selects the listview with corresponding assembly version type.
/// </summary>
/// <param name="assemblyVersionType">
/// <c>AssemblyVersionType</c> for which listview should be selected.
/// </param>
public void SelectListView(AssemblyVersionType assemblyVersionType)
{
switch (assemblyVersionType)
{
case AssemblyVersionType.AssemblyVersion:
m_radioButtonAssemblyVersions.PerformClick();
break;
case AssemblyVersionType.AssemblyFileVersion:
m_radioButtonAssemblyFileVersions.PerformClick();
break;
case AssemblyVersionType.AssemblyInformationalVersion:
m_radioButtonAssemblyInformationalVersions.PerformClick();
break;
}
}
/// <summary>
/// Saves version to resource file.
/// </summary>
/// <param name="typeToSave">
/// Flags specifying which versions to save.
/// </param>
/// <param name="newVersion">
/// New version to save.
/// </param>
public override void SaveVersion(AssemblyVersionType typeToSave, string newVersion)
{
Debug.Assert(typeToSave != AssemblyVersionType.All);
if (typeToSave == AssemblyVersionType.AssemblyVersion)
{
return;
}
if (typeToSave == AssemblyVersionType.AssemblyFileVersion)
{
SetHeaderVersionString(FileVersionCaps, newVersion);
SetBlockVersionString(FileVersionQuoted, newVersion);
}
if (typeToSave == AssemblyVersionType.AssemblyInformationalVersion)
{
SetHeaderVersionString(ProductVersionCaps, newVersion);
SetBlockVersionString(ProductVersionQuoted, newVersion);
}
FileUtil.SaveTextFile(Filename, m_fileContent, m_encoding);
}
protected ProjectVersion GetVersion(AssemblyVersionType versionType)
{
Debug.Assert(versionType != AssemblyVersionType.All);
string assemblyVersionString = GetVersionString(versionType);
if (assemblyVersionString.Length == 0)
{
return(ProjectVersion.Empty);
}
Regex regex = new Regex(VersionPattern);
Match match = regex.Match(assemblyVersionString);
if (match.Length > 0)
{
return(new ProjectVersion(match.Value, versionType));
}
regex = new Regex(QuotesEnclosedPattern);
match = regex.Match(assemblyVersionString);
return(new ProjectVersion(match.ToString().Trim('\"'), versionType));
}
/// <summary>
/// Determines if an <c>AssemblyVersion</c> for the project should be
/// updated according to configured settings, <c>AssemblyVersionType</c>
/// and highest <c>ProjectVersion</c>provided.
/// </summary>
/// <param name="projectInfo">
/// <c>ProjectInfo</c> for the project that is considered.
/// </param>
/// <param name="assemblyVersionType">
/// <c>AssemblyVersionType</c> for which version update is determined.
/// </param>
/// <param name="highestProjectVersion">
/// Highest <c>ProjectVersion</c> used as a reference for update.
/// </param>
/// <returns>
/// <c>true</c> if version should be incremented.
/// </returns>
public bool ShouldUpdate(ProjectInfo projectInfo, AssemblyVersionType assemblyVersionType, ProjectVersion highestProjectVersion)
{
if (m_numberingOptions.SynchronizeAllVersionTypes)
{
if (!projectInfo.CurrentAssemblyVersions.AreVersionsSynchronized)
{
return(true);
}
}
foreach (AssemblyVersionType at in AssemblyVersions.AssemblyVersionTypes)
{
if ((assemblyVersionType & at) == at)
{
if (ShouldUpdateOneOfAssemblyVersionTypes(projectInfo, at, highestProjectVersion))
{
return(true);
}
}
}
return(false);
}
/// <summary>
/// Provides the updated version as a string.
/// </summary>
/// <param name="projectInfo">
/// <c>ProjectInfo</c> for the project that is updated.
/// </param>
/// <param name="assemblyVersionType">
/// <c>AssemblyVersionType</c> for which version update is done.
/// </param>
/// <param name="highestProjectVersion">
/// Highest <c>ProjectVersion</c> used as a reference for update.
/// </param>
/// <returns>
/// New version as a string.
/// </returns>
public string ProvideNewVersion(ProjectInfo projectInfo, AssemblyVersionType assemblyVersionType, ProjectVersion highestProjectVersion)
{
Debug.Assert(assemblyVersionType != AssemblyVersionType.All);
switch (m_numberingOptions.BatchCommandIncrementScheme)
{
case BatchCommandIncrementScheme.IncrementModifiedIndependently:
case BatchCommandIncrementScheme.IncrementAllIndependently:
if (m_numberingOptions.SynchronizeAllVersionTypes && !projectInfo.ToUpdate)
{
return(projectInfo.CurrentAssemblyVersions.HighestProjectVersion.ToString());
}
return(projectInfo.ToBecomeAssemblyVersions[assemblyVersionType].ToString());
case (BatchCommandIncrementScheme.IncrementAllAndSynchronize):
case (BatchCommandIncrementScheme.IncrementModifiedOnlyAndSynchronize):
int resetBuildAndRevisionValues = (int)m_numberingOptions.ResetBuildAndRevisionTo;
return(ProjectVersion.ApplyVersionPattern(highestProjectVersion.ToString(), projectInfo.CurrentAssemblyVersions[assemblyVersionType].ToString(), resetBuildAndRevisionValues));// highestProjectVersion.ToString();
}
Debug.Assert(false, "Not supported option");
return(null);
}
/// <summary>
/// Searches the file content for the version provided.
/// </summary>
/// <param name="versionName">
/// Short attribute name to search for.
/// </param>
/// <returns></returns>
protected override string GetVersionString(AssemblyVersionType versionType)
{
Debug.Assert(versionType != AssemblyVersionType.All);
string shortAttributeName = versionType.ToString();
Debug.Assert(shortAttributeName != null && !shortAttributeName.EndsWith(Attribute));
// first try with a short name
string pattern = BuildAttributeLinePattern(shortAttributeName);
Regex regex = new Regex(pattern, RegexOptions.Multiline);
Match match = regex.Match(m_fileContent);
if (match.Length > 0)
{
return(match.ToString());
}
// now try with a long one
pattern = BuildAttributeLinePattern(shortAttributeName + Attribute);
regex = new Regex(pattern, RegexOptions.Multiline);
match = regex.Match(m_fileContent);
return(match.ToString());
}
/// <summary>
/// Mark assembly version(s) for update.
/// </summary>
/// <param name="versionType">
/// Version type to mark. May be any combination of flags, including
/// <c>AssemblyVersionType.All</c>.
/// </param>
public void MarkAssemblyVersionsForUpdate(AssemblyVersionType versionType)
{
if ((versionType & AssemblyVersionType.AssemblyVersion) == AssemblyVersionType.AssemblyVersion)
{
if (CurrentAssemblyVersions[AssemblyVersionType.AssemblyVersion] != ProjectVersion.Empty)
{
m_assemblyVersionsUpdateInfo[AssemblyVersionType.AssemblyVersion] = true;
}
}
if ((versionType & AssemblyVersionType.AssemblyFileVersion) == AssemblyVersionType.AssemblyFileVersion)
{
if (CurrentAssemblyVersions[AssemblyVersionType.AssemblyFileVersion] != ProjectVersion.Empty)
{
m_assemblyVersionsUpdateInfo[AssemblyVersionType.AssemblyFileVersion] = true;
}
}
if ((versionType & AssemblyVersionType.AssemblyInformationalVersion) == AssemblyVersionType.AssemblyInformationalVersion)
{
if (CurrentAssemblyVersions[AssemblyVersionType.AssemblyInformationalVersion] != ProjectVersion.Empty)
{
m_assemblyVersionsUpdateInfo[AssemblyVersionType.AssemblyInformationalVersion] = true;
}
}
}
public override void SaveVersion(AssemblyVersionType typeToSave, string newVersion)
{
SetVersionString(typeToSave, newVersion);
FileUtil.SaveTextFile(Filename, m_fileContent, m_encoding);
}
public bool ContainsVersion(AssemblyVersionType assemblyVersionType)
{
Debug.Assert(assemblyVersionType != AssemblyVersionType.All && assemblyVersionType != AssemblyVersionType.None);
return(Array.IndexOf(GetValidVersionTypes(), assemblyVersionType) > -1);
}
/// <summary>
/// Creates <c>AssemblyVersionTypeSelection</c> object with
/// <c>AssemblyVersionType</c> provided.
/// </summary>
/// <param name="assemblyVersionType">
/// <c>AssemblyVersionType</c> to initialize with.
/// </param>
public AssemblyVersionTypeSelection(AssemblyVersionType assemblyVersionType) : this()
{
m_assemblyVersionType = assemblyVersionType;
}
/// <summary>
/// Gets a flag indicating if an assembly version is marked for
/// update.
/// </summary>
/// <param name="versionType">
/// Version type for which flag should be provided.
/// </param>
/// <returns>
/// <c>true</c> if version type is marked for update.
/// </returns>
public bool IsMarkedForUpdate(AssemblyVersionType versionType)
{
Debug.Assert(versionType != AssemblyVersionType.All);
return((bool)m_assemblyVersionsUpdateInfo[versionType]);
}
protected abstract string GetVersionString(AssemblyVersionType versionType);
public abstract void SaveVersion(AssemblyVersionType typeToSave, string newVersion);
public AssemblyVersionItem this[AssemblyVersionType assemblyVersionType] {
get {
return((AssemblyVersionItem)m_assemblyVersions[assemblyVersionType]);
}
}
/// <summary>
/// Creates a <c>ProjectInfoList</c> containing <c>ProjectInfo</c>
/// objects that have passed the filter provided.
/// </summary>
/// <param name="projectInfos">
/// An array of all <c>ProjectInfo</c> objects.
/// </param>
/// <param name="filter">
/// A filter used to select <c>ProjectInfo</c> objects.
/// </param>
/// <param name="newVersionProvider">
/// <c>NewVersionProvider</c> object responsible to propose a new
/// version for each <c>ProjectInfo</c> object.
/// </param>
/// <param name="assemblyVersionsUpdateMask">
/// Mask defining which versions (AssemblyInfo, Informational or
/// Product) may be updated.
/// </param>
public ProjectInfoList(ProjectInfo[] projectInfos, IProjectFilter filter, NewVersionProvider newVersionProvider, AssemblyVersionType assemblyVersionsUpdateMask)
{
m_projectInfos = new ArrayList(projectInfos.Length);
m_highestToBeAssemblyVersions = AssemblyVersions.MinValue;
m_highestProposedAssemblyVersion = AssemblyVersions.MinValue;
foreach (ProjectInfo projectInfo in projectInfos)
{
if (filter.Pass(projectInfo))
{
ProjectInfo pi = projectInfo;
pi.SetToBecomeVersion(newVersionProvider);
if (pi.Modified)
{
pi.MarkAssemblyVersionsForUpdate(assemblyVersionsUpdateMask);
}
m_projectInfos.Add(pi);
m_highestToBeAssemblyVersions = AssemblyVersions.Max(m_highestToBeAssemblyVersions, pi);
m_highestProposedAssemblyVersion = AssemblyVersions.MaxProposed(m_highestProposedAssemblyVersion, pi);
}
}
}