parse.go 10.4 KB
Newer Older
1 2 3
package cli

import (
Juan Batiz-Benet's avatar
Juan Batiz-Benet committed
4
	"fmt"
5
	"os"
6
	"path"
7
	"path/filepath"
8
	"runtime"
Jeromy's avatar
Jeromy committed
9
	"sort"
Juan Batiz-Benet's avatar
Juan Batiz-Benet committed
10
	"strings"
11

12 13
	cmds "github.com/ipfs/go-ipfs/commands"
	files "github.com/ipfs/go-ipfs/commands/files"
14
	logging "gx/ipfs/QmYtB7Qge8cJpXc4irsEp8zRqfnZMBeB7aTrMEkPk67DRv/go-log"
15
	u "gx/ipfs/QmZNVWh8LLjAavuQ2JXuFmuYH3C11xo988vSgp7UQrTRj1/go-ipfs-util"
16 17
)

18 19
var log = logging.Logger("commands/cli")

Juan Batiz-Benet's avatar
Juan Batiz-Benet committed
20 21
// Parse parses the input commandline string (cmd, flags, and args).
// returns the corresponding command Request object.
22
func Parse(input []string, stdin *os.File, root *cmds.Command) (cmds.Request, *cmds.Command, []string, error) {
Etienne Laurin's avatar
Etienne Laurin committed
23
	path, opts, stringVals, cmd, err := parseOpts(input, root)
24
	if err != nil {
Etienne Laurin's avatar
Etienne Laurin committed
25
		return nil, nil, path, err
26 27
	}

28 29
	optDefs, err := root.GetOptions(path)
	if err != nil {
30
		return nil, cmd, path, err
31 32
	}

33 34 35 36
	req, err := cmds.NewRequest(path, opts, nil, nil, cmd, optDefs)
	if err != nil {
		return nil, cmd, path, err
	}
37

38 39 40 41 42 43 44
	// if -r is provided, and it is associated with the package builtin
	// recursive path option, allow recursive file paths
	recursiveOpt := req.Option(cmds.RecShort)
	recursive := false
	if recursiveOpt != nil && recursiveOpt.Definition() == cmds.OptionRecursivePath {
		recursive, _, err = recursiveOpt.Bool()
		if err != nil {
45
			return req, nil, nil, u.ErrCast()
46
		}
47
	}
48

Jeromy's avatar
Jeromy committed
49 50 51 52 53 54 55 56 57 58 59
	// if '--hidden' is provided, enumerate hidden paths
	hiddenOpt := req.Option("hidden")
	hidden := false
	if hiddenOpt != nil {
		hidden, _, err = hiddenOpt.Bool()
		if err != nil {
			return req, nil, nil, u.ErrCast()
		}
	}

	stringArgs, fileArgs, err := parseArgs(stringVals, stdin, cmd.Arguments, recursive, hidden, root)
60
	if err != nil {
61
		return req, cmd, path, err
62
	}
63 64
	req.SetArguments(stringArgs)

65 66 67 68
	if len(fileArgs) > 0 {
		file := files.NewSliceFile("", "", fileArgs)
		req.SetFiles(file)
	}
69 70 71

	err = cmd.CheckArguments(req)
	if err != nil {
72
		return req, cmd, path, err
73 74
	}

75
	return req, cmd, path, nil
76 77
}

