Update vendors

vendor/github.com/cosiner/argv/LICENSE

@@ -0,0 +1,24 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 aihui zhu
+
+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.

vendor/github.com/cosiner/argv/argv.go

@@ -0,0 +1,34 @@
+// Package argv parse command line string into arguments array using the bash syntax.
+package argv
+
+import "strings"
+
+// ParseEnv parsing environment variables as key/value pair.
+//
+// Item will be ignored if one of the key and value is empty.
+func ParseEnv(env []string) map[string]string {
+	var m map[string]string
+	for _, e := range env {
+		secs := strings.SplitN(e, "=", 2)
+		if len(secs) == 2 {
+			key := strings.TrimSpace(secs[0])
+			val := strings.TrimSpace(secs[1])
+			if key == "" || val == "" {
+				continue
+			}
+			if m == nil {
+				m = make(map[string]string)
+			}
+			m[key] = val
+		}
+	}
+	return m
+}
+
+// Argv split cmdline string as array of argument array by the '|' character.
+//
+// The parsing rules is same as bash. The environment variable will be replaced
+// and string surround by '`' will be passed to reverse quote parser.
+func Argv(cmdline []rune, env map[string]string, reverseQuoteParser ReverseQuoteParser) ([][]string, error) {
+	return NewParser(NewScanner(cmdline, env), reverseQuoteParser).Parse()
+}

vendor/github.com/cosiner/argv/cmd.go

