Support sorting protos in DNS order.

PiperOrigin-RevId: 802614039

Author: txtpbfmt-copybara-robot

ast/ast.go

@@ -183,21 +183,24 @@ func getFieldValueForByFieldValue(n *Node) *Value {
 	return n.Values[0]
 }
 
-// ByFieldValue is a NodeLess function that orders adjacent scalar nodes with the same name by
-// their scalar value.
-func ByFieldValue(_, ni, nj *Node, isWholeSlice bool) bool {
-	if isWholeSlice {
-		return false
-	}
-	vi := getFieldValueForByFieldValue(ni)
-	vj := getFieldValueForByFieldValue(nj)
-	if vi == nil {
-		return vj != nil
-	}
-	if vj == nil {
-		return false
+// ByFieldValue returns a NodeLess function that orders adjacent scalar nodes
+// with the same name by their scalar value. The values are passed through
+// `projection` before sorting.
+func ByFieldValue(projection func(string) string) NodeLess {
+	return func(_, ni, nj *Node, isWholeSlice bool) bool {
+		if isWholeSlice {
+			return false
+		}
+		vi := getFieldValueForByFieldValue(ni)
+		vj := getFieldValueForByFieldValue(nj)
+		if vi == nil {
+			return vj != nil
+		}
+		if vj == nil {
+			return false
+		}
+		return projection(vi.Value) < projection(vj.Value)
 	}
-	return vi.Value < vj.Value
 }
 
 func getChildValueByFieldSubfield(field, subfield string, n *Node) *Value {
@@ -245,8 +248,9 @@ func ByFieldSubfield(field, subfield string) NodeLess {
 
 // ByFieldSubfieldPath returns a NodeLess function that orders adjacent message nodes with the given
 // field name by the given subfield path value. If no field name is provided, it compares the
-// subfields of any adjacent nodes with matching names.
-func ByFieldSubfieldPath(field string, subfieldPath []string) NodeLess {
+// subfields of any adjacent nodes with matching names. Values are passed
+// through `projection` before sorting.
+func ByFieldSubfieldPath(field string, subfieldPath []string, projection func(string) string) NodeLess {
 	return func(_, ni, nj *Node, isWholeSlice bool) bool {
 		if isWholeSlice {
 			return false
@@ -259,7 +263,7 @@ func ByFieldSubfieldPath(field string, subfieldPath []string) NodeLess {
 		if vj == nil {
 			return false
 		}
-		return vi.Value < vj.Value
+		return projection(vi.Value) < projection(vj.Value)
 	}
 }
 

config/config.go

@@ -35,6 +35,11 @@ type Config struct {
 	// Sort the Sort* fields by descending order instead of ascending order.
 	ReverseSort bool
 
+	// Sort content fields in a way that's suitable for DNS names. It splits the
+	// value around '.' characters, reverses the substrings, and concatenates to
+	// generate the sort key.
+	DNSSortOrder bool
+
 	// Map from Node.Name to the order of all fields within that node. See AddFieldSortOrder().
 	FieldSortOrder map[string][]string
 

docs/config.md

@@ -153,6 +153,22 @@ order. Does nothing if not used with at least 1 other `sort_*` field.
 
 [Example](examples/reverse_sort.OUT.textproto)
 
+## DNSSortOrder
+`# txtpbfmt: dns_sort_order`
+
+When sorting field contents, sorts in a way intended for DNS names. It splits
+the contents on '.' characters, reverses the substrings, and sorts on their
+concatenation. This puts, e.g., `a.com` and `c.com` next to each other even if
+`b.au` is in the list.
+
+### Before formatting
+
+[Example](examples/sort_repeated_fields_by_subfield_in_dns_order.IN.textproto)
+
+### After formatting
+
+[Example](examples/sort_repeated_fields_by_subfield_in_dns_order.OUT.textproto)
+
 ## WrapHTMLStrings
 `# txtpbfmt: wrap_html_strings`
 

docs/examples/sort_repeated_fields_by_subfield_in_dns_order.IN.textproto

@@ -0,0 +1,13 @@
+# txtpbfmt: sort_repeated_fields_by_subfield=hostinfo.name
+# txtpbfmt: dns_sort_order
+head {
+  hostinfo {
+    name: "a.com"
+  }
+  hostinfo {
+    name: "b.au"
+  }
+  hostinfo {
+    name: "c.com"
+  }
+}

docs/examples/sort_repeated_fields_by_subfield_in_dns_order.OUT.textproto

@@ -0,0 +1,13 @@
+# txtpbfmt: sort_repeated_fields_by_subfield=hostinfo.name
+# txtpbfmt: dns_sort_order
+head {
+  hostinfo {
+    name: "b.au"
+  }
+  hostinfo {
+    name: "a.com"
+  }
+  hostinfo {
+    name: "c.com"
+  }
+}

impl/impl.go

@@ -209,6 +209,8 @@ func addToConfig(metaComment string, c *config.Config) error {
 		c.SortRepeatedFieldsBySubfield = append(c.SortRepeatedFieldsBySubfield, val)
 	case "reverse_sort":
 		c.ReverseSort = true
+	case "dns_sort_order":
+		c.DNSSortOrder = true
 	case "wrap_strings_at_column":
 		// If multiple of this MetaComment exists in the file, take the last one.
 		if !hasEqualSign {

parser/parser_test.go

@@ -2147,6 +2147,48 @@ func TestParserConfigs(t *testing.T) {
   }
   auto_reviewers: "reviewerA"
 }
+`,
+	}, {
+		name: "SortRepeatedFieldsByContentInDNSOrder",
+		in: `head {
+  host: "a.com"
+  host: "b.au"
+  host: "c.com"
+}
+`,
+		config: config.Config{SortRepeatedFieldsByContent: true, DNSSortOrder: true},
+		out: `head {
+  host: "b.au"
+  host: "a.com"
+  host: "c.com"
+}
+`,
+	}, {
+		name: "SortRepeatedFieldsBySubfieldInDNSOrder",
+		in: `head {
+  hostinfo {
+    name: "a.com"
+  }
+  hostinfo {
+    name: "b.au"
+  }
+  hostinfo {
+    name: "c.com"
+  }
+}
+`,
+		config: config.Config{SortRepeatedFieldsBySubfield: []string{"hostinfo.name"}, DNSSortOrder: true},
+		out: `head {
+  hostinfo {
+    name: "b.au"
+  }
+  hostinfo {
+    name: "a.com"
+  }
+  hostinfo {
+    name: "c.com"
+  }
+}
 `,
 	}, {
 		name: "SortFieldNamesAndContents",

sort/sort.go

@@ -32,6 +32,19 @@ func (e *UnsortedFieldsError) Error() string {
 	return fmt.Sprintf("fields parsed that were not specified in the parser.AddFieldSortOrder() call:\n%s", strings.Join(errs, "\n"))
 }
 
+func identityProjection(s string) string {
+	return s
+}
+
+func dnsProjection(s string) string {
+	parts := strings.Split(s, ".")
+	// Reverse `parts`.
+	for i, j := 0, len(parts)-1; i < j; i, j = i+1, j-1 {
+		parts[i], parts[j] = parts[j], parts[i]
+	}
+	return strings.Join(parts, ".")
+}
+
 // nodeSortFunction sorts the given nodes, using the parent node as context. parent can be nil.
 type nodeSortFunction func(parent *ast.Node, nodes []*ast.Node) error
 
@@ -130,13 +143,18 @@ func nodeSortFunctionConfig(c config.Config) nodeSortFunction {
 	if c.SortFieldsByFieldName {
 		sorter = ast.ChainNodeLess(sorter, ast.ByFieldName)
 	}
+	projection := identityProjection
+	if c.DNSSortOrder {
+		projection = dnsProjection
+	}
 	if c.SortRepeatedFieldsByContent {
-		sorter = ast.ChainNodeLess(sorter, ast.ByFieldValue)
+		sorter = ast.ChainNodeLess(sorter, ast.ByFieldValue(projection))
 	}
 	for _, sf := range c.SortRepeatedFieldsBySubfield {
 		field, subfieldPath := parseSubfieldSpec(sf)
 		if len(subfieldPath) > 0 {
-			sorter = ast.ChainNodeLess(sorter, ast.ByFieldSubfieldPath(field, subfieldPath))
+			sorter = ast.ChainNodeLess(sorter, ast.ByFieldSubfieldPath(field, subfieldPath,
+				projection))
 		}
 	}
 	if sorter != nil {

sort/sort_test.go

@@ -317,6 +317,10 @@ func TestNodeSortFunction(t *testing.T) {
 		name: "SortRepeatedFieldsBySubfield",
 		c:    config.Config{SortRepeatedFieldsBySubfield: []string{"field.subfield"}},
 		want: true,
+	}, {
+		name: "SortRepeatedFieldsBySubfieldInDNSOrder",
+		c:    config.Config{SortRepeatedFieldsBySubfield: []string{"field.subfield"}, DNSSortOrder: true},
+		want: true,
 	}, {
 		name: "FieldSortOrder",
 		c: config.Config{