Etienne Laurin's avatar
Etienne Laurin committed
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97
// Parse a command line made up of sub-commands, short arguments, long arguments and positional arguments
func parseOpts(args []string, root *cmds.Command) (
	path []string,
	opts map[string]interface{},
	stringVals []string,
	cmd *cmds.Command,
	err error,
) {
	path = make([]string, 0, len(args))
	stringVals = make([]string, 0, len(args))
	optDefs := map[string]cmds.Option{}
	opts = map[string]interface{}{}
	cmd = root

	// parseFlag checks that a flag is valid and saves it into opts
	// Returns true if the optional second argument is used
	parseFlag := func(name string, arg *string, mustUse bool) (bool, error) {
		if _, ok := opts[name]; ok {
			return false, fmt.Errorf("Duplicate values for option '%s'", name)
		}
98

Etienne Laurin's avatar
Etienne Laurin committed
99 100 101 102
		optDef, found := optDefs[name]
		if !found {
			err = fmt.Errorf("Unrecognized option '%s'", name)
			return false, err
Juan Batiz-Benet's avatar
Juan Batiz-Benet committed
103
		}
104 105 106 107 108 109
		// mustUse implies that you must use the argument given after the '='
		// eg. -r=true means you must take true into consideration
		//		mustUse == true in the above case
		// eg. ipfs -r <file> means disregard <file> since there is no '='
		//		mustUse == false in the above situation
		//arg == nil implies the flag was specified without an argument
Etienne Laurin's avatar
Etienne Laurin committed
110
		if optDef.Type() == cmds.Bool {
111 112 113 114 115 116 117 118 119 120 121 122 123 124
			if arg == nil || !mustUse {
				opts[name] = true
				return false, nil
			}
			argVal := strings.ToLower(*arg)
			switch argVal {
			case "true":
				opts[name] = true
				return true, nil
			case "false":
				opts[name] = false
				return true, nil
			default:
				return true, fmt.Errorf("Option '%s' takes true/false arguments, but was passed '%s'", name, argVal)
Etienne Laurin's avatar
Etienne Laurin committed
125 126 127 128 129 130 131
			}
		} else {
			if arg == nil {
				return true, fmt.Errorf("Missing argument for option '%s'", name)
			}
			opts[name] = *arg
			return true, nil
Juan Batiz-Benet's avatar
Juan Batiz-Benet committed
132 133
		}
	}
134

Etienne Laurin's avatar
Etienne Laurin committed
135 136 137 138
	optDefs, err = root.GetOptions(path)
	if err != nil {
		return
	}
139

Etienne Laurin's avatar
Etienne Laurin committed
140 141 142 143 144 145 146
	consumed := false
	for i, arg := range args {
		switch {
		case consumed:
			// arg was already consumed by the preceding flag
			consumed = false
			continue
147

Etienne Laurin's avatar
Etienne Laurin committed
148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
		case arg == "--":
			// treat all remaining arguments as positional arguments
			stringVals = append(stringVals, args[i+1:]...)
			return

		case strings.HasPrefix(arg, "--"):
			// arg is a long flag, with an optional argument specified
			// using `=' or in args[i+1]
			var slurped bool
			var next *string
			split := strings.SplitN(arg, "=", 2)
			if len(split) == 2 {
				slurped = false
				arg = split[0]
				next = &split[1]
			} else {
				slurped = true
				if i+1 < len(args) {
					next = &args[i+1]
				} else {
					next = nil
				}
Juan Batiz-Benet's avatar
Juan Batiz-Benet committed
170
			}
Etienne Laurin's avatar
Etienne Laurin committed
171 172 173
			consumed, err = parseFlag(arg[2:], next, len(split) == 2)
			if err != nil {
				return
Juan Batiz-Benet's avatar
Juan Batiz-Benet committed
174
			}
Etienne Laurin's avatar
Etienne Laurin committed
175 176
			if !slurped {
				consumed = false
Juan Batiz-Benet's avatar
Juan Batiz-Benet committed
177
			}
178

Etienne Laurin's avatar
Etienne Laurin committed
179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202
		case strings.HasPrefix(arg, "-") && arg != "-":
			// args is one or more flags in short form, followed by an optional argument
			// all flags except the last one have type bool
			for arg = arg[1:]; len(arg) != 0; arg = arg[1:] {
				var rest *string
				var slurped bool
				mustUse := false
				if len(arg) > 1 {
					slurped = false
					str := arg[1:]
					if len(str) > 0 && str[0] == '=' {
						str = str[1:]
						mustUse = true
					}
					rest = &str
				} else {
					slurped = true
					if i+1 < len(args) {
						rest = &args[i+1]
					} else {
						rest = nil
					}
				}
				var end bool
rht's avatar
rht committed
203
				end, err = parseFlag(arg[:1], rest, mustUse)
Etienne Laurin's avatar
Etienne Laurin committed
204 205 206 207 208 209 210 211
				if err != nil {
					return
				}
				if end {
					consumed = slurped
					break
				}
			}
212

Etienne Laurin's avatar
Etienne Laurin committed
213 214 215 216 217 218 219 220 221 222
		default:
			// arg is a sub-command or a positional argument
			sub := cmd.Subcommand(arg)
			if sub != nil {
				cmd = sub
				path = append(path, arg)
				optDefs, err = root.GetOptions(path)
				if err != nil {
					return
				}
223 224 225 226 227 228 229

				// If we've come across an external binary call, pass all the remaining
				// arguments on to it
				if cmd.External {
					stringVals = append(stringVals, args[i+1:]...)
					return
				}
Etienne Laurin's avatar
Etienne Laurin committed
230 231
			} else {
				stringVals = append(stringVals, arg)
232 233 234 235 236
				if len(path) == 0 {
					// found a typo or early argument
					err = printSuggestions(stringVals, root)
					return
				}
Etienne Laurin's avatar
Etienne Laurin committed
237
			}
Juan Batiz-Benet's avatar
Juan Batiz-Benet committed
238 239
		}
	}
Etienne Laurin's avatar
Etienne Laurin committed
240
	return
241
}
242

