implement simple list() command; refactor to share temp + execute code as run; fewer if's :)

Author: clipperhouse

custom.go

@@ -14,7 +14,6 @@ func custom(filename string) error {
 	p := pkg{
 		Name:    "main",
 		Imports: stdImports,
-		Main:    false,
 	}
 
 	if err := tmpl.Execute(w, p); err != nil {

main.go

@@ -33,7 +33,6 @@ func main() {
 				},
 				Usage: "Creates a custom _gen.go file in which to specify your own typewriter imports",
 			},
-
 			{
 				Name: "get",
 				Action: func(c *cli.Context) {
@@ -46,6 +45,13 @@ func main() {
 					cli.BoolFlag{"u", "use the network to update the typewriter packages and their dependencies"},
 				},
 			},
+			{
+				Name: "list",
+				Action: func(c *cli.Context) {
+					list(customFilename)
+				},
+				Usage: "Lists current typewriters",
+			},
 		},
 	}
 

pkg.go

@@ -8,5 +8,4 @@ var stdImports = []string{
 type pkg struct {
 	Name    string
 	Imports []string
-	Main    bool
 }

run.go

@@ -13,54 +13,46 @@ import (
 	"github.com/clipperhouse/gen/typewriter"
 )
 
-// filename is the optional file containing custom typewriters
-func run(filename string) error {
-	if src, err := os.Open(filename); err == nil {
+// execute runs a gen command by first determining whether a custom imports file (typically _gen.go) exists
+//
+// If no custom file exists, it executes the passed 'standard' func.
+//
+// If the custom file exists, new files are written to a temp directory and executed via `go run` in the shell.
+func execute(standard func() error, customFilename string, imports []string, body string) error {
+	if src, err := os.Open(customFilename); err == nil {
 		// custom imports file exists, use it
 		defer src.Close()
 
-		if err := runCustom(src); err != nil {
+		if err := executeCustom(src, imports, body); err != nil {
 			return err
 		}
 	} else {
 		// do it the regular way
-		if err := runStandard(); err != nil {
+		if err := standard(); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
-func runStandard() error {
-	app, err := typewriter.NewApp("+gen")
-
-	if err != nil {
-		return err
-	}
-
-	if err := app.WriteAll(); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func runCustom(src io.Reader) error {
-
+// executeCustom creates a temp directory, copies src into it and generates a main() using the passed imports and body.
+//
+// `go run` is then called on those files via os.Command.
+func executeCustom(src io.Reader, imports []string, body string) error {
 	temp, err := getTempDir()
 	if err != nil {
 		return err
 	}
 	defer os.RemoveAll(temp)
 
 	// set up imports file containing the custom typewriters (from _gen.go)
-	imports, err := os.Create(filepath.Join(temp, "imports.go"))
+	imps, err := os.Create(filepath.Join(temp, "imports.go"))
 	if err != nil {
 		return err
 	}
-	defer imports.Close()
+	defer imps.Close()
 
-	io.Copy(imports, src)
+	io.Copy(imps, src)
 
 	// set up main to be run
 	main, err := os.Create(filepath.Join(temp, "main.go"))
@@ -70,20 +62,24 @@ func runCustom(src io.Reader) error {
 	defer main.Close()
 
 	p := pkg{
-		Name: "main",
-		Imports: []string{
-			`"github.com/clipperhouse/gen/typewriter"`,
-		},
-		Main: true,
+		Name:    "main",
+		Imports: imports,
 	}
 
+	// execute the package declaration and imports
 	if err := tmpl.Execute(main, p); err != nil {
 		return err
 	}
 
+	// write the body, usually a main()
+	if _, err := main.WriteString(body); err != nil {
+		return err
+	}
+
+	// call `go run` on these files & send back output/err
 	var out, outerr bytes.Buffer
 
-	cmd := exec.Command("go", "run", main.Name(), imports.Name())
+	cmd := exec.Command("go", "run", main.Name(), imps.Name())
 	cmd.Stdout = &out
 	cmd.Stderr = &outerr
 
@@ -104,3 +100,51 @@ func runCustom(src io.Reader) error {
 
 	return nil
 }
+
+func run(customFilename string) error {
+	imports := []string{
+		`"log"`,
+		`"github.com/clipperhouse/gen/typewriter"`,
+	}
+
+	return execute(runStandard, customFilename, imports, runBody)
+}
+
+func runStandard() error {
+	app, err := typewriter.NewApp("+gen")
+
+	if err != nil {
+		return err
+	}
+
+	if err := app.WriteAll(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func list(customFilename string) error {
+	imports := []string{
+		`"fmt"`,
+		`"log"`,
+		`"github.com/clipperhouse/gen/typewriter"`,
+	}
+
+	return execute(listStandard, customFilename, imports, listBody)
+}
+
+func listStandard() error {
+	app, err := typewriter.NewApp("+gen")
+
+	if err != nil {
+		return err
+	}
+
+	fmt.Println("Installed typewriters:")
+	for _, tw := range app.TypeWriters {
+		fmt.Println("  " + tw.Name())
+	}
+
+	return nil
+}

run_test.go

@@ -8,7 +8,7 @@ import (
 // +gen methods:"Where"
 type dummy int
 
-func TestRunCustom(t *testing.T) {
+func TestRun(t *testing.T) {
 	customName := "_gen_test.go"
 	genName := "dummy_gen.go"
 	fooName := "dummy_foo.go"
@@ -47,7 +47,6 @@ func TestRunCustom(t *testing.T) {
 			// non-standard typewriter
 			`_ "github.com/clipperhouse/gen/typewriters/foowriter"`,
 		},
-		Main: false,
 	}
 
 	if err := tmpl.Execute(w, p); err != nil {

write.go

@@ -20,18 +20,33 @@ var tmpl = template.Must(template.New("package").Parse(`package {{.Name}}
 import ({{range .Imports}}
 	{{.}}{{end}}
 )
-{{end}}
-{{if .Main}}
+{{end}}`))
+
+const runBody string = `
 func main() {
 	app, err := typewriter.NewApp("+gen")
 
 	if err != nil {
-		panic(err)
+		log.Fatal(err)
 	}
 
 	if err := app.WriteAll(); err != nil {
-		panic(err)
+		log.Fatal(err)
+	}
+}
+`
+
+const listBody string = `
+func main() {
+	app, err := typewriter.NewApp("+gen")
+
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	fmt.Println("Installed typewriters (custom):")
+	for _, tw := range app.TypeWriters {
+		fmt.Println("  " + tw.Name())
 	}
 }
-{{end}}
-`))
+`