Fix up how tosec works

Author: stilvoid

TODO.md

@@ -0,0 +1,3 @@
+# Todo
+
+* Handle cases where Sort results in >`size` _directories_

cmd/retro-sort.go cmd/retro-sort/main.gocmd/retro-sort.go renamed to cmd/retro-sort/main.go

@@ -4,10 +4,11 @@ import (
 	"fmt"
 	"maps"
 	"os"
+	"runtime/debug"
 	"slices"
 
 	"github.com/spf13/cobra"
-	"github.com/stilvoid/retrosort"
+	retrosort "github.com/stilvoid/retro-sort"
 )
 
 var src, dst string
@@ -25,6 +26,10 @@ func init() {
 	rootCmd.Flags().BoolVarP(&printOnly, "dry-run", "n", false, "Dry run. Print the file names and exit")
 	rootCmd.Flags().BoolVarP(&quiet, "quiet", "q", false, "Don't print anything, just do it")
 	rootCmd.Flags().BoolVar(&tosec, "tosec", false, "Experimental: Detect TOSEC filenames and group related files")
+
+	if b, ok := debug.ReadBuildInfo(); ok {
+		rootCmd.Version = b.Main.Version
+	}
 }
 
 var rootCmd = &cobra.Command{

entry.go

@@ -0,0 +1,79 @@
+package retrosort
+
+import (
+	"regexp"
+	"strings"
+
+	"path/filepath"
+)
+
+func getPrefix(fn string, prefixSize int) string {
+	fn = strings.ToLower(filepath.Base(fn))
+
+	if len(fn) < prefixSize {
+		return fn
+	}
+
+	return fn[:prefixSize]
+}
+
+func getCategory(fn string) string {
+	c := strings.ToLower(filepath.Base(fn))[0]
+
+	if c >= 'a' && c <= 'z' {
+		return string(c)
+	}
+
+	return "#"
+}
+
+// entry represents a single entry in the output tree
+// name is the file name for a single source
+// or the group name for multiple sources
+// sources is a list of paths to copy from
+type entry struct {
+	name     string
+	sortName string
+	sources  []string
+}
+
+var sortNameRe = regexp.MustCompile(`[^a-z0-9]+`)
+
+func newEntry(name string, sources []string) entry {
+	sortName := strings.ToLower(name)
+	sortName = sortNameRe.ReplaceAllString(sortName, "_")
+
+	return entry{
+		name:     name,
+		sortName: sortName,
+		sources:  sources,
+	}
+}
+
+func (e entry) prefix(size int) string {
+	if size == 1 {
+		return getCategory(e.sortName[:size])
+	}
+
+	if size >= len(e.sortName) {
+		return e.sortName
+	}
+
+	return e.sortName[:size]
+}
+
+func (e entry) fileMap() map[string]string {
+	out := make(map[string]string)
+
+	for _, source := range e.sources {
+		path := filepath.Base(source)
+
+		if len(e.sources) > 1 {
+			path = filepath.Join(e.name, path)
+		}
+
+		out[source] = path
+	}
+
+	return out
+}

entry_test.go

@@ -0,0 +1,82 @@
+package retrosort
+
+import (
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+)
+
+func TestEntryPrefixLong(t *testing.T) {
+	e := newEntry("a file name.foo", []string{"a file name.foo"})
+
+	if d := cmp.Diff("a_file_name_foo", e.prefix(15)); d != "" {
+		t.Error(d)
+	}
+
+	if d := cmp.Diff("a_file_name_foo", e.prefix(16)); d != "" {
+		t.Error(d)
+	}
+}
+
+func TestEntryPrefixSingle(t *testing.T) {
+	es := []entry{
+		newEntry("123", []string{}),
+		newEntry(".-#", []string{}),
+		newEntry(" _%3", []string{}),
+	}
+
+	for _, e := range es {
+		if d := cmp.Diff("#", e.prefix(1)); d != "" {
+			t.Error(e, d)
+		}
+	}
+}
+
+func TestEntryPrefixVarious(t *testing.T) {
+	e := newEntry("my great(-)file.yes", []string{})
+
+	testCases := []struct {
+		expected string
+		size     int
+	}{
+		{"m", 1},
+		{"my_great", 8},
+		{"my_great_file", 13},
+	}
+
+	for _, c := range testCases {
+
+		if d := cmp.Diff(c.expected, e.prefix(c.size)); d != "" {
+			t.Error(d)
+		}
+	}
+}
+
+func TestEntryFileMapSingle(t *testing.T) {
+	e := newEntry("a", []string{"/path/to/a.file"})
+
+	expected := map[string]string{
+		"/path/to/a.file": "a.file",
+	}
+
+	actual := e.fileMap()
+
+	if d := cmp.Diff(expected, actual); d != "" {
+		t.Error(d)
+	}
+}
+
+func TestEntryFileMapMultiple(t *testing.T) {
+	e := newEntry("a", []string{"/path/to/a.file", "/other/path/for/a [test].file"})
+
+	expected := map[string]string{
+		"/path/to/a.file":               "a/a.file",
+		"/other/path/for/a [test].file": "a/a [test].file",
+	}
+
+	actual := e.fileMap()
+
+	if d := cmp.Diff(expected, actual); d != "" {
+		t.Error(d)
+	}
+}

go.mod

@@ -1,4 +1,4 @@
-module github.com/stilvoid/retrosort
+module github.com/stilvoid/retro-sort
 
 go 1.19
 

group.go

@@ -2,8 +2,6 @@ package retrosort
 
 import (
 	"fmt"
-	"maps"
-	"regexp"
 	"slices"
 	"strings"
 
@@ -13,104 +11,62 @@ import (
 // Sort converts a list of paths to files into a mapping from source paths
 // to destination paths where no directory in the destinations
 // contains any more than size files
-func Sort(files []string, size int) map[string]string {
-	group := newGroup(files)
+func Sort(sources []string, size int) map[string]string {
+	group := newGroup(sources)
 
 	groups := group.sort(size)
 
 	return groups.fileMap()
 }
 
-func getPrefix(fn string, prefixSize int) string {
-	fn = strings.ToLower(filepath.Base(fn))
-
-	if len(fn) < prefixSize {
-		return fn
-	}
-
-	return fn[:prefixSize]
-}
-
-func getCategory(fn string) string {
-	c := strings.ToLower(filepath.Base(fn))[0]
-
-	if c >= 'a' && c <= 'z' {
-		return string(c)
-	}
-
-	return "#"
-}
-
-type file struct {
-	name     string
-	sortName string
+type group struct {
+	entries    []entry
+	prefixSize int
+	path       string
 }
 
-var sortNameRe = regexp.MustCompile(`[^a-z0-9]+`)
-
-func newFile(fn string) file {
-	if TosecMode {
-		fn = doTosec(fn)
-	}
-
-	sortName := filepath.Base(fn)
-	sortName = strings.ToLower(sortName)
-	sortName = sortNameRe.ReplaceAllString(sortName, "_")
+func newGroup(sources []string) group {
+	groupedSources := make(map[string][]string)
+	for _, fn := range sources {
+		name := filepath.Base(fn)
 
-	return file{
-		name:     fn,
-		sortName: sortName,
-	}
-}
+		if TosecMode {
+			name = tosecName(name)
+		}
 
-func (f file) prefix(size int) string {
-	if size == 1 {
-		return getCategory(f.sortName[:size])
-	}
+		if _, ok := groupedSources[name]; !ok {
+			groupedSources[name] = make([]string, 0)
+		}
 
-	if size >= len(f.sortName) {
-		return f.sortName
+		groupedSources[name] = append(groupedSources[name], fn)
 	}
 
-	return f.sortName[:size]
-}
-
-type group struct {
-	files      []file
-	prefixSize int
-	path       string
-}
-
-func newGroup(names []string) group {
-	dedupFiles := make(map[string]file)
-	for _, name := range names {
-		f := newFile(name)
-		dedupFiles[f.name] = f
+	entries := make([]entry, 0)
+	for name, sources := range groupedSources {
+		entries = append(entries, newEntry(name, sources))
 	}
 
-	files := slices.Collect(maps.Values(dedupFiles))
-
-	slices.SortStableFunc(files, func(a, b file) int {
+	slices.SortStableFunc(entries, func(a, b entry) int {
 		return strings.Compare(a.sortName, b.sortName)
 	})
 
 	return group{
-		files:      files,
+		entries:    entries,
 		prefixSize: 0,
 	}
 }
 
 func (g group) Len() int {
-	return len(g.files)
+	return len(g.entries)
 }
 
 func (g group) name() string {
 	if g.prefixSize == 0 {
 		return ""
 	}
 
-	a := g.files[0].prefix(g.prefixSize)
-	b := g.files[g.Len()-1].prefix(g.prefixSize)
+	a := g.entries[0].prefix(g.prefixSize)
+	b := g.entries[g.Len()-1].prefix(g.prefixSize)
 
 	if g.prefixSize == 1 {
 		a = getCategory(a)
@@ -133,8 +89,8 @@ func (g group) split(prefixSize, size int) (groups, bool) {
 	prefixes := make([]string, 0)
 
 	// Fail if any individual prefix is too big
-	for _, file := range g.files {
-		prefix := file.prefix(prefixSize)
+	for _, entry := range g.entries {
+		prefix := entry.prefix(prefixSize)
 
 		if counts[prefix] == 0 {
 			prefixes = append(prefixes, prefix)
@@ -157,7 +113,7 @@ func (g group) split(prefixSize, size int) (groups, bool) {
 	for i, prefix := range prefixes {
 		// Copy
 		for j := 0; j < counts[prefix]; j++ {
-			cur.files = append(cur.files, g.files[pos])
+			cur.entries = append(cur.entries, g.entries[pos])
 			pos++
 		}
 
@@ -170,7 +126,7 @@ func (g group) split(prefixSize, size int) (groups, bool) {
 		}
 	}
 
-	if len(cur.files) > 0 {
+	if len(cur.entries) > 0 {
 		groups = append(groups, cur)
 	}
 
@@ -216,8 +172,10 @@ func (g group) String() string {
 func (g group) fileMap() map[string]string {
 	out := make(map[string]string)
 
-	for _, file := range g.files {
-		out[file.name] = filepath.Join(g.path, g.name(), filepath.Base(file.name))
+	for _, entry := range g.entries {
+		for src, dst := range entry.fileMap() {
+			out[src] = filepath.Join(g.path, g.name(), dst)
+		}
 	}
 
 	return out
@@ -230,13 +188,7 @@ func (gs groups) fileMap() map[string]string {
 
 	for _, g := range gs {
 		for src, dst := range g.fileMap() {
-			if fileNames, ok := tosecFiles[src]; TosecMode && ok {
-				for _, fn := range fileNames {
-					out[fn] = filepath.Join(dst, filepath.Base(fn))
-				}
-			} else {
-				out[src] = dst
-			}
+			out[src] = dst
 		}
 	}