243 244
const msgStdinInfo = "ipfs: Reading from %s; send Ctrl-d to stop.\n"

Jeromy's avatar
Jeromy committed
245
func parseArgs(inputs []string, stdin *os.File, argDefs []cmds.Argument, recursive, hidden bool, root *cmds.Command) ([]string, []files.File, error) {
246 247 248 249 250
	// ignore stdin on Windows
	if runtime.GOOS == "windows" {
		stdin = nil
	}

251
	// count required argument definitions
252
	numRequired := 0
253
	for _, argDef := range argDefs {
254
		if argDef.Required {
255
			numRequired++
256
		}
257
	}
258

259 260 261
	// count number of values provided by user.
	// if there is at least one ArgDef, we can safely trigger the inputs loop
	// below to parse stdin.
262
	numInputs := len(inputs)
263
	if len(argDefs) > 0 && argDefs[len(argDefs)-1].SupportsStdin && stdin != nil {
264
		numInputs += 1
265 266
	}

267 268 269
	// if we have more arg values provided than argument definitions,
	// and the last arg definition is not variadic (or there are no definitions), return an error
	notVariadic := len(argDefs) == 0 || !argDefs[len(argDefs)-1].Variadic
Christian Couder's avatar
Christian Couder committed
270
	if notVariadic && len(inputs) > len(argDefs) {
271 272
		err := printSuggestions(inputs, root)
		return nil, nil, err
273 274
	}

275
	stringArgs := make([]string, 0, numInputs)
276

Jeromy's avatar
Jeromy committed
277
	fileArgs := make(map[string]files.File)
278
	argDefIndex := 0 // the index of the current argument definition
279
	for i := 0; i < numInputs; i++ {
280
		argDef := getArgDef(argDefIndex, argDefs)
281

282
		// skip optional argument definitions if there aren't sufficient remaining inputs
283 284 285 286 287
		for numInputs-i <= numRequired && !argDef.Required {
			argDefIndex++
			argDef = getArgDef(argDefIndex, argDefs)
		}
		if argDef.Required {
288
			numRequired--
289
		}
290

291 292
		fillingVariadic := argDefIndex+1 > len(argDefs)

293
		if argDef.Type == cmds.ArgString {
294
			if len(inputs) > 0 {
295
				stringArgs, inputs = append(stringArgs, inputs[0]), inputs[1:]
296
			} else {
297
				break
298
			}
299
		} else if argDef.Type == cmds.ArgFile {
300
			if len(inputs) > 0 {
301
				// treat stringArg values as file paths
Jeromy's avatar
Jeromy committed
302 303
				fpath := inputs[0]
				inputs = inputs[1:]
304 305 306
				var file files.File
				var err error
				if fpath == "-" {
307
					if err = printReadInfo(stdin, msgStdinInfo); err == nil {
308 309
						fpath = stdin.Name()
						file = files.NewReaderFile("", fpath, stdin, nil)
310
					}
311 312 313
				} else {
					file, err = appendFile(fpath, argDef, recursive, hidden)
				}
314 315 316 317
				if err != nil {
					return nil, nil, err
				}

Jeromy's avatar
Jeromy committed
318
				fileArgs[fpath] = file
319
			} else {
320 321
				if stdin != nil && argDef.SupportsStdin &&
					argDef.Required && !fillingVariadic {
322 323 324
					if err := printReadInfo(stdin, msgStdinInfo); err != nil {
						return nil, nil, err
					}
325 326
					fpath := stdin.Name()
					fileArgs[fpath] = files.NewReaderFile("", fpath, stdin, nil)
327 328
				} else {
					break
329
				}
330 331
			}
		}
332 333

		argDefIndex++
334 335
	}

336
	// check to make sure we didn't miss any required arguments
337 338 339 340 341
	if len(argDefs) > argDefIndex {
		for _, argDef := range argDefs[argDefIndex:] {
			if argDef.Required {
				return nil, nil, fmt.Errorf("Argument '%s' is required", argDef.Name)
			}
342 343 344
		}
	}

Jeromy's avatar
Jeromy committed
345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361
	return stringArgs, filesMapToSortedArr(fileArgs), nil
}

