repo mirror list: co-locate and simplify sortRows · Entire
repo mirror list: co-locate and simplify sortRows
110a063→main·
gtrrz-victor·1w ago·4 files·+96 added/-145 removed
sortRows is only used by mirror list, so move it (and its test) out of the generic corecmd.go into repo_mirror.go next to filterByRepo/sortMirrorsDefault. Inline the headerIndex/cellAt helpers and drop the key-permutation micro-opt — a plain stable sort over the row cells is enough for CLI-sized lists.
Co-Authored-By: Claude Opus 4.8 (1M context) noreply@anthropic.com
Sessions
01KWY6XMPEG22C7961HMJR6K0BView transcript
Changes
4
cmd/entire/cli
Mcorecmd.go-58
Mcorecmd_test.go-87
Mrepo_mirror.go+32
Mrepo_mirror_test.go+64
5 unmodified lines
6
7
8
9
9
10
11
449 unmodified lines
461
462
463
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
464
465
466
5 unmodified lines
"errors"
"fmt"
"io"
"sort"
"strings"
"charm.land/huh/v2"
449 unmodified lines
return err
}
// sortRows orders items in place by one column's rendered value, ascending
// case-insensitive string order. spec is a header name; a leading '-' sorts
// descending. An empty spec sorts by the first column (the primary identifier),
// so a list is always deterministically ordered. An unknown column name is an
// error naming the valid columns. Stable, so rows equal on the sort column keep
// their input order. The sort key for each item is computed once (not per
// comparison): keys are precomputed and a stable permutation of indices is
// sorted against them, then items are reordered to match.
func sortRows[T any](items []T, headers []string, row func(T) []string, spec string) error {
desc := strings.HasPrefix(spec, "-")
name := strings.ToLower(strings.TrimSpace(strings.TrimPrefix(spec, "-")))
idx := 0
if name != "" {
if idx = headerIndex(headers, name); idx < 0 {
return fmt.Errorf("unknown sort column %q; valid columns: %s", name, strings.ToLower(strings.Join(headers, ", ")))
}
}
keys := make([]string, len(items))
perm := make([]int, len(items))
for i, it := range items {
keys[i] = strings.ToLower(cellAt(row(it), idx))
perm[i] = i
}
sort.SliceStable(perm, func(a, b int) bool {
if desc {
return keys[perm[a]] > keys[perm[b]]
}
return keys[perm[a]] < keys[perm[b]]
})
sorted := make([]T, len(items))
for i, p := range perm {
sorted[i] = items[p]
}
copy(items, sorted)
return nil
}
// headerIndex returns the index of the column named name (case-insensitive), or
// -1 if no header matches.
func headerIndex(headers []string, name string) int {
for i, h := range headers {
if strings.EqualFold(h, name) {
return i
}
}
return -1
}
// cellAt returns cells[i], or "" when i is out of range — so a row with fewer
// cells than headers sorts/filters as empty rather than panicking.
func cellAt(cells []string, i int) string {
if i >= 0 && i < len(cells) {
return cells[i]
}
return ""
}
// printJSON writes v as indented JSON to w — the --json view for list/get
// and mutations.
func printJSON(w io.Writer, v any) error {
Mcmd/entire/cli/corecmd.go-58
146 unmodified lines
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
146 unmodified lines
t.Errorf("printFields output:\n%q\nwant:\n%q", got, want)
}
}
// filterSortRow is the test fixture: two columns, REPO and PRIVATE, mapped by
// filterSortRowFn — exercises sortRows over a real multi-column row.
type filterSortRow struct {
repo string
private string
}
var filterSortHeaders = []string{"REPO", "PRIVATE"}
func filterSortRowFn(r filterSortRow) []string { return []string{r.repo, r.private} }
func filterSortRepos(items []filterSortRow) []string {
out := make([]string, len(items))
for i, it := range items {
out[i] = it.repo
}
return out
}
func TestSortRows(t *testing.T) {
t.Parallel()
t.Run("empty spec sorts by first column ascending", func(t *testing.T) {
t.Parallel()
items := []filterSortRow{{repo: "b/y"}, {repo: "a/x"}, {repo: "c/z"}}
if err := sortRows(items, filterSortHeaders, filterSortRowFn, ""); err != nil {
t.Fatalf("sortRows: %v", err)
}
if want := []string{"a/x", "b/y", "c/z"}; !equalStrings(filterSortRepos(items), want) {
t.Errorf("default sort: got %v, want %v", filterSortRepos(items), want)
}
})
t.Run("leading dash sorts descending", func(t *testing.T) {
t.Parallel()
items := []filterSortRow{{repo: "b/y"}, {repo: "a/x"}, {repo: "c/z"}}
if err := sortRows(items, filterSortHeaders, filterSortRowFn, "-repo"); err != nil {
t.Fatalf("sortRows: %v", err)
}
if want := []string{"c/z", "b/y", "a/x"}; !equalStrings(filterSortRepos(items), want) {
t.Errorf("descending sort: got %v, want %v", filterSortRepos(items), want)
}
})
t.Run("sorts by named column", func(t *testing.T) {
t.Parallel()
items := []filterSortRow{
{repo: "a", private: "yes"},
{repo: "b", private: "no"},
}
if err := sortRows(items, filterSortHeaders, filterSortRowFn, "private"); err != nil {
t.Fatalf("sortRows: %v", err)
}
// "no" < "yes", so the second row comes first.
if want := []string{"b", "a"}; !equalStrings(filterSortRepos(items), want) {
t.Errorf("named-column sort: got %v, want %v", filterSortRepos(items), want)
}
})
t.Run("stable for equal keys", func(t *testing.T) {
t.Parallel()
items := []filterSortRow{
{repo: "same", private: "1"},
{repo: "same", private: "2"},
{repo: "same", private: "3"},
}
if err := sortRows(items, filterSortHeaders, filterSortRowFn, "repo"); err != nil {
t.Fatalf("sortRows: %v", err)
}
if items[0].private != "1" || items[1].private != "2" || items[2].private != "3" {
t.Errorf("stability: equal keys reordered: %+v", items)
}
})
t.Run("unknown column errors naming valid columns", func(t *testing.T) {
t.Parallel()
items := []filterSortRow{{repo: "a"}}
err := sortRows(items, filterSortHeaders, filterSortRowFn, "nope")
if err == nil {
t.Fatal("unknown column: expected error, got nil")
}
if !strings.Contains(err.Error(), "unknown sort column") || !strings.Contains(err.Error(), "repo") {
t.Errorf("unknown column: message %q must name the bad column and valid columns", err)
}
})
}
Mcmd/entire/cli/corecmd_test.go-87
52 unmodified lines
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
52 unmodified lines
})
}
// sortRows orders items in place by one column's rendered value, ascending
// case-insensitive string order. spec is a header name; a leading '-' sorts
// descending. An empty spec sorts by the first column. An unknown column name
// is an error naming the valid columns. Stable, so rows equal on the sort
// column keep their input order. row must return one cell per header, which the
// mirror/available row funcs do.
func sortRows[T any](items []T, headers []string, row func(T) []string, spec string) error {
desc := strings.HasPrefix(spec, "-")
name := strings.ToLower(strings.TrimSpace(strings.TrimPrefix(spec, "-")))
idx := 0
if name != "" {
idx = -1
for i, h := range headers {
if strings.EqualFold(h, name) {
idx = i
break
}
}
if idx < 0 {
return fmt.Errorf("unknown sort column %q; valid columns: %s", name, strings.ToLower(strings.Join(headers, ", ")))
}
}
sort.SliceStable(items, func(a, b int) bool {
ka, kb := strings.ToLower(row(items[a])[idx]), strings.ToLower(row(items[b])[idx])
if desc {
return ka > kb
}
return ka < kb
})
return nil
}
// filterByRepo keeps items whose repo name contains substr (case-insensitive).
// The control plane already filters by owner/provider/cluster server-side but
// not by repo name, so `repo mirror list --repo` narrows that last dimension
Mcmd/entire/cli/repo_mirror.go+32
1015 unmodified lines
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1015 unmodified lines
require.Empty(t, out.String())
})
}
// sortRowsRow is the TestSortRows fixture: two columns, REPO and PRIVATE,
// mapped by sortRowsRowFn — exercises sortRows over a real multi-column row.
type sortRowsRow struct {
repo string
private string
}
var sortRowsHeaders = []string{"REPO", "PRIVATE"}
func sortRowsRowFn(r sortRowsRow) []string { return []string{r.repo, r.private} }
func sortRowsRepos(items []sortRowsRow) []string {
out := make([]string, len(items))
for i, it := range items {
out[i] = it.repo
}
return out
}
func TestSortRows(t *testing.T) {
t.Parallel()
t.Run("empty spec sorts by first column ascending", func(t *testing.T) {
t.Parallel()
items := []sortRowsRow{{repo: "b/y"}, {repo: "a/x"}, {repo: "c/z"}}
require.NoError(t, sortRows(items, sortRowsHeaders, sortRowsRowFn, ""))
require.Equal(t, []string{"a/x", "b/y", "c/z"}, sortRowsRepos(items))
})
t.Run("leading dash sorts descending", func(t *testing.T) {
t.Parallel()
items := []sortRowsRow{{repo: "b/y"}, {repo: "a/x"}, {repo: "c/z"}}
require.NoError(t, sortRows(items, sortRowsHeaders, sortRowsRowFn, "-repo"))
require.Equal(t, []string{"c/z", "b/y", "a/x"}, sortRowsRepos(items))
})
t.Run("sorts by named column", func(t *testing.T) {
t.Parallel()
items := []sortRowsRow{{repo: "a", private: "yes"}, {repo: "b", private: "no"}}
require.NoError(t, sortRows(items, sortRowsHeaders, sortRowsRowFn, "private"))
// "no" < "yes", so the second row comes first.
require.Equal(t, []string{"b", "a"}, sortRowsRepos(items))
})
t.Run("stable for equal keys", func(t *testing.T) {
t.Parallel()
items := []sortRowsRow{
{repo: "same", private: "1"},
{repo: "same", private: "2"},
{repo: "same", private: "3"},
}
require.NoError(t, sortRows(items, sortRowsHeaders, sortRowsRowFn, "repo"))
require.Equal(t, []string{"1", "2", "3"}, []string{items[0].private, items[1].private, items[2].private})
})
t.Run("unknown column errors naming valid columns", func(t *testing.T) {
t.Parallel()
err := sortRows([]sortRowsRow{{repo: "a"}}, sortRowsHeaders, sortRowsRowFn, "nope")
require.Error(t, err)
require.Contains(t, err.Error(), "unknown sort column")
require.Contains(t, err.Error(), "repo")
})
}
Mcmd/entire/cli/repo_mirror_test.go+64