Genesis

Author: ammario

.sail/Dockerfile

@@ -0,0 +1,6 @@
+FROM codercom/ubuntu-dev-go
+RUN sudo apt-get install -y htop
+LABEL project_root "~/go/src/go.coder.com"
+
+# Modules break much of Go's tooling.
+ENV GO111MODULE=off

LICENSE.md

@@ -0,0 +1,7 @@
+Copyright 2019 Coder
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,112 @@
+# cli
+
+A minimal, command-oriented CLI packages.
+
+[![GoDoc](https://godoc.org/github.com/golang/gddo?status.svg)](https://godoc.org/go.coder.com/cli)
+
+## Features
+
+- Very small, simple API.
+- Uses stdlib as much as possible.
+- 0 dependencies.
+
+## Examples
+
+See `examples/` for more.
+
+### Simple CLI
+```go
+package main
+
+import (
+    "flag"
+    "fmt"
+
+    "go.coder.com/cli"
+)
+
+type cmd struct {
+    verbose bool
+}
+
+func (c *cmd) Run(fl *flag.FlagSet) {
+    if c.verbose {
+        fmt.Println("verbose enabled")
+    }
+    fmt.Println("we run")
+}
+
+func (c *cmd) Spec() cli.CommandSpec {
+    return cli.CommandSpec{
+        Name:  "simple-example",
+        Usage: "[flags]",
+        Desc:  `This is a simple example of the cli package.`,
+    }
+}
+
+func (c *cmd) RegisterFlags(fl *flag.FlagSet) {
+    fl.BoolVar(&c.verbose, "v", false, "sets verbose mode")
+}
+
+func main() {
+    cli.RunRoot(&cmd{})
+}
+
+```
+
+### Subcommands
+
+```go
+package main
+
+import (
+    "flag"
+    "fmt"
+
+    "go.coder.com/cli"
+)
+
+type subcmd struct {
+}
+
+func (c *subcmd) Run(fl *flag.FlagSet) {
+    fmt.Println("subcommand invoked")
+}
+
+func (c *subcmd) Spec() cli.CommandSpec {
+    return cli.CommandSpec{
+        Name:  "sub",
+        Usage: "",
+        Desc:  `This is a simple subcommand.`,
+    }
+}
+
+type cmd struct {
+    message string
+}
+
+func (c *cmd) Run(fl *flag.FlagSet) {
+    // This root command has no default action, so print the help.
+    fl.Usage()
+}
+
+func (c *cmd) Spec() cli.CommandSpec {
+    return cli.CommandSpec{
+        Name:  "subcommand",
+        Usage: "[flags]",
+        Desc:  `This is a simple example of subcommands.`,
+    }
+}
+
+func (c *cmd) Subcommands() []cli.Command {
+    return []cli.Command{
+        &subcmd{},
+    }
+}
+
+func main() {
+    cli.RunRoot(&cmd{message: "subcommands"})
+}
+
+
+```

command.go

@@ -0,0 +1,49 @@
+package cli
+
+import (
+	"flag"
+	"strings"
+)
+
+// CommandSpec describes a Command's usage.
+//
+// It should not list flags.
+type CommandSpec struct {
+	// Name is the name of the command.
+	// It should be the leaf name of the entire command. E.g `run` for the full
+	// command `sail run`.
+	Name string
+	// Usage is the command's usage string.
+	// E.g "[flags] <path>"
+	Usage string
+	// Desc is the description of the command.
+	// The first line is used as an abbreviated description.
+	Desc string
+}
+
+// ShortDesc returns the first line of Desc.
+func (c CommandSpec) ShortDesc() string {
+	return strings.Split(c.Desc, "\n")[0]
+}
+
+// Command describes a command or subcommand.
+type Command interface {
+	// Spec returns metadata about the command.
+	Spec() CommandSpec
+	// Run invokes the command's main routine with parsed flags.
+	Run(fl *flag.FlagSet)
+}
+
+// ParentCommand is an optional interface for commands that have subcommands.
+//
+// A ParentCommand may pass itself into children as it creates them in order to
+// pass high-level configuration and state.
+type ParentCommand interface {
+	Subcommands() []Command
+}
+
+// FlaggedCommand is an optional interface for commands that have flags.
+type FlaggedCommand interface {
+	// RegisterFlags lets the command register flags which be sent to Handle.
+	RegisterFlags(fl *flag.FlagSet)
+}

doc.go

@@ -0,0 +1,17 @@
+// Package cli provides a thin CLI abstraction around the standard flag package.
+// It is minimal, command-struct-oriented, and trades off "power" for flexibility
+// and clarity at the caller level.
+//
+// It pretends that Go's single dash (-flag) support doesn't exist, and renders
+// helps with --.
+//
+// Optional interface adherence can be asserted with a statement like
+//  var _ interface {
+//  	cli.Command
+//  	cli.FlaggedCommand
+//  	cli.ParentCommand
+//  } = new(rootCmd)
+//
+// This package is exported since we think it could be interesting to the community,
+// but the API is subject to change in support of sail.
+package cli

examples/simple/main.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"go.coder.com/cli"
+)
+
+type cmd struct {
+	verbose bool
+}
+
+func (c *cmd) Run(fl *flag.FlagSet) {
+	if c.verbose {
+		fmt.Println("verbose enabled")
+	}
+	fmt.Println("we run")
+}
+
+func (c *cmd) Spec() cli.CommandSpec {
+	return cli.CommandSpec{
+		Name:  "simple-example",
+		Usage: "[flags]",
+		Desc:  `This is a simple example of the cli package.`,
+	}
+}
+
+func (c *cmd) RegisterFlags(fl *flag.FlagSet) {
+	fl.BoolVar(&c.verbose, "v", false, "sets verbose mode")
+}
+
+func main() {
+	cli.RunRoot(&cmd{})
+}

examples/subcommands/main.go

@@ -0,0 +1,50 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"go.coder.com/cli"
+)
+
+type subcmd struct {
+}
+
+func (c *subcmd) Run(fl *flag.FlagSet) {
+	fmt.Println("subcommand invoked")
+}
+
+func (c *subcmd) Spec() cli.CommandSpec {
+	return cli.CommandSpec{
+		Name:  "sub",
+		Usage: "",
+		Desc:  `This is a simple subcommand.`,
+	}
+}
+
+type cmd struct {
+	message string
+}
+
+func (c *cmd) Run(fl *flag.FlagSet) {
+	// This root command has no default action, so print the help.
+	fl.Usage()
+}
+
+func (c *cmd) Spec() cli.CommandSpec {
+	return cli.CommandSpec{
+		Name:  "subcommand",
+		Usage: "[flags]",
+		Desc:  `This is a simple example of subcommands.`,
+	}
+}
+
+func (c *cmd) Subcommands() []cli.Command {
+	return []cli.Command{
+		&subcmd{},
+	}
+}
+
+func main() {
+	cli.RunRoot(&cmd{message: "subcommands"})
+}

