rule: make value sorting configurable (alternative implementation) (b…

…azel-contrib#1719)

* rule: add tests for attribute value sorting

* rule: make value sorting configurable

rule/rule.go

@@ -725,10 +725,11 @@ func (l *Load) sync() {
 // Rule represents a rule statement within a build file.
 type Rule struct {
 	stmt
-	kind    bzl.Expr
-	args    []bzl.Expr
-	attrs   map[string]attrValue
-	private map[string]interface{}
+	kind        bzl.Expr
+	args        []bzl.Expr
+	attrs       map[string]attrValue
+	private     map[string]interface{}
+	sortedAttrs []string
 }
 
 type attrValue struct {
@@ -746,10 +747,11 @@ func NewRule(kind, name string) *Rule {
 	call := &bzl.CallExpr{X: kindIdent}
 
 	r := &Rule{
-		stmt:    stmt{expr: call},
-		kind:    kindIdent,
-		attrs:   map[string]attrValue{},
-		private: map[string]interface{}{},
+		stmt:        stmt{expr: call},
+		kind:        kindIdent,
+		attrs:       map[string]attrValue{},
+		private:     map[string]interface{}{},
+		sortedAttrs: []string{"deps", "srcs"},
 	}
 	if name != "" {
 		nameAttr := attrValue{
@@ -1014,6 +1016,17 @@ func (r *Rule) AddArg(value bzl.Expr) {
 	r.updated = true
 }
 
+// SortedAttrs returns the keys of attributes whose values will be sorted
+func (r *Rule) SortedAttrs() []string {
+	return r.sortedAttrs
+}
+
+// SetSortedAttrs sets the keys of attributes whose values will be sorted
+func (r *Rule) SetSortedAttrs(keys []string) {
+	r.sortedAttrs = keys
+	r.updated = true
+}
+
 // Insert marks this statement for insertion at the end of the file. Multiple
 // statements will be inserted in the order Insert is called.
 func (r *Rule) Insert(f *File) {
@@ -1057,7 +1070,7 @@ func (r *Rule) sync() {
 	}
 	r.updated = false
 
-	for _, k := range []string{"srcs", "deps"} {
+	for _, k := range r.sortedAttrs {
 		attr, ok := r.attrs[k]
 		_, isUnsorted := attr.val.(UnsortedStrings)
 		if ok && !isUnsorted {

rule/rule_test.go

@@ -666,3 +666,82 @@ export_files(glob(["**"]))
 		t.Errorf("got:%s\nwant:%s", got, want)
 	}
 }
+
+func TestAttributeValueSorting(t *testing.T) {
+	f := EmptyFile("foo", "bar")
+
+	r := NewRule("a_rule", "")
+	r.SetAttr("deps", []string{"foo", "bar", "baz"})
+	r.SetAttr("srcs", UnsortedStrings{"foo", "bar", "baz"})
+	r.SetAttr("hdrs", []string{"foo", "bar", "baz"})
+
+	r.Insert(f)
+	f.Sync()
+
+	got := strings.TrimSpace(string(bzl.FormatWithoutRewriting(f.File)))
+	want := strings.TrimSpace(`
+a_rule(
+    srcs = [
+        "foo",
+        "bar",
+        "baz",
+    ],
+    hdrs = [
+        "foo",
+        "bar",
+        "baz",
+    ],
+    deps = [
+        "bar",
+        "baz",
+        "foo",
+    ],
+)
+`)
+
+	if got != want {
+		t.Errorf("got:%s\nwant:%s", got, want)
+	}
+}
+
+func TestAttributeValueSortingOverride(t *testing.T) {
+	f := EmptyFile("foo", "bar")
+
+	r := NewRule("a_rule", "")
+	r.SetAttr("deps", []string{"foo", "bar", "baz"})
+	r.SetAttr("srcs", UnsortedStrings{"foo", "bar", "baz"})
+	r.SetAttr("hdrs", []string{"foo", "bar", "baz"})
+	r.SetSortedAttrs([]string{"srcs", "hdrs"})
+
+	r.Insert(f)
+	f.Sync()
+
+	got := strings.TrimSpace(string(bzl.FormatWithoutRewriting(f.File)))
+	want := strings.TrimSpace(`
+a_rule(
+    srcs = [
+        "foo",
+        "bar",
+        "baz",
+    ],
+    hdrs = [
+        "bar",
+        "baz",
+        "foo",
+    ],
+    deps = [
+        "foo",
+        "bar",
+        "baz",
+    ],
+)
+`)
+
+	if got != want {
+		t.Errorf("got:%s\nwant:%s", got, want)
+	}
+
+	if !reflect.DeepEqual(r.SortedAttrs(), []string{"srcs", "hdrs"}) {
+		t.Errorf("Unexpected r.SortedAttrs(): %v", r.SortedAttrs())
+	}
+}