func filesMapToSortedArr(fs map[string]files.File) []files.File {
	var names []string
	for name, _ := range fs {
		names = append(names, name)
	}

	sort.Strings(names)

	var out []files.File
	for _, f := range names {
		out = append(out, fs[f])
	}

	return out
362
}
363

364 365 366 367 368 369 370 371 372 373 374 375 376 377
func getArgDef(i int, argDefs []cmds.Argument) *cmds.Argument {
	if i < len(argDefs) {
		// get the argument definition (usually just argDefs[i])
		return &argDefs[i]

	} else if len(argDefs) > 0 {
		// but if i > len(argDefs) we use the last argument definition)
		return &argDefs[len(argDefs)-1]
	}

	// only happens if there aren't any definitions
	return nil
}

Jeromy's avatar
Jeromy committed
378 379 380
const notRecursiveFmtStr = "'%s' is a directory, use the '-%s' flag to specify directories"
const dirNotSupportedFmtStr = "Invalid path '%s', argument '%s' does not support directories"

Jeromy's avatar
Jeromy committed
381
func appendFile(fpath string, argDef *cmds.Argument, recursive, hidden bool) (files.File, error) {
382 383 384
	if fpath == "." {
		cwd, err := os.Getwd()
		if err != nil {
Jeromy's avatar
Jeromy committed
385
			return nil, err
386 387 388
		}
		fpath = cwd
	}
Jeromy's avatar
Jeromy committed
389

390 391
	fpath = filepath.ToSlash(filepath.Clean(fpath))

Jeromy's avatar
Jeromy committed
392
	stat, err := os.Lstat(fpath)
393
	if err != nil {
Jeromy's avatar
Jeromy committed
394
		return nil, err
395 396 397 398
	}

	if stat.IsDir() {
		if !argDef.Recursive {
Jeromy's avatar
Jeromy committed
399
			return nil, fmt.Errorf(dirNotSupportedFmtStr, fpath, argDef.Name)
400 401
		}
		if !recursive {
Jeromy's avatar
Jeromy committed
402
			return nil, fmt.Errorf(notRecursiveFmtStr, fpath, cmds.RecShort)
403 404 405
		}
	}

Jeromy's avatar
Jeromy committed
406
	return files.NewSerialFile(path.Base(fpath), fpath, hidden, stat)
407
}
408 409 410 411 412 413 414 415 416 417 418 419 420 421 422

// Inform the user if a file is waiting on input
func printReadInfo(f *os.File, msg string) error {
	fInfo, err := f.Stat()
	if err != nil {
		log.Error(err)
		return err
	}

	if (fInfo.Mode() & os.ModeCharDevice) != 0 {
		fmt.Fprintf(os.Stderr, msg, f.Name())
	}

	return nil
}