blob: c0c3dbd76960b0250dc9166e4e58e67554610e27 [file] [log] [blame]
// Copyright 2018 The CUE Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package cmd
import (
"context"
"io"
"os"
"strings"
"github.com/spf13/cobra"
"cuelang.org/go/cue/errors"
"cuelang.org/go/cue/token"
)
// TODO: commands
// fix: rewrite/refactor configuration files
// -i interactive: open diff and ask to update
// serve: like cmd, but for servers
// get: convert cue from other languages, like proto and go.
// gen: generate files for other languages
// generate like go generate (also convert cue to go doc)
// test load and fully evaluate test files.
//
// TODO: documentation of concepts
// tasks the key element for cmd, serve, and fix
type runFunction func(cmd *Command, args []string) error
func mkRunE(c *Command, f runFunction) func(*cobra.Command, []string) error {
return func(cmd *cobra.Command, args []string) error {
c.Command = cmd
err := f(c, args)
if err != nil {
exitOnErr(c, err, true)
}
return err
}
}
// newRootCmd creates the base command when called without any subcommands
func newRootCmd() *Command {
cmd := &cobra.Command{
Use: "cue",
Short: "cue emits configuration files to user-defined commands.",
Long: `cue evaluates CUE files, an extension of JSON, and sends them
to user-defined commands for processing.
Commands are defined in CUE as follows:
import "tool/exec"
command: deploy: {
exec.Run
cmd: "kubectl"
args: [ "-f", "deploy" ]
in: json.Encode(userValue) // encode the emitted configuration.
}
cue can also combine the results of http or grpc request with the input
configuration for further processing. For more information on defining commands
run 'cue help cmd' or go to cuelang.org/pkg/cmd.
For more information on writing CUE configuration files see cuelang.org.`,
// Uncomment the following line if your bare application
// has an action associated with it:
// Run: func(cmd *cobra.Command, args []string) { },
SilenceUsage: true,
}
c := &Command{Command: cmd, root: cmd}
cmdCmd := newCmdCmd(c)
c.cmd = cmdCmd
subCommands := []*cobra.Command{
cmdCmd,
newCompletionCmd(c),
newEvalCmd(c),
newDefCmd(c),
newExportCmd(c),
newFixCmd(c),
newFmtCmd(c),
newGetCmd(c),
newImportCmd(c),
newModCmd(c),
newTrimCmd(c),
newVersionCmd(c),
newVetCmd(c),
// Hidden
newAddCmd(c),
}
subCommands = append(subCommands, newHelpTopics(c)...)
addGlobalFlags(cmd.PersistentFlags())
for _, sub := range subCommands {
cmd.AddCommand(sub)
}
return c
}
// MainTest is like Main, runs the cue tool and returns the code for passing to os.Exit.
func MainTest() int {
inTest = true
return Main()
}
// Main runs the cue tool and returns the code for passing to os.Exit.
func Main() int {
cwd, _ := os.Getwd()
err := mainErr(context.Background(), os.Args[1:])
if err != nil {
if err != ErrPrintedError {
errors.Print(os.Stderr, err, &errors.Config{
Cwd: cwd,
ToSlash: inTest,
})
}
return 1
}
return 0
}
func mainErr(ctx context.Context, args []string) error {
cmd, err := New(args)
if err != nil {
return err
}
return cmd.Run(ctx)
}
type Command struct {
// The currently active command.
*cobra.Command
root *cobra.Command
// Subcommands
cmd *cobra.Command
hasErr bool
}
type errWriter Command
func (w *errWriter) Write(b []byte) (int, error) {
c := (*Command)(w)
c.hasErr = true
return c.Command.OutOrStderr().Write(b)
}
// Hint: search for uses of OutOrStderr other than the one here to see
// which output does not trigger a non-zero exit code. os.Stderr may never
// be used directly.
// Stderr returns a writer that should be used for error messages.
func (c *Command) Stderr() io.Writer {
return (*errWriter)(c)
}
// TODO: add something similar for Stdout. The output model of Cobra isn't
// entirely clear, and such a change seems non-trivial.
// Consider overriding these methods from Cobra using OutOrStdErr.
// We don't use them currently, but may be safer to block. Having them
// will encourage their usage, and the naming is inconsistent with other CUE APIs.
// PrintErrf(format string, args ...interface{})
// PrintErrln(args ...interface{})
// PrintErr(args ...interface{})
func (c *Command) SetOutput(w io.Writer) {
c.root.SetOut(w)
}
func (c *Command) SetInput(r io.Reader) {
c.root.SetIn(r)
}
// ErrPrintedError indicates error messages have been printed to stderr.
var ErrPrintedError = errors.New("terminating because of errors")
func (c *Command) Run(ctx context.Context) (err error) {
// Three categories of commands:
// - normal
// - user defined
// - help
// For the latter two, we need to use the default loading.
defer recoverError(&err)
if err := c.root.Execute(); err != nil {
return err
}
if c.hasErr {
return ErrPrintedError
}
return nil
}
func recoverError(err *error) {
switch e := recover().(type) {
case nil:
case panicError:
*err = e.Err
default:
panic(e)
}
// We use panic to escape, instead of os.Exit
}
func New(args []string) (cmd *Command, err error) {
defer recoverError(&err)
cmd = newRootCmd()
rootCmd := cmd.root
if len(args) == 0 {
return cmd, nil
}
rootCmd.SetArgs(args)
var sub = map[string]*subSpec{
"cmd": {commandSection, cmd.cmd},
// "serve": {"server", nil},
// "fix": {"fix", nil},
}
// handle help, --help and -h on root 'cue' command
if args[0] == "help" || args[0] == "--help" || args[0] == "-h" {
// Allow errors.
_ = addSubcommands(cmd, sub, args[1:], true)
return cmd, nil
}
if _, ok := sub[args[0]]; ok {
return cmd, addSubcommands(cmd, sub, args, false)
}
// TODO: clean this up once we either use Cobra properly or when we remove
// it.
err = cmd.cmd.ParseFlags(args)
if err != nil {
return nil, err
}
args = cmd.cmd.Flags().Args()
rootCmd.SetArgs(args)
if c, _, err := rootCmd.Find(args); err == nil && c != nil {
return cmd, nil
}
if !isCommandName(args[0]) {
return cmd, nil // Forces unknown command message from Cobra.
}
tools, err := buildTools(cmd, args[1:])
if err != nil {
return cmd, err
}
_, err = addCustom(cmd, rootCmd, commandSection, args[0], tools)
if err != nil {
err = errors.Newf(token.NoPos,
`%s %q is not defined
Ensure commands are defined in a "_tool.cue" file.
Run 'cue help' to show available commands.`,
commandSection, args[0],
)
return cmd, err
}
return cmd, nil
}
type subSpec struct {
name string
cmd *cobra.Command
}
func addSubcommands(cmd *Command, sub map[string]*subSpec, args []string, isHelp bool) error {
if len(args) > 0 {
if _, ok := sub[args[0]]; ok {
oldargs := []string{args[0]}
args = args[1:]
// Check for 'cue cmd --help|-h'
// it is behaving differently for this one command, cobra does not seem to pick it up
// See issue #340
if len(args) == 1 && (args[0] == "--help" || args[0] == "-h") {
return cmd.Usage()
}
if !isHelp {
err := cmd.cmd.ParseFlags(args)
if err != nil {
return err
}
args = cmd.cmd.Flags().Args()
cmd.root.SetArgs(append(oldargs, args...))
}
}
}
if len(args) > 0 {
if !isCommandName(args[0]) {
return nil // Forces unknown command message from Cobra.
}
args = args[1:]
}
tools, err := buildTools(cmd, args)
if err != nil {
return err
}
// TODO: for now we only allow one instance. Eventually, we can allow
// more if they all belong to the same package and we merge them
// before computing commands.
for _, spec := range sub {
commands := tools.Lookup(spec.name)
if !commands.Exists() {
return nil
}
i, err := commands.Fields()
if err != nil {
return errors.Newf(token.NoPos, "could not create command definitions: %v", err)
}
for i.Next() {
_, _ = addCustom(cmd, spec.cmd, spec.name, i.Label(), tools)
}
}
return nil
}
func isCommandName(s string) bool {
return !strings.Contains(s, `/\`) &&
!strings.HasPrefix(s, ".") &&
!strings.HasSuffix(s, ".cue")
}
type panicError struct {
Err error
}
func exit() {
panic(panicError{ErrPrintedError})
}