go/src/github.com/visualfc/gotools/command/command.go - third_party - Git at Google

 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 //modify 2013-2014 visualfc

 package command

 import (
 	"bytes"
 	"flag"
 	"fmt"
 	"io"
 	"log"
 	"os"
 	"strings"
 	"sync"
 	"text/template"
 	"unicode"
 	"unicode/utf8"
 )

 // A Command is an implementation of a go command
 // like go build or go fix.
 type Command struct {
 	// Run runs the command.
 	// The args are the arguments after the command name.
 	Run func(cmd *Command, args []string) error

 	// UsageLine is the one-line usage message.
 	// The first word in the line is taken to be the command name.
 	UsageLine string

 	// Short is the short description shown in the 'go help' output.
 	Short string

 	// Long is the long message shown in the 'go help <this-command>' output.
 	Long string

 	// Flag is a set of flags specific to this command.
 	Flag flag.FlagSet

 	// CustomFlags indicates that the command will do its own
 	// flag parsing.
 	CustomFlags bool

 	Stdin  io.Reader
 	Stdout io.Writer
 	Stderr io.Writer
 }

 // Name returns the command's name: the first word in the usage line.
 func (c *Command) Name() string {
 	name := c.UsageLine
 	i := strings.Index(name, " ")
 	if i >= 0 {
 		name = name[:i]
 	}
 	return name
 }

 func (c *Command) Usage() {
 	fmt.Fprintf(os.Stderr, "usage: %s %s\n", AppName, c.UsageLine)
 	c.Flag.SetOutput(os.Stderr)
 	c.Flag.PrintDefaults()
 	//fmt.Fprintf(os.Stderr, "%s\n", strings.TrimSpace(c.Long))
 	os.Exit(2)
 }

 func (c *Command) PrintUsage() {
 	fmt.Fprintf(Stderr, "usage: %s %s\n", AppName, c.UsageLine)
 	c.Flag.SetOutput(Stderr)
 	c.Flag.PrintDefaults()
 }

 // Runnable reports whether the command can be run; otherwise
 // it is a documentation pseudo-command such as importpath.
 func (c *Command) Runnable() bool {
 	return c.Run != nil
 }

 func (c *Command) Println(args ...interface{}) {
 	fmt.Fprintln(c.Stdout, args...)
 }

 func (c *Command) Printf(format string, args ...interface{}) {
 	fmt.Fprintf(c.Stdout, format, args...)
 }

 var commands []*Command

 func Register(cmd *Command) {
 	commands = append(commands, cmd)
 }

 func CommandList() (cmds []string) {
 	for _, cmd := range commands {
 		cmds = append(cmds, cmd.Name())
 	}
 	return
 }

 var exitStatus = 0
 var exitMu sync.Mutex

 func SetExitStatus(n int) {
 	exitMu.Lock()
 	if exitStatus < n {
 		exitStatus = n
 	}
 	exitMu.Unlock()
 }

 var (
 	Stdout io.Writer = os.Stdout
 	Stderr io.Writer = os.Stderr
 	Stdin  io.Reader = os.Stdin
 )

 func RunArgs(arguments []string, stdin io.Reader, stdout io.Writer, stderr io.Writer) error {
 	flag.CommandLine.Parse(arguments)
 	args := flag.Args()
 	if len(args) < 1 {
 		printUsage(os.Stderr)
 		return os.ErrInvalid
 	}

 	if len(args) == 1 && strings.TrimSpace(args[0]) == "" {
 		printUsage(os.Stderr)
 		return os.ErrInvalid
 	}

 	if args[0] == "help" {
 		if !help(args[1:]) {
 			return os.ErrInvalid
 		}
 		return nil
 	}

 	for _, cmd := range commands {
 		if cmd.Name() == args[0] && cmd.Run != nil {
 			cmd.Flag.Usage = func() { cmd.Usage() }
 			if cmd.CustomFlags {
 				args = args[1:]
 			} else {
 				cmd.Flag.Parse(args[1:])
 				args = cmd.Flag.Args()
 			}
 			cmd.Stdin = stdin
 			cmd.Stdout = stdout
 			cmd.Stderr = stderr
 			return cmd.Run(cmd, args)
 		}
 	}

 	fmt.Fprintf(os.Stderr, "%s: unknown subcommand %q\nRun '%s help' for usage.\n",
 		AppName, args[0], AppName)
 	return os.ErrInvalid
 }

 func Main() {
 	flag.Usage = usage
 	flag.Parse()
 	log.SetFlags(0)

 	args := flag.Args()
 	if len(args) < 1 {
 		usage()
 	}

 	if len(args) == 1 && strings.TrimSpace(args[0]) == "" {
 		usage()
 	}

 	if args[0] == "help" {
 		if !help(args[1:]) {
 			os.Exit(2)
 		}
 		return
 	}

 	for _, cmd := range commands {
 		if cmd.Name() == args[0] && cmd.Run != nil {
 			cmd.Flag.Usage = func() { cmd.Usage() }
 			if cmd.CustomFlags {
 				args = args[1:]
 			} else {
 				cmd.Flag.Parse(args[1:])
 				args = cmd.Flag.Args()
 			}
 			cmd.Stdin = Stdin
 			cmd.Stdout = Stdout
 			cmd.Stderr = Stderr
 			cmd.Run(cmd, args)
 			Exit()
 			return
 		}
 	}

 	fmt.Fprintf(os.Stderr, "%s: unknown subcommand %q\nRun '%s help' for usage.\n",
 		AppName, args[0], AppName)
 	SetExitStatus(2)
 	Exit()
 }

 var AppInfo string = "LiteIDE golang tool."
 var AppName string = "tools"

 var usageTemplate = `
 Usage:

 	{{AppName}} command [arguments]

 The commands are:
 {{range .}}{{if .Runnable}}
     {{.Name | printf "%-11s"}} {{.Short}}{{end}}{{end}}

 Use "{{AppName}} help [command]" for more information about a command.

 Additional help topics:
 {{range .}}{{if not .Runnable}}
     {{.Name | printf "%-11s"}} {{.Short}}{{end}}{{end}}

 Use "{{AppName}} help [topic]" for more information about that topic.

 `

 var helpTemplate = `{{if .Runnable}}usage: {{AppName}} {{.UsageLine}}

 {{end}}{{.Long | trim}}
 `

 var documentationTemplate = `//
 /*
 {{range .}}{{if .Short}}{{.Short | capitalize}}

 {{end}}{{if .Runnable}}Usage:

 	{{AppName}} {{.UsageLine}}

 {{end}}{{.Long | trim}}


 {{end}}*/
 package main
 `

 // tmpl executes the given template text on data, writing the result to w.
 func tmpl(w io.Writer, text string, data interface{}) {
 	t := template.New("top")
 	t.Funcs(template.FuncMap{"trim": strings.TrimSpace, "capitalize": capitalize})
 	template.Must(t.Parse(text))
 	if err := t.Execute(w, data); err != nil {
 		panic(err)
 	}
 }

 func capitalize(s string) string {
 	if s == "" {
 		return s
 	}
 	r, n := utf8.DecodeRuneInString(s)
 	return string(unicode.ToTitle(r)) + s[n:]
 }

 func printUsage(w io.Writer) {
 	if len(AppInfo) > 0 {
 		fmt.Fprintln(w, AppInfo)
 	}
 	tmpl(w, strings.Replace(usageTemplate, "{{AppName}}", AppName, -1), commands)
 }

 func usage() {
 	printUsage(os.Stderr)
 	os.Exit(2)
 }

 // help implements the 'help' command.
 func help(args []string) bool {
 	if len(args) == 0 {
 		printUsage(os.Stdout)
 		// not exit 2: succeeded at 'go help'.
 		return true
 	}
 	if len(args) != 1 {
 		fmt.Fprintf(os.Stderr, "usage: %s help command\n\nToo many arguments given.\n", AppName)
 		return false
 	}

 	arg := args[0]

 	// 'go help documentation' generates doc.go.
 	if arg == "documentation" {
 		buf := new(bytes.Buffer)
 		printUsage(buf)
 		usage := &Command{Long: buf.String()}
 		tmpl(os.Stdout, strings.Replace(documentationTemplate, "{{AppName}}", AppName, -1), append([]*Command{usage}, commands...))
 		return false
 	}

 	for _, cmd := range commands {
 		if cmd.Name() == arg {
 			tmpl(os.Stdout, strings.Replace(helpTemplate, "{{AppName}}", AppName, -1), cmd)
 			// not exit 2: succeeded at 'go help cmd'.
 			return true
 		}
 	}

 	fmt.Fprintf(os.Stderr, "Unknown help topic %#q.  Run '%s help'.\n", arg, AppName)
 	//os.Exit(2) // failed at 'go help cmd'
 	return false
 }

 var atexitFuncs []func()

 func Atexit(f func()) {
 	atexitFuncs = append(atexitFuncs, f)
 }

 func Exit() {
 	for _, f := range atexitFuncs {
 		f()
 	}
 	os.Exit(exitStatus)
 }

 func Fatalf(format string, args ...interface{}) {
 	Errorf(format, args...)
 	Exit()
 }

 func Errorf(format string, args ...interface{}) {
 	log.Printf(format, args...)
 	SetExitStatus(1)
 }

 var logf = log.Printf

 func ExitIfErrors() {
 	if exitStatus != 0 {
 		Exit()
 	}
 }
	// Copyright 2011 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	//modify 2013-2014 visualfc

	package command

	import (
	"bytes"
	"flag"
	"fmt"
	"io"
	"log"
	"os"
	"strings"
	"sync"
	"text/template"
	"unicode"
	"unicode/utf8"
	)

	// A Command is an implementation of a go command
	// like go build or go fix.
	type Command struct {
	// Run runs the command.
	// The args are the arguments after the command name.
	Run func(cmd *Command, args []string) error

	// UsageLine is the one-line usage message.
	// The first word in the line is taken to be the command name.
	UsageLine string

	// Short is the short description shown in the 'go help' output.
	Short string

	// Long is the long message shown in the 'go help <this-command>' output.
	Long string

	// Flag is a set of flags specific to this command.
	Flag flag.FlagSet

	// CustomFlags indicates that the command will do its own
	// flag parsing.
	CustomFlags bool

	Stdin io.Reader
	Stdout io.Writer
	Stderr io.Writer
	}

	// Name returns the command's name: the first word in the usage line.
	func (c *Command) Name() string {
	name := c.UsageLine
	i := strings.Index(name, " ")
	if i >= 0 {
	name = name[:i]
	}
	return name
	}

	func (c *Command) Usage() {
	fmt.Fprintf(os.Stderr, "usage: %s %s\n", AppName, c.UsageLine)
	c.Flag.SetOutput(os.Stderr)
	c.Flag.PrintDefaults()
	//fmt.Fprintf(os.Stderr, "%s\n", strings.TrimSpace(c.Long))
	os.Exit(2)
	}

	func (c *Command) PrintUsage() {
	fmt.Fprintf(Stderr, "usage: %s %s\n", AppName, c.UsageLine)
	c.Flag.SetOutput(Stderr)
	c.Flag.PrintDefaults()
	}

	// Runnable reports whether the command can be run; otherwise
	// it is a documentation pseudo-command such as importpath.
	func (c *Command) Runnable() bool {
	return c.Run != nil
	}

	func (c *Command) Println(args ...interface{}) {
	fmt.Fprintln(c.Stdout, args...)
	}

	func (c *Command) Printf(format string, args ...interface{}) {
	fmt.Fprintf(c.Stdout, format, args...)
	}

	var commands []*Command

	func Register(cmd *Command) {
	commands = append(commands, cmd)
	}

	func CommandList() (cmds []string) {
	for _, cmd := range commands {
	cmds = append(cmds, cmd.Name())
	}
	return
	}

	var exitStatus = 0
	var exitMu sync.Mutex

	func SetExitStatus(n int) {
	exitMu.Lock()
	if exitStatus < n {
	exitStatus = n
	}
	exitMu.Unlock()
	}

	var (
	Stdout io.Writer = os.Stdout
	Stderr io.Writer = os.Stderr
	Stdin io.Reader = os.Stdin
	)

	func RunArgs(arguments []string, stdin io.Reader, stdout io.Writer, stderr io.Writer) error {
	flag.CommandLine.Parse(arguments)
	args := flag.Args()
	if len(args) < 1 {
	printUsage(os.Stderr)
	return os.ErrInvalid
	}

	if len(args) == 1 && strings.TrimSpace(args[0]) == "" {
	printUsage(os.Stderr)
	return os.ErrInvalid
	}

	if args[0] == "help" {
	if !help(args[1:]) {
	return os.ErrInvalid
	}
	return nil
	}

	for _, cmd := range commands {
	if cmd.Name() == args[0] && cmd.Run != nil {
	cmd.Flag.Usage = func() { cmd.Usage() }
	if cmd.CustomFlags {
	args = args[1:]
	} else {
	cmd.Flag.Parse(args[1:])
	args = cmd.Flag.Args()
	}
	cmd.Stdin = stdin
	cmd.Stdout = stdout
	cmd.Stderr = stderr
	return cmd.Run(cmd, args)
	}
	}

	fmt.Fprintf(os.Stderr, "%s: unknown subcommand %q\nRun '%s help' for usage.\n",
	AppName, args[0], AppName)
	return os.ErrInvalid
	}

	func Main() {
	flag.Usage = usage
	flag.Parse()
	log.SetFlags(0)

	args := flag.Args()
	if len(args) < 1 {
	usage()
	}

	if len(args) == 1 && strings.TrimSpace(args[0]) == "" {
	usage()
	}

	if args[0] == "help" {
	if !help(args[1:]) {
	os.Exit(2)
	}
	return
	}

	for _, cmd := range commands {
	if cmd.Name() == args[0] && cmd.Run != nil {
	cmd.Flag.Usage = func() { cmd.Usage() }
	if cmd.CustomFlags {
	args = args[1:]
	} else {
	cmd.Flag.Parse(args[1:])
	args = cmd.Flag.Args()
	}
	cmd.Stdin = Stdin
	cmd.Stdout = Stdout
	cmd.Stderr = Stderr
	cmd.Run(cmd, args)
	Exit()
	return
	}
	}

	fmt.Fprintf(os.Stderr, "%s: unknown subcommand %q\nRun '%s help' for usage.\n",
	AppName, args[0], AppName)
	SetExitStatus(2)
	Exit()
	}

	var AppInfo string = "LiteIDE golang tool."
	var AppName string = "tools"

	var usageTemplate = `
	Usage:

	{{AppName}} command [arguments]

	The commands are:
	{{range .}}{{if .Runnable}}
	{{.Name \| printf "%-11s"}} {{.Short}}{{end}}{{end}}

	Use "{{AppName}} help [command]" for more information about a command.

	Additional help topics:
	{{range .}}{{if not .Runnable}}
	{{.Name \| printf "%-11s"}} {{.Short}}{{end}}{{end}}

	Use "{{AppName}} help [topic]" for more information about that topic.

	`

	var helpTemplate = `{{if .Runnable}}usage: {{AppName}} {{.UsageLine}}

	{{end}}{{.Long \| trim}}
	`

	var documentationTemplate = `//
	/*
	{{range .}}{{if .Short}}{{.Short \| capitalize}}

	{{end}}{{if .Runnable}}Usage:

	{{AppName}} {{.UsageLine}}

	{{end}}{{.Long \| trim}}


	{{end}}*/
	package main
	`

	// tmpl executes the given template text on data, writing the result to w.
	func tmpl(w io.Writer, text string, data interface{}) {
	t := template.New("top")
	t.Funcs(template.FuncMap{"trim": strings.TrimSpace, "capitalize": capitalize})
	template.Must(t.Parse(text))
	if err := t.Execute(w, data); err != nil {
	panic(err)
	}
	}

	func capitalize(s string) string {
	if s == "" {
	return s
	}
	r, n := utf8.DecodeRuneInString(s)
	return string(unicode.ToTitle(r)) + s[n:]
	}

	func printUsage(w io.Writer) {
	if len(AppInfo) > 0 {
	fmt.Fprintln(w, AppInfo)
	}
	tmpl(w, strings.Replace(usageTemplate, "{{AppName}}", AppName, -1), commands)
	}

	func usage() {
	printUsage(os.Stderr)
	os.Exit(2)
	}

	// help implements the 'help' command.
	func help(args []string) bool {
	if len(args) == 0 {
	printUsage(os.Stdout)
	// not exit 2: succeeded at 'go help'.
	return true
	}
	if len(args) != 1 {
	fmt.Fprintf(os.Stderr, "usage: %s help command\n\nToo many arguments given.\n", AppName)
	return false
	}

	arg := args[0]

	// 'go help documentation' generates doc.go.
	if arg == "documentation" {
	buf := new(bytes.Buffer)
	printUsage(buf)
	usage := &Command{Long: buf.String()}
	tmpl(os.Stdout, strings.Replace(documentationTemplate, "{{AppName}}", AppName, -1), append([]*Command{usage}, commands...))
	return false
	}

	for _, cmd := range commands {
	if cmd.Name() == arg {
	tmpl(os.Stdout, strings.Replace(helpTemplate, "{{AppName}}", AppName, -1), cmd)
	// not exit 2: succeeded at 'go help cmd'.
	return true
	}
	}

	fmt.Fprintf(os.Stderr, "Unknown help topic %#q. Run '%s help'.\n", arg, AppName)
	//os.Exit(2) // failed at 'go help cmd'
	return false
	}

	var atexitFuncs []func()

	func Atexit(f func()) {
	atexitFuncs = append(atexitFuncs, f)
	}

	func Exit() {
	for _, f := range atexitFuncs {
	f()
	}
	os.Exit(exitStatus)
	}

	func Fatalf(format string, args ...interface{}) {
	Errorf(format, args...)
	Exit()
	}

	func Errorf(format string, args ...interface{}) {
	log.Printf(format, args...)
	SetExitStatus(1)
	}

	var logf = log.Printf

	func ExitIfErrors() {
	if exitStatus != 0 {
	Exit()
	}
	}