func init() { registerCommand(&cmd.Command{ Name: "doc", UsageLine: `doc <pkg> <sym>[.<method>]`, Short: "show documentation for a package or symbol", Long: ` Doc shows documentation for a package or symbol. See 'go help doc'. `, Run: func(ctx *gb.Context, args []string) error { env := cmd.MergeEnv(os.Environ(), map[string]string{ "GOPATH": fmt.Sprintf("%s:%s", ctx.Projectdir(), filepath.Join(ctx.Projectdir(), "vendor")), }) if len(args) == 0 { args = append(args, ".") } cmd := exec.Command("godoc", args...) cmd.Env = env cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr return cmd.Run() }, SkipParseArgs: true, }) }
func init() { registerCommand(&cmd.Command{ Name: "doc", UsageLine: `doc <pkg> <sym>[.<method>]`, Short: "show documentation for a package or symbol", Long: ` Doc shows documentation for a package or symbol. See 'go help doc'. `, Run: func(ctx *gb.Context, args []string) error { env := cmd.MergeEnv(os.Environ(), map[string]string{ "GOPATH": fmt.Sprintf("%s:%s", ctx.Projectdir(), filepath.Join(ctx.Projectdir(), "vendor")), }) if len(args) == 0 { args = append(args, ".") } args = append([]string{filepath.Join(ctx.Context.GOROOT, "bin", "godoc")}, args...) cmd := exec.Cmd{ Path: args[0], Args: args, Env: env, Stdin: os.Stdin, Stdout: os.Stdout, Stderr: os.Stderr, } return cmd.Run() }, ParseArgs: func(_ *gb.Context, _ string, args []string) []string { return args }, }) }
func run(ctx *gb.Context, args []string) error { if len(args) == 0 { return errors.New(DocUsage) } // Build up the fake env env := cmd.MergeEnv(os.Environ(), map[string]string{ "GOPATH": fmt.Sprintf("%s%s%s", projectRoot, string(os.PathListSeparator), path.Join(projectRoot, "vendor")), }) // Switch on the subcommand switch args[0] { case "serve", "deploy", "build", "test": return goapp(ctx, args, env) case "raw": return raw(ctx, args, env) case "appcfg": return appcfg(ctx, args, env) default: return fmt.Errorf("Unknown subcommand: %s\n\n%v", args[0], DocUsage) } }
func main() { fatalf := func(format string, args ...interface{}) { fmt.Fprintf(os.Stderr, "FATAL: "+format+"\n", args...) os.Exit(1) } args := os.Args if len(args) < 2 || args[1] == "-h" { fs.Usage() os.Exit(1) } name := args[1] if name == "help" { help(args[2:]) return } command, ok := commands[name] if (command != nil && !command.Runnable()) || !ok { plugin, err := lookupPlugin(name) if err != nil { fmt.Fprintf(os.Stderr, "FATAL: unknown command %q\n", name) fs.Usage() os.Exit(1) } command = &cmd.Command{ Run: func(ctx *gb.Context, args []string) error { args = append([]string{plugin}, args...) env := cmd.MergeEnv(os.Environ(), map[string]string{ "GB_PROJECT_DIR": ctx.Projectdir(), }) cmd := exec.Cmd{ Path: plugin, Args: args, Env: env, Stdin: os.Stdin, Stdout: os.Stdout, Stderr: os.Stderr, } return cmd.Run() }, // plugin should not interpret arguments ParseArgs: func(_ *gb.Context, _ string, args []string) []string { return args }, } } // add extra flags if necessary if command.AddFlags != nil { command.AddFlags(fs) } var err error if command.FlagParse != nil { err = command.FlagParse(fs, args) } else { err = fs.Parse(args[2:]) } if err != nil { fatalf("could not parse flags: %v", err) } args = fs.Args() // reset args to the leftovers from fs.Parse if command == commands["plugin"] { args = append([]string{name}, args...) } cwd, err := filepath.Abs(cwd) // if cwd was passed in via -R, make sure it is absolute if err != nil { fatalf("could not make project root absolute: %v", err) } ctx, err := cmd.NewContext( cwd, // project root gb.GcToolchain(), gb.Gcflags(gcflags...), gb.Ldflags(ldflags...), gb.Tags(buildtags...), ) if err != nil { fatalf("unable to construct context: %v", err) } if !noDestroyContext { defer ctx.Destroy() } if command.ParseArgs != nil { args = command.ParseArgs(ctx, ctx.Projectdir(), args) } else { args = cmd.ImportPaths(ctx, cwd, args) } debug.Debugf("args: %v", args) if err := command.Run(ctx, args); err != nil { if !noDestroyContext { ctx.Destroy() } fatalf("command %q failed: %v", name, err) } }
func init() { registerCommand(GenerateCmd) } var GenerateCmd = &cmd.Command{ Name: "generate", UsageLine: "generate [-run regexp] [file.go... | packages]", Short: "generate Go files by processing source", Long: ` Generate runs commands described by directives within existing files. Those commands can run any process, but the intent is to create or update Go source files, for instance by running yacc. See 'go help generate'. `, Run: func(ctx *gb.Context, args []string) error { env := cmd.MergeEnv(os.Environ(), map[string]string{ "GOPATH": fmt.Sprintf("%s:%s", ctx.Projectdir(), filepath.Join(ctx.Projectdir(), "vendor")), }) cmd := exec.Command("go", append([]string{"generate"}, args...)...) cmd.Env = env cmd.Stdin = os.Stdin cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr return cmd.Run() }, }
func main() { args := os.Args if len(args) < 2 || args[1] == "-h" { fs.Usage() // usage calles exit(2) } name := args[1] if name == "help" { help(args[2:]) exit(0) } command, ok := commands[name] if (command != nil && !command.Runnable()) || !ok { plugin, err := lookupPlugin(name) if err != nil { fmt.Fprintf(os.Stderr, "FATAL: unknown command %q\n", name) fs.Usage() // usage calles exit(2) } command = &cmd.Command{ Run: func(ctx *gb.Context, args []string) error { args = append([]string{plugin}, args...) env := cmd.MergeEnv(os.Environ(), map[string]string{ "GB_PROJECT_DIR": ctx.Projectdir(), }) cmd := exec.Cmd{ Path: plugin, Args: args, Env: env, Stdin: os.Stdin, Stdout: os.Stdout, Stderr: os.Stderr, } return cmd.Run() }, // plugin should not interpret arguments SkipParseArgs: true, } } // add extra flags if necessary if command.AddFlags != nil { command.AddFlags(fs) } var err error if command.FlagParse != nil { err = command.FlagParse(fs, args) } else { err = fs.Parse(args[2:]) } if err != nil { fatalf("could not parse flags: %v", err) } args = fs.Args() // reset args to the leftovers from fs.Parse debug.Debugf("args: %v", args) if command == commands["plugin"] { args = append([]string{name}, args...) } cwd, err := filepath.Abs(cwd) // if cwd was passed in via -R, make sure it is absolute if err != nil { fatalf("could not make project root absolute: %v", err) } ctx, err := cmd.NewContext( cwd, // project root gb.GcToolchain(), gb.Gcflags(gcflags...), gb.Ldflags(ldflags...), gb.Tags(buildtags...), func(c *gb.Context) error { if !race { return nil } // check this is a supported platform if runtime.GOARCH != "amd64" { fatalf("race detector not supported on %s/%s", runtime.GOOS, runtime.GOARCH) } switch runtime.GOOS { case "linux", "windows", "darwin", "freebsd": // supported default: fatalf("race detector not supported on %s/%s", runtime.GOOS, runtime.GOARCH) } // check the race runtime is built _, err := os.Stat(filepath.Join(runtime.GOROOT(), "pkg", fmt.Sprintf("%s_%s_race", runtime.GOOS, runtime.GOARCH), "runtime.a")) if os.IsNotExist(err) || err != nil { fatalf("go installation at %s is missing race support. See https://getgb.io/faq/#missing-race-support", runtime.GOROOT()) } return gb.WithRace(c) }, ) if err != nil { fatalf("unable to construct context: %v", err) } if !command.SkipParseArgs { args = cmd.ImportPaths(ctx, cwd, args) } debug.Debugf("args: %v", args) if destroyContext { atExit = append(atExit, ctx.Destroy) } if err := command.Run(ctx, args); err != nil { fatalf("command %q failed: %v", name, err) } exit(0) }
See gb help plugins. `, Run: func(ctx *gb.Context, args []string) error { if len(args) < 1 { return fmt.Errorf("plugin: no command supplied") } path, err := lookupPlugin(args[0]) if err != nil { return err } args[0] = path env := cmd.MergeEnv(os.Environ(), map[string]string{ "GB_PROJECT_DIR": ctx.Projectdir(), }) cmd := exec.Cmd{ Path: path, Args: args, Env: env, Stdin: os.Stdin, Stdout: os.Stdout, Stderr: os.Stderr, } return cmd.Run() }, // plugin should not interpret arguments