@shortlink-org/portolan 0.1.0 → 0.2.0

package/internal/commands/commands_test.go

@@ -1,323 +0,0 @@
-package commands
-
-import (
-	"encoding/json"
-	"flag"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/shortlink-org/portolan/catalog"
-)
-
-var update = flag.Bool("update", false, "rewrite the golden list instead of comparing against it")
-
-const goldenPath = "testdata/golden/commands.json"
-
-func read(t *testing.T) []catalog.Command {
-	t.Helper()
-	cmds, warnings := Read("testdata/estate")
-	if len(warnings) != 0 {
-		t.Fatalf("warnings: %v", warnings)
-	}
-
-	return cmds
-}
-
-func find(t *testing.T, cmds []catalog.Command, run string) catalog.Command {
-	t.Helper()
-	for _, cmd := range cmds {
-		if cmd.Run == run {
-			return cmd
-		}
-	}
-	t.Fatalf("no command %q in %s", run, names(cmds))
-
-	return catalog.Command{}
-}
-
-func names(cmds []catalog.Command) string {
-	out := make([]string, 0, len(cmds))
-	for _, cmd := range cmds {
-		out = append(out, cmd.Run)
-	}
-
-	return strings.Join(out, ", ")
-}
-
-func absent(t *testing.T, cmds []catalog.Command, run string) {
-	t.Helper()
-	for _, cmd := range cmds {
-		if cmd.Run == run {
-			t.Errorf("%q is listed and should not be", run)
-		}
-	}
-}
-
-func TestMakefileTargetsAndDocs(t *testing.T) {
-	cmds := read(t)
-
-	gen := find(t, cmds, "make gen")
-	if gen.Doc != "Regenerate the gRPC stubs" {
-		t.Errorf("gen doc = %q", gen.Doc)
-	}
-	if !strings.HasPrefix(gen.Body, "buf generate $(GRPC)/quote/proto") || strings.Count(gen.Body, "\n") != 1 {
-		t.Errorf("gen body = %q", gen.Body)
-	}
-	if gen.Source != "testdata/estate/Makefile:10" {
-		t.Errorf("gen source = %q", gen.Source)
-	}
-
-	build := find(t, cmds, "make build")
-	if build.Doc != "Compiles every package. Nothing is installed." {
-		t.Errorf("comment over a target is its doc; got %q", build.Doc)
-	}
-
-	// Two targets on one rule are two commands.
-	find(t, cmds, "make test")
-	find(t, cmds, "make lint")
-	// Inside a conditional is still a target.
-	find(t, cmds, "make ci")
-
-	for _, hidden := range []string{"make .PHONY", "make _internal", "make $(BIN)", "make %.pb.go", "make GRPC", "make BIN", "make ifeq"} {
-		absent(t, cmds, hidden)
-	}
-}
-
-func TestJustfileRecipes(t *testing.T) {
-	cmds := read(t)
-
-	dev := find(t, cmds, "just dev")
-	if dev.Doc != "Run the service against the compose stack" || dev.Body != "docker compose up -d\ncargo run" {
-		t.Errorf("dev = %+v", dev)
-	}
-	test := find(t, cmds, "just test")
-	if test.Doc != "Run the tests, unit and integration" {
-		t.Errorf("doc attribute beats the comment; got %q", test.Doc)
-	}
-	for _, hidden := range []string{"just release", "just _setup", "just alias", "just set", "just port"} {
-		absent(t, cmds, hidden)
-	}
-}
-
-func TestTaskfileTasks(t *testing.T) {
-	cmds := read(t)
-
-	build := find(t, cmds, "task build")
-	if build.Doc != "Compile the binary" || build.Body != "go build -o bin/svc ./cmd/svc" {
-		t.Errorf("build = %+v", build)
-	}
-	if migrate := find(t, cmds, "task migrate"); migrate.Doc != "Apply pending migrations" || migrate.Body != "goose up" {
-		t.Errorf("migrate = %+v", migrate)
-	}
-	if def := find(t, cmds, "task default"); def.Body != "task build" {
-		t.Errorf("default = %+v", def)
-	}
-	if fmt := find(t, cmds, "task fmt"); fmt.Body != "gofmt -w ." {
-		t.Errorf("fmt = %+v", fmt)
-	}
-	absent(t, cmds, "task lint")
-	absent(t, cmds, "task _shared")
-}
-
-func TestPackageScriptsInFileOrder(t *testing.T) {
-	cmds := read(t)
-
-	var npm []string
-	for _, cmd := range cmds {
-		if cmd.Runner == "npm" {
-			npm = append(npm, cmd.Run)
-		}
-	}
-	want := "npm run build, npm start, npm test, npm run build:watch, npm run generate, npm run generate:api"
-	if got := strings.Join(npm, ", "); got != want {
-		t.Errorf("scripts = %s\n     want %s", got, want)
-	}
-	if build := find(t, cmds, "npm run build"); build.Body != "tsc -p tsconfig.build.json" || build.Source != "testdata/estate/package.json:4" {
-		t.Errorf("build = %+v", build)
-	}
-	if watch := find(t, cmds, "npm run build:watch"); watch.Source != "testdata/estate/package.json:8" {
-		t.Errorf("a name containing another name has its own line; got %q", watch.Source)
-	}
-}
-
-func TestPackageRunnerFollowsTheLockfile(t *testing.T) {
-	root := t.TempDir()
-	if err := os.WriteFile(filepath.Join(root, "package.json"), []byte(`{"scripts":{"test":"vitest"}}`), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(root, "pnpm-lock.yaml"), nil, 0o644); err != nil {
-		t.Fatal(err)
-	}
-	cmds, _ := Read(root)
-	if len(cmds) != 1 || cmds[0].Run != "pnpm test" || cmds[0].Runner != "pnpm" {
-		t.Errorf("commands = %+v", cmds)
-	}
-}
-
-func TestPyprojectTasks(t *testing.T) {
-	cmds := read(t)
-
-	if test := find(t, cmds, "poe test"); test.Body != "pytest" {
-		t.Errorf("test = %+v", test)
-	}
-	if lint := find(t, cmds, "poe lint"); lint.Body != "ruff check ." {
-		t.Errorf("lint = %+v", lint)
-	}
-	if serve := find(t, cmds, "poe serve"); serve.Doc != "Run the dev server" || serve.Body != "python manage.py runserver" {
-		t.Errorf("serve = %+v", serve)
-	}
-	migrate := find(t, cmds, "poe migrate")
-	if migrate.Doc != "Apply pending migrations" || migrate.Body != "python manage.py migrate" || migrate.Source != "testdata/estate/pyproject.toml:14" {
-		t.Errorf("migrate = %+v", migrate)
-	}
-	if check := find(t, cmds, "poe check"); check.Body != "lint\ntest" {
-		t.Errorf("check = %+v", check)
-	}
-	if worker := find(t, cmds, "pdm run worker"); worker.Doc != "Run the celery worker" || worker.Body != "celery -A billing worker" {
-		t.Errorf("worker = %+v", worker)
-	}
-	find(t, cmds, "pdm run test")
-	absent(t, cmds, "pdm run pre_test")
-	absent(t, cmds, "poe _hidden")
-	// Entry points are programs the package installs, not tasks.
-	absent(t, cmds, "poe billing")
-}
-
-func TestPomPhasesAndPluginGoals(t *testing.T) {
-	cmds := read(t)
-
-	if test := find(t, cmds, "mvn test"); test.Source != "testdata/estate/pom.xml:5" || test.Doc == "" {
-		t.Errorf("test = %+v", test)
-	}
-	find(t, cmds, "mvn package")
-	if run := find(t, cmds, "mvn spring-boot:run"); run.Doc != "Run the application" || run.Source != "testdata/estate/pom.xml:22" {
-		t.Errorf("spring-boot:run = %+v", run)
-	}
-	// A plugin bound to a phase is run by the phase, not typed; a plugin
-	// under pluginManagement or in dependencies is not part of the build.
-	for _, hidden := range []string{"mvn protobuf:compile", "mvn jib:dockerBuild", "mvn flyway:migrate"} {
-		absent(t, cmds, hidden)
-	}
-}
-
-func TestPomIsTypedAtTheWrapper(t *testing.T) {
-	root := t.TempDir()
-	if err := os.WriteFile(filepath.Join(root, "pom.xml"), []byte("<project><packaging>jar</packaging></project>"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(root, "mvnw"), []byte("#!/bin/sh\n"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	cmds, _ := Read(root)
-	if len(cmds) != 2 || cmds[0].Run != "./mvnw test" || cmds[0].Runner != "./mvnw" {
-		t.Errorf("commands = %+v", cmds)
-	}
-}
-
-func TestGradleTasks(t *testing.T) {
-	cmds := read(t)
-
-	find(t, cmds, "gradle build")
-	find(t, cmds, "gradle test")
-	if run := find(t, cmds, "gradle run"); run.Source != "testdata/estate/build.gradle.kts:3" {
-		t.Errorf("run = %+v", run)
-	}
-	if boot := find(t, cmds, "gradle bootRun"); boot.Source != "testdata/estate/build.gradle.kts:2" {
-		t.Errorf("bootRun = %+v", boot)
-	}
-	if gen := find(t, cmds, "gradle generateProto"); gen.Doc != "Regenerate the gRPC stubs" || gen.Source != "testdata/estate/build.gradle.kts:6" {
-		t.Errorf("generateProto = %+v", gen)
-	}
-	if smoke := find(t, cmds, "gradle smokeTest"); smoke.Doc != "Run the tests that need the compose stack" {
-		t.Errorf("smokeTest = %+v", smoke)
-	}
-	find(t, cmds, "gradle legacyTask")
-	absent(t, cmds, "gradle _shared")
-}
-
-func TestCargoAliasesAndXtask(t *testing.T) {
-	cmds := read(t)
-
-	if xtask := find(t, cmds, "cargo xtask"); xtask.Body != "run --package xtask --" || xtask.Source != "testdata/estate/.cargo/config.toml:5" {
-		t.Errorf("xtask = %+v", xtask)
-	}
-	if gen := find(t, cmds, "cargo gen"); gen.Body != "run --package xtask -- gen" {
-		t.Errorf("gen = %+v", gen)
-	}
-	absent(t, cmds, "cargo _secret")
-
-	if gen := find(t, cmds, "cargo xtask gen"); gen.Doc != "Regenerate the gRPC stubs from the vendored protos" || gen.Source != "testdata/estate/xtask/src/main.rs:12" {
-		t.Errorf("xtask gen = %+v", gen)
-	}
-	if ci := find(t, cmds, "cargo xtask ci"); ci.Doc != "Run fmt, clippy and the tests the way CI does" {
-		t.Errorf("xtask ci = %+v", ci)
-	}
-	if dist := find(t, cmds, "cargo xtask dist"); dist.Doc != "Build the release artefacts" {
-		t.Errorf("xtask dist = %+v", dist)
-	}
-	// Match arms add what the enum does not name, once each.
-	if bench := find(t, cmds, "cargo xtask bench"); bench.Doc != "Run the benchmarks against the compose stack" {
-		t.Errorf("bench = %+v", bench)
-	}
-	if perf := find(t, cmds, "cargo xtask perf"); perf.Doc != "Run the benchmarks against the compose stack" {
-		t.Errorf("perf = %+v", perf)
-	}
-	count := 0
-	for _, cmd := range cmds {
-		if cmd.Run == "cargo xtask gen" {
-			count++
-		}
-	}
-	if count != 1 {
-		t.Errorf("cargo xtask gen listed %d times", count)
-	}
-}
-
-func TestNothingToReadIsNothing(t *testing.T) {
-	cmds, warnings := Read(t.TempDir())
-	if len(cmds) != 0 || len(warnings) != 0 {
-		t.Errorf("commands = %+v, warnings = %v", cmds, warnings)
-	}
-}
-
-func TestBrokenFilesWarnRatherThanFail(t *testing.T) {
-	root := t.TempDir()
-	if err := os.WriteFile(filepath.Join(root, "Taskfile.yml"), []byte("tasks: [\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(root, "package.json"), []byte(`{"scripts": "nope"}`), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	cmds, warnings := Read(root)
-	if len(cmds) != 0 || len(warnings) != 2 {
-		t.Errorf("commands = %+v, warnings = %v", cmds, warnings)
-	}
-}
-
-func TestGolden(t *testing.T) {
-	cmds := read(t)
-	got, err := json.MarshalIndent(cmds, "", "  ")
-	if err != nil {
-		t.Fatal(err)
-	}
-	got = append(got, '\n')
-	if *update {
-		if err := os.MkdirAll(filepath.Dir(goldenPath), 0o755); err != nil {
-			t.Fatal(err)
-		}
-		if err := os.WriteFile(goldenPath, got, 0o644); err != nil {
-			t.Fatal(err)
-		}
-
-		return
-	}
-	want, err := os.ReadFile(goldenPath)
-	if err != nil {
-		t.Fatalf("%v (run with -update to write it)", err)
-	}
-	if string(want) != string(got) {
-		t.Errorf("golden differs from what is read now; run with -update and review the diff\n%s", got)
-	}
-}

package/internal/commands/gradle.go

@@ -1,77 +0,0 @@
-package commands
-
-import (
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-
-	"github.com/shortlink-org/portolan/catalog"
-)
-
-var gradleRegister = regexp.MustCompile(`(?m)^[ \t]*(?:tasks\.register(?:<[^>]+>)?\(\s*["']([A-Za-z][\w-]*)["']|task\s+([A-Za-z][\w-]*)\s*[({]|val\s+([A-Za-z][\w-]*)\s+by\s+tasks\.(?:registering|creating))`)
-var gradleDescription = regexp.MustCompile(`description\s*(?:=|\.set\()\s*["']([^"']*)["']`)
-var gradlePlugin = regexp.MustCompile(`(?m)^[ \t]*(?:id\s*\(?\s*["']([\w.-]+)["']\)?|apply\s+plugin:\s*["']([\w.-]+)["']|\b(application|java|java-library|kotlin)\b\s*$)`)
-
-// readGradle lists what a Gradle build answers to: `build` and `test`, which
-// every JVM build has; `run` when the application plugin is applied and
-// `bootRun` for Spring Boot; and the tasks the script registers itself, with
-// the description it sets on them. The line is typed at the wrapper when the
-// checkout keeps one.
-//
-// A build script is a program, and this reads it as text: a task registered
-// inside a loop or by a plugin the script does not name is not here.
-func readGradle(root, file, src string) []catalog.Command {
-	runner, prefix := "gradle", "gradle "
-	if _, err := os.Stat(filepath.Join(root, "gradlew")); err == nil {
-		runner, prefix = "./gradlew", "./gradlew "
-	}
-
-	out := []catalog.Command{
-		{Runner: runner, Name: "build", Run: prefix + "build", Doc: "Assemble and test the project", Source: file},
-		{Runner: runner, Name: "test", Run: prefix + "test", Doc: "Run the tests", Source: file},
-	}
-
-	plugins := map[string]int{}
-	for _, m := range gradlePlugin.FindAllStringSubmatchIndex(src, -1) {
-		for _, group := range [][2]int{{m[2], m[3]}, {m[4], m[5]}, {m[6], m[7]}} {
-			if group[0] >= 0 {
-				plugins[src[group[0]:group[1]]] = 1 + strings.Count(src[:group[0]], "\n")
-			}
-		}
-	}
-	if line, ok := plugins["application"]; ok {
-		out = append(out, catalog.Command{Runner: runner, Name: "run", Run: prefix + "run", Doc: "Run the application", Source: at(file, line)})
-	}
-	if line, ok := plugins["org.springframework.boot"]; ok {
-		out = append(out, catalog.Command{Runner: runner, Name: "bootRun", Run: prefix + "bootRun", Doc: "Run the Spring Boot application", Source: at(file, line)})
-	}
-
-	matches := gradleRegister.FindAllStringSubmatchIndex(src, -1)
-	for i, m := range matches {
-		name := ""
-		for _, group := range [][2]int{{m[2], m[3]}, {m[4], m[5]}, {m[6], m[7]}} {
-			if group[0] >= 0 {
-				name = src[group[0]:group[1]]
-			}
-		}
-		if !typeable(name) {
-			continue
-		}
-		// The description is read from the task's own block: from its
-		// registration up to the next one. A script that sets one task's
-		// description after registering the next is read wrong, and that
-		// is the price of not running Gradle.
-		end := len(src)
-		if i+1 < len(matches) {
-			end = matches[i+1][0]
-		}
-		doc := ""
-		if d := gradleDescription.FindStringSubmatch(src[m[0]:end]); d != nil {
-			doc = d[1]
-		}
-		out = append(out, catalog.Command{Runner: runner, Name: name, Run: prefix + name, Doc: doc, Source: at(file, 1+strings.Count(src[:m[0]], "\n"))})
-	}
-
-	return out
-}

package/internal/commands/justfile.go

@@ -1,82 +0,0 @@
-package commands
-
-import (
-	"regexp"
-	"strings"
-
-	"github.com/shortlink-org/portolan/catalog"
-)
-
-var justRecipe = regexp.MustCompile(`^(@?)([A-Za-z_][A-Za-z0-9_-]*)((?:\s+[+*$]?[A-Za-z_][A-Za-z0-9_-]*(?:=[^\s]+)?)*)\s*:(?:\s|$)`)
-var justDocAttribute = regexp.MustCompile(`\[doc\((['"])(.*?)['"]\)\]`)
-
-// readJustfile lists the recipes of a justfile.
-//
-// A recipe is a name at column 0 followed by its parameters and a colon; the
-// lines indented under it are the body. `#` lines directly over the recipe
-// are its doc, which is what `just --list` shows too, and a `[doc("...")]`
-// attribute beats them. `[private]`, `_`-prefixed and aliased names are left
-// out, as `--list` leaves them out.
-func readJustfile(file, src string) []catalog.Command {
-	lines := strings.Split(src, "\n")
-	var out []catalog.Command
-	for i := 0; i < len(lines); i++ {
-		line := lines[i]
-		match := justRecipe.FindStringSubmatch(line)
-		if match == nil || strings.HasPrefix(line, "alias ") || strings.HasPrefix(line, "set ") || strings.HasPrefix(line, "mod ") || strings.HasPrefix(line, "import ") {
-			continue
-		}
-		name := match[2]
-
-		// Attributes sit on their own lines above the recipe, above the
-		// comment or between it and the recipe; read up through both.
-		private := !typeable(name)
-		doc := ""
-		top := i
-		for j := i - 1; j >= 0; j-- {
-			text := strings.TrimSpace(lines[j])
-			if !strings.HasPrefix(text, "[") {
-				break
-			}
-			if strings.Contains(text, "[private]") {
-				private = true
-			}
-			if m := justDocAttribute.FindStringSubmatch(text); m != nil {
-				doc = m[2]
-			}
-			top = j
-		}
-		if doc == "" {
-			doc = commentAbove(lines, top, "#")
-		}
-		if private {
-			continue
-		}
-
-		var body []string
-		for j := i + 1; j < len(lines); j++ {
-			next := lines[j]
-			if strings.HasPrefix(next, " ") || strings.HasPrefix(next, "\t") {
-				body = append(body, strings.TrimSpace(next))
-
-				continue
-			}
-			if strings.TrimSpace(next) == "" {
-				continue
-			}
-
-			break
-		}
-
-		out = append(out, catalog.Command{
-			Runner: "just",
-			Name:   name,
-			Run:    "just " + name,
-			Doc:    doc,
-			Body:   strings.Join(body, "\n"),
-			Source: at(file, i+1),
-		})
-	}
-
-	return out
-}

package/internal/commands/makefile.go

@@ -1,106 +0,0 @@
-package commands
-
-import (
-	"strings"
-
-	"github.com/shortlink-org/portolan/catalog"
-)
-
-// readMakefile lists the targets of a Makefile a person would type.
-//
-// A target is a line at column 0 with a colon that is not an assignment. Left
-// out: special targets (`.PHONY`), pattern and variable-spelled ones (`%.o`,
-// `$(BIN)`), and the `_`-prefixed ones a Makefile keeps for itself. The
-// description is the `## comment` on the target's own line - the convention
-// every `make help` recipe on the internet greps for - or, failing that, the
-// comment block sat directly over it. The recipe is the body.
-func readMakefile(file, src string) []catalog.Command {
-	lines := strings.Split(src, "\n")
-	var out []catalog.Command
-	for i := 0; i < len(lines); i++ {
-		line := lines[i]
-		names, rest, ok := makeTargets(line)
-		if !ok {
-			continue
-		}
-
-		doc := ""
-		if _, help, found := strings.Cut(rest, "##"); found {
-			doc = strings.TrimSpace(help)
-		} else {
-			doc = commentAbove(lines, i, "#")
-		}
-
-		var recipe []string
-		for j := i + 1; j < len(lines); j++ {
-			next := lines[j]
-			if strings.HasPrefix(next, "\t") {
-				recipe = append(recipe, strings.TrimSpace(strings.TrimPrefix(next, "\t")))
-
-				continue
-			}
-			if strings.TrimSpace(next) == "" || strings.HasPrefix(strings.TrimSpace(next), "#") {
-				continue
-			}
-
-			break
-		}
-		body := strings.Join(recipe, "\n")
-
-		for _, name := range names {
-			if !typeable(name) {
-				continue
-			}
-			out = append(out, catalog.Command{
-				Runner: "make",
-				Name:   name,
-				Run:    "make " + name,
-				Doc:    doc,
-				Body:   body,
-				Source: at(file, i+1),
-			})
-		}
-	}
-
-	return out
-}
-
-// makeTargets reads `a b: deps ## help` into its names and the rest of the
-// line, and refuses anything that is not a rule: assignments, directives,
-// recipes, comments.
-func makeTargets(line string) ([]string, string, bool) {
-	if line == "" || line[0] == '\t' || line[0] == '#' || line[0] == ' ' {
-		return nil, "", false
-	}
-	colon := strings.IndexByte(line, ':')
-	if colon <= 0 {
-		return nil, "", false
-	}
-	head := line[:colon]
-	tail := line[colon+1:]
-	// `X := 1`, `X ::= 1`, and `X = 1` (no colon at all) are assignments.
-	if strings.HasPrefix(tail, "=") || strings.HasPrefix(tail, ":=") || strings.ContainsAny(head, "=#") {
-		return nil, "", false
-	}
-	tail = strings.TrimPrefix(tail, ":")
-	names := strings.Fields(head)
-	if len(names) == 0 {
-		return nil, "", false
-	}
-	for _, name := range names {
-		switch {
-		case strings.HasPrefix(name, "."), strings.ContainsAny(name, "%$()"):
-			return nil, "", false
-		}
-	}
-	switch names[0] {
-	case "ifeq", "ifneq", "ifdef", "ifndef", "else", "endif", "include", "-include", "define", "endef", "export", "unexport", "override", "vpath":
-		return nil, "", false
-	}
-
-	return names, tail, true
-}
-
-func typeable(name string) bool {
-	return name != "" && !strings.HasPrefix(name, "_")
-}

package/internal/commands/maven.go

@@ -1,93 +0,0 @@
-package commands
-
-import (
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-
-	"github.com/shortlink-org/portolan/catalog"
-)
-
-// mavenGoals are the goals a person types, by the plugin that declares them.
-// Maven has no task list of its own: the pom declares plugins, and a plugin's
-// goals are either bound to a lifecycle phase - run by `mvn package`, never
-// typed - or offered to be typed, and only the plugin's documentation says
-// which. This is that documentation, for the plugins an estate meets.
-var mavenGoals = map[string][]struct{ goal, doc string }{
-	"spring-boot-maven-plugin":       {{"spring-boot:run", "Run the application"}},
-	"quarkus-maven-plugin":           {{"quarkus:dev", "Run the application in dev mode, reloading on change"}},
-	"flyway-maven-plugin":            {{"flyway:migrate", "Apply pending migrations"}},
-	"liquibase-maven-plugin":         {{"liquibase:update", "Apply pending changesets"}},
-	"exec-maven-plugin":              {{"exec:java", "Run the main class"}},
-	"jib-maven-plugin":               {{"jib:dockerBuild", "Build the container image into the local Docker daemon"}},
-	"docker-maven-plugin":            {{"docker:build", "Build the container image"}},
-	"openapi-generator-maven-plugin": {{"openapi-generator:generate", "Regenerate code from the OpenAPI document"}},
-}
-
-var pomArtifact = regexp.MustCompile(`<artifactId>\s*([^<\s]+)\s*</artifactId>`)
-
-// readPom lists what a Maven project answers to: the two lifecycle phases
-// every pom accepts, and the goals of the plugins it declares under
-// `<build><plugins>`. The line is typed at the wrapper when the checkout
-// keeps one, because that is the Maven the project was built with.
-func readPom(root, file, src string) []catalog.Command {
-	runner, prefix := "mvn", "mvn "
-	if _, err := os.Stat(filepath.Join(root, "mvnw")); err == nil {
-		runner, prefix = "./mvnw", "./mvnw "
-	}
-
-	lines := strings.Split(src, "\n")
-	self := 1
-	for i, line := range lines {
-		if strings.Contains(line, "<packaging>") {
-			self = i + 1
-
-			break
-		}
-	}
-
-	out := []catalog.Command{
-		{Runner: runner, Name: "test", Run: prefix + "test", Doc: "Run the tests (lifecycle phase)", Source: at(file, self)},
-		{Runner: runner, Name: "package", Run: prefix + "package", Doc: "Build the artifact (lifecycle phase)", Source: at(file, self)},
-	}
-
-	// Only the build's own plugins, not the ones a dependency's pom names
-	// or the ones under <pluginManagement>, which pin a version without
-	// running anything.
-	build := section(src, "build")
-	if build == "" {
-		return out
-	}
-	plugins := section(strings.Replace(build, section(build, "pluginManagement"), "", 1), "plugins")
-	offset := strings.Index(src, plugins)
-	seen := map[string]bool{}
-	for _, m := range pomArtifact.FindAllStringSubmatchIndex(plugins, -1) {
-		artifact := plugins[m[2]:m[3]]
-		goals, known := mavenGoals[artifact]
-		if !known || seen[artifact] {
-			continue
-		}
-		seen[artifact] = true
-		line := 1 + strings.Count(src[:offset+m[2]], "\n")
-		for _, g := range goals {
-			out = append(out, catalog.Command{Runner: runner, Name: g.goal, Run: prefix + g.goal, Doc: g.doc, Source: at(file, line)})
-		}
-	}
-
-	return out
-}
-
-// section is the text of the first `<name>...</name>` element, or "".
-func section(src, name string) string {
-	open := strings.Index(src, "<"+name+">")
-	if open < 0 {
-		return ""
-	}
-	close := strings.Index(src[open:], "</"+name+">")
-	if close < 0 {
-		return ""
-	}
-
-	return src[open : open+close+len(name)+3]
-}