diff --git a/src/Az.Shared.props b/src/Az.Shared.props
index d8a92525cdec..8bf1ec4b6641 100644
--- a/src/Az.Shared.props
+++ b/src/Az.Shared.props
@@ -16,6 +16,8 @@
false
false
true
+
+ NU1901;NU1902;NU1903;NU1904
diff --git a/tools/RunVersionController.ps1 b/tools/RunVersionController.ps1
index 75b604a1fb17..f1b627e41ee3 100644
--- a/tools/RunVersionController.ps1
+++ b/tools/RunVersionController.ps1
@@ -164,10 +164,10 @@ function Update-ChangeLog
[Parameter(Mandatory = $true)]
[string[]]$Content,
[Parameter(Mandatory = $true)]
- [string]$RootPath
+ [string]$FilePath
)
- $ChangeLogFile = Get-Item -Path "$RootPath\ChangeLog.md"
+ $ChangeLogFile = Get-Item -Path $FilePath
$ChangeLogContent = Get-Content -Path $ChangeLogFile.FullName
($Content + $ChangeLogContent) | Set-Content -Path $ChangeLogFile.FullName -Encoding UTF8
}
@@ -295,7 +295,7 @@ function Bump-AzVersion
}
Update-ModuleManifest -Path "$PSScriptRoot\Az\Az.psd1" -ModuleVersion $newVersion -ReleaseNotes $releaseNotes
- Update-ChangeLog -Content $changeLog -RootPath $rootPath
+ Update-ChangeLog -Content $changeLog -FilePath "$rootPath\ChangeLog.md"
New-CommandMappingFile
@@ -392,8 +392,26 @@ function Update-AzPreviewChangelog
$changeLog += "#### $updatedModule $($moduleMetadata.ModuleVersion)"
$changeLog += $moduleReleaseNotes + "`n"
}
- Update-ChangeLog -Content $changeLog -RootPath $rootPath/tools/AzPreview
+ Update-ChangeLog -Content $changeLog -FilePath "$rootPath/tools/AzPreview/ChangeLog.md"
+}
+function Update-AzSyntaxChangelog
+{
+ Write-Host "starting revise SyntaxChangelog"
+ $rootPath = "$PSScriptRoot\.."
+ $NewVersion = (Import-PowerShellDataFile "$PSScriptRoot\Az\Az.psd1").ModuleVersion
+ Update-ChangeLog -Content "## $NewVersion - $Release" -FilePath "$rootPath\documentation\SyntaxChangelog.md"
+ $changeLog = Get-Content "$rootPath\documentation\SyntaxChangelog.md" -Raw
+ $regex = '####\s+(Az\.\w+)\s+(?![\d\.])'
+ $matches = Select-String -Pattern $regex -InputObject $changelog -AllMatches
+ foreach ($match in $matches.Matches) {
+ $moduleName = $match.Groups[1].Value
+ $moduleMetadata = Get-ModuleMetadata -Module $moduleName -RootPath $rootPath
+ $newVersion = $moduleMetadata.ModuleVersion
+ $replacement = "#### $moduleName $newVersion `r`n"
+ $changelog = $changelog -replace [regex]::Escape($match.Value), $replacement
+ }
+ Set-Content -Path "$rootPath\documentation\SyntaxChangelog.md" -Value $changelog
}
function New-CommandMappingFile
@@ -502,6 +520,7 @@ switch ($PSCmdlet.ParameterSetName)
# Refresh AzPreview.psd1
Update-AzPreview
Update-AzPreviewChangelog
+ Update-AzSyntaxChangelog
# We need to generate the upcoming-breaking-changes.md after the process of bump version in minor release
if ([PSVersion]::MINOR -Eq $versionBump)
{
diff --git a/tools/VersionController/Models/CmdletDiffInfomation.cs b/tools/VersionController/Models/CmdletDiffInfomation.cs
new file mode 100644
index 000000000000..edf9c024f60f
--- /dev/null
+++ b/tools/VersionController/Models/CmdletDiffInfomation.cs
@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace VersionController.Netcore.Models
+{
+ public enum ChangeType
+ {
+ CmdletAdd,
+ CmdletRemove,
+ CmdletSupportsShouldProcessChange,
+ CmdletSupportsPagingChange,
+ AliasAdd,
+ AliasRemove,
+ ParameterAdd,
+ ParameterRemove,
+ ParameterAliasAdd,
+ ParameterAliasRemove,
+ ParameterTypeChange,
+ ParameterAttributeChange,
+ ParameterSetAdd,
+ ParameterSetRemove,
+ ParameterSetAttributePropertyChange,
+ OutputTypeChange
+ }
+ public class CmdletDiffInformation
+ {
+ public string ModuleName { get; set; }
+ public string CmdletName { get; set; }
+ public ChangeType Type { get; set; }
+ public string ParameterSetName { get; set; }
+ public string ParameterName { get; set; }
+ public List Before { get; set; }
+ public List After { get; set; }
+ public string PropertyName { get; set; }
+ }
+}
\ No newline at end of file
diff --git a/tools/VersionController/Models/SyntaxChangelogGenerator.cs b/tools/VersionController/Models/SyntaxChangelogGenerator.cs
new file mode 100644
index 000000000000..94e9c4df2393
--- /dev/null
+++ b/tools/VersionController/Models/SyntaxChangelogGenerator.cs
@@ -0,0 +1,534 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using Tools.Common.Loaders;
+using Tools.Common.Loggers;
+using Tools.Common.Models;
+using Tools.Common.Utilities;
+
+namespace VersionController.Netcore.Models
+{
+ public class SyntaxChangelogGenerator
+ {
+ public AnalysisLogger Logger { get; set; }
+ public string Name { get; set; }
+ public string CmdletDiffIssueReportLoggerName { get; set; }
+ private List _ignoreParameters = new List
+ {
+ "AzureRMContext", "Break", "Debug", "DefaultProfile", "EnableTestCoverage",
+ "ErrorAction", "ErrorVariable", "HttpPipelineAppend", "HttpPipelinePrepend", "InformationAction",
+ "InformationVariable", "OutBuffer", "OutVariable", "PipelineVariable", "Proxy",
+ "ProxyCredential", "ProxyUseDefaultCredentials", "Verbose", "WarningAction", "WarningVariable"
+ };
+ private List diffInfo = new List();
+ public void Analyze(String srcDirs)
+ {
+ var savedDirectory = Directory.GetCurrentDirectory();
+ var manifestFiles = Directory.EnumerateFiles(srcDirs, "*.psd1", SearchOption.AllDirectories)
+ .Where(file =>
+ !Path.GetDirectoryName(file)
+ .EndsWith("autorest", StringComparison.OrdinalIgnoreCase))
+ .ToList();
+ foreach (var psd1 in manifestFiles)
+ {
+ var moduleVersion = ExtractModuleVersion(psd1);
+ if (moduleVersion.CompareTo(new Version("1.0.0")) < 0) continue;
+ var psd1FileName = Path.GetFileName(psd1);
+ var moduleName = psd1FileName.Replace(".psd1", "");
+ if (ModuleFilter.IsAzureStackModule(moduleName.Replace("Az.", ""))) continue;
+ Console.WriteLine("Analyzing module: {0}", moduleName);
+ var newModuleMetadata = MetadataLoader.GetModuleMetadata(moduleName);
+ var executingPath = Path.GetDirectoryName(new Uri(Assembly.GetExecutingAssembly().Location).AbsolutePath);
+ var filePath = Path.Combine(executingPath, "SerializedCmdlets", $"{moduleName}.json");
+ if (!File.Exists(filePath)) continue;
+ var oldModuleMetadata = ModuleMetadata.DeserializeCmdlets(filePath);
+ CmdletLoader.ModuleMetadata = newModuleMetadata;
+ CompareModuleMetedata(oldModuleMetadata, newModuleMetadata, moduleName);
+ }
+ Directory.SetCurrentDirectory(savedDirectory);
+ var markDownPath = Path.Combine(savedDirectory, "documentation/SyntaxChangelog.md");
+ GenerateMarkdown(markDownPath);
+ Console.WriteLine("Cmdlets Differences written to {0}", markDownPath);
+ }
+
+ public Version ExtractModuleVersion(string filePath)
+ {
+ string moduleVersion = null;
+
+ var lines = File.ReadAllLines(filePath);
+
+ foreach (var line in lines)
+ {
+ if (line.Trim().StartsWith("ModuleVersion", StringComparison.OrdinalIgnoreCase))
+ {
+ var versionPart = line.Split('=');
+ if (versionPart.Length == 2)
+ {
+ moduleVersion = versionPart[1].Trim().Trim('\'', '"');
+ break;
+ }
+ }
+ }
+
+ return new Version(moduleVersion);
+ }
+ private void CompareModuleMetedata(ModuleMetadata oldModuleMetadata,
+ ModuleMetadata newModuleMetadata,
+ string moduleName)
+ {
+ var newCmdletList = newModuleMetadata.Cmdlets;
+ Dictionary newCmdletMetadataMap = new Dictionary();
+ foreach (var cmdlet in newCmdletList)
+ {
+ newCmdletMetadataMap.Add(cmdlet.Name, cmdlet);
+ }
+
+ var oldCmdletList = oldModuleMetadata.Cmdlets;
+ Dictionary oldCmdletMetadataMap = new Dictionary();
+ foreach (var cmdlet in oldCmdletList)
+ {
+ oldCmdletMetadataMap.Add(cmdlet.Name, cmdlet);
+ }
+ foreach (string cmdletName in oldCmdletMetadataMap.Keys)
+ {
+ if (!newCmdletMetadataMap.ContainsKey(cmdletName))
+ {
+ diffInfo.Add(new CmdletDiffInformation()
+ {
+ ModuleName = moduleName,
+ CmdletName = cmdletName,
+ Type = ChangeType.CmdletRemove,
+ Before = new List { cmdletName },
+ });
+ oldCmdletMetadataMap.Remove(cmdletName);
+ }
+ else
+ // both old and new module have the same cmdlet
+ {
+ if (oldCmdletMetadataMap[cmdletName] == null || oldCmdletMetadataMap[cmdletName]?.Equals(newCmdletMetadataMap[cmdletName]) == false)
+ {
+ CompareCmdletsAlias(oldCmdletMetadataMap[cmdletName], newCmdletMetadataMap[cmdletName],
+ moduleName);
+ CompareCmdletsSupportsShouldProcess(oldCmdletMetadataMap[cmdletName], newCmdletMetadataMap[cmdletName],
+ moduleName);
+ CompareCmdletsParameter(oldCmdletMetadataMap[cmdletName], newCmdletMetadataMap[cmdletName],
+ moduleName);
+ CompareCmdletsOutputChange(oldCmdletMetadataMap[cmdletName], newCmdletMetadataMap[cmdletName],
+ moduleName);
+ }
+ oldCmdletMetadataMap.Remove(cmdletName);
+ newCmdletMetadataMap.Remove(cmdletName);
+ }
+ }
+ foreach (string cmdletName in newCmdletMetadataMap.Keys)
+ {
+ diffInfo.Add(new CmdletDiffInformation()
+ {
+ ModuleName = moduleName,
+ CmdletName = cmdletName,
+ Type = ChangeType.CmdletAdd,
+ After = new List { cmdletName },
+ });
+ }
+ }
+
+ private void CompareCmdletsAlias(
+ CmdletMetadata oldCmdletMetadata,
+ CmdletMetadata newCmdletMetadata,
+ string moduleName)
+ {
+ var removedAliases = oldCmdletMetadata.AliasList.Except(newCmdletMetadata.AliasList).ToList();
+ var addedAliases = newCmdletMetadata.AliasList.Except(oldCmdletMetadata.AliasList).ToList();
+
+ AddAliasChangeInfo(moduleName, oldCmdletMetadata.Name, ChangeType.AliasRemove, removedAliases);
+ AddAliasChangeInfo(moduleName, oldCmdletMetadata.Name, ChangeType.AliasAdd, addedAliases);
+ }
+ private void AddAliasChangeInfo(string moduleName, string cmdletName, ChangeType changeType, List aliases)
+ {
+ if (aliases.Any())
+ {
+ if (changeType == ChangeType.AliasAdd)
+ {
+ diffInfo.Add(new CmdletDiffInformation()
+ {
+ ModuleName = moduleName,
+ CmdletName = cmdletName,
+ Type = changeType,
+ After = aliases,
+ });
+ }
+ else
+ {
+ diffInfo.Add(new CmdletDiffInformation()
+ {
+ ModuleName = moduleName,
+ CmdletName = cmdletName,
+ Type = changeType,
+ Before = aliases,
+ });
+ }
+ }
+ }
+
+ private void CompareCmdletsSupportsShouldProcess(
+ CmdletMetadata oldCmdlet,
+ CmdletMetadata newCmdlet,
+ string moduleName)
+ {
+ if (oldCmdlet.SupportsShouldProcess != newCmdlet.SupportsShouldProcess)
+ {
+ diffInfo.Add(new CmdletDiffInformation()
+ {
+ ModuleName = moduleName,
+ CmdletName = oldCmdlet.Name,
+ Type = ChangeType.CmdletSupportsShouldProcessChange,
+ Before = new List { oldCmdlet.SupportsShouldProcess.ToString() },
+ After = new List { newCmdlet.SupportsShouldProcess.ToString() },
+ });
+ }
+ }
+ private void CompareCmdletsParameter(CmdletMetadata oldCmdletMetadata,
+ CmdletMetadata newCmdletMetadata,
+ string moduleName)
+ {
+ // Parameter remove/ add
+ List oldParameterNames = new List();
+ List newParameterNames = new List();
+ foreach (var parameterMetadata in oldCmdletMetadata.Parameters)
+ {
+ if (_ignoreParameters.Contains(parameterMetadata.Name))
+ {
+ continue;
+ }
+ oldParameterNames.Add(parameterMetadata.Name);
+ }
+ foreach (var parameterMetadata in newCmdletMetadata.Parameters)
+ {
+ if (_ignoreParameters.Contains(parameterMetadata.Name))
+ {
+ continue;
+ }
+ newParameterNames.Add(parameterMetadata.Name);
+ }
+ if (!(oldParameterNames.Count == newParameterNames.Count && oldParameterNames.Count(t => !newParameterNames.Contains(t)) == 0))
+ {
+ CompareChangedParameter(moduleName, oldCmdletMetadata.Name, oldParameterNames, newParameterNames);
+ }
+ CompareCmdletsParamProperties(oldCmdletMetadata, newCmdletMetadata, moduleName);
+ }
+
+ private void CompareChangedParameter(string moduleName, string cmdletName, List oldParameterNames, List newParameterNames)
+ {
+ var removedParameters = oldParameterNames.Except(newParameterNames).ToList();
+ var addedParameters = newParameterNames.Except(oldParameterNames).ToList();
+
+ AddParameterChangeInfo(moduleName, cmdletName, ChangeType.ParameterRemove, removedParameters);
+ AddParameterChangeInfo(moduleName, cmdletName, ChangeType.ParameterAdd, addedParameters);
+ }
+
+ private void AddParameterChangeInfo(string moduleName, string cmdletName, ChangeType changeType, List parameters)
+ {
+ if (!parameters.Any())
+ {
+ return;
+ }
+ if (changeType == ChangeType.ParameterAdd)
+ {
+ diffInfo.Add(new CmdletDiffInformation()
+ {
+ ModuleName = moduleName,
+ CmdletName = cmdletName,
+ Type = changeType,
+ ParameterName = String.Join(", ", parameters),
+ After = parameters,
+ });
+ }
+ else
+ {
+ diffInfo.Add(new CmdletDiffInformation()
+ {
+ ModuleName = moduleName,
+ CmdletName = cmdletName,
+ Type = changeType,
+ ParameterName = String.Join(", ", parameters),
+ Before = parameters,
+ });
+ }
+ }
+
+ private void CompareCmdletsParamProperties(CmdletMetadata oldCmdletMetadata,
+ CmdletMetadata newCmdletMetadata,
+ string moduleName)
+ {
+ // ParameterAlias remove/ add && ParameterTypeChange,
+ List oldParameterMetadatas = oldCmdletMetadata.Parameters;
+ List newParameterMetadatas = newCmdletMetadata.Parameters;
+
+ var compareParameterMetadatas =
+ from oldParam in oldParameterMetadatas
+ where !_ignoreParameters.Contains(oldParam.Name)
+ join newParam in newParameterMetadatas on oldParam.Name equals newParam.Name
+ where !_ignoreParameters.Contains(newParam.Name)
+ select (oldParam, newParam);
+
+ foreach (var (oldParameterMetadata, newParameterMetadata) in compareParameterMetadatas)
+ {
+ CompareChangedParameterAliases(moduleName, oldCmdletMetadata.Name, oldParameterMetadata, newParameterMetadata);
+ CompareChangedParameterType(moduleName, oldCmdletMetadata, oldParameterMetadata, newParameterMetadata);
+ }
+ }
+
+ private void CompareChangedParameterAliases(string moduleName, string cmdletName, ParameterMetadata oldParameterMetadata, ParameterMetadata newParameterMetadata)
+ {
+ if (!(oldParameterMetadata.AliasList.Count == newParameterMetadata.AliasList.Count
+ && oldParameterMetadata.AliasList.Count(t => !newParameterMetadata.AliasList.Contains(t)) == 0))
+ {
+ List addedAliases = newParameterMetadata.AliasList.Except(oldParameterMetadata.AliasList).ToList();
+ ProcessChangedParameterAliases(moduleName, cmdletName, ChangeType.ParameterAliasAdd, oldParameterMetadata, addedAliases);
+ List removedAliases = oldParameterMetadata.AliasList.Except(newParameterMetadata.AliasList).ToList();
+ ProcessChangedParameterAliases(moduleName, cmdletName, ChangeType.ParameterAliasRemove, oldParameterMetadata, removedAliases);
+ }
+ }
+ private void ProcessChangedParameterAliases(string moduleName, string cmdletName, ChangeType changeType,
+ ParameterMetadata oldParameterMetadata,
+ List addedOrRemovedAliases)
+ {
+ if (!addedOrRemovedAliases.Any())
+ {
+ return;
+ }
+ if (changeType == ChangeType.ParameterAliasAdd)
+ {
+ diffInfo.Add(new CmdletDiffInformation()
+ {
+ ModuleName = moduleName,
+ CmdletName = cmdletName,
+ Type = changeType,
+ ParameterName = oldParameterMetadata.Name,
+ After = addedOrRemovedAliases,
+ });
+ }
+ else
+ {
+ diffInfo.Add(new CmdletDiffInformation()
+ {
+ ModuleName = moduleName,
+ CmdletName = cmdletName,
+ Type = changeType,
+ ParameterName = oldParameterMetadata.Name,
+ Before = addedOrRemovedAliases,
+ });
+ }
+ }
+ void CompareChangedParameterType(string moduleName, CmdletMetadata oldCmdletMetadata, ParameterMetadata oldParameterMetadata,
+ ParameterMetadata newParameterMetadata)
+ {
+ string oldParameterTypeName = GetSimplifiedParameterTypeName(oldParameterMetadata);
+ string newParameterTypeName = GetSimplifiedParameterTypeName(newParameterMetadata);
+ if (oldParameterTypeName != newParameterTypeName)
+ {
+ diffInfo.Add(new CmdletDiffInformation()
+ {
+ ModuleName = moduleName,
+ CmdletName = oldCmdletMetadata.Name,
+ Type = ChangeType.ParameterTypeChange,
+ ParameterName = oldParameterMetadata.Name,
+ Before = new List { oldParameterTypeName },
+ After = new List { newParameterTypeName },
+ });
+ }
+ }
+ private void CompareCmdletsOutputChange(CmdletMetadata oldCmd,
+ CmdletMetadata newCmd,
+ string moduleName)
+ {
+ // OutputTypeChange
+ bool outputTypeChanged = false;
+ List oldOutputType = new List();
+ List newOutputType = new List();
+
+ foreach (var outputMetadata in oldCmd.OutputTypes)
+ {
+ string oldOutputTypeName = GetSimplifiedOutputTypeName(outputMetadata);
+ oldOutputType.Add($"`{oldOutputTypeName}`");
+ }
+
+ foreach (var outputMetadata in newCmd.OutputTypes)
+ {
+ string newOutputTypeName = GetSimplifiedOutputTypeName(outputMetadata);
+ newOutputType.Add($"`{newOutputTypeName}`");
+ }
+
+ outputTypeChanged = oldOutputType.Any(x => !newOutputType.Contains(x));
+
+ if (outputTypeChanged)
+ {
+ diffInfo.Add(new CmdletDiffInformation()
+ {
+ ModuleName = moduleName,
+ CmdletName = oldCmd.Name,
+ Type = ChangeType.OutputTypeChange,
+ Before = oldOutputType,
+ After = newOutputType,
+ });
+ }
+ }
+
+ public void GenerateMarkdown(string filePath)
+ {
+ var sb = new StringBuilder();
+ if (diffInfo == null)
+ {
+ return;
+ }
+ for (int i = 0; i < diffInfo.Count; i++)
+ {
+ if (i == 0 || diffInfo[i].ModuleName != diffInfo[i - 1].ModuleName)
+ {
+ sb.AppendFormat("#### {0} \n", diffInfo[i].ModuleName);
+ }
+ if (i == 0 || diffInfo[i].CmdletName != diffInfo[i - 1].CmdletName)
+ {
+ if (diffInfo[i].Type == ChangeType.CmdletAdd)
+ {
+ sb.AppendFormat("* Added cmdlet `{0}`\n", diffInfo[i].CmdletName);
+ }
+ else if (diffInfo[i].Type == ChangeType.CmdletRemove)
+ {
+ sb.AppendFormat("* Removed cmdlet `{0}`\n", diffInfo[i].CmdletName);
+ }
+ else
+ {
+ sb.AppendFormat("* Modified cmdlet `{0}`", diffInfo[i].CmdletName);
+ }
+ }
+ if (GetDescription(diffInfo[i]) != "")
+ {
+ sb.Append("\n * " + GetDescription(diffInfo[i]));
+ if (i < diffInfo.Count - 1 && diffInfo[i + 1].CmdletName != diffInfo[i].CmdletName)
+ {
+ sb.Append("\n");
+ }
+ }
+ }
+ File.AppendAllText(filePath, sb.ToString());
+ }
+ private string FormatListString(List list, Func formatter)
+ {
+ var builder = new StringBuilder();
+ for (int i = 0; i < list.Count; i++)
+ {
+ builder.Append(formatter(list[i]));
+ if (i != list.Count - 1)
+ {
+ builder.Append(", ");
+ }
+ }
+ return builder.ToString();
+ }
+ private string GetDescription_CmdletAdd(CmdletDiffInformation info)
+ {
+ return "";
+ }
+ private string GetDescription_CmdletRemove(CmdletDiffInformation info)
+ {
+ return "";
+ }
+ private string GetDescription_CmdletSupportsShouldProcessChange(CmdletDiffInformation info)
+ {
+ return $"`SupportsShouldProcess` changed from {info.Before[0]} to {info.After[0]}";
+ }
+ private string GetDescription_CmdletSupportsPagingChange(CmdletDiffInformation info)
+ {
+ return $"`SupportsPaging` changed from {info.Before[0]} to {info.After[0]}";
+ }
+ private string GetDescription_AliasAdd(CmdletDiffInformation info)
+ {
+ var aliasString = info.After.Count() == 1 ? "alias" : "aliases";
+ var aliasListString = FormatListString(info.After, t => $"`{t}`");
+ return $"Added {aliasString} {aliasListString} to `{info.CmdletName}`";
+ }
+ private string GetDescription_AliasRemove(CmdletDiffInformation info)
+ {
+ var aliasString = info.Before.Count() == 1 ? "alias" : "aliases";
+ var aliasListString = FormatListString(info.Before, t => $"`{t}`");
+ return $"Removed {aliasString} {aliasListString} from `{info.CmdletName}`";
+ }
+ private string GetDescription_ParameterAdd(CmdletDiffInformation info)
+ {
+ var parameterString = info.After.Count == 1 ? "parameter" : "parameters";
+ var parameterListString = FormatListString(info.After, t => $"`-{t}`");
+ return $"Added {parameterString} {parameterListString}";
+ }
+ private string GetDescription_ParameterRemove(CmdletDiffInformation info)
+ {
+ var parameterString = info.Before.Count == 1 ? "parameter" : "parameters";
+ var parameterListString = FormatListString(info.Before, t => $"`-{t}`");
+ return $"Removed {parameterString} {parameterListString}";
+ }
+ private string GetDescription_ParameterAliasAdd(CmdletDiffInformation info)
+ {
+ var aliasString = info.After.Count == 1 ? "alias" : "aliases";
+ var aliasListString = FormatListString(info.After, t => $"`{t}`");
+ return $"Added parameter {aliasString} {aliasListString} to parameter `-{info.ParameterName}`";
+ }
+ private string GetDescription_ParameterAliasRemove(CmdletDiffInformation info)
+ {
+ var aliasString = info.Before.Count == 1 ? "alias" : "aliases";
+ var aliasListString = FormatListString(info.Before, t => $"`{t}`");
+ return $"Removed parameter {aliasString} {aliasListString} from parameter `-{info.ParameterName}`";
+ }
+ private string GetDescription_ParameterTypeChange(CmdletDiffInformation info)
+ {
+ return $"Changed the type of parameter `-{info.ParameterName}` from `{info.Before[0]}` to `{info.After[0]}`";
+ }
+
+ private string GetDescription_OutputTypeChange(CmdletDiffInformation info)
+ {
+ return $"Output type changed from {FormatListString(info.Before, t => $"`{t}`")} to {FormatListString(info.After, t => $"`{t}`")}";
+ }
+ public string GetDescription(CmdletDiffInformation info)
+ {
+ Dictionary> mapper = new Dictionary>();
+ mapper.Add(ChangeType.CmdletAdd, GetDescription_CmdletAdd);
+ mapper.Add(ChangeType.CmdletRemove, GetDescription_CmdletRemove);
+ mapper.Add(ChangeType.CmdletSupportsShouldProcessChange, GetDescription_CmdletSupportsShouldProcessChange);
+ mapper.Add(ChangeType.CmdletSupportsPagingChange, GetDescription_CmdletSupportsPagingChange);
+ mapper.Add(ChangeType.AliasAdd, GetDescription_AliasAdd);
+ mapper.Add(ChangeType.AliasRemove, GetDescription_AliasRemove);
+ mapper.Add(ChangeType.ParameterAdd, GetDescription_ParameterAdd);
+ mapper.Add(ChangeType.ParameterRemove, GetDescription_ParameterRemove);
+ mapper.Add(ChangeType.ParameterAliasAdd, GetDescription_ParameterAliasAdd);
+ mapper.Add(ChangeType.ParameterAliasRemove, GetDescription_ParameterAliasRemove);
+ mapper.Add(ChangeType.ParameterTypeChange, GetDescription_ParameterTypeChange);
+ mapper.Add(ChangeType.OutputTypeChange, GetDescription_OutputTypeChange);
+
+ if (mapper.ContainsKey(info.Type))
+ {
+ return mapper[info.Type](info);
+ }
+ return "";
+ }
+ string GetSimplifiedParameterTypeName(ParameterMetadata parameterMetadata)
+ {
+ string parameterTypeName = parameterMetadata.Type.Name;
+ if (parameterTypeName.StartsWith(parameterMetadata.Type.Namespace + "."))
+ {
+ parameterTypeName = parameterTypeName.Substring(parameterMetadata.Type.Namespace.Length + 1);
+ }
+ return parameterTypeName;
+ }
+ string GetSimplifiedOutputTypeName(OutputMetadata outputMetadata)
+ {
+ string outputTypeName = outputMetadata.Type.Name;
+ if (outputTypeName.StartsWith(outputMetadata.Type.Namespace + "."))
+ {
+ outputTypeName = outputTypeName.Substring(outputMetadata.Type.Namespace.Length + 1);
+ }
+ return outputTypeName;
+ }
+ }
+}
diff --git a/tools/VersionController/Program.cs b/tools/VersionController/Program.cs
index 32ca1a7489ca..511dcac9fe0b 100644
--- a/tools/VersionController/Program.cs
+++ b/tools/VersionController/Program.cs
@@ -22,13 +22,14 @@
using Tools.Common.Models;
using Tools.Common.Utilities;
using VersionController.Models;
+using VersionController.Netcore.Models;
namespace VersionController
{
public class Program
{
private static VersionBumper _versionBumper;
-
+ private static SyntaxChangelogGenerator _syntaxChangelogGenerator = new SyntaxChangelogGenerator();
private static Dictionary _minimalVersion = new Dictionary();
private static List _projectDirectories, _outputDirectories;
private static string _rootDirectory, _moduleNameFilter;
@@ -45,7 +46,6 @@ public class Program
"SignatureIssues.csv",
"ExampleIssues.csv"
};
-
public static void Main(string[] args)
{
var executingAssemblyPath = Assembly.GetExecutingAssembly().Location;
@@ -76,9 +76,13 @@ public static void Main(string[] args)
ConsolidateExceptionFiles(exceptionsDirectory);
ValidateManifest();
+ GenerateSyntaxChangelog(Path.Combine(_rootDirectory, @"src\"));
BumpVersions();
}
-
+ private static void GenerateSyntaxChangelog(string _projectDirectories)
+ {
+ _syntaxChangelogGenerator.Analyze(_projectDirectories);
+ }
private static void ValidateManifest()
{
foreach (var directory in _projectDirectories)