changelog sort (Azure#19578)

* changelog sort

* add changelog sort test

* gofmt

* Licensed

* add sortFuncItem func

Author: Alancere

eng/tools/generator/autorest/model/changelog.go

@@ -5,9 +5,11 @@ package model
 
 import (
 	"fmt"
+	"sort"
 	"strings"
 
 	"github.com/Azure/azure-sdk-for-go/eng/tools/internal/delta"
+	"github.com/Azure/azure-sdk-for-go/eng/tools/internal/exports"
 	"github.com/Azure/azure-sdk-for-go/eng/tools/internal/markdown"
 	"github.com/Azure/azure-sdk-for-go/eng/tools/internal/report"
 )
@@ -124,19 +126,20 @@ func getNewContents(c *delta.Content) []string {
 	var items []string
 
 	if len(c.Consts) > 0 {
-		for k := range c.Consts {
+		for _, k := range sortChangeItem(c.Consts) {
 			line := fmt.Sprintf("New const `%s`", k)
 			items = append(items, line)
 		}
 	}
 	if len(c.TypeAliases) > 0 {
-		for k := range c.TypeAliases {
+		for _, k := range sortChangeItem(c.TypeAliases) {
 			line := fmt.Sprintf("New type alias `%s`", k)
 			items = append(items, line)
 		}
 	}
 	if len(c.Funcs) > 0 {
-		for k, v := range c.Funcs {
+		for _, k := range sortFuncItem(c.Funcs) {
+			v := c.Funcs[k]
 			params := ""
 			if v.Params != nil {
 				params = *v.Params
@@ -160,13 +163,14 @@ func getNewContents(c *delta.Content) []string {
 	}
 	if len(c.Structs) > 0 {
 		modified := c.GetModifiedStructs()
-		for s, f := range modified {
+		for _, s := range sortChangeItem(modified) {
+			f := modified[s]
 			for _, af := range f.AnonymousFields {
 				line := fmt.Sprintf("New anonymous field `%s` in struct `%s`", af, s)
 				items = append(items, line)
 			}
-			for f := range f.Fields {
-				line := fmt.Sprintf("New field `%s` in struct `%s`", f, s)
+			for _, field := range sortChangeItem(f.Fields) {
+				line := fmt.Sprintf("New field `%s` in struct `%s`", field, s)
 				items = append(items, line)
 			}
 		}
@@ -199,22 +203,24 @@ func getSignatureChangeItems(b *report.BreakingChanges) []string {
 
 	// write const changes
 	if len(b.Consts) > 0 {
-		for k, v := range b.Consts {
+		for _, k := range sortChangeItem(b.Consts) {
+			v := b.Consts[k]
 			line := fmt.Sprintf("Const `%s` type has been changed from `%s` to `%s`", k, v.From, v.To)
 			items = append(items, line)
 		}
-		// TODO -- sort?
 	}
 	// write type alias changes
 	if len(b.TypeAliases) > 0 {
-		for k, v := range b.TypeAliases {
+		for _, k := range sortChangeItem(b.TypeAliases) {
+			v := b.TypeAliases[k]
 			line := fmt.Sprintf("Type alias `%s` type has been changed from `%s` to `%s`", k, v.From, v.To)
 			items = append(items, line)
 		}
 	}
 	// write function changes
 	if len(b.Funcs) > 0 {
-		for k, v := range b.Funcs {
+		for _, k := range sortFuncItem(b.Funcs) {
+			v := b.Funcs[k]
 			if v.Params != nil {
 				line := fmt.Sprintf("Function `%s` parameter(s) have been changed from `(%s)` to `(%s)`", k, v.Params.From, v.Params.To)
 				items = append(items, line)
@@ -227,7 +233,8 @@ func getSignatureChangeItems(b *report.BreakingChanges) []string {
 	}
 	// write struct changes
 	if len(b.Structs) > 0 {
-		for k, v := range b.Structs {
+		for _, k := range sortChangeItem(b.Structs) {
+			v := b.Structs[k]
 			for f, d := range v.Fields {
 				line := fmt.Sprintf("Type of `%s.%s` has been changed from `%s` to `%s`", k, f, d.From, d.To)
 				items = append(items, line)
@@ -247,21 +254,21 @@ func getRemovedContent(removed *delta.Content) []string {
 	var items []string
 	// write constants
 	if len(removed.Consts) > 0 {
-		for k := range removed.Consts {
+		for _, k := range sortChangeItem(removed.Consts) {
 			line := fmt.Sprintf("Const `%s` has been removed", k)
 			items = append(items, line)
 		}
 	}
 	// write type alias
 	if len(removed.TypeAliases) > 0 {
-		for k := range removed.TypeAliases {
+		for _, k := range sortChangeItem(removed.TypeAliases) {
 			line := fmt.Sprintf("Type alias `%s` has been removed", k)
 			items = append(items, line)
 		}
 	}
 	// write functions
 	if len(removed.Funcs) > 0 {
-		for k := range removed.Funcs {
+		for _, k := range sortFuncItem(removed.Funcs) {
 			line := fmt.Sprintf("Function `%s` has been removed", k)
 			items = append(items, line)
 		}
@@ -276,17 +283,79 @@ func getRemovedContent(removed *delta.Content) []string {
 	// write struct modification (some fields are removed)
 	modified := removed.GetModifiedStructs()
 	if len(modified) > 0 {
-		for s, f := range modified {
+		for _, s := range sortChangeItem(modified) {
+			f := modified[s]
 			for _, af := range f.AnonymousFields {
 				line := fmt.Sprintf("Field `%s` of struct `%s` has been removed", af, s)
 				items = append(items, line)
 			}
-			for f := range f.Fields {
-				line := fmt.Sprintf("Field `%s` of struct `%s` has been removed", f, s)
+			for _, field := range sortChangeItem(f.Fields) {
+				line := fmt.Sprintf("Field `%s` of struct `%s` has been removed", field, s)
 				items = append(items, line)
 			}
 		}
 	}
 
 	return items
 }
+
+type sortItem interface {
+	delta.Signature | delta.StructDef | exports.Const | exports.TypeAlias | exports.Struct | string
+}
+
+func sortChangeItem[T sortItem](change map[string]T) []string {
+	s := make([]string, 0, len(change))
+	for k := range change {
+		s = append(s, k)
+	}
+
+	sort.Strings(s)
+	return s
+}
+
+func sortFuncItem[T delta.FuncSig | exports.Func](change map[string]T) []string {
+	s := make([]string, 0, len(change))
+	for k := range change {
+		s = append(s, k)
+	}
+
+	sort.Slice(s, func(i, j int) bool {
+		si := removePattern(s[i], getReturnValue(change[s[i]]))
+		sj := removePattern(s[j], getReturnValue(change[s[j]]))
+		return si < sj
+	})
+
+	return s
+}
+
+func getReturnValue(t interface{}) string {
+	switch value := t.(type) {
+	case delta.FuncSig:
+		if value.Returns == nil {
+			return ""
+		}
+		return value.Returns.To
+	case exports.Func:
+		if value.Returns == nil {
+			return ""
+		}
+		return *value.Returns
+	}
+	return ""
+}
+
+func removePattern(funcName string, returnValue string) string {
+	funcName = strings.TrimLeft(strings.TrimLeft(funcName, "*"), "New")
+	before, after, b := strings.Cut(funcName, ".")
+	if !b {
+		return funcName
+	}
+
+	if strings.Contains(returnValue, "runtime.Poller") {
+		after = strings.TrimLeft(after, "Begin")
+	} else if strings.Contains(returnValue, "runtime.Pager") {
+		after = strings.TrimLeft(after, "New")
+	}
+
+	return fmt.Sprintf("%s.%s", before, after)
+}

eng/tools/generator/autorest/model/changelog_test.go

@@ -0,0 +1,47 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+package model
+
+import (
+	"testing"
+
+	"github.com/Azure/azure-sdk-for-go/eng/tools/internal/exports"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSortFuncItem(t *testing.T) {
+	get := "PrivateEndpointConnectionsClientGetResponse, error"
+	beginDelete := "*runtime.Poller[PrivateEndpointConnectionsClientDeleteResponse], error"
+	beginCreate := "*runtime.Poller[PrivateEndpointConnectionsClientCreateResponse], error"
+	newListPager := "*runtime.Pager[PrivateEndpointConnectionsClientListResponse]"
+	newClient := "*PrivateEndpointConnectionsClient, error"
+
+	s := map[string]exports.Func{
+		"*PrivateEndpointConnectionsClient.Get": {
+			Returns: &get,
+		},
+		"*PrivateEndpointConnectionsClient.BeginDelete": {
+			Returns: &beginDelete,
+		},
+		"*PrivateEndpointConnectionsClient.BeginCreate": {
+			Returns: &beginCreate,
+		},
+		"*PrivateEndpointConnectionsClient.NewListPager": {
+			Returns: &newListPager,
+		},
+		"NewPrivateEndpointConnectionsClient": {
+			Returns: &newClient,
+		},
+	}
+
+	sortResult := sortFuncItem(s)
+	expcted := []string{
+		"NewPrivateEndpointConnectionsClient",
+		"*PrivateEndpointConnectionsClient.BeginCreate",
+		"*PrivateEndpointConnectionsClient.BeginDelete",
+		"*PrivateEndpointConnectionsClient.Get",
+		"*PrivateEndpointConnectionsClient.NewListPager",
+	}
+	assert.Equal(t, expcted, sortResult)
+}