@@ -0,0 +1,79 @@
+package argv
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"os/exec"
+	"strings"
+)
+
+// Run execute cmdline string and return the output
+func Run(cmdline []rune, env map[string]string) ([]rune, error) {
+	args, err := Argv(cmdline, env, Run)
+	if err != nil {
+		return nil, err
+	}
+	cmds, err := Cmds(args)
+	if err != nil {
+		return nil, err
+	}
+
+	output := bytes.NewBuffer(make([]byte, 0, 1024))
+	err = Pipe(nil, output, cmds...)
+	str := output.String()
+	str = strings.TrimSpace(str)
+	return []rune(str), err
+}
+
+// Cmds generate exec.Cmd for each command.
+func Cmds(args [][]string) ([]*exec.Cmd, error) {
+	var cmds []*exec.Cmd
+	for _, argv := range args {
+		if len(argv) == 0 {
+			return nil, errors.New("invalid cmd")
+		}
+
+		cmds = append(cmds, exec.Command(argv[0], argv[1:]...))
+	}
+	return cmds, nil
+}
+
+// Pipe pipe previous command's stdout to next command's stdin, if in or
+// out is nil, it will be ignored.
+func Pipe(in io.Reader, out io.Writer, cmds ...*exec.Cmd) error {
+	l := len(cmds)
+	if l == 0 {
+		return nil
+	}
+
+	var err error
+	for i := 1; i < l; i++ {
+		cmds[i].Stdin, err = cmds[i-1].StdoutPipe()
+		if err != nil {
+			break
+		}
+	}
+	if err != nil {
+		return err
+	}
+	if in != nil {
+		cmds[0].Stdin = in
+	}
+	if out != nil {
+		cmds[l-1].Stdout = out
+	}
+	for i := range cmds {
+		err = cmds[i].Start()
+		if err != nil {
+			return err
+		}
+	}
+	for i := range cmds {
+		err = cmds[i].Wait()
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

vendor/github.com/cosiner/argv/parser.go

@@ -0,0 +1,222 @@
+package argv
+
+import "errors"
+
+type (
+	// ReverseQuoteParser parse strings quoted by '`' and return it's result. Commonly,
+	// it should run it os command.
+	ReverseQuoteParser func([]rune, map[string]string) ([]rune, error)
+
+	// Parser take tokens from Scanner, and do syntax checking, and generate the splitted arguments array.
+	Parser struct {
+		s      *Scanner
+		tokbuf []Token
+		r      ReverseQuoteParser
+
+		sections    [][]string
+		currSection []string
+
+		currStrValid bool
+		currStr      []rune
+	}
+)
+
+// NewParser create a cmdline string parser.
+func NewParser(s *Scanner, r ReverseQuoteParser) *Parser {
+	if r == nil {
+		r = func(r []rune, env map[string]string) ([]rune, error) {
+			return r, nil
+		}
+	}
+
+	return &Parser{
+		s: s,
+		r: r,
+	}
+}
+
+func (p *Parser) nextToken() (Token, error) {
+	if l := len(p.tokbuf); l > 0 {
+		tok := p.tokbuf[l-1]
+		p.tokbuf = p.tokbuf[:l-1]
+		return tok, nil
+	}
+
+	return p.s.Next()
+}
+
+var (
+	// ErrInvalidSyntax was reported if there is a syntax error in command line string.
+	ErrInvalidSyntax = errors.New("invalid syntax")
+)
+
+func (p *Parser) unreadToken(tok Token) {
+	p.tokbuf = append(p.tokbuf, tok)
+}
+
+// Parse split command line string into arguments array.
+//
+// EBNF:
+//   Cmdline = Section [ Pipe Cmdline ]
+//   Section = [Space] SpacedSection { SpacedSection }
+//   SpacedSection = MultipleUnit [Space]
+//   MultipleUnit = Unit {Unit}
+//   Unit = String | ReverseQuote
+func (p *Parser) Parse() ([][]string, error) {
+	err := p.cmdline()
+	if err != nil {
+		return nil, err
+	}
+	return p.sections, nil
+}
+
+func (p *Parser) cmdline() error {
+	err := p.section()
+	if err != nil {
+		return err
+	}
+	p.endSection()
+
+	tok, err := p.nextToken()
+	if err != nil {
+		return err
+	}
+	if tok.Type == TokEOF {
+		return nil
+	}
+	if !p.accept(tok.Type, TokPipe) {
+		return ErrInvalidSyntax
+	}
+	return p.cmdline()
+}
+
+func (p *Parser) section() error {
+	leftSpace, err := p.optional(TokSpace)
+	if err != nil {
+		return err
+	}
+
+	var isFirst = true
+	for {
+		unit, err := p.spacedSection()
+		if isFirst {
+			isFirst = false
+		} else {
+			if err == ErrInvalidSyntax {
+				break
+			}
+		}
+		if err != nil {
+			return err
+		}
+
+		p.appendUnit(leftSpace, unit)
+		leftSpace = unit.rightSpace
+	}
+	return nil
+}
+
+type unit struct {
+	rightSpace bool
+	toks       []Token
+}
+
+func (p *Parser) spacedSection() (u unit, err error) {
+	u.toks, err = p.multipleUnit()
+	if err != nil {
+		return
+	}
+	u.rightSpace, err = p.optional(TokSpace)
+	return
+}
+
+func (p *Parser) multipleUnit() ([]Token, error) {
+	var (
+		toks    []Token
+		isFirst = true
+	)
+	for {
+		tok, err := p.unit()
+		if isFirst {
+			isFirst = false
+		} else {
+			if err == ErrInvalidSyntax {
+				break
+			}
+		}
+		if err != nil {
+			return nil, err
+		}
+		toks = append(toks, tok)
+	}
+	return toks, nil
+}
+
+func (p *Parser) unit() (Token, error) {
+	tok, err := p.nextToken()
+	if err != nil {
+		return tok, err
+	}
+	if p.accept(tok.Type, TokString, TokReversequote) {
+		return tok, nil
+	}
+	p.unreadToken(tok)
+	return tok, ErrInvalidSyntax
+}
+
+func (p *Parser) optional(typ TokenType) (bool, error) {
+	tok, err := p.nextToken()
+	if err != nil {
+		return false, err
+	}
+	var ok bool
+	if ok = p.accept(tok.Type, typ); !ok {
+		p.unreadToken(tok)
+	}
+	return ok, nil
+}
+
+func (p *Parser) accept(t TokenType, types ...TokenType) bool {
+	for _, typ := range types {
+		if t == typ {
+			return true
+		}
+	}
+	return false
+}
+
+func (p *Parser) appendUnit(leftSpace bool, u unit) error {
+	if leftSpace {
+		p.currStr = p.currStr[:0]
+	}
+	for _, tok := range u.toks {
+		if tok.Type == TokReversequote {
+			val, err := p.r(tok.Value, p.s.envs())
+			if err != nil {
+				return err
+			}
+			p.currStr = append(p.currStr, val...)
+		} else {
+			p.currStr = append(p.currStr, tok.Value...)
+		}
+	}
+	p.currStrValid = true
+	if u.rightSpace {
+		p.currSection = append(p.currSection, string(p.currStr))
+		p.currStr = p.currStr[:0]
+		p.currStrValid = false
+	}
+	return nil
+}
+
+func (p *Parser) endSection() {
+	if p.currStrValid {
+		p.currSection = append(p.currSection, string(p.currStr))
+	}
+	p.currStr = p.currStr[:0]
+	p.currStrValid = false
+	if len(p.currSection) > 0 {
+		p.sections = append(p.sections, p.currSection)
+		p.currSection = nil
+	}
+}

vendor/github.com/cosiner/argv/scanner.go

@@ -0,0 +1,282 @@
+package argv
+
+import "unicode"
+
+// Scanner is a cmdline string scanner.
+//
+// It split cmdline string to tokens: space, string, pipe, reverse quote string.
+type Scanner struct {
+	env map[string]string
+
+	text      []rune
+	rpos      int
+	dollarBuf []rune
+}
+
+// NewScanner create a scanner and init it's internal states.
+func NewScanner(text []rune, env map[string]string) *Scanner {
+	return &Scanner{
+		text: text,
+		env:  env,
+	}
+}
+
+func (s *Scanner) envs() map[string]string {
+	return s.env
+}
+
+const _RuneEOF = 0
+
+func (s *Scanner) nextRune() rune {
+	if s.rpos >= len(s.text) {
+		return _RuneEOF
+	}
+
+	r := s.text[s.rpos]
+	s.rpos++
+	return r
+}
+
+func (s *Scanner) unreadRune(r rune) {
+	if r != _RuneEOF {
+		s.rpos--
+	}
+}
+
+func (s *Scanner) isEscapeChars(r rune) (rune, bool) {
+	switch r {
+	case 'a':
+		return '\a', true
+	case 'b':
+		return '\b', true
+	case 'f':
+		return '\f', true
+	case 'n':
+		return '\n', true
+	case 'r':
+		return '\r', true
+	case 't':
+		return '\t', true
+	case 'v':
+		return '\v', true
+	case '\\':
+		return '\\', true
+	case '$':
+		return '$', true
+	}
+	return r, false
+}
+
+func (s *Scanner) endEnv(r rune) bool {
+	if r == '_' || (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') {
+		return false
+	}
+	return true
+}
+
+// TokenType is the type of tokens recognized by the scanner.
+type TokenType uint32
+
+// Token is generated by the scanner with a type and value.
+type Token struct {
+	Type  TokenType
+	Value []rune
+}
+
+const (
+	// TokString for string, single quoted string and double quoted string
+	TokString TokenType = iota + 1
+	// TokPipe is the '|' character
+	TokPipe
+	// TokReversequote is reverse quoted string
+	TokReversequote
+	// TokSpace represent space character sequence
+	TokSpace
+	// TokEOF means the input end.
+	TokEOF
+)
+
+func (s *Scanner) getEnv(name string) string {
+	return s.env[name]
+}
+
+func (s *Scanner) specialVar(r rune) (string, bool) {
+	switch r {
+	case '0', '*', '#', '@', '?', '$':
+		v, has := s.env[string(r)]
+		return v, has
+	default:
+		return "", false
+	}
+}
+
+func (s *Scanner) checkDollarStart(tok *Token, r rune, from, switchTo uint8) uint8 {
+	state := from
+	nr := s.nextRune()
+	if val, has := s.specialVar(nr); has {
+		if val != "" {
+			tok.Value = append(tok.Value, []rune(val)...)
+		}
+	} else if s.endEnv(nr) {
+		tok.Value = append(tok.Value, r)
+		s.unreadRune(nr)
+	} else {
+		state = switchTo
+		s.dollarBuf = append(s.dollarBuf[:0], nr)
+	}
+	return state
+}
+
+func (s *Scanner) checkDollarEnd(tok *Token, r rune, from, switchTo uint8) uint8 {
+	var state = from
+	if s.endEnv(r) {
+		tok.Value = append(tok.Value, []rune(s.getEnv(string(s.dollarBuf)))...)
+		state = switchTo
+		s.unreadRune(r)
+	} else {
+		s.dollarBuf = append(s.dollarBuf, r)
+	}
+	return state
+}
+
+// Next return next token, if it reach the end, TOK_EOF will be returned.
+//
+// Error is returned for invalid syntax such as unpaired quotes.
+func (s *Scanner) Next() (Token, error) {
+	const (
+		Initial = iota + 1
+		Space
+		ReverseQuote
+		String
+		StringDollar
+		StringQuoteSingle
+		StringQuoteDouble
+		StringQuoteDoubleDollar
+	)
+
+	var (
+		tok Token
+
+		state uint8 = Initial
+	)
+	s.dollarBuf = s.dollarBuf[:0]
+	for {
+		r := s.nextRune()
+		switch state {
+		case Initial:
+			switch {
+			case r == _RuneEOF:
+				tok.Type = TokEOF
+				return tok, nil
+			case r == '|':
+				tok.Type = TokPipe
+				return tok, nil
+			case r == '`':
+				state = ReverseQuote
+			case unicode.IsSpace(r):
+				state = Space
+				s.unreadRune(r)
+			default:
+				state = String
+				s.unreadRune(r)
+			}
+		case Space:
+			if r == _RuneEOF || !unicode.IsSpace(r) {
+				s.unreadRune(r)
+				tok.Type = TokSpace
+				return tok, nil
+			}
+		case ReverseQuote:
+			switch r {
+			case _RuneEOF:
+				return tok, ErrInvalidSyntax
+			case '`':
+				tok.Type = TokReversequote
+				return tok, nil
+			default:
+				tok.Value = append(tok.Value, r)
+			}
+		case String:
+			switch {
+			case r == _RuneEOF || r == '|' || r == '`' || unicode.IsSpace(r):
+				tok.Type = TokString
+				s.unreadRune(r)
+				return tok, nil
+			case r == '\'':
+				state = StringQuoteSingle
+			case r == '"':
+				state = StringQuoteDouble
+			case r == '\\':
+				nr := s.nextRune()
+				if nr == _RuneEOF {
+					return tok, ErrInvalidSyntax
+				}
+				tok.Value = append(tok.Value, nr)
+			case r == '$':
+				state = s.checkDollarStart(&tok, r, state, StringDollar)
+			default:
+				tok.Value = append(tok.Value, r)
+			}
+		case StringDollar:
+			state = s.checkDollarEnd(&tok, r, state, String)
+		case StringQuoteSingle:
+			switch r {
+			case _RuneEOF:
+				return tok, ErrInvalidSyntax
+			case '\'':
+				state = String
+			case '\\':
+				nr := s.nextRune()
+				if escape, ok := s.isEscapeChars(nr); ok {
+					tok.Value = append(tok.Value, escape)
+				} else {
+					tok.Value = append(tok.Value, r)
+					s.unreadRune(nr)
+				}
+			default:
+				tok.Value = append(tok.Value, r)
+			}
+		case StringQuoteDouble:
+			switch r {
+			case _RuneEOF:
+				return tok, ErrInvalidSyntax
+			case '"':
+				state = String
+			case '\\':
+				nr := s.nextRune()
+				if nr == _RuneEOF {
+					return tok, ErrInvalidSyntax
+				}
+				if escape, ok := s.isEscapeChars(nr); ok {
+					tok.Value = append(tok.Value, escape)
+				} else {
+					tok.Value = append(tok.Value, r)
+					s.unreadRune(nr)
+				}
+			case '$':
+				state = s.checkDollarStart(&tok, r, state, StringQuoteDoubleDollar)
+			default:
+				tok.Value = append(tok.Value, r)
+			}
+		case StringQuoteDoubleDollar:
+			state = s.checkDollarEnd(&tok, r, state, StringQuoteDouble)
+		}
+	}
+}
+
+// Scan is a utility function help split input text as tokens.
+func Scan(text []rune, env map[string]string) ([]Token, error) {
+	s := NewScanner(text, env)
+	var tokens []Token
+	for {
+		tok, err := s.Next()
+		if err != nil {
+			return nil, err
+		}
+		tokens = append(tokens, tok)
+		if tok.Type == TokEOF {
+			break
+		}
+	}
+	return tokens, nil
+}