go.mod

@@ -0,0 +1,3 @@
+module go.coder.com/cli
+
+go 1.12

help.go

@@ -0,0 +1,56 @@
+package cli
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"unicode/utf8"
+)
+
+func flagDashes(name string) string {
+	if utf8.RuneCountInString(name) > 1 {
+		return "--"
+	}
+	return "-"
+}
+
+func renderFlagHelp(fl *flag.FlagSet, w io.Writer) {
+	fmt.Fprintf(w, "%v flags:\n", fl.Name())
+	var count int
+	fl.VisitAll(func(f *flag.Flag) {
+		count++
+		if f.DefValue == "" {
+			fmt.Fprintf(w, "\t%v%v\t%v\n", flagDashes(f.Name), f.Name, f.Usage)
+		} else {
+			fmt.Fprintf(w, "\t%v%v\t%v\t(%v)\n", flagDashes(f.Name), f.Name, f.Usage, f.DefValue)
+		}
+	})
+	if count == 0 {
+		fmt.Fprintf(w, "\n")
+	}
+}
+
+// renderHelp generates a command's help page.
+func renderHelp(cmd Command, fl *flag.FlagSet, w io.Writer) {
+	// Render usage and description.
+	fmt.Fprintf(w, "Usage: %v %v\n\n",
+		fl.Name(), cmd.Spec().Usage,
+	)
+	fmt.Fprintf(w, "%v\n\n", cmd.Spec().Desc)
+
+	// Render flag help.
+	renderFlagHelp(fl, w)
+
+	// Render subcommand summaries.
+	pc, ok := cmd.(ParentCommand)
+	if ok {
+		if len(pc.Subcommands()) > 0 {
+            // Give some space from flags.
+			fmt.Fprintf(w, "\n")
+			fmt.Fprint(w, "Commands:\n")
+		}
+		for _, cmd := range pc.Subcommands() {
+			fmt.Fprintf(w, "\t%v\t%v\n", cmd.Spec().Name, cmd.Spec().ShortDesc())
+		}
+	}
+}