feat: new tk tool importers-count (#1232)

* feat: new `tk tool imported-count`
This is useful to find which files are used widely and which aren't used at all
Example:
```
julienduchesne@triceratops ksonnet % tk tool imported-count lib/meta
lib/meta/clusters.libsonnet: 523
lib/meta/certificates.libsonnet: 257
lib/meta/namespaces.libsonnet: 249
lib/meta/teams.libsonnet: 248
lib/meta/environment.libsonnet: 231
lib/meta/envs.libsonnet: 229
lib/meta/functions.libsonnet: 229
lib/meta/remote_write.libsonnet: 71
lib/meta/cells.libsonnet: 70
lib/meta/networking.libsonnet: 5
lib/meta/datasources.libsonnet: 3
lib/meta/alerting.libsonnet: 2
lib/meta/repositories.libsonnet: 1
```

* Rename command

Author: julienduchesne

cmd/tk/tool.go

@@ -28,6 +28,7 @@ func toolCmd() *cli.Command {
 		jpathCmd(),
 		importsCmd(),
 		importersCmd(),
+		importersCountCmd(),
 		chartsCmd(),
 	)
 	return cmd
@@ -184,6 +185,50 @@ if the file is not a vendored (located at <tk-root>/vendor/) or a lib file (loca
 	return cmd
 }
 
+func importersCountCmd() *cli.Command {
+	cmd := &cli.Command{
+		Use:   "importers-count <dir>",
+		Short: "for each file in the given directory, list the number of environments that import it",
+		Long: `for each file in the given directory, list the number of environments that import it
+
+As optimization,
+if the file is not a vendored (located at <tk-root>/vendor/) or a lib file (located at <tk-root>/lib/), we assume:
+- it is used in a Tanka environment
+- it will not be imported by any lib or vendor files
+- the environment base (closest main file in parent dirs) will be considered an importer
+- if no base is found, all main files in child dirs will be considered importers
+`,
+		Args: cli.Args{
+			Validator: cli.ArgsExact(1),
+			Predictor: complete.PredictDirs("*"),
+		},
+	}
+
+	root := cmd.Flags().String("root", ".", "root directory to search for environments")
+	recursive := cmd.Flags().Bool("recursive", false, "find files recursively")
+	filenameRegex := cmd.Flags().String("filename-regex", "", "only count files that match the given regex. Matches only jsonnet files by default")
+
+	cmd.Run = func(_ *cli.Command, args []string) error {
+		dir := args[0]
+
+		root, err := filepath.Abs(*root)
+		if err != nil {
+			return fmt.Errorf("resolving root: %w", err)
+		}
+
+		result, err := jsonnet.CountImporters(root, dir, *recursive, *filenameRegex)
+		if err != nil {
+			return fmt.Errorf("resolving imports: %s", err)
+		}
+
+		fmt.Println(result)
+
+		return nil
+	}
+
+	return cmd
+}
+
 func gitRoot() (string, error) {
 	s, err := git("rev-parse", "--show-toplevel")
 	return strings.TrimRight(s, "\n"), err

pkg/jsonnet/find_importers.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"regexp"
 	"sort"
 	"strings"
 
@@ -82,6 +83,87 @@ func FindImporterForFiles(root string, files []string) ([]string, error) {
 	return mapToArray(importers), nil
 }
 
+// CountImporters lists all the files in the given directory and for each file counts the number of environments that import it.
+func CountImporters(root string, dir string, recursive bool, filenameRegexStr string) (string, error) {
+	root, err := filepath.Abs(root)
+	if err != nil {
+		return "", fmt.Errorf("resolving root: %w", err)
+	}
+
+	if filenameRegexStr == "" {
+		filenameRegexStr = "^.*\\.(jsonnet|libsonnet)$"
+	}
+	filenameRegexp, err := regexp.Compile(filenameRegexStr)
+	if err != nil {
+		return "", fmt.Errorf("compiling filename regex: %w", err)
+	}
+	var files []string
+	err = filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if info.IsDir() && !recursive && path != dir {
+			return filepath.SkipDir
+		}
+
+		if !info.Mode().IsRegular() {
+			return nil
+		}
+
+		if !filenameRegexp.MatchString(path) {
+			return nil
+		}
+
+		if info.Name() == jpath.DefaultEntrypoint {
+			return nil
+		}
+
+		if info.IsDir() {
+			return nil
+		}
+
+		files = append(files, path)
+
+		return nil
+	})
+	if err != nil {
+		return "", fmt.Errorf("walking directory: %w", err)
+	}
+
+	importers := map[string]int{}
+	for _, file := range files {
+		importersList, err := FindImporterForFiles(root, []string{file})
+		if err != nil {
+			return "", fmt.Errorf("resolving imports: %w", err)
+		}
+		importers[file] = len(importersList)
+	}
+
+	// Print sorted by count
+	type importer struct {
+		File  string `json:"file"`
+		Count int    `json:"count"`
+	}
+	var importersList []importer
+	for file, count := range importers {
+		importersList = append(importersList, importer{File: file, Count: count})
+	}
+	sort.Slice(importersList, func(i, j int) bool {
+		if importersList[i].Count == importersList[j].Count {
+			return importersList[i].File < importersList[j].File
+		}
+		return importersList[i].Count > importersList[j].Count
+	})
+
+	var sb strings.Builder
+	for _, importer := range importersList {
+		sb.WriteString(fmt.Sprintf("%s: %d\n", importer.File, importer.Count))
+	}
+
+	return sb.String(), nil
+}
+
 // expandSymlinksInFiles takes an array of files and adds to it:
 // - all symlinks that point to the files
 // - all files that are pointed to by the symlinks

pkg/jsonnet/find_importers_test.go

@@ -239,6 +239,53 @@ func TestFindImportersForFiles(t *testing.T) {
 	}
 }
 
+func TestCountImporters(t *testing.T) {
+	testcases := []struct {
+		name       string
+		dir        string
+		recursive  bool
+		fileRegexp string
+		expected   string
+	}{
+		{
+			name:      "project with no imports",
+			dir:       "testdata/findImporters/environments/no-imports",
+			recursive: true,
+			expected:  "",
+		},
+		{
+			name:      "project with imports",
+			dir:       "testdata/findImporters/environments/imports-locals-and-vendored",
+			recursive: true,
+			expected: `testdata/findImporters/environments/imports-locals-and-vendored/local-file1.libsonnet: 1
+testdata/findImporters/environments/imports-locals-and-vendored/local-file2.libsonnet: 1
+`,
+		},
+		{
+			name:      "lib non-recursive",
+			dir:       "testdata/findImporters/lib/lib1",
+			recursive: false,
+			expected: `testdata/findImporters/lib/lib1/main.libsonnet: 1
+`,
+		},
+		{
+			name:      "lib recursive",
+			dir:       "testdata/findImporters/lib/lib1",
+			recursive: true,
+			expected: `testdata/findImporters/lib/lib1/main.libsonnet: 1
+testdata/findImporters/lib/lib1/subfolder/test.libsonnet: 0
+`,
+		},
+	}
+	for _, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			count, err := CountImporters("testdata/findImporters", tc.dir, tc.recursive, tc.fileRegexp)
+			require.NoError(t, err)
+			require.Equal(t, tc.expected, count)
+		})
+	}
+}
+
 func BenchmarkFindImporters(b *testing.B) {
 	// Create a very large and complex project
 	tempDir, err := filepath.EvalSymlinks(b.TempDir())

pkg/jsonnet/testdata/findImporters/lib/lib1/subfolder/test.libsonnet

@@ -0,0 +1 @@
+{}