Migrate to acmd (#6)

Author: cristaloleg

go.mod

@@ -1,3 +1,5 @@
 module github.com/cristaloleg/go-perftuner
 
 go 1.10
+
+require github.com/cristalhq/acmd v0.1.5

go.sum

@@ -0,0 +1,2 @@
+github.com/cristalhq/acmd v0.1.5 h1:sQJ4hfJsGyMa0opX8uqNNnH9Bvf5wL2Png5F1yuIX+A=
+github.com/cristalhq/acmd v0.1.5/go.mod h1:LG5oa43pE/BbxtfMoImHCQN++0Su7dzipdgBjMCBVDQ=

perftune.go

@@ -1,123 +1,71 @@
 package main
 
 import (
+	"context"
 	"flag"
 	"fmt"
 	"log"
 	"os"
-)
-
-var asJSON bool
-
-var subCommands = []*subCommand{
-	{
-		runner:    &almostInlinedRunner{},
-		name:      "almostInlined",
-		shortName: "inl",
-		summary:   "find functions that cross inlining threshold just barely",
-	},
-	{
-		runner:    &escapeAnalysisRunner{},
-		name:      "escapedVariables",
-		shortName: "esc",
-		summary:   "find variables that are escaped to the heap",
-	},
-	{
-		runner:    &boundCheckRunner{},
-		name:      "boundChecks",
-		shortName: "bce",
-		summary:   "find slice/array that has bound check",
-	},
-}
 
-type subCommandRunner interface {
-	Init()
-	Run(pkg string) error
-}
+	"github.com/cristalhq/acmd"
+)
 
-type subCommand struct {
-	runner    subCommandRunner
-	name      string
-	shortName string
-	summary   string
-}
+const version = "v0.0.0"
 
 func main() {
-	log.SetFlags(0)
-
-	argv := os.Args
-	if len(argv) < 2 {
-		terminate("not enough arguments, expected sub-command name", printUsage)
-	}
-
-	subIdx := 1 // [0] is program name
-	sub := os.Args[subIdx]
-	// Erase sub-command argument (index=1) to make it invisible for
-	// sub commands themselves.
-	os.Args = append(os.Args[:subIdx], os.Args[subIdx+1:]...)
-
-	// Choose and run sub-command main.
-	cmd := findSubCommand(sub)
-	if cmd == nil {
-		terminate("unknown sub-command: "+sub, printSupportedSubs)
-	}
-	flag.Usage = func() {
-		log.Printf("usage: [flags] package...")
-		flag.PrintDefaults()
+	if len(os.Args) < 2 {
+		panic("not enough arguments, expected sub-command name")
 	}
 
+	log.SetFlags(0)
 	flag.BoolVar(&asJSON, "json", false, `return result as JSON`)
-
-	cmd.runner.Init()
 	flag.Parse()
 
-	for _, pkg := range flag.Args() {
-		log.SetPrefix(sub + ": " + pkg + ": ")
-		if err := cmd.runner.Run(pkg); err != nil {
-			log.Printf("%s: %v", pkg, err)
-		}
-	}
-}
-
-// findSubCommand looks up subCommand by its name.
-// Returns nil if requested command not found.
-func findSubCommand(name string) *subCommand {
-	for _, cmd := range subCommands {
-		if cmd.name == name || cmd.shortName == name {
-			return cmd
-		}
+	r := acmd.RunnerOf(cmds, acmd.Config{
+		Version: version,
+	})
+	if err := r.Run(); err != nil {
+		log.Fatal(fmt.Errorf("dbumper: %w", err))
 	}
-	return nil
 }
 
-func printUsage() {
-	// TODO: implement me. For now, print supported commands.
-	printSupportedSubs()
+var cmds = []acmd.Command{
+	{
+		Name:        "inl",
+		Description: "find functions that cross inlining threshold just barely",
+		Do: func(_ context.Context, _ []string) error {
+			return run(&almostInlinedRunner{})
+		},
+	},
+	{
+		Name:        "esc",
+		Description: "find variables that are escaped to the heap",
+		Do: func(_ context.Context, _ []string) error {
+			return run(&escapeAnalysisRunner{})
+		},
+	},
+	{
+		Name:        "bce",
+		Description: "find slice/array that has bound check",
+		Do: func(_ context.Context, _ []string) error {
+			return run(&boundCheckRunner{})
+		},
+	},
 }
 
-func printSupportedSubs() {
-	stderrPrintf("Supported sub-commands:\n")
-	for _, cmd := range subCommands {
-		stderrPrintf("\t%s (or %s) - %s\n", cmd.name, cmd.shortName, cmd.summary)
+func run(cmd subCommandRunner) error {
+	cmd.Init()
+	for _, pkg := range flag.Args()[1:] {
+		if err := cmd.Run(pkg); err != nil {
+			log.Printf("%s: %v", pkg, err)
+		}
 	}
+	return nil
 }
 
-// terminate prints error specified by reason, runs optional printHelp
-// function and then exists with non-zero status.
-func terminate(reason string, printHelp func()) {
-	stderrPrintf("error: %s\n", reason)
-	if printHelp != nil {
-		stderrPrintf("\n")
-		printHelp()
-	}
-	os.Exit(1)
-}
+var asJSON bool
 
-// stderrPrintf writes formatted message to stderr and checks for error
-// making "not annoying at all" linters happy.
-func stderrPrintf(format string, args ...interface{}) {
-	_, err := fmt.Fprintf(os.Stderr, format, args...)
-	if err != nil {
-		panic(fmt.Sprintf("stderr write error: %v", err))
-	}
+type subCommandRunner interface {
+	Init()
+	Run(pkg string) error
 }