compiler: Add error output to the compiler

tools/grammars/cmd/grammar-compiler/main.go

@@ -1,80 +1,120 @@
 package main
 
 import (
-	"flag"
-	"fmt"
 	"os"
-	"os/exec"
 
 	"github.com/github/linguist/tools/grammars/compiler"
+	"github.com/urfave/cli"
 )
 
-var linguistRoot = flag.String("linguist", "", "path to Linguist installation")
-var protoOut = flag.String("proto", "", "dump Protobuf library")
-var jsonOut = flag.String("json", "", "dump JSON output")
-var addGrammar = flag.String("add", "", "add a new grammar source")
-var updateList = flag.Bool("update", false, "update grammars.yml instead of verifying its contents")
-var report = flag.String("report", "", "write report to file")
+func cwd() string {
+	cwd, _ := os.Getwd()
+	return cwd
+}
 
-func fatal(err error) {
-	fmt.Fprintf(os.Stderr, "FATAL: %s\n", err)
-	os.Exit(1)
+func wrap(err error) error {
+	return cli.NewExitError(err, 255)
 }
 
 func main() {
-	flag.Parse()
+	app := cli.NewApp()
+	app.Name = "Linguist Grammars Compiler"
+	app.Usage = "Compile user-submitted grammars and check them for errors"
 
-	if _, err := exec.LookPath("csonc"); err != nil {
-		fatal(err)
+	app.Flags = []cli.Flag{
+		cli.StringFlag{
+			Name:  "linguist-path",
+			Value: cwd(),
+			Usage: "path to Linguist root",
+		},
 	}
 
-	if *linguistRoot == "" {
-		cwd, err := os.Getwd()
-		if err != nil {
-			fatal(err)
-		}
-		*linguistRoot = cwd
+	app.Commands = []cli.Command{
+		{
+			Name:  "add",
+			Usage: "add a new grammar source",
+			Flags: []cli.Flag{
+				cli.BoolFlag{
+					Name:  "force, f",
+					Usage: "ignore compilation errors",
+				},
+			},
+			Action: func(c *cli.Context) error {
+				conv, err := compiler.NewConverter(c.String("linguist-path"))
+				if err != nil {
+					return wrap(err)
+				}
+				if err := conv.AddGrammar(c.Args().First()); err != nil {
+					if !c.Bool("force") {
+						return wrap(err)
+					}
+				}
+				if err := conv.WriteGrammarList(); err != nil {
+					return wrap(err)
+				}
+				return nil
+			},
+		},
+		{
+			Name:  "update",
+			Usage: "update grammars.yml with the contents of the grammars library",
+			Flags: []cli.Flag{
+				cli.BoolFlag{
+					Name:  "force, f",
+					Usage: "write grammars.yml even if grammars fail to compile",
+				},
+			},
+			Action: func(c *cli.Context) error {
+				conv, err := compiler.NewConverter(c.String("linguist-path"))
+				if err != nil {
+					return wrap(err)
+				}
+				if err := conv.ConvertGrammars(true); err != nil {
+					return wrap(err)
+				}
+				if err := conv.Report(); err != nil {
+					if !c.Bool("force") {
+						return wrap(err)
+					}
+				}
+				if err := conv.WriteGrammarList(); err != nil {
+					return wrap(err)
+				}
+				return nil
+			},
+		},
+		{
+			Name:  "compile",
+			Usage: "convert the grammars from the library",
+			Flags: []cli.Flag{
+				cli.StringFlag{Name: "proto-out, P"},
+				cli.StringFlag{Name: "out, o"},
+			},
+			Action: func(c *cli.Context) error {
+				conv, err := compiler.NewConverter(c.String("linguist-path"))
+				if err != nil {
+					return cli.NewExitError(err, 1)
+				}
+				if err := conv.ConvertGrammars(false); err != nil {
+					return cli.NewExitError(err, 1)
+				}
+				if out := c.String("proto-out"); out != "" {
+					if err := conv.WriteProto(out); err != nil {
+						return cli.NewExitError(err, 1)
+					}
+				}
+				if out := c.String("out"); out != "" {
+					if err := conv.WriteJSON(out); err != nil {
+						return cli.NewExitError(err, 1)
+					}
+				}
+				if err := conv.Report(); err != nil {
+					return wrap(err)
+				}
+				return nil
+			},
+		},
 	}
 
-	conv, err := compiler.NewConverter(*linguistRoot)
-	if err != nil {
-		fatal(err)
-	}
-
-	if *addGrammar != "" {
-		if err := conv.AddGrammar(*addGrammar); err != nil {
-			fatal(err)
-		}
-	}
-
-	if err := conv.ConvertGrammars(*updateList); err != nil {
-		fatal(err)
-	}
-
-	if err := conv.WriteGrammarList(); err != nil {
-		fatal(err)
-	}
-
-	if *protoOut != "" {
-		if err := conv.WriteProto(*protoOut); err != nil {
-			fatal(err)
-		}
-	}
-
-	if *jsonOut != "" {
-		if err := conv.WriteJSON(*jsonOut); err != nil {
-			fatal(err)
-		}
-	}
-
-	if *report == "" {
-		conv.Report(os.Stderr)
-	} else {
-		f, err := os.Create(*report)
-		if err != nil {
-			fatal(err)
-		}
-		conv.Report(f)
-		f.Close()
-	}
+	app.Run(os.Args)
 }