rewrite checkpoint

vendor/github.com/AlecAivazis/survey/.tasks.yml

@@ -0,0 +1,23 @@
+autoplay-tests:
+  summary: Replaying interactive tests
+  command: |-
+    cd tests
+    set -e
+    for test in autoplay/*.go; do
+      echo "==> Running $test"
+      go run $test
+    done
+
+install-deps:
+  summary: Install all of package dependencies
+  command: |-
+    go get -t {{.files}}
+    # for autoplay tests
+    go get github.com/kr/pty
+
+tests:
+  summary: Run the test suite
+  command: go test {{.files}}
+
+variables:
+  files: '$(go list -v ./... | grep -iEv "github.com/AlecAivazis/survey/(tests|examples)")'

vendor/github.com/AlecAivazis/survey/.travis.yml

@@ -0,0 +1,11 @@
+language: go
+
+before_install:
+  - go get github.com/AlecAivazis/run
+
+install:
+  - run install-deps
+
+script:
+  - run tests
+  # - run autoplay-tests

vendor/github.com/AlecAivazis/survey/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Alec Aivazis
+
+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/AlecAivazis/survey/README.md

@@ -0,0 +1,291 @@
+# Survey
+[![Build Status](https://travis-ci.org/AlecAivazis/survey.svg?branch=feature%2Fpretty)](https://travis-ci.org/AlecAivazis/survey)
+[![GoDoc](http://img.shields.io/badge/godoc-reference-5272B4.svg)](https://godoc.org/github.com/AlecAivazis/survey)
+
+A library for building interactive prompts. Heavily inspired by the great [inquirer.js](https://github.com/SBoudrias/Inquirer.js/).
+
+![](https://zippy.gfycat.com/AmusingBossyArrowworm.gif)
+
+```go
+package main
+
+import (
+    "fmt"
+    "gopkg.in/AlecAivazis/survey.v1"
+)
+
+// the questions to ask
+var qs = []*survey.Question{
+    {
+        Name:     "name",
+        Prompt:   &survey.Input{Message: "What is your name?"},
+        Validate: survey.Required,
+    },
+    {
+        Name: "color",
+        Prompt: &survey.Select{
+            Message: "Choose a color:",
+            Options: []string{"red", "blue", "green"},
+            Default: "red",
+        },
+    },
+    {
+        Name: "age",
+        Prompt:   &survey.Input{Message: "How old are you?"},
+    },
+}
+
+func main() {
+    // the answers will be written to this struct
+    answers := struct {
+        Name          string                  // survey will match the question and field names
+        FavoriteColor string `survey:"color"` // or you can tag fields to match a specific name
+        Age           int                     // if the types don't match exactly, survey will try to convert for you
+    }{}
+
+    // perform the questions
+    err := survey.Ask(qs, &answers)
+    if err != nil {
+        fmt.Println(err.Error())
+        return
+    }
+
+    fmt.Printf("%s chose %s.", answers.Name, answers.FavoriteColor)
+}
+```
+
+## Table of Contents
+
+1. [Examples](#examples)
+1. [Prompts](#prompts)
+    1. [Input](#input)
+    1. [Password](#password)
+    1. [Confirm](#confirm)
+    1. [Select](#select)
+    1. [MultiSelect](#multiselect)
+1. [Validation](#validation)
+    1. [Built-in Validators](#built-in-validators)
+1. [Help Text](#help-text)
+    1. [Changing the input rune](#changing-the-input-run)
+1. [Custom Types](#custom-types)
+1. [Customizing Output](#customizing-output)
+1. [Versioning](#versioning)
+
+## Examples
+
+Examples can be found in the `examples/` directory. Run them
+to see basic behavior:
+
+```bash
+go get github.com/AlecAivazis/survey
+
+# ... navigate to the repo in your GOPATH
+
+go run examples/simple.go
+go run examples/validation.go
+```
+
+## Prompts
+
+### Input
+
+<img src="https://media.giphy.com/media/3og0IxS8JsuD9Z8syA/giphy.gif" width="400px"/>
+
+```golang
+name := ""
+prompt := &survey.Input{
+    Message: "ping",
+}
+survey.AskOne(prompt, &name, nil)
+```
+
+
+### Password
+
+<img src="https://media.giphy.com/media/26FmQr6mUivkq71GE/giphy.gif" width="400px" />
+
+```golang
+password := ""
+prompt := &survey.Password{
+    Message: "Please type your password",
+}
+survey.AskOne(prompt, &password, nil)
+```
+
+
+### Confirm
+
+<img src="https://media.giphy.com/media/3oKIPgsUmTp4m3eo4E/giphy.gif" width="400px"/>
+
+```golang
+name := false
+prompt := &survey.Confirm{
+    Message: "Do you like pie?",
+}
+survey.AskOne(prompt, &name, nil)
+```
+
+
+### Select
+
+<img src="https://media.giphy.com/media/3oKIPxigmMu5YqpUPK/giphy.gif" width="400px"/>
+
+```golang
+color := ""
+prompt := &survey.Select{
+    Message: "Choose a color:",
+    Options: []string{"red", "blue", "green"},
+}
+survey.AskOne(prompt, &color, nil)
+```
+
+By default, the select prompt is limited to showing 7 options at a time
+and will paginate lists of options longer than that. To increase, you can either
+change the global `survey.PageCount`, or set the `PageSize` field on the prompt:
+
+```golang
+prompt := &survey.Select{..., PageSize: 10}
+```
+
+### MultiSelect
+
+<img src="https://media.giphy.com/media/3oKIP8lHYFtGeQDH0c/giphy.gif" width="400px"/>
+
+```golang
+days := []string{}
+prompt := &survey.MultiSelect{
+    Message: "What days do you prefer:",
+    Options: []string{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"},
+}
+survey.AskOne(prompt, &days, nil)
+```
+
+By default, the MultiSelect prompt is limited to showing 7 options at a time
+and will paginate lists of options longer than that. To increase, you can either
+change the global `survey.PageCount`, or set the `PageSize` field on the prompt:
+
+```golang
+prompt := &survey.MultiSelect{..., PageSize: 10}
+```
+
+## Validation
+
+Validating individual responses for a particular question can be done by defining a
+`Validate` field on the `survey.Question` to be validated. This function takes an
+`interface{}` type and returns an error to show to the user, prompting them for another
+response:
+
+```golang
+q := &survey.Question{
+    Prompt: &survey.Input{Message: "Hello world validation"},
+    Validate: func (val interface{}) error {
+        // since we are validating an Input, the assertion will always succeed
+        if str, ok := val.(string) ; ok && len(str) > 10 {
+            return errors.New("This response cannot be longer than 10 characters.")
+        }
+    }
+}
+```
+
+### Built-in Validators
+
+`survey` comes prepackaged with a few validators to fit common situations. Currently these
+validators include:
+
+|    name      |   valid types   |       description                                             |
+|--------------|-----------------|---------------------------------------------------------------|
+| Required     |   any           |   Rejects zero values of the response type                    |
+| MinLength(n) |   string        |   Enforces that a response is at least the given length       |
+| MaxLength(n) |   string        |   Enforces that a response is no longer than the given length |
+
+## Help Text
+
+All of the prompts have a `Help` field which can be defined to provide more information to your users:
+
+<img src="https://media.giphy.com/media/l1KVbc5CehW6r7pss/giphy.gif" width="400px" style="margin-top: 8px"/>
+
+```golang
+&survey.Input{
+    Message: "What is your phone number:",
+    Help:    "Phone number should include the area code",
+}
+```
+
+### Changing the input rune
+
+In some situations, `?` is a perfectly valid response. To handle this, you can change the rune that survey
+looks for by setting the `HelpInputRune` variable in `survey/core`:
+
+```golang
+
+import (
+    "gopkg.in/AlecAivazis/survey.v1"
+    surveyCore "gopkg.in/AlecAivazis/survey.v1/core"
+)
+
+number := ""
+prompt := &survey.Input{
+    Message: "If you have this need, please give me a reasonable message.",
+    Help:    "I couldn't come up with one.",
+}
+
+surveyCore.HelpInputRune = '^'
+
+survey.AskOne(prompt, &number, nil)
+```
+
+## Custom Types
+
+survey will assign prompt answers to your custom types if they implement this interface:
+
+```golang
+type settable interface {
+    WriteAnswer(field string, value interface{}) error
+}
+```
+
+Here is an example how to use them:
+
+```golang
+type MyValue struct {
+    value string
+}
+func (my *MyValue) WriteAnswer(name string, value interface{}) error {
+     my.value = value.(string)
+}
+
+myval := MyValue{}
+survey.AskOne(
+    &survey.Input{
+        Message: "Enter something:",
+    },
+    &myval,
+    nil,
+)
+```
+
+## Customizing Output
+
+Customizing the icons and various parts of survey can easily be done by setting the following variables
+in `survey/core`:
+
+|   name              |     default    |    description                                                    |
+|---------------------|----------------|-------------------------------------------------------------------|
+| ErrorIcon           |       ✘        | Before an error                                                   |
+| HelpIcon            |       ⓘ       | Before help text                                                   |
+| QuestionIcon        |       ?        | Before the message of a prompt                                    |
+| SelectFocusIcon     |       ❯        | Marks the current focus in `Select` and `MultiSelect` prompts     |
+| MarkedOptionIcon    |       ◉        | Marks a chosen selection in a `MultiSelect` prompt                |
+| UnmarkedOptionIcon  |       ◯        | Marks an unselected option in a `MultiSelect` prompt              |
+
+## Versioning
+
+This project tries to maintain semantic GitHub releases as closely as possible. As such, services
+like [gopkg.in](http://labix.org/gopkg.in) work very well to ensure non-breaking changes whenever
+you build your application. For example, importing v1 of survey could look something like
+
+```golang
+package main
+
+import "gopkg.in/AlecAivazis/survey.v1"
+```

vendor/github.com/AlecAivazis/survey/confirm.go

@@ -0,0 +1,138 @@
+package survey
+
+import (
+	"fmt"
+	"os"
+	"regexp"
+
+	"github.com/AlecAivazis/survey/core"
+	"github.com/AlecAivazis/survey/terminal"
+)
+
+// Confirm is a regular text input that accept yes/no answers. Response type is a bool.
+type Confirm struct {
+	core.Renderer
+	Message string
+	Default bool
+	Help    string
+}
+
+// data available to the templates when processing
+type ConfirmTemplateData struct {
+	Confirm
+	Answer   string
+	ShowHelp bool
+}
+
+// Templates with Color formatting. See Documentation: https://github.com/mgutz/ansi#style-format
+var ConfirmQuestionTemplate = `
+{{- if .ShowHelp }}{{- color "cyan"}}{{ HelpIcon }} {{ .Help }}{{color "reset"}}{{"\n"}}{{end}}
+{{- color "green+hb"}}{{ QuestionIcon }} {{color "reset"}}
+{{- color "default+hb"}}{{ .Message }} {{color "reset"}}
+{{- if .Answer}}
+  {{- color "cyan"}}{{.Answer}}{{color "reset"}}{{"\n"}}
+{{- else }}
+  {{- if and .Help (not .ShowHelp)}}{{color "cyan"}}[{{ HelpInputRune }} for help]{{color "reset"}} {{end}}
+  {{- color "white"}}{{if .Default}}(Y/n) {{else}}(y/N) {{end}}{{color "reset"}}
+{{- end}}`
+
+// the regex for answers
+var (
+	yesRx = regexp.MustCompile("^(?i:y(?:es)?)$")
+	noRx  = regexp.MustCompile("^(?i:n(?:o)?)$")
+)
+
+func yesNo(t bool) string {
+	if t {
+		return "Yes"
+	}
+	return "No"
+}
+
+func (c *Confirm) getBool(showHelp bool) (bool, error) {
+	rr := terminal.NewRuneReader(os.Stdin)
+	rr.SetTermMode()
+	defer rr.RestoreTermMode()
+	// start waiting for input
+	for {
+		line, err := rr.ReadLine(0)
+		if err != nil {
+			return false, err
+		}
+		// move back up a line to compensate for the \n echoed from terminal
+		terminal.CursorPreviousLine(1)
+		val := string(line)
+
+		// get the answer that matches the
+		var answer bool
+		switch {
+		case yesRx.Match([]byte(val)):
+			answer = true
+		case noRx.Match([]byte(val)):
+			answer = false
+		case val == "":
+			answer = c.Default
+		case val == string(core.HelpInputRune) && c.Help != "":
+			err := c.Render(
+				ConfirmQuestionTemplate,
+				ConfirmTemplateData{Confirm: *c, ShowHelp: true},
+			)
+			if err != nil {
+				// use the default value and bubble up
+				return c.Default, err
+			}
+			showHelp = true
+			continue
+		default:
+			// we didnt get a valid answer, so print error and prompt again
+			if err := c.Error(fmt.Errorf("%q is not a valid answer, please try again.", val)); err != nil {
+				return c.Default, err
+			}
+			err := c.Render(
+				ConfirmQuestionTemplate,
+				ConfirmTemplateData{Confirm: *c, ShowHelp: showHelp},
+			)
+			if err != nil {
+				// use the default value and bubble up
+				return c.Default, err
+			}
+			continue
+		}
+		return answer, nil
+	}
+	// should not get here
+	return c.Default, nil
+}
+
+/*
+Prompt prompts the user with a simple text field and expects a reply followed
+by a carriage return.
+
+	likesPie := false
+	prompt := &survey.Confirm{ Message: "What is your name?" }
+	survey.AskOne(prompt, &likesPie, nil)
+*/
+func (c *Confirm) Prompt() (interface{}, error) {
+	// render the question template
+	err := c.Render(
+		ConfirmQuestionTemplate,
+		ConfirmTemplateData{Confirm: *c},
+	)
+	if err != nil {
+		return "", err
+	}
+
+	// get input and return
+	return c.getBool(false)
+}
+
+// Cleanup overwrite the line with the finalized formatted version
+func (c *Confirm) Cleanup(val interface{}) error {
+	// if the value was previously true
+	ans := yesNo(val.(bool))
+	// render the template
+	return c.Render(
+		ConfirmQuestionTemplate,
+		ConfirmTemplateData{Confirm: *c, Answer: ans},
+	)
+}

vendor/github.com/AlecAivazis/survey/confirm_test.go

@@ -0,0 +1,71 @@
+package survey
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/AlecAivazis/survey/core"
+	"github.com/AlecAivazis/survey/terminal"
+	"github.com/stretchr/testify/assert"
+)
+
+func init() {
+	// disable color output for all prompts to simplify testing
+	core.DisableColor = true
+}
+
+func TestConfirmRender(t *testing.T) {
+
+	tests := []struct {
+		title    string
+		prompt   Confirm
+		data     ConfirmTemplateData
+		expected string
+	}{
+		{
+			"Test Confirm question output with default true",
+			Confirm{Message: "Is pizza your favorite food?", Default: true},
+			ConfirmTemplateData{},
+			`? Is pizza your favorite food? (Y/n) `,
+		},
+		{
+			"Test Confirm question output with default false",
+			Confirm{Message: "Is pizza your favorite food?", Default: false},
+			ConfirmTemplateData{},
+			`? Is pizza your favorite food? (y/N) `,
+		},
+		{
+			"Test Confirm answer output",
+			Confirm{Message: "Is pizza your favorite food?"},
+			ConfirmTemplateData{Answer: "Yes"},
+			"? Is pizza your favorite food? Yes\n",
+		},
+		{
+			"Test Confirm with help but help message is hidden",
+			Confirm{Message: "Is pizza your favorite food?", Help: "This is helpful"},
+			ConfirmTemplateData{},
+			"? Is pizza your favorite food? [? for help] (y/N) ",
+		},
+		{
+			"Test Confirm help output with help message shown",
+			Confirm{Message: "Is pizza your favorite food?", Help: "This is helpful"},
+			ConfirmTemplateData{ShowHelp: true},
+			`ⓘ This is helpful
+? Is pizza your favorite food? (y/N) `,
+		},
+	}
+
+	outputBuffer := bytes.NewBufferString("")
+	terminal.Stdout = outputBuffer
+
+	for _, test := range tests {
+		outputBuffer.Reset()
+		test.data.Confirm = test.prompt
+		err := test.prompt.Render(
+			ConfirmQuestionTemplate,
+			test.data,
+		)
+		assert.Nil(t, err, test.title)
+		assert.Equal(t, test.expected, outputBuffer.String(), test.title)
+	}
+}

vendor/github.com/AlecAivazis/survey/core/renderer.go

@@ -0,0 +1,62 @@
+package core
+
+import (
+	"strings"
+
+	"github.com/AlecAivazis/survey/terminal"
+)
+
+type Renderer struct {
+	lineCount      int
+	errorLineCount int
+}
+
+var ErrorTemplate = `{{color "red"}}{{ ErrorIcon }} Sorry, your reply was invalid: {{.Error}}{{color "reset"}}
+`
+
+func (r *Renderer) Error(invalid error) error {
+	// since errors are printed on top we need to reset the prompt
+	// as well as any previous error print
+	r.resetPrompt(r.lineCount + r.errorLineCount)
+	// we just cleared the prompt lines
+	r.lineCount = 0
+	out, err := RunTemplate(ErrorTemplate, invalid)
+	if err != nil {
+		return err
+	}
+	// keep track of how many lines are printed so we can clean up later
+	r.errorLineCount = strings.Count(out, "\n")
+
+	// send the message to the user
+	terminal.Print(out)
+	return nil
+}
+
+func (r *Renderer) resetPrompt(lines int) {
+	// clean out current line in case tmpl didnt end in newline
+	terminal.CursorHorizontalAbsolute(0)
+	terminal.EraseLine(terminal.ERASE_LINE_ALL)
+	// clean up what we left behind last time
+	for i := 0; i < lines; i++ {
+		terminal.CursorPreviousLine(1)
+		terminal.EraseLine(terminal.ERASE_LINE_ALL)
+	}
+}
+
+func (r *Renderer) Render(tmpl string, data interface{}) error {
+	r.resetPrompt(r.lineCount)
+	// render the template summarizing the current state
+	out, err := RunTemplate(tmpl, data)
+	if err != nil {
+		return err
+	}
+
+	// keep track of how many lines are printed so we can clean up later
+	r.lineCount = strings.Count(out, "\n")
+
+	// print the summary
+	terminal.Print(out)
+
+	// nothing went wrong
+	return nil
+}

vendor/github.com/AlecAivazis/survey/core/template.go

@@ -0,0 +1,83 @@
+package core
+
+import (
+	"bytes"
+	"text/template"
+
+	"github.com/mgutz/ansi"
+)
+
+var DisableColor = false
+
+var (
+	HelpInputRune = '?'
+
+	ErrorIcon    = "✘"
+	HelpIcon     = "ⓘ"
+	QuestionIcon = "?"
+
+	MarkedOptionIcon   = "◉"
+	UnmarkedOptionIcon = "◯"
+
+	SelectFocusIcon = "❯"
+)
+
+var TemplateFuncs = map[string]interface{}{
+	// Templates with Color formatting. See Documentation: https://github.com/mgutz/ansi#style-format
+	"color": func(color string) string {
+		if DisableColor {
+			return ""
+		}
+		return ansi.ColorCode(color)
+	},
+	"HelpInputRune": func() string {
+		return string(HelpInputRune)
+	},
+	"ErrorIcon": func() string {
+		return ErrorIcon
+	},
+	"HelpIcon": func() string {
+		return HelpIcon
+	},
+	"QuestionIcon": func() string {
+		return QuestionIcon
+	},
+	"MarkedOptionIcon": func() string {
+		return MarkedOptionIcon
+	},
+	"UnmarkedOptionIcon": func() string {
+		return UnmarkedOptionIcon
+	},
+	"SelectFocusIcon": func() string {
+		return SelectFocusIcon
+	},
+}
+
+var memoizedGetTemplate = map[string]*template.Template{}
+
+func getTemplate(tmpl string) (*template.Template, error) {
+	if t, ok := memoizedGetTemplate[tmpl]; ok {
+		return t, nil
+	}
+
+	t, err := template.New("prompt").Funcs(TemplateFuncs).Parse(tmpl)
+	if err != nil {
+		return nil, err
+	}
+
+	memoizedGetTemplate[tmpl] = t
+	return t, nil
+}
+
+func RunTemplate(tmpl string, data interface{}) (string, error) {
+	t, err := getTemplate(tmpl)
+	if err != nil {
+		return "", err
+	}
+	buf := bytes.NewBufferString("")
+	err = t.Execute(buf, data)
+	if err != nil {
+		return "", err
+	}
+	return buf.String(), err
+}

vendor/github.com/AlecAivazis/survey/core/write.go

@@ -0,0 +1,209 @@
+package core
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+// the tag used to denote the name of the question
+const tagName = "survey"
+
+// add a few interfaces so users can configure how the prompt values are set
+type settable interface {
+	WriteAnswer(field string, value interface{}) error
+}
+
+func WriteAnswer(t interface{}, name string, v interface{}) (err error) {
+	// if the field is a custom type
+	if s, ok := t.(settable); ok {
+		// use the interface method
+		return s.WriteAnswer(name, v)
+	}
+
+	// the target to write to
+	target := reflect.ValueOf(t)
+	// the value to write from
+	value := reflect.ValueOf(v)
+
+	// make sure we are writing to a pointer
+	if target.Kind() != reflect.Ptr {
+		return errors.New("you must pass a pointer as the target of a Write operation")
+	}
+	// the object "inside" of the target pointer
+	elem := target.Elem()
+
+	// handle the special types
+	switch elem.Kind() {
+	// if we are writing to a struct
+	case reflect.Struct:
+		// get the name of the field that matches the string we  were given
+		fieldIndex, err := findFieldIndex(elem, name)
+		// if something went wrong
+		if err != nil {
+			// bubble up
+			return err
+		}
+		field := elem.Field(fieldIndex)
+		// handle references to the settable interface aswell
+		if s, ok := field.Interface().(settable); ok {
+			// use the interface method
+			return s.WriteAnswer(name, v)
+		}
+		if field.CanAddr() {
+			if s, ok := field.Addr().Interface().(settable); ok {
+				// use the interface method
+				return s.WriteAnswer(name, v)
+			}
+		}
+
+		// copy the value over to the normal struct
+		return copy(field, value)
+	case reflect.Map:
+		mapType := reflect.TypeOf(t).Elem()
+		if mapType.Key().Kind() != reflect.String || mapType.Elem().Kind() != reflect.Interface {
+			return errors.New("answer maps must be of type map[string]interface")
+		}
+		mt := *t.(*map[string]interface{})
+		mt[name] = value.Interface()
+		return nil
+	}
+	// otherwise just copy the value to the target
+	return copy(elem, value)
+}
+
+// BUG(AlecAivazis): the current implementation might cause weird conflicts if there are
+// two fields with same name that only differ by casing.
+func findFieldIndex(s reflect.Value, name string) (int, error) {
+	// the type of the value
+	sType := s.Type()
+
+	// first look for matching tags so we can overwrite matching field names
+	for i := 0; i < sType.NumField(); i++ {
+		// the field we are current scanning
+		field := sType.Field(i)
+
+		// the value of the survey tag
+		tag := field.Tag.Get(tagName)
+		// if the tag matches the name we are looking for
+		if tag != "" && tag == name {
+			// then we found our index
+			return i, nil
+		}
+	}
+
+	// then look for matching names
+	for i := 0; i < sType.NumField(); i++ {
+		// the field we are current scanning
+		field := sType.Field(i)
+
+		// if the name of the field matches what we're looking for
+		if strings.ToLower(field.Name) == strings.ToLower(name) {
+			return i, nil
+		}
+	}
+
+	// we didn't find the field
+	return -1, fmt.Errorf("could not find field matching %v", name)
+}
+
+// Write takes a value and copies it to the target
+func copy(t reflect.Value, v reflect.Value) (err error) {
+	// if something ends up panicing we need to catch it in a deferred func
+	defer func() {
+		if r := recover(); r != nil {
+			// if we paniced with an error
+			if _, ok := r.(error); ok {
+				// cast the result to an error object
+				err = r.(error)
+			} else if _, ok := r.(string); ok {
+				// otherwise we could have paniced with a string so wrap it in an error
+				err = errors.New(r.(string))
+			}
+		}
+	}()
+
+	// attempt to copy the underlying value to the target
+	if v.Kind() == reflect.String && v.Type() != t.Type() {
+		var castVal interface{}
+		var casterr error
+		vString := v.Interface().(string)
+
+		switch t.Kind() {
+		case reflect.Bool:
+			castVal, casterr = strconv.ParseBool(vString)
+		case reflect.Int:
+			castVal, casterr = strconv.Atoi(vString)
+		case reflect.Int8:
+			var val64 int64
+			val64, casterr = strconv.ParseInt(vString, 10, 8)
+			if casterr == nil {
+				castVal = int8(val64)
+			}
+		case reflect.Int16:
+			var val64 int64
+			val64, casterr = strconv.ParseInt(vString, 10, 16)
+			if casterr == nil {
+				castVal = int16(val64)
+			}
+		case reflect.Int32:
+			var val64 int64
+			val64, casterr = strconv.ParseInt(vString, 10, 32)
+			if casterr == nil {
+				castVal = int32(val64)
+			}
+		case reflect.Int64:
+			castVal, casterr = strconv.ParseInt(vString, 10, 64)
+		case reflect.Uint:
+			var val64 uint64
+			val64, casterr = strconv.ParseUint(vString, 10, 8)
+			if casterr == nil {
+				castVal = uint(val64)
+			}
+		case reflect.Uint8:
+			var val64 uint64
+			val64, casterr = strconv.ParseUint(vString, 10, 8)
+			if casterr == nil {
+				castVal = uint8(val64)
+			}
+		case reflect.Uint16:
+			var val64 uint64
+			val64, casterr = strconv.ParseUint(vString, 10, 16)
+			if casterr == nil {
+				castVal = uint16(val64)
+			}
+		case reflect.Uint32:
+			var val64 uint64
+			val64, casterr = strconv.ParseUint(vString, 10, 32)
+			if casterr == nil {
+				castVal = uint32(val64)
+			}
+		case reflect.Uint64:
+			castVal, casterr = strconv.ParseUint(vString, 10, 64)
+		case reflect.Float32:
+			var val64 float64
+			val64, casterr = strconv.ParseFloat(vString, 32)
+			if casterr == nil {
+				castVal = float32(val64)
+			}
+		case reflect.Float64:
+			castVal, casterr = strconv.ParseFloat(vString, 64)
+		default:
+			return fmt.Errorf("Unable to convert from string to type %s", t.Kind())
+		}
+
+		if casterr != nil {
+			return casterr
+		}
+
+		t.Set(reflect.ValueOf(castVal))
+		return
+	}
+
+	t.Set(v)
+
+	// we're done
+	return
+}

vendor/github.com/AlecAivazis/survey/core/write_test.go

@@ -0,0 +1,534 @@
+package core
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestWrite_returnsErrorIfTargetNotPtr(t *testing.T) {
+	// try to copy a value to a non-pointer
+	err := WriteAnswer(true, "hello", true)
+	// make sure there was an error
+	if err == nil {
+		t.Error("Did not encounter error when writing to non-pointer.")
+	}
+}
+
+func TestWrite_canWriteToBool(t *testing.T) {
+	// a pointer to hold the boolean value
+	ptr := true
+
+	// try to copy a false value to the pointer
+	WriteAnswer(&ptr, "", false)
+
+	// if the value is true
+	if ptr {
+		// the test failed
+		t.Error("Could not write a false bool to a pointer")
+	}
+}
+
+func TestWrite_canWriteString(t *testing.T) {
+	// a pointer to hold the boolean value
+	ptr := ""
+
+	// try to copy a false value to the pointer
+	err := WriteAnswer(&ptr, "", "hello")
+	if err != nil {
+		t.Error(err)
+	}
+
+	// if the value is not what we wrote
+	if ptr != "hello" {
+		t.Error("Could not write a string value to a pointer")
+	}
+}
+
+func TestWrite_canWriteSlice(t *testing.T) {
+	// a pointer to hold the value
+	ptr := []string{}
+
+	// copy in a value
+	WriteAnswer(&ptr, "", []string{"hello", "world"})
+
+	// make sure there are two entries
+	if len(ptr) != 2 {
+		// the test failed
+		t.Errorf("Incorrect number of entries in written list. Expected 2, found %v.", len(ptr))
+		// dont move on
+		return
+	}
+
+	// make sure the first entry is hello
+	if ptr[0] != "hello" {
+		// the test failed
+		t.Errorf("incorrect first value in written pointer. expected hello found %v.", ptr[0])
+	}
+
+	// make sure the second entry is world
+	if ptr[1] != "world" {
+		// the test failed
+		t.Errorf("incorrect second value in written pointer. expected world found %v.", ptr[0])
+	}
+}
+
+func TestWrite_recoversInvalidReflection(t *testing.T) {
+	// a variable to mutate
+	ptr := false
+
+	// write a boolean value to the string
+	err := WriteAnswer(&ptr, "", "hello")
+
+	// if there was no error
+	if err == nil {
+		// the test failed
+		t.Error("Did not encounter error when forced invalid write.")
+	}
+}
+
+func TestWriteAnswer_handlesNonStructValues(t *testing.T) {
+	// the value to write to
+	ptr := ""
+
+	// write a value to the pointer
+	WriteAnswer(&ptr, "", "world")
+
+	// if we didn't change the value appropriate
+	if ptr != "world" {
+		// the test failed
+		t.Error("Did not write value to primitive pointer")
+	}
+}
+
+func TestWriteAnswer_canMutateStruct(t *testing.T) {
+	// the struct to hold the answer
+	ptr := struct{ Name string }{}
+
+	// write a value to an existing field
+	err := WriteAnswer(&ptr, "name", "world")
+	if err != nil {
+		// the test failed
+		t.Errorf("Encountered error while writing answer: %v", err.Error())
+		// we're done here
+		return
+	}
+
+	// make sure we changed the field
+	if ptr.Name != "world" {
+		// the test failed
+		t.Error("Did not mutate struct field when writing answer.")
+	}
+}
+
+func TestWriteAnswer_canMutateMap(t *testing.T) {
+	// the map to hold the answer
+	ptr := make(map[string]interface{})
+
+	// write a value to an existing field
+	err := WriteAnswer(&ptr, "name", "world")
+	if err != nil {
+		// the test failed
+		t.Errorf("Encountered error while writing answer: %v", err.Error())
+		// we're done here
+		return
+	}
+
+	// make sure we changed the field
+	if ptr["name"] != "world" {
+		// the test failed
+		t.Error("Did not mutate map when writing answer.")
+	}
+}
+
+func TestWrite_returnsErrorIfInvalidMapType(t *testing.T) {
+	// try to copy a value to a non map[string]interface{}
+	ptr := make(map[int]string)
+
+	err := WriteAnswer(&ptr, "name", "world")
+	// make sure there was an error
+	if err == nil {
+		t.Error("Did not encounter error when writing to invalid map.")
+	}
+}
+
+func TestWriteAnswer_returnsErrWhenFieldNotFound(t *testing.T) {
+	// the struct to hold the answer
+	ptr := struct{ Name string }{}
+
+	// write a value to an existing field
+	err := WriteAnswer(&ptr, "", "world")
+
+	if err == nil {
+		// the test failed
+		t.Error("Did not encountered error while writing answer to non-existing field.")
+	}
+}
+
+func TestFindFieldIndex_canFindExportedField(t *testing.T) {
+	// create a reflective wrapper over the struct to look through
+	val := reflect.ValueOf(struct{ Name string }{})
+
+	// find the field matching "name"
+	fieldIndex, err := findFieldIndex(val, "name")
+	// if something went wrong
+	if err != nil {
+		// the test failed
+		t.Error(err.Error())
+		return
+	}
+
+	// make sure we got the right value
+	if val.Type().Field(fieldIndex).Name != "Name" {
+		// the test failed
+		t.Errorf("Did not find the correct field name. Expected 'Name' found %v.", val.Type().Field(fieldIndex).Name)
+	}
+}
+
+func TestFindFieldIndex_canFindTaggedField(t *testing.T) {
+	// the struct to look through
+	val := reflect.ValueOf(struct {
+		Username string `survey:"name"`
+	}{})
+
+	// find the field matching "name"
+	fieldIndex, err := findFieldIndex(val, "name")
+	// if something went wrong
+	if err != nil {
+		// the test failed
+		t.Error(err.Error())
+		return
+	}
+
+	// make sure we got the right value
+	if val.Type().Field(fieldIndex).Name != "Username" {
+		// the test failed
+		t.Errorf("Did not find the correct field name. Expected 'Username' found %v.", val.Type().Field(fieldIndex).Name)
+	}
+}
+
+func TestFindFieldIndex_canHandleCapitalAnswerNames(t *testing.T) {
+	// create a reflective wrapper over the struct to look through
+	val := reflect.ValueOf(struct{ Name string }{})
+
+	// find the field matching "name"
+	fieldIndex, err := findFieldIndex(val, "Name")
+	// if something went wrong
+	if err != nil {
+		// the test failed
+		t.Error(err.Error())
+		return
+	}
+
+	// make sure we got the right value
+	if val.Type().Field(fieldIndex).Name != "Name" {
+		// the test failed
+		t.Errorf("Did not find the correct field name. Expected 'Name' found %v.", val.Type().Field(fieldIndex).Name)
+	}
+}
+
+func TestFindFieldIndex_tagOverwriteFieldName(t *testing.T) {
+	// the struct to look through
+	val := reflect.ValueOf(struct {
+		Name     string
+		Username string `survey:"name"`
+	}{})
+
+	// find the field matching "name"
+	fieldIndex, err := findFieldIndex(val, "name")
+	// if something went wrong
+	if err != nil {
+		// the test failed
+		t.Error(err.Error())
+		return
+	}
+
+	// make sure we got the right value
+	if val.Type().Field(fieldIndex).Name != "Username" {
+		// the test failed
+		t.Errorf("Did not find the correct field name. Expected 'Username' found %v.", val.Type().Field(fieldIndex).Name)
+	}
+}
+
+type testFieldSettable struct {
+	Values map[string]string
+}
+
+type testStringSettable struct {
+	Value string `survey:"string"`
+}
+
+type testTaggedStruct struct {
+	TaggedValue testStringSettable `survey:"tagged"`
+}
+
+type testPtrTaggedStruct struct {
+	TaggedValue *testStringSettable `survey:"tagged"`
+}
+
+func (t *testFieldSettable) WriteAnswer(name string, value interface{}) error {
+	if t.Values == nil {
+		t.Values = map[string]string{}
+	}
+	if v, ok := value.(string); ok {
+		t.Values[name] = v
+		return nil
+	}
+	return fmt.Errorf("Incompatible type %T", value)
+}
+
+func (t *testStringSettable) WriteAnswer(_ string, value interface{}) error {
+	t.Value = value.(string)
+	return nil
+}
+
+func TestWriteWithFieldSettable(t *testing.T) {
+	testSet1 := testFieldSettable{}
+	err := WriteAnswer(&testSet1, "values", "stringVal")
+	assert.Nil(t, err)
+	assert.Equal(t, map[string]string{"values": "stringVal"}, testSet1.Values)
+
+	testSet2 := testFieldSettable{}
+	err = WriteAnswer(&testSet2, "values", 123)
+	assert.Error(t, fmt.Errorf("Incompatible type int64"), err)
+	assert.Equal(t, map[string]string{}, testSet2.Values)
+
+	testString1 := testStringSettable{}
+	err = WriteAnswer(&testString1, "", "value1")
+	assert.Nil(t, err)
+	assert.Equal(t, testStringSettable{"value1"}, testString1)
+
+	testSetStruct := testTaggedStruct{}
+	err = WriteAnswer(&testSetStruct, "tagged", "stringVal1")
+	assert.Nil(t, err)
+	assert.Equal(t, testTaggedStruct{TaggedValue: testStringSettable{"stringVal1"}}, testSetStruct)
+
+	testPtrSetStruct := testPtrTaggedStruct{&testStringSettable{}}
+	err = WriteAnswer(&testPtrSetStruct, "tagged", "stringVal1")
+	assert.Nil(t, err)
+	assert.Equal(t, testPtrTaggedStruct{TaggedValue: &testStringSettable{"stringVal1"}}, testPtrSetStruct)
+}
+
+// CONVERSION TESTS
+func TestWrite_canStringToBool(t *testing.T) {
+	// a pointer to hold the boolean value
+	ptr := true
+
+	// try to copy a false value to the pointer
+	WriteAnswer(&ptr, "", "false")
+
+	// if the value is true
+	if ptr {
+		// the test failed
+		t.Error("Could not convert string to pointer type")
+	}
+}
+
+func TestWrite_canStringToInt(t *testing.T) {
+	// a pointer to hold the value
+	var ptr int = 1
+
+	// try to copy a value to the pointer
+	WriteAnswer(&ptr, "", "2")
+
+	// if the value is true
+	if ptr != 2 {
+		// the test failed
+		t.Error("Could not convert string to pointer type")
+	}
+}
+
+func TestWrite_canStringToInt8(t *testing.T) {
+	// a pointer to hold the value
+	var ptr int8 = 1
+
+	// try to copy a value to the pointer
+	WriteAnswer(&ptr, "", "2")
+
+	// if the value is true
+	if ptr != 2 {
+		// the test failed
+		t.Error("Could not convert string to pointer type")
+	}
+}
+
+func TestWrite_canStringToInt16(t *testing.T) {
+	// a pointer to hold the value
+	var ptr int16 = 1
+
+	// try to copy a value to the pointer
+	WriteAnswer(&ptr, "", "2")
+
+	// if the value is true
+	if ptr != 2 {
+		// the test failed
+		t.Error("Could not convert string to pointer type")
+	}
+}
+
+func TestWrite_canStringToInt32(t *testing.T) {
+	// a pointer to hold the value
+	var ptr int32 = 1
+
+	// try to copy a value to the pointer
+	WriteAnswer(&ptr, "", "2")
+
+	// if the value is true
+	if ptr != 2 {
+		// the test failed
+		t.Error("Could not convert string to pointer type")
+	}
+}
+
+func TestWrite_canStringToInt64(t *testing.T) {
+	// a pointer to hold the value
+	var ptr int64 = 1
+
+	// try to copy a value to the pointer
+	WriteAnswer(&ptr, "", "2")
+
+	// if the value is true
+	if ptr != 2 {
+		// the test failed
+		t.Error("Could not convert string to pointer type")
+	}
+}
+
+func TestWrite_canStringToUint(t *testing.T) {
+	// a pointer to hold the value
+	var ptr uint = 1
+
+	// try to copy a value to the pointer
+	WriteAnswer(&ptr, "", "2")
+
+	// if the value is true
+	if ptr != 2 {
+		// the test failed
+		t.Error("Could not convert string to pointer type")
+	}
+}
+
+func TestWrite_canStringToUint8(t *testing.T) {
+	// a pointer to hold the value
+	var ptr uint8 = 1
+
+	// try to copy a value to the pointer
+	WriteAnswer(&ptr, "", "2")
+
+	// if the value is true
+	if ptr != 2 {
+		// the test failed
+		t.Error("Could not convert string to pointer type")
+	}
+}
+
+func TestWrite_canStringToUint16(t *testing.T) {
+	// a pointer to hold the value
+	var ptr uint16 = 1
+
+	// try to copy a value to the pointer
+	WriteAnswer(&ptr, "", "2")
+
+	// if the value is true
+	if ptr != 2 {
+		// the test failed
+		t.Error("Could not convert string to pointer type")
+	}
+}
+
+func TestWrite_canStringToUint32(t *testing.T) {
+	// a pointer to hold the value
+	var ptr uint32 = 1
+
+	// try to copy a value to the pointer
+	WriteAnswer(&ptr, "", "2")
+
+	// if the value is true
+	if ptr != 2 {
+		// the test failed
+		t.Error("Could not convert string to pointer type")
+	}
+}
+
+func TestWrite_canStringToUint64(t *testing.T) {
+	// a pointer to hold the value
+	var ptr uint64 = 1
+
+	// try to copy a value to the pointer
+	WriteAnswer(&ptr, "", "2")
+
+	// if the value is true
+	if ptr != 2 {
+		// the test failed
+		t.Error("Could not convert string to pointer type")
+	}
+}
+
+func TestWrite_canStringToFloat32(t *testing.T) {
+	// a pointer to hold the value
+	var ptr float32 = 1.0
+
+	// try to copy a value to the pointer
+	WriteAnswer(&ptr, "", "2.5")
+
+	// if the value is true
+	if ptr != 2.5 {
+		// the test failed
+		t.Error("Could not convert string to pointer type")
+	}
+}
+
+func TestWrite_canStringToFloat64(t *testing.T) {
+	// a pointer to hold the value
+	var ptr float64 = 1.0
+
+	// try to copy a value to the pointer
+	WriteAnswer(&ptr, "", "2.5")
+
+	// if the value is true
+	if ptr != 2.5 {
+		// the test failed
+		t.Error("Could not convert string to pointer type")
+	}
+}
+
+func TestWrite_canConvertStructFieldTypes(t *testing.T) {
+	// the struct to hold the answer
+	ptr := struct {
+		Name   string
+		Age    uint
+		Male   bool
+		Height float64
+	}{}
+
+	// write the values as strings
+	check(t, WriteAnswer(&ptr, "name", "Bob"))
+	check(t, WriteAnswer(&ptr, "age", "22"))
+	check(t, WriteAnswer(&ptr, "male", "true"))
+	check(t, WriteAnswer(&ptr, "height", "6.2"))
+
+	// make sure we changed the fields
+	if ptr.Name != "Bob" {
+		t.Error("Did not mutate Name when writing answer.")
+	}
+
+	if ptr.Age != 22 {
+		t.Error("Did not mutate Age when writing answer.")
+	}
+
+	if !ptr.Male {
+		t.Error("Did not mutate Male when writing answer.")
+	}
+
+	if ptr.Height != 6.2 {
+		t.Error("Did not mutate Height when writing answer.")
+	}
+}
+
+func check(t *testing.T, err error) {
+	if err != nil {
+		t.Fatalf("Encountered error while writing answer: %v", err.Error())
+	}
+}

vendor/github.com/AlecAivazis/survey/examples/longlist.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/AlecAivazis/survey"
+)
+
+// the questions to ask
+var simpleQs = []*survey.Question{
+	{
+		Name: "letter",
+		Prompt: &survey.Select{
+			Message: "Choose a letter:",
+			Options: []string{
+				"a",
+				"b",
+				"c",
+				"d",
+				"e",
+				"f",
+				"g",
+				"h",
+				"i",
+				"j",
+			},
+		},
+		Validate: survey.Required,
+	},
+}
+
+func main() {
+	answers := struct {
+		Letter string
+	}{}
+
+	// ask the question
+	err := survey.Ask(simpleQs, &answers)
+
+	if err != nil {
+		fmt.Println(err.Error())
+		return
+	}
+	// print the answers
+	fmt.Printf("you chose %s.\n", answers.Letter)
+}

vendor/github.com/AlecAivazis/survey/examples/map.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/AlecAivazis/survey"
+)
+
+// the questions to ask
+var simpleQs = []*survey.Question{
+	{
+		Name: "name",
+		Prompt: &survey.Input{
+			Message: "What is your name?",
+		},
+		Validate: survey.Required,
+	},
+	{
+		Name: "color",
+		Prompt: &survey.Select{
+			Message: "Choose a color:",
+			Options: []string{"red", "blue", "green"},
+		},
+		Validate: survey.Required,
+	},
+}
+
+func main() {
+	ansmap := make(map[string]string)
+
+	// ask the question
+	err := survey.Ask(simpleQs, &ansmap)
+
+	if err != nil {
+		fmt.Println(err.Error())
+		return
+	}
+	// print the answers
+	fmt.Printf("%s chose %s.\n", ansmap["name"], ansmap["color"])
+}

vendor/github.com/AlecAivazis/survey/examples/simple.go

@@ -0,0 +1,43 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/AlecAivazis/survey"
+)
+
+// the questions to ask
+var simpleQs = []*survey.Question{
+	{
+		Name: "name",
+		Prompt: &survey.Input{
+			Message: "What is your name?",
+		},
+		Validate: survey.Required,
+	},
+	{
+		Name: "color",
+		Prompt: &survey.Select{
+			Message: "Choose a color:",
+			Options: []string{"red", "blue", "green"},
+		},
+		Validate: survey.Required,
+	},
+}
+
+func main() {
+	answers := struct {
+		Name  string
+		Color string
+	}{}
+
+	// ask the question
+	err := survey.Ask(simpleQs, &answers)
+
+	if err != nil {
+		fmt.Println(err.Error())
+		return
+	}
+	// print the answers
+	fmt.Printf("%s chose %s.\n", answers.Name, answers.Color)
+}

vendor/github.com/AlecAivazis/survey/examples/validation.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/AlecAivazis/survey"
+)
+
+// the questions to ask
+var validationQs = []*survey.Question{
+	{
+		Name:     "name",
+		Prompt:   &survey.Input{Message: "What is your name?"},
+		Validate: survey.Required,
+	},
+	{
+		Name:   "valid",
+		Prompt: &survey.Input{Message: "Enter 'foo':", Default: "not foo"},
+		Validate: func(val interface{}) error {
+			// if the input matches the expectation
+			if str := val.(string); str != "foo" {
+				return fmt.Errorf("You entered %s, not 'foo'.", str)
+			}
+			// nothing was wrong
+			return nil
+		},
+	},
+}
+
+func main() {
+	// the place to hold the answers
+	answers := struct {
+		Name  string
+		Valid string
+	}{}
+	err := survey.Ask(validationQs, &answers)
+
+	if err != nil {
+		fmt.Println("\n", err.Error())
+	}
+}

vendor/github.com/AlecAivazis/survey/input.go

@@ -0,0 +1,98 @@
+package survey
+
+import (
+	"os"
+
+	"github.com/AlecAivazis/survey/core"
+	"github.com/AlecAivazis/survey/terminal"
+)
+
+/*
+Input is a regular text input that prints each character the user types on the screen
+and accepts the input with the enter key. Response type is a string.
+
+	name := ""
+	prompt := &survey.Input{ Message: "What is your name?" }
+	survey.AskOne(prompt, &name, nil)
+*/
+type Input struct {
+	core.Renderer
+	Message string
+	Default string
+	Help    string
+}
+
+// data available to the templates when processing
+type InputTemplateData struct {
+	Input
+	Answer     string
+	ShowAnswer bool
+	ShowHelp   bool
+}
+
+// Templates with Color formatting. See Documentation: https://github.com/mgutz/ansi#style-format
+var InputQuestionTemplate = `
+{{- if .ShowHelp }}{{- color "cyan"}}{{ HelpIcon }} {{ .Help }}{{color "reset"}}{{"\n"}}{{end}}
+{{- color "green+hb"}}{{ QuestionIcon }} {{color "reset"}}
+{{- color "default+hb"}}{{ .Message }} {{color "reset"}}
+{{- if .ShowAnswer}}
+  {{- color "cyan"}}{{.Answer}}{{color "reset"}}{{"\n"}}
+{{- else }}
+  {{- if and .Help (not .ShowHelp)}}{{color "cyan"}}[{{ HelpInputRune }} for help]{{color "reset"}} {{end}}
+  {{- if .Default}}{{color "white"}}({{.Default}}) {{color "reset"}}{{end}}
+{{- end}}`
+
+func (i *Input) Prompt() (interface{}, error) {
+	// render the template
+	err := i.Render(
+		InputQuestionTemplate,
+		InputTemplateData{Input: *i},
+	)
+	if err != nil {
+		return "", err
+	}
+
+	// start reading runes from the standard in
+	rr := terminal.NewRuneReader(os.Stdin)
+	rr.SetTermMode()
+	defer rr.RestoreTermMode()
+
+	line := []rune{}
+	// get the next line
+	for {
+		line, err = rr.ReadLine(0)
+		if err != nil {
+			return string(line), err
+		}
+		// terminal will echo the \n so we need to jump back up one row
+		terminal.CursorPreviousLine(1)
+
+		if string(line) == string(core.HelpInputRune) && i.Help != "" {
+			err = i.Render(
+				InputQuestionTemplate,
+				InputTemplateData{Input: *i, ShowHelp: true},
+			)
+			if err != nil {
+				return "", err
+			}
+			continue
+		}
+		break
+	}
+
+	// if the line is empty
+	if line == nil || len(line) == 0 {
+		// use the default value
+		return i.Default, err
+	}
+
+	// we're done
+	return string(line), err
+}
+
+func (i *Input) Cleanup(val interface{}) error {
+	return i.Render(
+		InputQuestionTemplate,
+		InputTemplateData{Input: *i, Answer: val.(string), ShowAnswer: true},
+	)
+}

vendor/github.com/AlecAivazis/survey/input_test.go

@@ -0,0 +1,84 @@
+package survey
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/AlecAivazis/survey/core"
+	"github.com/AlecAivazis/survey/terminal"
+	"github.com/stretchr/testify/assert"
+)
+
+func init() {
+	// disable color output for all prompts to simplify testing
+	core.DisableColor = true
+}
+
+func TestInputRender(t *testing.T) {
+
+	tests := []struct {
+		title    string
+		prompt   Input
+		data     InputTemplateData
+		expected string
+	}{
+		{
+			"Test Input question output without default",
+			Input{Message: "What is your favorite month:"},
+			InputTemplateData{},
+			"? What is your favorite month: ",
+		},
+		{
+			"Test Input question output with default",
+			Input{Message: "What is your favorite month:", Default: "April"},
+			InputTemplateData{},
+			"? What is your favorite month: (April) ",
+		},
+		{
+			"Test Input answer output",
+			Input{Message: "What is your favorite month:"},
+			InputTemplateData{Answer: "October", ShowAnswer: true},
+			"? What is your favorite month: October\n",
+		},
+		{
+			"Test Input question output without default but with help hidden",
+			Input{Message: "What is your favorite month:", Help: "This is helpful"},
+			InputTemplateData{},
+			"? What is your favorite month: [? for help] ",
+		},
+		{
+			"Test Input question output with default and with help hidden",
+			Input{Message: "What is your favorite month:", Default: "April", Help: "This is helpful"},
+			InputTemplateData{},
+			"? What is your favorite month: [? for help] (April) ",
+		},
+		{
+			"Test Input question output without default but with help shown",
+			Input{Message: "What is your favorite month:", Help: "This is helpful"},
+			InputTemplateData{ShowHelp: true},
+			`ⓘ This is helpful
+? What is your favorite month: `,
+		},
+		{
+			"Test Input question output with default and with help shown",
+			Input{Message: "What is your favorite month:", Default: "April", Help: "This is helpful"},
+			InputTemplateData{ShowHelp: true},
+			`ⓘ This is helpful
+? What is your favorite month: (April) `,
+		},
+	}
+
+	outputBuffer := bytes.NewBufferString("")
+	terminal.Stdout = outputBuffer
+
+	for _, test := range tests {
+		outputBuffer.Reset()
+		test.data.Input = test.prompt
+		err := test.prompt.Render(
+			InputQuestionTemplate,
+			test.data,
+		)
+		assert.Nil(t, err, test.title)
+		assert.Equal(t, test.expected, outputBuffer.String(), test.title)
+	}
+}

vendor/github.com/AlecAivazis/survey/multiselect.go

@@ -0,0 +1,204 @@
+package survey
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/AlecAivazis/survey/core"
+	"github.com/AlecAivazis/survey/terminal"
+)
+
+/*
+MultiSelect is a prompt that presents a list of various options to the user
+for them to select using the arrow keys and enter. Response type is a slice of strings.
+
+	days := []string{}
+	prompt := &survey.MultiSelect{
+		Message: "What days do you prefer:",
+		Options: []string{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"},
+	}
+	survey.AskOne(prompt, &days, nil)
+*/
+type MultiSelect struct {
+	core.Renderer
+	Message       string
+	Options       []string
+	Default       []string
+	Help          string
+	PageSize      int
+	selectedIndex int
+	checked       map[string]bool
+	showingHelp   bool
+}
+
+// data available to the templates when processing
+type MultiSelectTemplateData struct {
+	MultiSelect
+	Answer        string
+	ShowAnswer    bool
+	Checked       map[string]bool
+	SelectedIndex int
+	ShowHelp      bool
+	PageEntries   []string
+}
+
+var MultiSelectQuestionTemplate = `
+{{- if .ShowHelp }}{{- color "cyan"}}{{ HelpIcon }} {{ .Help }}{{color "reset"}}{{"\n"}}{{end}}
+{{- color "green+hb"}}{{ QuestionIcon }} {{color "reset"}}
+{{- color "default+hb"}}{{ .Message }}{{color "reset"}}
+{{- if .ShowAnswer}}{{color "cyan"}} {{.Answer}}{{color "reset"}}{{"\n"}}
+{{- else }}
+  {{- if and .Help (not .ShowHelp)}} {{color "cyan"}}[{{ HelpInputRune }} for help]{{color "reset"}}{{end}}
+  {{- "\n"}}
+  {{- range $ix, $option := .PageEntries}}
+    {{- if eq $ix $.SelectedIndex}}{{color "cyan"}}{{ SelectFocusIcon }}{{color "reset"}}{{else}} {{end}}
+    {{- if index $.Checked $option}}{{color "green"}} {{ MarkedOptionIcon }} {{else}}{{color "default+hb"}} {{ UnmarkedOptionIcon }} {{end}}
+    {{- color "reset"}}
+    {{- " "}}{{$option}}{{"\n"}}
+  {{- end}}
+{{- end}}`
+
+// OnChange is called on every keypress.
+func (m *MultiSelect) OnChange(line []rune, pos int, key rune) (newLine []rune, newPos int, ok bool) {
+	if key == terminal.KeyArrowUp {
+		// if we are at the top of the list
+		if m.selectedIndex == 0 {
+			// go to the bottom
+			m.selectedIndex = len(m.Options) - 1
+		} else {
+			// decrement the selected index
+			m.selectedIndex--
+		}
+	} else if key == terminal.KeyArrowDown {
+		// if we are at the bottom of the list
+		if m.selectedIndex == len(m.Options)-1 {
+			// start at the top
+			m.selectedIndex = 0
+		} else {
+			// increment the selected index
+			m.selectedIndex++
+		}
+		// if the user pressed down and there is room to move
+	} else if key == terminal.KeySpace {
+		if old, ok := m.checked[m.Options[m.selectedIndex]]; !ok {
+			// otherwise just invert the current value
+			m.checked[m.Options[m.selectedIndex]] = true
+		} else {
+			// otherwise just invert the current value
+			m.checked[m.Options[m.selectedIndex]] = !old
+		}
+		// only show the help message if we have one to show
+	} else if key == core.HelpInputRune && m.Help != "" {
+		m.showingHelp = true
+	}
+
+	// paginate the options
+	opts, idx := paginate(m.PageSize, m.Options, m.selectedIndex)
+
+	// render the options
+	m.Render(
+		MultiSelectQuestionTemplate,
+		MultiSelectTemplateData{
+			MultiSelect:   *m,
+			SelectedIndex: idx,
+			Checked:       m.checked,
+			ShowHelp:      m.showingHelp,
+			PageEntries:   opts,
+		},
+	)
+
+	// if we are not pressing ent
+	return line, 0, true
+}
+
+func (m *MultiSelect) Prompt() (interface{}, error) {
+	// compute the default state
+	m.checked = make(map[string]bool)
+	// if there is a default
+	if len(m.Default) > 0 {
+		for _, dflt := range m.Default {
+			for _, opt := range m.Options {
+				// if the option correponds to the default
+				if opt == dflt {
+					// we found our initial value
+					m.checked[opt] = true
+					// stop looking
+					break
+				}
+			}
+		}
+	}
+
+	// if there are no options to render
+	if len(m.Options) == 0 {
+		// we failed
+		return "", errors.New("please provide options to select from")
+	}
+
+	// hide the cursor
+	terminal.CursorHide()
+	// show the cursor when we're done
+	defer terminal.CursorShow()
+
+	// paginate the options
+	opts, idx := paginate(m.PageSize, m.Options, m.selectedIndex)
+
+	// ask the question
+	err := m.Render(
+		MultiSelectQuestionTemplate,
+		MultiSelectTemplateData{
+			MultiSelect:   *m,
+			SelectedIndex: idx,
+			Checked:       m.checked,
+			PageEntries:   opts,
+		},
+	)
+	if err != nil {
+		return "", err
+	}
+
+	rr := terminal.NewRuneReader(os.Stdin)
+	rr.SetTermMode()
+	defer rr.RestoreTermMode()
+
+	// start waiting for input
+	for {
+		r, _, _ := rr.ReadRune()
+		if r == '\r' || r == '\n' {
+			break
+		}
+		if r == terminal.KeyInterrupt {
+			return "", fmt.Errorf("interrupt")
+		}
+		if r == terminal.KeyEndTransmission {
+			break
+		}
+		m.OnChange(nil, 0, r)
+	}
+
+	answers := []string{}
+	for _, option := range m.Options {
+		if val, ok := m.checked[option]; ok && val {
+			answers = append(answers, option)
+		}
+	}
+
+	return answers, nil
+}
+
+// Cleanup removes the options section, and renders the ask like a normal question.
+func (m *MultiSelect) Cleanup(val interface{}) error {
+	// execute the output summary template with the answer
+	return m.Render(
+		MultiSelectQuestionTemplate,
+		MultiSelectTemplateData{
+			MultiSelect:   *m,
+			SelectedIndex: m.selectedIndex,
+			Checked:       m.checked,
+			Answer:        strings.Join(val.([]string), ", "),
+			ShowAnswer:    true,
+		},
+	)
+}

vendor/github.com/AlecAivazis/survey/multiselect_test.go

@@ -0,0 +1,105 @@
+package survey
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/AlecAivazis/survey/core"
+	"github.com/AlecAivazis/survey/terminal"
+	"github.com/stretchr/testify/assert"
+)
+
+func init() {
+	// disable color output for all prompts to simplify testing
+	core.DisableColor = true
+}
+
+func TestMultiSelectRender(t *testing.T) {
+
+	prompt := MultiSelect{
+		Message: "Pick your words:",
+		Options: []string{"foo", "bar", "baz", "buz"},
+		Default: []string{"bar", "buz"},
+	}
+
+	helpfulPrompt := prompt
+	helpfulPrompt.Help = "This is helpful"
+
+	tests := []struct {
+		title    string
+		prompt   MultiSelect
+		data     MultiSelectTemplateData
+		expected string
+	}{
+		{
+			"Test MultiSelect question output",
+			prompt,
+			MultiSelectTemplateData{
+				SelectedIndex: 2,
+				PageEntries:   prompt.Options,
+				Checked:       map[string]bool{"bar": true, "buz": true},
+			},
+			`? Pick your words:
+  ◯  foo
+  ◉  bar
+❯ ◯  baz
+  ◉  buz
+`,
+		},
+		{
+			"Test MultiSelect answer output",
+			prompt,
+			MultiSelectTemplateData{
+				Answer:     "foo, buz",
+				ShowAnswer: true,
+			},
+			"? Pick your words: foo, buz\n",
+		},
+		{
+			"Test MultiSelect question output with help hidden",
+			helpfulPrompt,
+			MultiSelectTemplateData{
+				SelectedIndex: 2,
+				PageEntries:   prompt.Options,
+				Checked:       map[string]bool{"bar": true, "buz": true},
+			},
+			`? Pick your words: [? for help]
+  ◯  foo
+  ◉  bar
+❯ ◯  baz
+  ◉  buz
+`,
+		},
+		{
+			"Test MultiSelect question output with help shown",
+			helpfulPrompt,
+			MultiSelectTemplateData{
+				SelectedIndex: 2,
+				PageEntries:   prompt.Options,
+				Checked:       map[string]bool{"bar": true, "buz": true},
+				ShowHelp:      true,
+			},
+			`ⓘ This is helpful
+? Pick your words:
+  ◯  foo
+  ◉  bar
+❯ ◯  baz
+  ◉  buz
+`,
+		},
+	}
+
+	outputBuffer := bytes.NewBufferString("")
+	terminal.Stdout = outputBuffer
+
+	for _, test := range tests {
+		outputBuffer.Reset()
+		test.data.MultiSelect = test.prompt
+		err := test.prompt.Render(
+			MultiSelectQuestionTemplate,
+			test.data,
+		)
+		assert.Nil(t, err, test.title)
+		assert.Equal(t, test.expected, outputBuffer.String(), test.title)
+	}
+}

vendor/github.com/AlecAivazis/survey/password.go

@@ -0,0 +1,84 @@
+package survey
+
+import (
+	"os"
+
+	"github.com/AlecAivazis/survey/core"
+	"github.com/AlecAivazis/survey/terminal"
+)
+
+/*
+Password is like a normal Input but the text shows up as *'s and there is no default. Response
+type is a string.
+
+	password := ""
+	prompt := &survey.Password{ Message: "Please type your password" }
+	survey.AskOne(prompt, &password, nil)
+*/
+type Password struct {
+	core.Renderer
+	Message string
+	Help    string
+}
+
+type PasswordTemplateData struct {
+	Password
+	ShowHelp bool
+}
+
+// Templates with Color formatting. See Documentation: https://github.com/mgutz/ansi#style-format
+var PasswordQuestionTemplate = `
+{{- if .ShowHelp }}{{- color "cyan"}}{{ HelpIcon }} {{ .Help }}{{color "reset"}}{{"\n"}}{{end}}
+{{- color "green+hb"}}{{ QuestionIcon }} {{color "reset"}}
+{{- color "default+hb"}}{{ .Message }} {{color "reset"}}
+{{- if and .Help (not .ShowHelp)}}{{color "cyan"}}[{{ HelpInputRune }} for help]{{color "reset"}} {{end}}`
+
+func (p *Password) Prompt() (line interface{}, err error) {
+	// render the question template
+	out, err := core.RunTemplate(
+		PasswordQuestionTemplate,
+		PasswordTemplateData{Password: *p},
+	)
+	terminal.Print(out)
+	if err != nil {
+		return "", err
+	}
+
+	rr := terminal.NewRuneReader(os.Stdin)
+	rr.SetTermMode()
+	defer rr.RestoreTermMode()
+
+	// no help msg?  Just return any response
+	if p.Help == "" {
+		line, err := rr.ReadLine('*')
+		return string(line), err
+	}
+
+	// process answers looking for help prompt answer
+	for {
+		line, err := rr.ReadLine('*')
+		if err != nil {
+			return string(line), err
+		}
+
+		if string(line) == string(core.HelpInputRune) {
+			// terminal will echo the \n so we need to jump back up one row
+			terminal.CursorPreviousLine(1)
+
+			err = p.Render(
+				PasswordQuestionTemplate,
+				PasswordTemplateData{Password: *p, ShowHelp: true},
+			)
+			if err != nil {
+				return "", err
+			}
+			continue
+		}
+		return string(line), err
+	}
+}
+
+// Cleanup hides the string with a fixed number of characters.
+func (prompt *Password) Cleanup(val interface{}) error {
+	return nil
+}

vendor/github.com/AlecAivazis/survey/password_test.go

@@ -0,0 +1,53 @@
+package survey
+
+import (
+	"testing"
+
+	"github.com/AlecAivazis/survey/core"
+	"github.com/stretchr/testify/assert"
+)
+
+func init() {
+	// disable color output for all prompts to simplify testing
+	core.DisableColor = true
+}
+
+func TestPasswordRender(t *testing.T) {
+
+	tests := []struct {
+		title    string
+		prompt   Password
+		data     PasswordTemplateData
+		expected string
+	}{
+		{
+			"Test Password question output",
+			Password{Message: "Tell me your secret:"},
+			PasswordTemplateData{},
+			"? Tell me your secret: ",
+		},
+		{
+			"Test Password question output with help hidden",
+			Password{Message: "Tell me your secret:", Help: "This is helpful"},
+			PasswordTemplateData{},
+			"? Tell me your secret: [? for help] ",
+		},
+		{
+			"Test Password question output with help shown",
+			Password{Message: "Tell me your secret:", Help: "This is helpful"},
+			PasswordTemplateData{ShowHelp: true},
+			`ⓘ This is helpful
+? Tell me your secret: `,
+		},
+	}
+
+	for _, test := range tests {
+		test.data.Password = test.prompt
+		actual, err := core.RunTemplate(
+			PasswordQuestionTemplate,
+			&test.data,
+		)
+		assert.Nil(t, err, test.title)
+		assert.Equal(t, test.expected, actual, test.title)
+	}
+}

vendor/github.com/AlecAivazis/survey/select.go

@@ -0,0 +1,210 @@
+package survey
+
+import (
+	"errors"
+	"fmt"
+	"os"
+
+	"github.com/AlecAivazis/survey/core"
+	"github.com/AlecAivazis/survey/terminal"
+)
+
+/*
+Select is a prompt that presents a list of various options to the user
+for them to select using the arrow keys and enter. Response type is a string.
+
+	color := ""
+	prompt := &survey.Select{
+		Message: "Choose a color:",
+		Options: []string{"red", "blue", "green"},
+	}
+	survey.AskOne(prompt, &color, nil)
+*/
+type Select struct {
+	core.Renderer
+	Message       string
+	Options       []string
+	Default       string
+	Help          string
+	PageSize      int
+	selectedIndex int
+	useDefault    bool
+	showingHelp   bool
+}
+
+// the data available to the templates when processing
+type SelectTemplateData struct {
+	Select
+	PageEntries   []string
+	SelectedIndex int
+	Answer        string
+	ShowAnswer    bool
+	ShowHelp      bool
+}
+
+var SelectQuestionTemplate = `
+{{- if .ShowHelp }}{{- color "cyan"}}{{ HelpIcon }} {{ .Help }}{{color "reset"}}{{"\n"}}{{end}}
+{{- color "green+hb"}}{{ QuestionIcon }} {{color "reset"}}
+{{- color "default+hb"}}{{ .Message }}{{color "reset"}}
+{{- if .ShowAnswer}}{{color "cyan"}} {{.Answer}}{{color "reset"}}{{"\n"}}
+{{- else}}
+  {{- if and .Help (not .ShowHelp)}} {{color "cyan"}}[{{ HelpInputRune }} for help]{{color "reset"}}{{end}}
+  {{- "\n"}}
+  {{- range $ix, $choice := .PageEntries}}
+    {{- if eq $ix $.SelectedIndex}}{{color "cyan+b"}}{{ SelectFocusIcon }} {{else}}{{color "default+hb"}}  {{end}}
+    {{- $choice}}
+    {{- color "reset"}}{{"\n"}}
+  {{- end}}
+{{- end}}`
+
+// OnChange is called on every keypress.
+func (s *Select) OnChange(line []rune, pos int, key rune) (newLine []rune, newPos int, ok bool) {
+	// if the user pressed the enter key
+	if key == terminal.KeyEnter {
+		return []rune(s.Options[s.selectedIndex]), 0, true
+		// if the user pressed the up arrow
+	} else if key == terminal.KeyArrowUp {
+		s.useDefault = false
+
+		// if we are at the top of the list
+		if s.selectedIndex == 0 {
+			// start from the button
+			s.selectedIndex = len(s.Options) - 1
+		} else {
+			// otherwise we are not at the top of the list so decrement the selected index
+			s.selectedIndex--
+		}
+		// if the user pressed down and there is room to move
+	} else if key == terminal.KeyArrowDown {
+		s.useDefault = false
+		// if we are at the bottom of the list
+		if s.selectedIndex == len(s.Options)-1 {
+			// start from the top
+			s.selectedIndex = 0
+		} else {
+			// increment the selected index
+			s.selectedIndex++
+		}
+		// only show the help message if we have one
+	} else if key == core.HelpInputRune && s.Help != "" {
+		s.showingHelp = true
+	}
+
+	// figure out the options and index to render
+	opts, idx := paginate(s.PageSize, s.Options, s.selectedIndex)
+
+	// render the options
+	s.Render(
+		SelectQuestionTemplate,
+		SelectTemplateData{
+			Select:        *s,
+			SelectedIndex: idx,
+			ShowHelp:      s.showingHelp,
+			PageEntries:   opts,
+		},
+	)
+
+	// if we are not pressing ent
+	return []rune(s.Options[s.selectedIndex]), 0, true
+}
+
+func (s *Select) Prompt() (interface{}, error) {
+	// if there are no options to render
+	if len(s.Options) == 0 {
+		// we failed
+		return "", errors.New("please provide options to select from")
+	}
+
+	// start off with the first option selected
+	sel := 0
+	// if there is a default
+	if s.Default != "" {
+		// find the choice
+		for i, opt := range s.Options {
+			// if the option correponds to the default
+			if opt == s.Default {
+				// we found our initial value
+				sel = i
+				// stop looking
+				break
+			}
+		}
+	}
+	// save the selected index
+	s.selectedIndex = sel
+
+	// figure out the options and index to render
+	opts, idx := paginate(s.PageSize, s.Options, sel)
+
+	// ask the question
+	err := s.Render(
+		SelectQuestionTemplate,
+		SelectTemplateData{
+			Select:        *s,
+			PageEntries:   opts,
+			SelectedIndex: idx,
+		},
+	)
+	if err != nil {
+		return "", err
+	}
+
+	// hide the cursor
+	terminal.CursorHide()
+	// show the cursor when we're done
+	defer terminal.CursorShow()
+
+	// by default, use the default value
+	s.useDefault = true
+
+	rr := terminal.NewRuneReader(os.Stdin)
+	rr.SetTermMode()
+	defer rr.RestoreTermMode()
+	// start waiting for input
+	for {
+		r, _, err := rr.ReadRune()
+		if err != nil {
+			return "", err
+		}
+		if r == '\r' || r == '\n' {
+			break
+		}
+		if r == terminal.KeyInterrupt {
+			return "", fmt.Errorf("interrupt")
+		}
+		if r == terminal.KeyEndTransmission {
+			break
+		}
+		s.OnChange(nil, 0, r)
+	}
+
+	var val string
+	// if we are supposed to use the default value
+	if s.useDefault {
+		// if there is a default value
+		if s.Default != "" {
+			// use the default value
+			val = s.Default
+		} else {
+			// there is no default value so use the first
+			val = s.Options[0]
+		}
+		// otherwise the selected index points to the value
+	} else {
+		// the
+		val = s.Options[s.selectedIndex]
+	}
+
+	return val, err
+}
+
+func (s *Select) Cleanup(val interface{}) error {
+	return s.Render(
+		SelectQuestionTemplate,
+		SelectTemplateData{
+			Select:     *s,
+			Answer:     val.(string),
+			ShowAnswer: true,
+		},
+	)
+}

vendor/github.com/AlecAivazis/survey/select_test.go

@@ -0,0 +1,89 @@
+package survey
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/AlecAivazis/survey/core"
+	"github.com/AlecAivazis/survey/terminal"
+	"github.com/stretchr/testify/assert"
+)
+
+func init() {
+	// disable color output for all prompts to simplify testing
+	core.DisableColor = true
+}
+
+func TestSelectRender(t *testing.T) {
+
+	prompt := Select{
+		Message: "Pick your word:",
+		Options: []string{"foo", "bar", "baz", "buz"},
+		Default: "baz",
+	}
+
+	helpfulPrompt := prompt
+	helpfulPrompt.Help = "This is helpful"
+
+	tests := []struct {
+		title    string
+		prompt   Select
+		data     SelectTemplateData
+		expected string
+	}{
+		{
+			"Test Select question output",
+			prompt,
+			SelectTemplateData{SelectedIndex: 2, PageEntries: prompt.Options},
+			`? Pick your word:
+  foo
+  bar
+❯ baz
+  buz
+`,
+		},
+		{
+			"Test Select answer output",
+			prompt,
+			SelectTemplateData{Answer: "buz", ShowAnswer: true, PageEntries: prompt.Options},
+			"? Pick your word: buz\n",
+		},
+		{
+			"Test Select question output with help hidden",
+			helpfulPrompt,
+			SelectTemplateData{SelectedIndex: 2, PageEntries: prompt.Options},
+			`? Pick your word: [? for help]
+  foo
+  bar
+❯ baz
+  buz
+`,
+		},
+		{
+			"Test Select question output with help shown",
+			helpfulPrompt,
+			SelectTemplateData{SelectedIndex: 2, ShowHelp: true, PageEntries: prompt.Options},
+			`ⓘ This is helpful
+? Pick your word:
+  foo
+  bar
+❯ baz
+  buz
+`,
+		},
+	}
+
+	outputBuffer := bytes.NewBufferString("")
+	terminal.Stdout = outputBuffer
+
+	for _, test := range tests {
+		outputBuffer.Reset()
+		test.data.Select = test.prompt
+		err := test.prompt.Render(
+			SelectQuestionTemplate,
+			test.data,
+		)
+		assert.Nil(t, err, test.title)
+		assert.Equal(t, test.expected, outputBuffer.String(), test.title)
+	}
+}

vendor/github.com/AlecAivazis/survey/survey.go

@@ -0,0 +1,180 @@
+package survey
+
+import (
+	"errors"
+
+	"github.com/AlecAivazis/survey/core"
+)
+
+// PageSize is the default maximum number of items to show in select/multiselect prompts
+var PageSize = 7
+
+// Validator is a function passed to a Question after a user has provided a response.
+// If the function returns an error, then the user will be prompted again for another
+// response.
+type Validator func(interface{}) error
+
+// Question is the core data structure for a survey questionnaire.
+type Question struct {
+	Name     string
+	Prompt   Prompt
+	Validate Validator
+}
+
+// Prompt is the primary interface for the objects that can take user input
+// and return a response.
+type Prompt interface {
+	Prompt() (interface{}, error)
+	Cleanup(interface{}) error
+	Error(error) error
+}
+
+/*
+AskOne performs the prompt for a single prompt and asks for validation if required.
+Response types should be something that can be casted from the response type designated
+in the documentation. For example:
+
+	name := ""
+	prompt := &survey.Input{
+		Message: "name",
+	}
+
+	survey.AskOne(prompt, &name, nil)
+
+*/
+func AskOne(p Prompt, response interface{}, v Validator) error {
+	err := Ask([]*Question{{Prompt: p, Validate: v}}, response)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+/*
+Ask performs the prompt loop, asking for validation when appropriate. The response
+type can be one of two options. If a struct is passed, the answer will be written to
+the field whose name matches the Name field on the corresponding question. Field types
+should be something that can be casted from the response type designated in the
+documentation. Note, a survey tag can also be used to identify a Otherwise, a
+map[string]interface{} can be passed, responses will be written to the key with the
+matching name. For example:
+
+	qs := []*survey.Question{
+		{
+			Name:     "name",
+			Prompt:   &survey.Input{Message: "What is your name?"},
+			Validate: survey.Required,
+		},
+	}
+
+	answers := struct{ Name string }{}
+
+
+	err := survey.Ask(qs, &answers)
+*/
+func Ask(qs []*Question, response interface{}) error {
+
+	// if we weren't passed a place to record the answers
+	if response == nil {
+		// we can't go any further
+		return errors.New("cannot call Ask() with a nil reference to record the answers")
+	}
+
+	// go over every question
+	for _, q := range qs {
+		// grab the user input and save it
+		ans, err := q.Prompt.Prompt()
+		// if there was a problem
+		if err != nil {
+			return err
+		}
+
+		// if there is a validate handler for this question
+		if q.Validate != nil {
+			// wait for a valid response
+			for invalid := q.Validate(ans); invalid != nil; invalid = q.Validate(ans) {
+				err := q.Prompt.Error(invalid)
+				// if there was a problem
+				if err != nil {
+					return err
+				}
+
+				// ask for more input
+				ans, err = q.Prompt.Prompt()
+				// if there was a problem
+				if err != nil {
+					return err
+				}
+			}
+		}
+
+		// tell the prompt to cleanup with the validated value
+		q.Prompt.Cleanup(ans)
+
+		// if something went wrong
+		if err != nil {
+			// stop listening
+			return err
+		}
+
+		// add it to the map
+		err = core.WriteAnswer(response, q.Name, ans)
+		// if something went wrong
+		if err != nil {
+			return err
+		}
+
+	}
+	// return the response
+	return nil
+}
+
+// paginate returns a single page of choices given the page size, the total list of
+// possible choices, and the current selected index in the total list.
+func paginate(page int, choices []string, sel int) ([]string, int) {
+	// the number of elements to show in a single page
+	var pageSize int
+	// if the select has a specific page size
+	if page != 0 {
+		// use the specified one
+		pageSize = page
+		// otherwise the select does not have a page size
+	} else {
+		// use the package default
+		pageSize = PageSize
+	}
+
+	var start, end, cursor int
+
+	if len(choices) < pageSize {
+		// if we dont have enough options to fill a page
+		start = 0
+		end = len(choices)
+		cursor = sel
+
+	} else if sel < pageSize/2 {
+		// if we are in the first half page
+		start = 0
+		end = pageSize
+		cursor = sel
+
+	} else if len(choices)-sel-1 < pageSize/2 {
+		// if we are in the last half page
+		start = len(choices) - pageSize
+		end = len(choices)
+		cursor = sel - start
+
+	} else {
+		// somewhere in the middle
+		above := pageSize / 2
+		below := pageSize - above
+
+		cursor = pageSize / 2
+		start = sel - above
+		end = sel + below
+	}
+
+	// return the subset we care about and the index
+	return choices[start:end], cursor
+}

vendor/github.com/AlecAivazis/survey/survey_test.go

@@ -0,0 +1,118 @@
+package survey
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/AlecAivazis/survey/core"
+	"github.com/stretchr/testify/assert"
+)
+
+func init() {
+	// disable color output for all prompts to simplify testing
+	core.DisableColor = true
+}
+
+func TestValidationError(t *testing.T) {
+
+	err := fmt.Errorf("Football is not a valid month")
+
+	actual, err := core.RunTemplate(
+		core.ErrorTemplate,
+		err,
+	)
+	if err != nil {
+		t.Errorf("Failed to run template to format error: %s", err)
+	}
+
+	expected := `✘ Sorry, your reply was invalid: Football is not a valid month
+`
+
+	if actual != expected {
+		t.Errorf("Formatted error was not formatted correctly. Found:\n%s\nExpected:\n%s", actual, expected)
+	}
+}
+
+func TestAsk_returnsErrorIfTargetIsNil(t *testing.T) {
+	// pass an empty place to leave the answers
+	err := Ask([]*Question{}, nil)
+
+	// if we didn't get an error
+	if err == nil {
+		// the test failed
+		t.Error("Did not encounter error when asking with no where to record.")
+	}
+}
+
+func TestPagination_tooFew(t *testing.T) {
+	// a small list of options
+	choices := []string{"choice1", "choice2", "choice3"}
+
+	// a page bigger than the total number
+	pageSize := 4
+	// the current selection
+	sel := 3
+
+	// compute the page info
+	page, idx := paginate(pageSize, choices, sel)
+
+	// make sure we see the full list of options
+	assert.Equal(t, choices, page)
+	// with the second index highlighted (no change)
+	assert.Equal(t, 3, idx)
+}
+
+func TestPagination_firstHalf(t *testing.T) {
+	// the choices for the test
+	choices := []string{"choice1", "choice2", "choice3", "choice4", "choice5", "choice6"}
+
+	// section the choices into groups of 4 so the choice is somewhere in the middle
+	// to verify there is no displacement of the page
+	pageSize := 4
+	// test the second item
+	sel := 2
+
+	// compute the page info
+	page, idx := paginate(pageSize, choices, sel)
+
+	// we should see the first three options
+	assert.Equal(t, choices[0:4], page)
+	// with the second index highlighted
+	assert.Equal(t, 2, idx)
+}
+
+func TestPagination_middle(t *testing.T) {
+	// the choices for the test
+	choices := []string{"choice0", "choice1", "choice2", "choice3", "choice4", "choice5"}
+
+	// section the choices into groups of 3
+	pageSize := 2
+	// test the second item so that we can verify we are in the middle of the list
+	sel := 3
+
+	// compute the page info
+	page, idx := paginate(pageSize, choices, sel)
+
+	// we should see the first three options
+	assert.Equal(t, choices[2:4], page)
+	// with the second index highlighted
+	assert.Equal(t, 1, idx)
+}
+
+func TestPagination_lastHalf(t *testing.T) {
+	// the choices for the test
+	choices := []string{"choice0", "choice1", "choice2", "choice3", "choice4", "choice5"}
+
+	// section the choices into groups of 3
+	pageSize := 3
+	// test the last item to verify we're not in the middle
+	sel := 5
+
+	// compute the page info
+	page, idx := paginate(pageSize, choices, sel)
+
+	// we should see the first three options
+	assert.Equal(t, choices[3:6], page)
+	// we should be at the bottom of the list
+	assert.Equal(t, 2, idx)
+}

vendor/github.com/AlecAivazis/survey/terminal/cursor.go

@@ -0,0 +1,134 @@
+// +build !windows
+
+package terminal
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// CursorUp moves the cursor n cells to up.
+func CursorUp(n int) {
+	fmt.Printf("\x1b[%dA", n)
+}
+
+// CursorDown moves the cursor n cells to down.
+func CursorDown(n int) {
+	fmt.Printf("\x1b[%dB", n)
+}
+
+// CursorForward moves the cursor n cells to right.
+func CursorForward(n int) {
+	fmt.Printf("\x1b[%dC", n)
+}
+
+// CursorBack moves the cursor n cells to left.
+func CursorBack(n int) {
+	fmt.Printf("\x1b[%dD", n)
+}
+
+// CursorNextLine moves cursor to beginning of the line n lines down.
+func CursorNextLine(n int) {
+	fmt.Printf("\x1b[%dE", n)
+}
+
+// CursorPreviousLine moves cursor to beginning of the line n lines up.
+func CursorPreviousLine(n int) {
+	fmt.Printf("\x1b[%dF", n)
+}
+
+// CursorHorizontalAbsolute moves cursor horizontally to x.
+func CursorHorizontalAbsolute(x int) {
+	fmt.Printf("\x1b[%dG", x)
+}
+
+// CursorShow shows the cursor.
+func CursorShow() {
+	fmt.Print("\x1b[?25h")
+}
+
+// CursorHide hide the cursor.
+func CursorHide() {
+	fmt.Print("\x1b[?25l")
+}
+
+// CursorMove moves the cursor to a specific x,y location.
+func CursorMove(x int, y int) {
+	fmt.Printf("\x1b[%d;%df", x, y)
+}
+
+// CursorLocation returns the current location of the cursor in the terminal
+func CursorLocation() (*Coord, error) {
+	// print the escape sequence to recieve the position in our stdin
+	fmt.Print("\x1b[6n")
+
+	// read from stdin to get the response
+	reader := bufio.NewReader(os.Stdin)
+	// spec says we read 'til R, so do that
+	text, err := reader.ReadSlice('R')
+	if err != nil {
+		return nil, err
+	}
+
+	// spec also says they're split by ;, so do that too
+	if strings.Contains(string(text), ";") {
+		// a regex to parse the output of the ansi code
+		re := regexp.MustCompile(`\d+;\d+`)
+		line := re.FindString(string(text))
+
+		// find the column and rows embedded in the string
+		coords := strings.Split(line, ";")
+
+		// try to cast the col number to an int
+		col, err := strconv.Atoi(coords[1])
+		if err != nil {
+			return nil, err
+		}
+
+		// try to cast the row number to an int
+		row, err := strconv.Atoi(coords[0])
+		if err != nil {
+			return nil, err
+		}
+
+		// return the coordinate object with the col and row we calculated
+		return &Coord{Short(col), Short(row)}, nil
+	}
+
+	// it didn't work so return an error
+	return nil, fmt.Errorf("could not compute the cursor position using ascii escape sequences")
+}
+
+// Size returns the height and width of the terminal.
+func Size() (*Coord, error) {
+	// the general approach here is to move the cursor to the very bottom
+	// of the terminal, ask for the current location and then move the
+	// cursor back where we started
+
+	// save the current location of the cursor
+	origin, err := CursorLocation()
+	if err != nil {
+		return nil, err
+	}
+
+	// move the cursor to the very bottom of the terminal
+	CursorMove(999, 999)
+
+	// ask for the current location
+	bottom, err := CursorLocation()
+	if err != nil {
+		return nil, err
+	}
+
+	// move back where we began
+	CursorUp(int(bottom.Y - origin.Y))
+	CursorHorizontalAbsolute(int(origin.X))
+
+	// sice the bottom was calcuated in the lower right corner, it
+	// is the dimensions we are looking for
+	return bottom, nil
+}

vendor/github.com/AlecAivazis/survey/terminal/cursor_windows.go

@@ -0,0 +1,101 @@
+package terminal
+
+import (
+	"os"
+	"syscall"
+	"unsafe"
+)
+
+func CursorUp(n int) {
+	cursorMove(0, n)
+}
+
+func CursorDown(n int) {
+	cursorMove(0, -1*n)
+}
+
+func CursorForward(n int) {
+	cursorMove(n, 0)
+}
+
+func CursorBack(n int) {
+	cursorMove(-1*n, 0)
+}
+
+func cursorMove(x int, y int) {
+	handle := syscall.Handle(os.Stdout.Fd())
+
+	var csbi consoleScreenBufferInfo
+	procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+
+	var cursor Coord
+	cursor.X = csbi.cursorPosition.X + Short(x)
+	cursor.Y = csbi.cursorPosition.Y + Short(y)
+
+	procSetConsoleCursorPosition.Call(uintptr(handle), uintptr(*(*int32)(unsafe.Pointer(&cursor))))
+}
+
+func CursorNextLine(n int) {
+	CursorUp(n)
+	CursorHorizontalAbsolute(0)
+}
+
+func CursorPreviousLine(n int) {
+	CursorDown(n)
+	CursorHorizontalAbsolute(0)
+}
+
+func CursorHorizontalAbsolute(x int) {
+	handle := syscall.Handle(os.Stdout.Fd())
+
+	var csbi consoleScreenBufferInfo
+	procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+
+	var cursor Coord
+	cursor.X = Short(x)
+	cursor.Y = csbi.cursorPosition.Y
+
+	if csbi.size.X < cursor.X {
+		cursor.X = csbi.size.X
+	}
+
+	procSetConsoleCursorPosition.Call(uintptr(handle), uintptr(*(*int32)(unsafe.Pointer(&cursor))))
+}
+
+func CursorShow() {
+	handle := syscall.Handle(os.Stdout.Fd())
+
+	var cci consoleCursorInfo
+	procGetConsoleCursorInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&cci)))
+	cci.visible = 1
+
+	procSetConsoleCursorInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&cci)))
+}
+
+func CursorHide() {
+	handle := syscall.Handle(os.Stdout.Fd())
+
+	var cci consoleCursorInfo
+	procGetConsoleCursorInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&cci)))
+	cci.visible = 0
+
+	procSetConsoleCursorInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&cci)))
+}
+
+func CursorLocation() (Coord, error) {
+	handle := syscall.Handle(os.Stdout.Fd())
+
+	var csbi consoleScreenBufferInfo
+	procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+
+	return csbi.cursorPosition, nil
+}
+
+func Size() (Coord, error) {
+	handle := syscall.Handle(os.Stdout.Fd())
+
+	var csbi consoleScreenBufferInfo
+	procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+
+	return csbi.size, nil
+}

vendor/github.com/AlecAivazis/survey/terminal/display.go

@@ -0,0 +1,9 @@
+package terminal
+
+type EraseLineMode int
+
+const (
+	ERASE_LINE_END EraseLineMode = iota
+	ERASE_LINE_START
+	ERASE_LINE_ALL
+)

vendor/github.com/AlecAivazis/survey/terminal/display_posix.go

@@ -0,0 +1,11 @@
+// +build !windows
+
+package terminal
+
+import (
+	"fmt"
+)
+
+func EraseLine(mode EraseLineMode) {
+	fmt.Printf("\x1b[%dK", mode)
+}

vendor/github.com/AlecAivazis/survey/terminal/display_windows.go

@@ -0,0 +1,28 @@
+package terminal
+
+import (
+	"os"
+	"syscall"
+	"unsafe"
+)
+
+func EraseLine(mode EraseLineMode) {
+	handle := syscall.Handle(os.Stdout.Fd())
+
+	var csbi consoleScreenBufferInfo
+	procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+
+	var w uint32
+	var x Short
+	cursor := csbi.cursorPosition
+	switch mode {
+	case ERASE_LINE_END:
+		x = csbi.size.X
+	case ERASE_LINE_START:
+		x = 0
+	case ERASE_LINE_ALL:
+		cursor.X = 0
+		x = csbi.size.X
+	}
+	procFillConsoleOutputCharacter.Call(uintptr(handle), uintptr(' '), uintptr(x), uintptr(*(*int32)(unsafe.Pointer(&cursor))), uintptr(unsafe.Pointer(&w)))
+}

vendor/github.com/AlecAivazis/survey/terminal/output.go

@@ -0,0 +1,20 @@
+// +build !windows
+
+package terminal
+
+import (
+	"io"
+	"os"
+)
+
+// Returns special stdout, which converts escape sequences to Windows API calls
+// on Windows environment.
+func NewAnsiStdout() io.Writer {
+	return os.Stdout
+}
+
+// Returns special stderr, which converts escape sequences to Windows API calls
+// on Windows environment.
+func NewAnsiStderr() io.Writer {
+	return os.Stderr
+}

vendor/github.com/AlecAivazis/survey/terminal/output_windows.go

@@ -0,0 +1,204 @@
+package terminal
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+	"strconv"
+	"strings"
+	"syscall"
+	"unsafe"
+
+	"github.com/mattn/go-isatty"
+)
+
+var (
+	singleArgFunctions = map[rune]func(int){
+		'A': CursorUp,
+		'B': CursorDown,
+		'C': CursorForward,
+		'D': CursorBack,
+		'E': CursorNextLine,
+		'F': CursorPreviousLine,
+		'G': CursorHorizontalAbsolute,
+	}
+)
+
+const (
+	foregroundBlue      = 0x1
+	foregroundGreen     = 0x2
+	foregroundRed       = 0x4
+	foregroundIntensity = 0x8
+	foregroundMask      = (foregroundRed | foregroundBlue | foregroundGreen | foregroundIntensity)
+	backgroundBlue      = 0x10
+	backgroundGreen     = 0x20
+	backgroundRed       = 0x40
+	backgroundIntensity = 0x80
+	backgroundMask      = (backgroundRed | backgroundBlue | backgroundGreen | backgroundIntensity)
+)
+
+type Writer struct {
+	out     io.Writer
+	handle  syscall.Handle
+	orgAttr word
+}
+
+func NewAnsiStdout() io.Writer {
+	var csbi consoleScreenBufferInfo
+	out := os.Stdout
+	if !isatty.IsTerminal(out.Fd()) {
+		return out
+	}
+	handle := syscall.Handle(out.Fd())
+	procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+	return &Writer{out: out, handle: handle, orgAttr: csbi.attributes}
+}
+
+func NewAnsiStderr() io.Writer {
+	var csbi consoleScreenBufferInfo
+	out := os.Stderr
+	if !isatty.IsTerminal(out.Fd()) {
+		return out
+	}
+	handle := syscall.Handle(out.Fd())
+	procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+	return &Writer{out: out, handle: handle, orgAttr: csbi.attributes}
+}
+
+func (w *Writer) Write(data []byte) (n int, err error) {
+	r := bytes.NewReader(data)
+
+	for {
+		ch, size, err := r.ReadRune()
+		if err != nil {
+			break
+		}
+		n += size
+
+		switch ch {
+		case '\x1b':
+			size, err = w.handleEscape(r)
+			n += size
+			if err != nil {
+				break
+			}
+		default:
+			fmt.Fprint(w.out, string(ch))
+		}
+	}
+	return
+}
+
+func (w *Writer) handleEscape(r *bytes.Reader) (n int, err error) {
+	buf := make([]byte, 0, 10)
+	buf = append(buf, "\x1b"...)
+
+	// Check '[' continues after \x1b
+	ch, size, err := r.ReadRune()
+	if err != nil {
+		fmt.Fprint(w.out, string(buf))
+		return
+	}
+	n += size
+	if ch != '[' {
+		fmt.Fprint(w.out, string(buf))
+		return
+	}
+
+	// Parse escape code
+	var code rune
+	argBuf := make([]byte, 0, 10)
+	for {
+		ch, size, err = r.ReadRune()
+		if err != nil {
+			fmt.Fprint(w.out, string(buf))
+			return
+		}
+		n += size
+		if ('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z') {
+			code = ch
+			break
+		}
+		argBuf = append(argBuf, string(ch)...)
+	}
+
+	w.applyEscapeCode(buf, string(argBuf), code)
+	return
+}
+
+func (w *Writer) applyEscapeCode(buf []byte, arg string, code rune) {
+	switch arg + string(code) {
+	case "?25h":
+		CursorShow()
+		return
+	case "?25l":
+		CursorHide()
+		return
+	}
+
+	if f, ok := singleArgFunctions[code]; ok {
+		if n, err := strconv.Atoi(arg); err == nil {
+			f(n)
+			return
+		}
+	}
+
+	switch code {
+	case 'm':
+		w.applySelectGraphicRendition(arg)
+	default:
+		buf = append(buf, string(code)...)
+		fmt.Fprint(w.out, string(buf))
+	}
+}
+
+// Original implementation: https://github.com/mattn/go-colorable
+func (w *Writer) applySelectGraphicRendition(arg string) {
+	if arg == "" {
+		procSetConsoleTextAttribute.Call(uintptr(w.handle), uintptr(w.orgAttr))
+		return
+	}
+
+	var csbi consoleScreenBufferInfo
+	procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
+	attr := csbi.attributes
+
+	for _, param := range strings.Split(arg, ";") {
+		n, err := strconv.Atoi(param)
+		if err != nil {
+			continue
+		}
+
+		switch {
+		case n == 0 || n == 100:
+			attr = w.orgAttr
+		case 1 <= n && n <= 5:
+			attr |= foregroundIntensity
+		case 30 <= n && n <= 37:
+			attr = (attr & backgroundMask)
+			if (n-30)&1 != 0 {
+				attr |= foregroundRed
+			}
+			if (n-30)&2 != 0 {
+				attr |= foregroundGreen
+			}
+			if (n-30)&4 != 0 {
+				attr |= foregroundBlue
+			}
+		case 40 <= n && n <= 47:
+			attr = (attr & foregroundMask)
+			if (n-40)&1 != 0 {
+				attr |= backgroundRed
+			}
+			if (n-40)&2 != 0 {
+				attr |= backgroundGreen
+			}
+			if (n-40)&4 != 0 {
+				attr |= backgroundBlue
+			}
+		}
+	}
+
+	procSetConsoleTextAttribute.Call(uintptr(w.handle), uintptr(attr))
+}

vendor/github.com/AlecAivazis/survey/terminal/print.go

@@ -0,0 +1,25 @@
+package terminal
+
+import (
+	"fmt"
+)
+
+var (
+	Stdout = NewAnsiStdout()
+)
+
+// Print prints given arguments with escape sequence conversion for windows.
+func Print(a ...interface{}) (n int, err error) {
+	return fmt.Fprint(Stdout, a...)
+}
+
+// Printf prints a given format with escape sequence conversion for windows.
+func Printf(format string, a ...interface{}) (n int, err error) {
+	return fmt.Fprintf(Stdout, format, a...)
+}
+
+// Println prints given arguments with newline and escape sequence conversion
+// for windows.
+func Println(a ...interface{}) (n int, err error) {
+	return fmt.Fprintln(Stdout, a...)
+}

vendor/github.com/AlecAivazis/survey/terminal/runereader.go

@@ -0,0 +1,184 @@
+package terminal
+
+import (
+	"fmt"
+	"os"
+	"unicode"
+)
+
+type RuneReader struct {
+	Input *os.File
+
+	state runeReaderState
+}
+
+func NewRuneReader(input *os.File) *RuneReader {
+	return &RuneReader{
+		Input: input,
+		state: newRuneReaderState(input),
+	}
+}
+
+func (rr *RuneReader) ReadLine(mask rune) ([]rune, error) {
+	line := []rune{}
+
+	// we only care about horizontal displacements from the origin so start counting at 0
+	index := 0
+
+	for {
+		// wait for some input
+		r, _, err := rr.ReadRune()
+		if err != nil {
+			return line, err
+		}
+
+		// if the user pressed enter or some other newline/termination like ctrl+d
+		if r == '\r' || r == '\n' || r == KeyEndTransmission {
+			// go to the beginning of the next line
+			Print("\r\n")
+
+			// we're done processing the input
+			return line, nil
+		}
+
+		// if the user interrupts (ie with ctrl+c)
+		if r == KeyInterrupt {
+			// go to the beginning of the next line
+			Print("\r\n")
+
+			// we're done processing the input, and treat interrupt like an error
+			return line, fmt.Errorf("interrupt")
+		}
+
+		// allow for backspace/delete editing of inputs
+		if r == KeyBackspace || r == KeyDelete {
+			// and we're not at the beginning of the line
+			if index > 0 && len(line) > 0 {
+				// if we are at the end of the word
+				if index == len(line) {
+					// just remove the last letter from the internal representation
+					line = line[:len(line)-1]
+
+					// go back one
+					CursorBack(1)
+
+					// clear the rest of the line
+					EraseLine(ERASE_LINE_END)
+				} else {
+					// we need to remove a character from the middle of the word
+
+					// remove the current index from the list
+					line = append(line[:index-1], line[index:]...)
+
+					// go back one space so we can clear the rest
+					CursorBack(1)
+
+					// clear the rest of the line
+					EraseLine(ERASE_LINE_END)
+
+					// print what comes after
+					Print(string(line[index-1:]))
+
+					// leave the cursor where the user left it
+					CursorBack(len(line) - index + 1)
+				}
+
+				// decrement the index
+				index--
+			} else {
+				// otherwise the user pressed backspace while at the beginning of the line
+				soundBell()
+			}
+
+			// we're done processing this key
+			continue
+		}
+
+		// if the left arrow is pressed
+		if r == KeyArrowLeft {
+			// and we have space to the left
+			if index > 0 {
+				// move the cursor to the left
+				CursorBack(1)
+				// decrement the index
+				index--
+
+			} else {
+				// otherwise we are at the beginning of where we started reading lines
+				// sound the bell
+				soundBell()
+			}
+
+			// we're done processing this key press
+			continue
+		}
+
+		// if the right arrow is pressed
+		if r == KeyArrowRight {
+			// and we have space to the right of the word
+			if index < len(line) {
+				// move the cursor to the right
+				CursorForward(1)
+				// increment the index
+				index++
+
+			} else {
+				// otherwise we are at the end of the word and can't go past
+				// sound the bell
+				soundBell()
+			}
+
+			// we're done processing this key press
+			continue
+		}
+
+		// if the letter is another escape sequence
+		if unicode.IsControl(r) {
+			// ignore it
+			continue
+		}
+
+		// the user pressed a regular key
+
+		// if we are at the end of the line
+		if index == len(line) {
+			// just append the character at the end of the line
+			line = append(line, r)
+			// increment the location counter
+			index++
+
+			// if we don't need to mask the input
+			if mask == 0 {
+				// just print the character the user pressed
+				Printf("%c", r)
+			} else {
+				// otherwise print the mask we were given
+				Printf("%c", mask)
+			}
+		} else {
+			// we are in the middle of the word so we need to insert the character the user pressed
+			line = append(line[:index], append([]rune{r}, line[index:]...)...)
+
+			// visually insert the character by deleting the rest of the line
+			EraseLine(ERASE_LINE_END)
+
+			// print the rest of the word after
+			for _, char := range line[index:] {
+				// if we don't need to mask the input
+				if mask == 0 {
+					// just print the character the user pressed
+					Printf("%c", char)
+				} else {
+					// otherwise print the mask we were given
+					Printf("%c", mask)
+				}
+			}
+
+			// leave the cursor where the user left it
+			CursorBack(len(line) - index - 1)
+
+			// accomodate the new letter in our counter
+			index++
+		}
+	}
+}

vendor/github.com/AlecAivazis/survey/terminal/runereader_bsd.go

@@ -0,0 +1,13 @@
+// copied from: https://github.com/golang/crypto/blob/master/ssh/terminal/util_bsd.go
+// Copyright 2013 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.
+
+// +build darwin dragonfly freebsd netbsd openbsd
+
+package terminal
+
+import "syscall"
+
+const ioctlReadTermios = syscall.TIOCGETA
+const ioctlWriteTermios = syscall.TIOCSETA

vendor/github.com/AlecAivazis/survey/terminal/runereader_linux.go

@@ -0,0 +1,12 @@
+// copied from https://github.com/golang/crypto/blob/master/ssh/terminal/util_linux.go
+// Copyright 2013 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.
+
+package terminal
+
+// These constants are declared here, rather than importing
+// them from the syscall package as some syscall packages, even
+// on linux, for example gccgo, do not declare them.
+const ioctlReadTermios = 0x5401  // syscall.TCGETS
+const ioctlWriteTermios = 0x5402 // syscall.TCSETS

vendor/github.com/AlecAivazis/survey/terminal/runereader_posix.go

@@ -0,0 +1,84 @@
+// +build !windows
+
+// The terminal mode manipluation code is derived heavily from:
+// https://github.com/golang/crypto/blob/master/ssh/terminal/util.go:
+// 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.
+
+package terminal
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"syscall"
+	"unsafe"
+)
+
+type runeReaderState struct {
+	term syscall.Termios
+	buf  *bufio.Reader
+}
+
+func newRuneReaderState(input *os.File) runeReaderState {
+	return runeReaderState{
+		buf: bufio.NewReader(input),
+	}
+}
+
+// For reading runes we just want to disable echo.
+func (rr *RuneReader) SetTermMode() error {
+	if _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(rr.Input.Fd()), ioctlReadTermios, uintptr(unsafe.Pointer(&rr.state.term)), 0, 0, 0); err != 0 {
+		return err
+	}
+
+	newState := rr.state.term
+	newState.Lflag &^= syscall.ECHO | syscall.ECHONL | syscall.ICANON | syscall.ISIG
+
+	if _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(rr.Input.Fd()), ioctlWriteTermios, uintptr(unsafe.Pointer(&newState)), 0, 0, 0); err != 0 {
+		return err
+	}
+
+	return nil
+}
+
+func (rr *RuneReader) RestoreTermMode() error {
+	if _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(rr.Input.Fd()), ioctlWriteTermios, uintptr(unsafe.Pointer(&rr.state.term)), 0, 0, 0); err != 0 {
+		return err
+	}
+	return nil
+}
+
+func (rr *RuneReader) ReadRune() (rune, int, error) {
+	r, size, err := rr.state.buf.ReadRune()
+	if err != nil {
+		return r, size, err
+	}
+	// parse ^[ sequences to look for arrow keys
+	if r == '\033' {
+		r, size, err = rr.state.buf.ReadRune()
+		if err != nil {
+			return r, size, err
+		}
+		if r != '[' {
+			return r, size, fmt.Errorf("Unexpected Escape Sequence: %q", []rune{'\033', r})
+		}
+		r, size, err = rr.state.buf.ReadRune()
+		if err != nil {
+			return r, size, err
+		}
+		switch r {
+		case 'D':
+			return KeyArrowLeft, 1, nil
+		case 'C':
+			return KeyArrowRight, 1, nil
+		case 'A':
+			return KeyArrowUp, 1, nil
+		case 'B':
+			return KeyArrowDown, 1, nil
+		}
+		return r, size, fmt.Errorf("Unknown Escape Sequence: %q", []rune{'\033', '[', r})
+	}
+	return r, size, err
+}

vendor/github.com/AlecAivazis/survey/terminal/runereader_windows.go

@@ -0,0 +1,130 @@
+package terminal
+
+import (
+	"os"
+	"syscall"
+	"unsafe"
+)
+
+var (
+	dll              = syscall.NewLazyDLL("kernel32.dll")
+	setConsoleMode   = dll.NewProc("SetConsoleMode")
+	getConsoleMode   = dll.NewProc("GetConsoleMode")
+	readConsoleInput = dll.NewProc("ReadConsoleInputW")
+)
+
+const (
+	EVENT_KEY = 0x0001
+
+	// key codes for arrow keys
+	// https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx
+	VK_LEFT  = 0x25
+	VK_UP    = 0x26
+	VK_RIGHT = 0x27
+	VK_DOWN  = 0x28
+
+	RIGHT_CTRL_PRESSED = 0x0004
+	LEFT_CTRL_PRESSED  = 0x0008
+
+	ENABLE_ECHO_INPUT      uint32 = 0x0004
+	ENABLE_LINE_INPUT      uint32 = 0x0002
+	ENABLE_PROCESSED_INPUT uint32 = 0x0001
+)
+
+type inputRecord struct {
+	eventType uint16
+	padding   uint16
+	event     [16]byte
+}
+
+type keyEventRecord struct {
+	bKeyDown          int32
+	wRepeatCount      uint16
+	wVirtualKeyCode   uint16
+	wVirtualScanCode  uint16
+	unicodeChar       uint16
+	wdControlKeyState uint32
+}
+
+type runeReaderState struct {
+	term uint32
+}
+
+func newRuneReaderState(input *os.File) runeReaderState {
+	return runeReaderState{}
+}
+
+func (rr *RuneReader) SetTermMode() error {
+	r, _, err := getConsoleMode.Call(uintptr(rr.Input.Fd()), uintptr(unsafe.Pointer(&rr.state.term)))
+	// windows return 0 on error
+	if r == 0 {
+		return err
+	}
+
+	newState := rr.state.term
+	newState &^= ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT
+	r, _, err = setConsoleMode.Call(uintptr(rr.Input.Fd()), uintptr(newState))
+	// windows return 0 on error
+	if r == 0 {
+		return err
+	}
+	return nil
+}
+
+func (rr *RuneReader) RestoreTermMode() error {
+	r, _, err := setConsoleMode.Call(uintptr(rr.Input.Fd()), uintptr(rr.state.term))
+	// windows return 0 on error
+	if r == 0 {
+		return err
+	}
+	return nil
+}
+
+func (rr *RuneReader) ReadRune() (rune, int, error) {
+	ir := &inputRecord{}
+	bytesRead := 0
+	for {
+		rv, _, e := readConsoleInput.Call(rr.Input.Fd(), uintptr(unsafe.Pointer(ir)), 1, uintptr(unsafe.Pointer(&bytesRead)))
+		// windows returns non-zero to indicate success
+		if rv == 0 && e != nil {
+			return 0, 0, e
+		}
+
+		if ir.eventType != EVENT_KEY {
+			continue
+		}
+
+		// the event data is really a c struct union, so here we have to do an usafe
+		// cast to put the data into the keyEventRecord (since we have already verified
+		// above that this event does correspond to a key event
+		key := (*keyEventRecord)(unsafe.Pointer(&ir.event[0]))
+		// we only care about key down events
+		if key.bKeyDown == 0 {
+			continue
+		}
+		if key.wdControlKeyState&(LEFT_CTRL_PRESSED|RIGHT_CTRL_PRESSED) != 0 && key.unicodeChar == 'C' {
+			return KeyInterrupt, bytesRead, nil
+		}
+
+		// not a normal character so look up the input sequence from the
+		// virtual key code mappings (VK_*)
+		if key.unicodeChar == 0 {
+			switch key.wVirtualKeyCode {
+			case VK_DOWN:
+				return KeyArrowDown, bytesRead, nil
+			case VK_LEFT:
+				return KeyArrowLeft, bytesRead, nil
+			case VK_RIGHT:
+				return KeyArrowRight, bytesRead, nil
+			case VK_UP:
+				return KeyArrowUp, bytesRead, nil
+			default:
+				// not a virtual key that we care about so just continue on to
+				// the next input key
+				continue
+			}
+		}
+		r := rune(key.unicodeChar)
+		return r, bytesRead, nil
+	}
+}

vendor/github.com/AlecAivazis/survey/terminal/sequences.go

@@ -0,0 +1,18 @@
+package terminal
+
+const (
+	KeyArrowLeft       = '\x02'
+	KeyArrowRight      = '\x06'
+	KeyArrowUp         = '\x10'
+	KeyArrowDown       = '\x0e'
+	KeySpace           = ' '
+	KeyEnter           = '\r'
+	KeyBackspace       = '\b'
+	KeyDelete          = '\x7f'
+	KeyInterrupt       = '\x03'
+	KeyEndTransmission = '\x04'
+)
+
+func soundBell() {
+	Print("\a")
+}

vendor/github.com/AlecAivazis/survey/terminal/syscall_windows.go

@@ -0,0 +1,39 @@
+package terminal
+
+import (
+	"syscall"
+)
+
+var (
+	kernel32                       = syscall.NewLazyDLL("kernel32.dll")
+	procGetConsoleScreenBufferInfo = kernel32.NewProc("GetConsoleScreenBufferInfo")
+	procSetConsoleTextAttribute    = kernel32.NewProc("SetConsoleTextAttribute")
+	procSetConsoleCursorPosition   = kernel32.NewProc("SetConsoleCursorPosition")
+	procFillConsoleOutputCharacter = kernel32.NewProc("FillConsoleOutputCharacterW")
+	procGetConsoleCursorInfo       = kernel32.NewProc("GetConsoleCursorInfo")
+	procSetConsoleCursorInfo       = kernel32.NewProc("SetConsoleCursorInfo")
+)
+
+type wchar uint16
+type dword uint32
+type word uint16
+
+type smallRect struct {
+	left   Short
+	top    Short
+	right  Short
+	bottom Short
+}
+
+type consoleScreenBufferInfo struct {
+	size              Coord
+	cursorPosition    Coord
+	attributes        word
+	window            smallRect
+	maximumWindowSize Coord
+}
+
+type consoleCursorInfo struct {
+	size    dword
+	visible int32
+}

vendor/github.com/AlecAivazis/survey/terminal/terminal.go

@@ -0,0 +1,8 @@
+package terminal
+
+type Short int16
+
+type Coord struct {
+	X Short
+	Y Short
+}

vendor/github.com/AlecAivazis/survey/tests/README.md

@@ -0,0 +1,6 @@
+# survey/tests
+
+Because of the nature of this library, I was having a hard time finding a reliable
+way to run unit tests, therefore I decided to try to create a suite
+of integration tests which must be run successfully before a PR can be merged.
+I will try to add to this suite as new edge cases are known.

vendor/github.com/AlecAivazis/survey/tests/ask.go

@@ -0,0 +1,60 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/AlecAivazis/survey"
+)
+
+// the questions to ask
+var simpleQs = []*survey.Question{
+	{
+		Name: "name",
+		Prompt: &survey.Input{
+			Message: "What is your name?",
+			Default: "Johnny Appleseed",
+		},
+	},
+	{
+		Name: "color",
+		Prompt: &survey.Select{
+			Message: "Choose a color:",
+			Options: []string{"red", "blue", "green", "yellow"},
+			Default: "yellow",
+		},
+		Validate: survey.Required,
+	},
+}
+
+func main() {
+
+	fmt.Println("Asking many.")
+	// a place to store the answers
+	ans := struct {
+		Name  string
+		Color string
+	}{}
+	err := survey.Ask(simpleQs, &ans)
+	if err != nil {
+		fmt.Println(err.Error())
+		return
+	}
+
+	fmt.Println("Asking one.")
+	answer := ""
+	err = survey.AskOne(simpleQs[0].Prompt, &answer, nil)
+	if err != nil {
+		fmt.Println(err.Error())
+		return
+	}
+	fmt.Printf("Answered with %v.\n", answer)
+
+	fmt.Println("Asking one with validation.")
+	vAns := ""
+	err = survey.AskOne(&survey.Input{Message: "What is your name?"}, &vAns, survey.Required)
+	if err != nil {
+		fmt.Println(err.Error())
+		return
+	}
+	fmt.Printf("Answered with %v.\n", vAns)
+}

vendor/github.com/AlecAivazis/survey/tests/autoplay/ask.go

@@ -0,0 +1,180 @@
+////////////////////////////////////////////////////////////////////////////////
+//                          DO NOT MODIFY THIS FILE!
+//
+//  This file was automatically generated via the commands:
+//
+//      go get github.com/coryb/autoplay
+//      autoplay -n autoplay/ask.go go run ask.go
+//
+////////////////////////////////////////////////////////////////////////////////
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"github.com/kr/pty"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+)
+
+const (
+	RED   = "\033[31m"
+	RESET = "\033[0m"
+)
+
+func main() {
+	fh, tty, _ := pty.Open()
+	defer tty.Close()
+	defer fh.Close()
+	c := exec.Command("go", "run", "ask.go")
+	c.Stdin = tty
+	c.Stdout = tty
+	c.Stderr = tty
+	c.Start()
+	buf := bufio.NewReaderSize(fh, 1024)
+
+	expect("Asking many.\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat is your name? \x1b[0m\x1b[37m(Johnny Appleseed) \x1b[0m", buf)
+	fh.Write([]byte("L"))
+	expect("L", buf)
+	fh.Write([]byte("a"))
+	expect("a", buf)
+	fh.Write([]byte("r"))
+	expect("r", buf)
+	fh.Write([]byte("r"))
+	expect("r", buf)
+	fh.Write([]byte("y"))
+	expect("y", buf)
+	fh.Write([]byte(" "))
+	expect(" ", buf)
+	fh.Write([]byte("B"))
+	expect("B", buf)
+	fh.Write([]byte("i"))
+	expect("i", buf)
+	fh.Write([]byte("r"))
+	expect("r", buf)
+	fh.Write([]byte("d"))
+	expect("d", buf)
+	fh.Write([]byte("\r"))
+	expect("\r\r\n", buf)
+	expect("\x1b[1F\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat is your name? \x1b[0m\x1b[36mLarry Bird\x1b[0m\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose a color:\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  red\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  blue\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  green\x1b[0m\r\n", buf)
+	expect("\x1b[1;36m❯ yellow\x1b[0m\r\n", buf)
+	expect("\x1b[?25l", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("A"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose a color:\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  red\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  blue\x1b[0m\r\n", buf)
+	expect("\x1b[1;36m❯ green\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  yellow\x1b[0m\r\n", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("A"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose a color:\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  red\x1b[0m\r\n", buf)
+	expect("\x1b[1;36m❯ blue\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  green\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  yellow\x1b[0m\r\n", buf)
+	fh.Write([]byte("\r"))
+	expect("\x1b[?25h\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose a color:\x1b[0m\x1b[36m blue\x1b[0m\r\n", buf)
+	expect("Asking one.\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat is your name? \x1b[0m\x1b[37m(Johnny Appleseed) \x1b[0m", buf)
+	fh.Write([]byte("L"))
+	expect("L", buf)
+	fh.Write([]byte("a"))
+	expect("a", buf)
+	fh.Write([]byte("r"))
+	expect("r", buf)
+	fh.Write([]byte("r"))
+	expect("r", buf)
+	fh.Write([]byte("y"))
+	expect("y", buf)
+	fh.Write([]byte(" "))
+	expect(" ", buf)
+	fh.Write([]byte("K"))
+	expect("K", buf)
+	fh.Write([]byte("i"))
+	expect("i", buf)
+	fh.Write([]byte("n"))
+	expect("n", buf)
+	fh.Write([]byte("g"))
+	expect("g", buf)
+	fh.Write([]byte("\r"))
+	expect("\r\r\n", buf)
+	expect("\x1b[1F\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat is your name? \x1b[0m\x1b[36mLarry King\x1b[0m\r\n", buf)
+	expect("Answered with Larry King.\r\n", buf)
+	expect("Asking one with validation.\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat is your name? \x1b[0m", buf)
+	fh.Write([]byte("\r"))
+	expect("\r\r\n", buf)
+	expect("\x1b[1F\x1b[0G\x1b[2K\x1b[31m✘ Sorry, your reply was invalid: Value is required\x1b[0m\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat is your name? \x1b[0m", buf)
+	fh.Write([]byte("L"))
+	expect("L", buf)
+	fh.Write([]byte("a"))
+	expect("a", buf)
+	fh.Write([]byte("r"))
+	expect("r", buf)
+	fh.Write([]byte("r"))
+	expect("r", buf)
+	fh.Write([]byte("y"))
+	expect("y", buf)
+	fh.Write([]byte(" "))
+	expect(" ", buf)
+	fh.Write([]byte("W"))
+	expect("W", buf)
+	fh.Write([]byte("a"))
+	expect("a", buf)
+	fh.Write([]byte("l"))
+	expect("l", buf)
+	fh.Write([]byte("l"))
+	expect("l", buf)
+	fh.Write([]byte("\r"))
+	expect("\r\r\n", buf)
+	expect("\x1b[1F\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat is your name? \x1b[0m\x1b[36mLarry Wall\x1b[0m\r\n", buf)
+	expect("Answered with Larry Wall.\r\n", buf)
+
+	c.Wait()
+	tty.Close()
+	fh.Close()
+}
+
+func expect(expected string, buf *bufio.Reader) {
+	sofar := []rune{}
+	for _, r := range expected {
+		got, _, _ := buf.ReadRune()
+		sofar = append(sofar, got)
+		if got != r {
+			fmt.Fprintln(os.Stderr, RESET)
+
+			// we want to quote the string but we also want to make the unexpected character RED
+			// so we use the strconv.Quote function but trim off the quoted characters so we can
+			// merge multiple quoted strings into one.
+			expStart := strings.TrimSuffix(strconv.Quote(expected[:len(sofar)-1]), "\"")
+			expMiss := strings.TrimSuffix(strings.TrimPrefix(strconv.Quote(string(expected[len(sofar)-1])), "\""), "\"")
+			expEnd := strings.TrimPrefix(strconv.Quote(expected[len(sofar):]), "\"")
+
+			fmt.Fprintf(os.Stderr, "Expected: %s%s%s%s%s\n", expStart, RED, expMiss, RESET, expEnd)
+
+			// read the rest of the buffer
+			p := make([]byte, buf.Buffered())
+			buf.Read(p)
+
+			gotStart := strings.TrimSuffix(strconv.Quote(string(sofar[:len(sofar)-1])), "\"")
+			gotMiss := strings.TrimSuffix(strings.TrimPrefix(strconv.Quote(string(sofar[len(sofar)-1])), "\""), "\"")
+			gotEnd := strings.TrimPrefix(strconv.Quote(string(p)), "\"")
+
+			fmt.Fprintf(os.Stderr, "Got:      %s%s%s%s%s\n", gotStart, RED, gotMiss, RESET, gotEnd)
+			panic(fmt.Errorf("Unexpected Rune %q, Expected %q\n", got, r))
+		} else {
+			fmt.Printf("%c", r)
+		}
+	}
+}

vendor/github.com/AlecAivazis/survey/tests/autoplay/confirm.go

@@ -0,0 +1,132 @@
+////////////////////////////////////////////////////////////////////////////////
+//                          DO NOT MODIFY THIS FILE!
+//
+//  This file was automatically generated via the commands:
+//
+//      go get github.com/coryb/autoplay
+//      autoplay -n autoplay/confirm.go go run confirm.go
+//
+////////////////////////////////////////////////////////////////////////////////
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"github.com/kr/pty"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+)
+
+const (
+	RED   = "\033[31m"
+	RESET = "\033[0m"
+)
+
+func main() {
+	fh, tty, _ := pty.Open()
+	defer tty.Close()
+	defer fh.Close()
+	c := exec.Command("go", "run", "confirm.go")
+	c.Stdin = tty
+	c.Stdout = tty
+	c.Stderr = tty
+	c.Start()
+	buf := bufio.NewReaderSize(fh, 1024)
+
+	expect("Enter 'yes'\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99myes: \x1b[0m\x1b[37m(y/N) \x1b[0m", buf)
+	fh.Write([]byte("y"))
+	expect("y", buf)
+	fh.Write([]byte("e"))
+	expect("e", buf)
+	fh.Write([]byte("s"))
+	expect("s", buf)
+	fh.Write([]byte("\r"))
+	expect("\r\r\n", buf)
+	expect("\x1b[1F\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99myes: \x1b[0m\x1b[36mYes\x1b[0m\r\n", buf)
+	expect("Answered true.\r\n", buf)
+	expect("---------------------\r\n", buf)
+	expect("Enter 'no'\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99myes: \x1b[0m\x1b[37m(y/N) \x1b[0m", buf)
+	fh.Write([]byte("n"))
+	expect("n", buf)
+	fh.Write([]byte("o"))
+	expect("o", buf)
+	fh.Write([]byte("\r"))
+	expect("\r\r\n", buf)
+	expect("\x1b[1F\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99myes: \x1b[0m\x1b[36mNo\x1b[0m\r\n", buf)
+	expect("Answered false.\r\n", buf)
+	expect("---------------------\r\n", buf)
+	expect("default\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99myes: \x1b[0m\x1b[37m(Y/n) \x1b[0m", buf)
+	fh.Write([]byte("\r"))
+	expect("\r\r\n", buf)
+	expect("\x1b[1F\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99myes: \x1b[0m\x1b[36mYes\x1b[0m\r\n", buf)
+	expect("Answered true.\r\n", buf)
+	expect("---------------------\r\n", buf)
+	expect("not recognized (enter random letter)\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99myes: \x1b[0m\x1b[37m(Y/n) \x1b[0m", buf)
+	fh.Write([]byte("x"))
+	expect("x", buf)
+	fh.Write([]byte("\r"))
+	expect("\r\r\n", buf)
+	expect("\x1b[1F\x1b[0G\x1b[2K\x1b[31m✘ Sorry, your reply was invalid: \"x\" is not a valid answer, please try again.\x1b[0m\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99myes: \x1b[0m\x1b[37m(Y/n) \x1b[0m", buf)
+	fh.Write([]byte("\r"))
+	expect("\r\r\n", buf)
+	expect("\x1b[1F\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99myes: \x1b[0m\x1b[36mYes\x1b[0m\r\n", buf)
+	expect("Answered true.\r\n", buf)
+	expect("---------------------\r\n", buf)
+	expect("no help - type '?'\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99myes: \x1b[0m\x1b[37m(Y/n) \x1b[0m", buf)
+	fh.Write([]byte("?"))
+	expect("?", buf)
+	fh.Write([]byte("\r"))
+	expect("\r\r\n", buf)
+	expect("\x1b[1F\x1b[0G\x1b[2K\x1b[31m✘ Sorry, your reply was invalid: \"?\" is not a valid answer, please try again.\x1b[0m\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99myes: \x1b[0m\x1b[37m(Y/n) \x1b[0m", buf)
+	fh.Write([]byte("\r"))
+	expect("\r\r\n", buf)
+	expect("\x1b[1F\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99myes: \x1b[0m\x1b[36mYes\x1b[0m\r\n", buf)
+	expect("Answered true.\r\n", buf)
+	expect("---------------------\r\n", buf)
+
+	c.Wait()
+	tty.Close()
+	fh.Close()
+}
+
+func expect(expected string, buf *bufio.Reader) {
+	sofar := []rune{}
+	for _, r := range expected {
+		got, _, _ := buf.ReadRune()
+		sofar = append(sofar, got)
+		if got != r {
+			fmt.Fprintln(os.Stderr, RESET)
+
+			// we want to quote the string but we also want to make the unexpected character RED
+			// so we use the strconv.Quote function but trim off the quoted characters so we can
+			// merge multiple quoted strings into one.
+			expStart := strings.TrimSuffix(strconv.Quote(expected[:len(sofar)-1]), "\"")
+			expMiss := strings.TrimSuffix(strings.TrimPrefix(strconv.Quote(string(expected[len(sofar)-1])), "\""), "\"")
+			expEnd := strings.TrimPrefix(strconv.Quote(expected[len(sofar):]), "\"")
+
+			fmt.Fprintf(os.Stderr, "Expected: %s%s%s%s%s\n", expStart, RED, expMiss, RESET, expEnd)
+
+			// read the rest of the buffer
+			p := make([]byte, buf.Buffered())
+			buf.Read(p)
+
+			gotStart := strings.TrimSuffix(strconv.Quote(string(sofar[:len(sofar)-1])), "\"")
+			gotMiss := strings.TrimSuffix(strings.TrimPrefix(strconv.Quote(string(sofar[len(sofar)-1])), "\""), "\"")
+			gotEnd := strings.TrimPrefix(strconv.Quote(string(p)), "\"")
+
+			fmt.Fprintf(os.Stderr, "Got:      %s%s%s%s%s\n", gotStart, RED, gotMiss, RESET, gotEnd)
+			panic(fmt.Errorf("Unexpected Rune %q, Expected %q\n", got, r))
+		} else {
+			fmt.Printf("%c", r)
+		}
+	}
+}

vendor/github.com/AlecAivazis/survey/tests/autoplay/doubleSelect.go

@@ -0,0 +1,104 @@
+////////////////////////////////////////////////////////////////////////////////
+//                          DO NOT MODIFY THIS FILE!
+//
+//  This file was automatically generated via the commands:
+//
+//      go get github.com/coryb/autoplay
+//      autoplay -n autoplay/doubleSelect.go go run doubleSelect.go
+//
+////////////////////////////////////////////////////////////////////////////////
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"github.com/kr/pty"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+)
+
+const (
+	RED   = "\033[31m"
+	RESET = "\033[0m"
+)
+
+func main() {
+	fh, tty, _ := pty.Open()
+	defer tty.Close()
+	defer fh.Close()
+	c := exec.Command("go", "run", "doubleSelect.go")
+	c.Stdin = tty
+	c.Stdout = tty
+	c.Stderr = tty
+	c.Start()
+	buf := bufio.NewReaderSize(fh, 1024)
+
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mselect1:\x1b[0m\r\n", buf)
+	expect("\x1b[1;36m❯ red\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  blue\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  green\x1b[0m\r\n", buf)
+	expect("\x1b[?25l", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mselect1:\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  red\x1b[0m\r\n", buf)
+	expect("\x1b[1;36m❯ blue\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  green\x1b[0m\r\n", buf)
+	fh.Write([]byte("\r"))
+	expect("\x1b[?25h\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mselect1:\x1b[0m\x1b[36m blue\x1b[0m\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mselect2:\x1b[0m\r\n", buf)
+	expect("\x1b[1;36m❯ red\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  blue\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  green\x1b[0m\r\n", buf)
+	expect("\x1b[?25l", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mselect2:\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  red\x1b[0m\r\n", buf)
+	expect("\x1b[1;36m❯ blue\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  green\x1b[0m\r\n", buf)
+	fh.Write([]byte("\r"))
+	expect("\x1b[?25h\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mselect2:\x1b[0m\x1b[36m blue\x1b[0m\r\n", buf)
+	expect("blue and blue.\r\n", buf)
+
+	c.Wait()
+	tty.Close()
+	fh.Close()
+}
+
+func expect(expected string, buf *bufio.Reader) {
+	sofar := []rune{}
+	for _, r := range expected {
+		got, _, _ := buf.ReadRune()
+		sofar = append(sofar, got)
+		if got != r {
+			fmt.Fprintln(os.Stderr, RESET)
+
+			// we want to quote the string but we also want to make the unexpected character RED
+			// so we use the strconv.Quote function but trim off the quoted characters so we can
+			// merge multiple quoted strings into one.
+			expStart := strings.TrimSuffix(strconv.Quote(expected[:len(sofar)-1]), "\"")
+			expMiss := strings.TrimSuffix(strings.TrimPrefix(strconv.Quote(string(expected[len(sofar)-1])), "\""), "\"")
+			expEnd := strings.TrimPrefix(strconv.Quote(expected[len(sofar):]), "\"")
+
+			fmt.Fprintf(os.Stderr, "Expected: %s%s%s%s%s\n", expStart, RED, expMiss, RESET, expEnd)
+
+			// read the rest of the buffer
+			p := make([]byte, buf.Buffered())
+			buf.Read(p)
+
+			gotStart := strings.TrimSuffix(strconv.Quote(string(sofar[:len(sofar)-1])), "\"")
+			gotMiss := strings.TrimSuffix(strings.TrimPrefix(strconv.Quote(string(sofar[len(sofar)-1])), "\""), "\"")
+			gotEnd := strings.TrimPrefix(strconv.Quote(string(p)), "\"")
+
+			fmt.Fprintf(os.Stderr, "Got:      %s%s%s%s%s\n", gotStart, RED, gotMiss, RESET, gotEnd)
+			panic(fmt.Errorf("Unexpected Rune %q, Expected %q\n", got, r))
+		} else {
+			fmt.Printf("%c", r)
+		}
+	}
+}

vendor/github.com/AlecAivazis/survey/tests/autoplay/help.go

@@ -0,0 +1,236 @@
+////////////////////////////////////////////////////////////////////////////////
+//                          DO NOT MODIFY THIS FILE!
+//
+//  This file was automatically generated via the commands:
+//
+//      go get github.com/coryb/autoplay
+//      autoplay -n autoplay/help.go go run help.go
+//
+////////////////////////////////////////////////////////////////////////////////
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"github.com/kr/pty"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+)
+
+const (
+	RED   = "\033[31m"
+	RESET = "\033[0m"
+)
+
+func main() {
+	fh, tty, _ := pty.Open()
+	defer tty.Close()
+	defer fh.Close()
+	c := exec.Command("go", "run", "help.go")
+	c.Stdin = tty
+	c.Stdout = tty
+	c.Stderr = tty
+	c.Start()
+	buf := bufio.NewReaderSize(fh, 1024)
+
+	expect("confirm\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mIs it raining? \x1b[0m\x1b[36m[? for help]\x1b[0m \x1b[37m(y/N) \x1b[0m", buf)
+	fh.Write([]byte("?"))
+	expect("?", buf)
+	fh.Write([]byte("\r"))
+	expect("\r\r\n", buf)
+	expect("\x1b[1F\x1b[0G\x1b[2K\x1b[36mⓘ Go outside, if your head becomes wet the answer is probably 'yes'\x1b[0m\r\n", buf)
+	expect("\x1b[1;92m? \x1b[0m\x1b[1;99mIs it raining? \x1b[0m\x1b[37m(y/N) \x1b[0m", buf)
+	fh.Write([]byte("y"))
+	expect("y", buf)
+	fh.Write([]byte("e"))
+	expect("e", buf)
+	fh.Write([]byte("s"))
+	expect("s", buf)
+	fh.Write([]byte("\r"))
+	expect("\r\r\n", buf)
+	expect("\x1b[1F\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mIs it raining? \x1b[0m\x1b[36mYes\x1b[0m\r\n", buf)
+	expect("Answered true.\r\n", buf)
+	expect("---------------------\r\n", buf)
+	expect("input\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat is your phone number: \x1b[0m\x1b[36m[? for help]\x1b[0m ", buf)
+	fh.Write([]byte("?"))
+	expect("?", buf)
+	fh.Write([]byte("\r"))
+	expect("\r\r\n", buf)
+	expect("\x1b[1F\x1b[0G\x1b[2K\x1b[36mⓘ Phone number should include the area code, parentheses optional\x1b[0m\r\n", buf)
+	expect("\x1b[1;92m? \x1b[0m\x1b[1;99mWhat is your phone number: \x1b[0m", buf)
+	fh.Write([]byte("1"))
+	expect("1", buf)
+	fh.Write([]byte("2"))
+	expect("2", buf)
+	fh.Write([]byte("3"))
+	expect("3", buf)
+	fh.Write([]byte("-"))
+	expect("-", buf)
+	fh.Write([]byte("1"))
+	expect("1", buf)
+	fh.Write([]byte("2"))
+	expect("2", buf)
+	fh.Write([]byte("3"))
+	expect("3", buf)
+	fh.Write([]byte("-"))
+	expect("-", buf)
+	fh.Write([]byte("1"))
+	expect("1", buf)
+	fh.Write([]byte("2"))
+	expect("2", buf)
+	fh.Write([]byte("3"))
+	expect("3", buf)
+	fh.Write([]byte("4"))
+	expect("4", buf)
+	fh.Write([]byte("\r"))
+	expect("\r\r\n", buf)
+	expect("\x1b[1F\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat is your phone number: \x1b[0m\x1b[36m123-123-1234\x1b[0m\r\n", buf)
+	expect("Answered 123-123-1234.\r\n", buf)
+	expect("---------------------\r\n", buf)
+	expect("select\r\n", buf)
+	expect("\x1b[?25l\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days are you available:\x1b[0m \x1b[36m[? for help]\x1b[0m\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Friday\r\n", buf)
+	fh.Write([]byte("?"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[36mⓘ We are closed weekends and avaibility is limited on Wednesday\x1b[0m\r\n", buf)
+	expect("\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days are you available:\x1b[0m\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Friday\r\n", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[36mⓘ We are closed weekends and avaibility is limited on Wednesday\x1b[0m\r\n", buf)
+	expect("\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days are you available:\x1b[0m\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[32m ◉ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Friday\r\n", buf)
+	fh.Write([]byte(" "))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[36mⓘ We are closed weekends and avaibility is limited on Wednesday\x1b[0m\r\n", buf)
+	expect("\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days are you available:\x1b[0m\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Friday\r\n", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[36mⓘ We are closed weekends and avaibility is limited on Wednesday\x1b[0m\r\n", buf)
+	expect("\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days are you available:\x1b[0m\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Friday\r\n", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[36mⓘ We are closed weekends and avaibility is limited on Wednesday\x1b[0m\r\n", buf)
+	expect("\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days are you available:\x1b[0m\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[32m ◉ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Friday\r\n", buf)
+	fh.Write([]byte(" "))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[36mⓘ We are closed weekends and avaibility is limited on Wednesday\x1b[0m\r\n", buf)
+	expect("\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days are you available:\x1b[0m\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Friday\r\n", buf)
+	fh.Write([]byte("\r"))
+	expect("\x1b[?25h\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days are you available:\x1b[0m\x1b[36m Monday, Friday\x1b[0m\r\n", buf)
+	expect("Answered [Monday Friday].\r\n", buf)
+	expect("---------------------\r\n", buf)
+	expect("select\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose a color:\x1b[0m \x1b[36m[? for help]\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  red\x1b[0m\r\n", buf)
+	expect("\x1b[1;36m❯ blue\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  green\x1b[0m\r\n", buf)
+	expect("\x1b[?25l", buf)
+	fh.Write([]byte("?"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[36mⓘ Blue is the best color, but it is your choice\x1b[0m\r\n", buf)
+	expect("\x1b[1;92m? \x1b[0m\x1b[1;99mChoose a color:\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  red\x1b[0m\r\n", buf)
+	expect("\x1b[1;36m❯ blue\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  green\x1b[0m\r\n", buf)
+	fh.Write([]byte("\r"))
+	expect("\x1b[?25h\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose a color:\x1b[0m\x1b[36m blue\x1b[0m\r\n", buf)
+	expect("Answered blue.\r\n", buf)
+	expect("---------------------\r\n", buf)
+	expect("password\r\n", buf)
+	expect("\x1b[1;92m? \x1b[0m\x1b[1;99mEnter a secret: \x1b[0m\x1b[36m[? for help]\x1b[0m ", buf)
+	fh.Write([]byte("?"))
+	expect("*", buf)
+	fh.Write([]byte("\r"))
+	expect("\r\r\n", buf)
+	expect("\x1b[1F\x1b[0G\x1b[2K\x1b[36mⓘ Don't really enter a secret, this is just for testing\x1b[0m\r\n", buf)
+	expect("\x1b[1;92m? \x1b[0m\x1b[1;99mEnter a secret: \x1b[0m", buf)
+	fh.Write([]byte("f"))
+	expect("*", buf)
+	fh.Write([]byte("o"))
+	expect("*", buf)
+	fh.Write([]byte("o"))
+	expect("*", buf)
+	fh.Write([]byte("b"))
+	expect("*", buf)
+	fh.Write([]byte("a"))
+	expect("*", buf)
+	fh.Write([]byte("r"))
+	expect("*", buf)
+	fh.Write([]byte("\r"))
+	expect("\r\r\n", buf)
+	expect("Answered foobar.\r\n", buf)
+	expect("---------------------\r\n", buf)
+
+	c.Wait()
+	tty.Close()
+	fh.Close()
+}
+
+func expect(expected string, buf *bufio.Reader) {
+	sofar := []rune{}
+	for _, r := range expected {
+		got, _, _ := buf.ReadRune()
+		sofar = append(sofar, got)
+		if got != r {
+			fmt.Fprintln(os.Stderr, RESET)
+
+			// we want to quote the string but we also want to make the unexpected character RED
+			// so we use the strconv.Quote function but trim off the quoted characters so we can
+			// merge multiple quoted strings into one.
+			expStart := strings.TrimSuffix(strconv.Quote(expected[:len(sofar)-1]), "\"")
+			expMiss := strings.TrimSuffix(strings.TrimPrefix(strconv.Quote(string(expected[len(sofar)-1])), "\""), "\"")
+			expEnd := strings.TrimPrefix(strconv.Quote(expected[len(sofar):]), "\"")
+
+			fmt.Fprintf(os.Stderr, "Expected: %s%s%s%s%s\n", expStart, RED, expMiss, RESET, expEnd)
+
+			// read the rest of the buffer
+			p := make([]byte, buf.Buffered())
+			buf.Read(p)
+
+			gotStart := strings.TrimSuffix(strconv.Quote(string(sofar[:len(sofar)-1])), "\"")
+			gotMiss := strings.TrimSuffix(strings.TrimPrefix(strconv.Quote(string(sofar[len(sofar)-1])), "\""), "\"")
+			gotEnd := strings.TrimPrefix(strconv.Quote(string(p)), "\"")
+
+			fmt.Fprintf(os.Stderr, "Got:      %s%s%s%s%s\n", gotStart, RED, gotMiss, RESET, gotEnd)
+			panic(fmt.Errorf("Unexpected Rune %q, Expected %q\n", got, r))
+		} else {
+			fmt.Printf("%c", r)
+		}
+	}
+}

vendor/github.com/AlecAivazis/survey/tests/autoplay/input.go

@@ -0,0 +1,176 @@
+////////////////////////////////////////////////////////////////////////////////
+//                          DO NOT MODIFY THIS FILE!
+//
+//  This file was automatically generated via the commands:
+//
+//      go get github.com/coryb/autoplay
+//      autoplay -n autoplay/input.go go run input.go
+//
+////////////////////////////////////////////////////////////////////////////////
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"github.com/kr/pty"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+)
+
+const (
+	RED   = "\033[31m"
+	RESET = "\033[0m"
+)
+
+func main() {
+	fh, tty, _ := pty.Open()
+	defer tty.Close()
+	defer fh.Close()
+	c := exec.Command("go", "run", "input.go")
+	c.Stdin = tty
+	c.Stdout = tty
+	c.Stderr = tty
+	c.Start()
+	buf := bufio.NewReaderSize(fh, 1024)
+
+	expect("no default\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mHello world \x1b[0m", buf)
+	fh.Write([]byte("a"))
+	expect("a", buf)
+	fh.Write([]byte("l"))
+	expect("l", buf)
+	fh.Write([]byte("e"))
+	expect("e", buf)
+	fh.Write([]byte("c"))
+	expect("c", buf)
+	fh.Write([]byte("\r"))
+	expect("\r\r\n", buf)
+	expect("\x1b[1F\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mHello world \x1b[0m\x1b[36malec\x1b[0m\r\n", buf)
+	expect("Answered alec.\r\n", buf)
+	expect("---------------------\r\n", buf)
+	expect("default\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mHello world \x1b[0m\x1b[37m(default) \x1b[0m", buf)
+	fh.Write([]byte("\r"))
+	expect("\r\r\n", buf)
+	expect("\x1b[1F\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mHello world \x1b[0m\x1b[36mdefault\x1b[0m\r\n", buf)
+	expect("Answered default.\r\n", buf)
+	expect("---------------------\r\n", buf)
+	expect("no help, send '?'\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mHello world \x1b[0m", buf)
+	fh.Write([]byte("?"))
+	expect("?", buf)
+	fh.Write([]byte("\r"))
+	expect("\r\r\n", buf)
+	expect("\x1b[1F\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mHello world \x1b[0m\x1b[36m?\x1b[0m\r\n", buf)
+	expect("Answered ?.\r\n", buf)
+	expect("---------------------\r\n", buf)
+	expect("input text in random location\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mHello \x1b[0m", buf)
+	fh.Write([]byte("h"))
+	expect("h", buf)
+	fh.Write([]byte("e"))
+	expect("e", buf)
+	fh.Write([]byte("l"))
+	expect("l", buf)
+	fh.Write([]byte("l"))
+	expect("l", buf)
+	fh.Write([]byte("o"))
+	expect("o", buf)
+	fh.Write([]byte(" "))
+	expect(" ", buf)
+	fh.Write([]byte("w"))
+	expect("w", buf)
+	fh.Write([]byte("o"))
+	expect("o", buf)
+	fh.Write([]byte("r"))
+	expect("r", buf)
+	fh.Write([]byte("l"))
+	expect("l", buf)
+	fh.Write([]byte("d"))
+	expect("d", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("D"))
+	expect("\x1b[1D", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	fh.Write([]byte("a"))
+	expect("\x1b[0Kad\x1b[1D", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("D"))
+	expect("\x1b[1D", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("D"))
+	expect("\x1b[1D", buf)
+	fh.Write([]byte("a"))
+	expect("\x1b[0Kalad\x1b[3D", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("D"))
+	expect("\x1b[1D", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("D"))
+	expect("\x1b[1D", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("D"))
+	expect("\x1b[1D", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("D"))
+	expect("\x1b[1D", buf)
+	fh.Write([]byte("\u007f"))
+	expect("\x1b[1D\x1b[0Kworalad\x1b[7D", buf)
+	fh.Write([]byte("\u007f"))
+	expect("\x1b[1D\x1b[0Kworalad\x1b[7D", buf)
+	fh.Write([]byte("\u007f"))
+	expect("\x1b[1D\x1b[0Kworalad\x1b[7D", buf)
+	fh.Write([]byte("\r"))
+	expect("\r\r\n", buf)
+	expect("\x1b[1F\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mHello \x1b[0m\x1b[36mhelworalad\x1b[0m\r\n", buf)
+	expect("Answered helworalad.\r\n", buf)
+	expect("---------------------\r\n", buf)
+
+	c.Wait()
+	tty.Close()
+	fh.Close()
+}
+
+func expect(expected string, buf *bufio.Reader) {
+	sofar := []rune{}
+	for _, r := range expected {
+		got, _, _ := buf.ReadRune()
+		sofar = append(sofar, got)
+		if got != r {
+			fmt.Fprintln(os.Stderr, RESET)
+
+			// we want to quote the string but we also want to make the unexpected character RED
+			// so we use the strconv.Quote function but trim off the quoted characters so we can
+			// merge multiple quoted strings into one.
+			expStart := strings.TrimSuffix(strconv.Quote(expected[:len(sofar)-1]), "\"")
+			expMiss := strings.TrimSuffix(strings.TrimPrefix(strconv.Quote(string(expected[len(sofar)-1])), "\""), "\"")
+			expEnd := strings.TrimPrefix(strconv.Quote(expected[len(sofar):]), "\"")
+
+			fmt.Fprintf(os.Stderr, "Expected: %s%s%s%s%s\n", expStart, RED, expMiss, RESET, expEnd)
+
+			// read the rest of the buffer
+			p := make([]byte, buf.Buffered())
+			buf.Read(p)
+
+			gotStart := strings.TrimSuffix(strconv.Quote(string(sofar[:len(sofar)-1])), "\"")
+			gotMiss := strings.TrimSuffix(strings.TrimPrefix(strconv.Quote(string(sofar[len(sofar)-1])), "\""), "\"")
+			gotEnd := strings.TrimPrefix(strconv.Quote(string(p)), "\"")
+
+			fmt.Fprintf(os.Stderr, "Got:      %s%s%s%s%s\n", gotStart, RED, gotMiss, RESET, gotEnd)
+			panic(fmt.Errorf("Unexpected Rune %q, Expected %q\n", got, r))
+		} else {
+			fmt.Printf("%c", r)
+		}
+	}
+}

vendor/github.com/AlecAivazis/survey/tests/autoplay/multiselect.go

@@ -0,0 +1,446 @@
+////////////////////////////////////////////////////////////////////////////////
+//                          DO NOT MODIFY THIS FILE!
+//
+//  This file was automatically generated via the commands:
+//
+//      go get github.com/coryb/autoplay
+//      autoplay -n autoplay/multiselect.go go run multiselect.go
+//
+////////////////////////////////////////////////////////////////////////////////
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"github.com/kr/pty"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+)
+
+const (
+	RED   = "\033[31m"
+	RESET = "\033[0m"
+)
+
+func main() {
+	fh, tty, _ := pty.Open()
+	defer tty.Close()
+	defer fh.Close()
+	c := exec.Command("go", "run", "multiselect.go")
+	c.Stdin = tty
+	c.Stdout = tty
+	c.Stderr = tty
+	c.Start()
+	buf := bufio.NewReaderSize(fh, 1024)
+
+	expect("standard\r\n", buf)
+	expect("\x1b[?25l\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte(" "))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte(" "))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[32m ◉ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte("\r"))
+	expect("\x1b[?25h\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\x1b[36m Monday, Friday\x1b[0m\r\n", buf)
+	expect("Answered [Monday Friday].\r\n", buf)
+	expect("---------------------\r\n", buf)
+	expect("default (sunday, tuesday)\r\n", buf)
+	expect("\x1b[?25l\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[32m ◉ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte(" "))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte(" "))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[32m ◉ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte(" "))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte(" "))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[32m ◉ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte("\r"))
+	expect("\x1b[?25h\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\x1b[36m Monday, Friday\x1b[0m\r\n", buf)
+	expect("Answered [Monday Friday].\r\n", buf)
+	expect("---------------------\r\n", buf)
+	expect("default not found\r\n", buf)
+	expect("\x1b[?25l\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte(" "))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte(" "))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[32m ◉ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte("\r"))
+	expect("\x1b[?25h\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\x1b[36m Monday, Friday\x1b[0m\r\n", buf)
+	expect("Answered [Monday Friday].\r\n", buf)
+	expect("---------------------\r\n", buf)
+	expect("no help - type ?\r\n", buf)
+	expect("\x1b[?25l\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte("?"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte(" "))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[1;99m ◯ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte(" "))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Sunday\r\n", buf)
+	expect(" \x1b[32m ◉ \x1b[0m Monday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Tuesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Wednesday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Thursday\r\n", buf)
+	expect("\x1b[36m❯\x1b[0m\x1b[32m ◉ \x1b[0m Friday\r\n", buf)
+	expect(" \x1b[1;99m ◯ \x1b[0m Saturday\r\n", buf)
+	fh.Write([]byte("\r"))
+	expect("\x1b[?25h\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat days do you prefer:\x1b[0m\x1b[36m Monday, Friday\x1b[0m\r\n", buf)
+	expect("Answered [Monday Friday].\r\n", buf)
+	expect("---------------------\r\n", buf)
+
+	c.Wait()
+	tty.Close()
+	fh.Close()
+}
+
+func expect(expected string, buf *bufio.Reader) {
+	sofar := []rune{}
+	for _, r := range expected {
+		got, _, _ := buf.ReadRune()
+		sofar = append(sofar, got)
+		if got != r {
+			fmt.Fprintln(os.Stderr, RESET)
+
+			// we want to quote the string but we also want to make the unexpected character RED
+			// so we use the strconv.Quote function but trim off the quoted characters so we can
+			// merge multiple quoted strings into one.
+			expStart := strings.TrimSuffix(strconv.Quote(expected[:len(sofar)-1]), "\"")
+			expMiss := strings.TrimSuffix(strings.TrimPrefix(strconv.Quote(string(expected[len(sofar)-1])), "\""), "\"")
+			expEnd := strings.TrimPrefix(strconv.Quote(expected[len(sofar):]), "\"")
+
+			fmt.Fprintf(os.Stderr, "Expected: %s%s%s%s%s\n", expStart, RED, expMiss, RESET, expEnd)
+
+			// read the rest of the buffer
+			p := make([]byte, buf.Buffered())
+			buf.Read(p)
+
+			gotStart := strings.TrimSuffix(strconv.Quote(string(sofar[:len(sofar)-1])), "\"")
+			gotMiss := strings.TrimSuffix(strings.TrimPrefix(strconv.Quote(string(sofar[len(sofar)-1])), "\""), "\"")
+			gotEnd := strings.TrimPrefix(strconv.Quote(string(p)), "\"")
+
+			fmt.Fprintf(os.Stderr, "Got:      %s%s%s%s%s\n", gotStart, RED, gotMiss, RESET, gotEnd)
+			panic(fmt.Errorf("Unexpected Rune %q, Expected %q\n", got, r))
+		} else {
+			fmt.Printf("%c", r)
+		}
+	}
+}

vendor/github.com/AlecAivazis/survey/tests/autoplay/password.go

@@ -0,0 +1,114 @@
+////////////////////////////////////////////////////////////////////////////////
+//                          DO NOT MODIFY THIS FILE!
+//
+//  This file was automatically generated via the commands:
+//
+//      go get github.com/coryb/autoplay
+//      autoplay -n autoplay/password.go go run password.go
+//
+////////////////////////////////////////////////////////////////////////////////
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"github.com/kr/pty"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+)
+
+const (
+	RED   = "\033[31m"
+	RESET = "\033[0m"
+)
+
+func main() {
+	fh, tty, _ := pty.Open()
+	defer tty.Close()
+	defer fh.Close()
+	c := exec.Command("go", "run", "password.go")
+	c.Stdin = tty
+	c.Stdout = tty
+	c.Stderr = tty
+	c.Start()
+	buf := bufio.NewReaderSize(fh, 1024)
+
+	expect("standard\r\n", buf)
+	expect("\x1b[1;92m? \x1b[0m\x1b[1;99mPlease type your password: \x1b[0m", buf)
+	fh.Write([]byte("f"))
+	expect("*", buf)
+	fh.Write([]byte("o"))
+	expect("*", buf)
+	fh.Write([]byte("o"))
+	expect("*", buf)
+	fh.Write([]byte("b"))
+	expect("*", buf)
+	fh.Write([]byte("a"))
+	expect("*", buf)
+	fh.Write([]byte("r"))
+	expect("*", buf)
+	fh.Write([]byte("\r"))
+	expect("\r\r\n", buf)
+	expect("Answered foobar.\r\n", buf)
+	expect("---------------------\r\n", buf)
+	expect("please make sure paste works\r\n", buf)
+	expect("\x1b[1;92m? \x1b[0m\x1b[1;99mPlease paste your password: \x1b[0m", buf)
+	fh.Write([]byte("f"))
+	fh.Write([]byte("o"))
+	fh.Write([]byte("o"))
+	fh.Write([]byte("b"))
+	fh.Write([]byte("a"))
+	fh.Write([]byte("r"))
+	expect("******", buf)
+	fh.Write([]byte("\r"))
+	expect("\r\r\n", buf)
+	expect("Answered foobar.\r\n", buf)
+	expect("---------------------\r\n", buf)
+	expect("no help, send '?'\r\n", buf)
+	expect("\x1b[1;92m? \x1b[0m\x1b[1;99mPlease type your password: \x1b[0m", buf)
+	fh.Write([]byte("?"))
+	expect("*", buf)
+	fh.Write([]byte("\r"))
+	expect("\r\r\n", buf)
+	expect("Answered ?.\r\n", buf)
+	expect("---------------------\r\n", buf)
+
+	c.Wait()
+	tty.Close()
+	fh.Close()
+}
+
+func expect(expected string, buf *bufio.Reader) {
+	sofar := []rune{}
+	for _, r := range expected {
+		got, _, _ := buf.ReadRune()
+		sofar = append(sofar, got)
+		if got != r {
+			fmt.Fprintln(os.Stderr, RESET)
+
+			// we want to quote the string but we also want to make the unexpected character RED
+			// so we use the strconv.Quote function but trim off the quoted characters so we can
+			// merge multiple quoted strings into one.
+			expStart := strings.TrimSuffix(strconv.Quote(expected[:len(sofar)-1]), "\"")
+			expMiss := strings.TrimSuffix(strings.TrimPrefix(strconv.Quote(string(expected[len(sofar)-1])), "\""), "\"")
+			expEnd := strings.TrimPrefix(strconv.Quote(expected[len(sofar):]), "\"")
+
+			fmt.Fprintf(os.Stderr, "Expected: %s%s%s%s%s\n", expStart, RED, expMiss, RESET, expEnd)
+
+			// read the rest of the buffer
+			p := make([]byte, buf.Buffered())
+			buf.Read(p)
+
+			gotStart := strings.TrimSuffix(strconv.Quote(string(sofar[:len(sofar)-1])), "\"")
+			gotMiss := strings.TrimSuffix(strings.TrimPrefix(strconv.Quote(string(sofar[len(sofar)-1])), "\""), "\"")
+			gotEnd := strings.TrimPrefix(strconv.Quote(string(p)), "\"")
+
+			fmt.Fprintf(os.Stderr, "Got:      %s%s%s%s%s\n", gotStart, RED, gotMiss, RESET, gotEnd)
+			panic(fmt.Errorf("Unexpected Rune %q, Expected %q\n", got, r))
+		} else {
+			fmt.Printf("%c", r)
+		}
+	}
+}

vendor/github.com/AlecAivazis/survey/tests/autoplay/select.go

@@ -0,0 +1,158 @@
+////////////////////////////////////////////////////////////////////////////////
+//                          DO NOT MODIFY THIS FILE!
+//
+//  This file was automatically generated via the commands:
+//
+//      go get github.com/coryb/autoplay
+//      autoplay -n autoplay/select.go go run select.go
+//
+////////////////////////////////////////////////////////////////////////////////
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"github.com/kr/pty"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+)
+
+const (
+	RED   = "\033[31m"
+	RESET = "\033[0m"
+)
+
+func main() {
+	fh, tty, _ := pty.Open()
+	defer tty.Close()
+	defer fh.Close()
+	c := exec.Command("go", "run", "select.go")
+	c.Stdin = tty
+	c.Stdout = tty
+	c.Stderr = tty
+	c.Start()
+	buf := bufio.NewReaderSize(fh, 1024)
+
+	expect("standard\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose a color:\x1b[0m\r\n", buf)
+	expect("\x1b[1;36m❯ red\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  blue\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  green\x1b[0m\r\n", buf)
+	expect("\x1b[?25l", buf)
+	fh.Write([]byte("\r"))
+	expect("\x1b[?25h\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose a color:\x1b[0m\x1b[36m red\x1b[0m\r\n", buf)
+	expect("Answered red.\r\n", buf)
+	expect("---------------------\r\n", buf)
+	expect("short\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose a color:\x1b[0m\r\n", buf)
+	expect("\x1b[1;36m❯ red\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  blue\x1b[0m\r\n", buf)
+	expect("\x1b[?25l", buf)
+	fh.Write([]byte("\r"))
+	expect("\x1b[?25h\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose a color:\x1b[0m\x1b[36m red\x1b[0m\r\n", buf)
+	expect("Answered red.\r\n", buf)
+	expect("---------------------\r\n", buf)
+	expect("default\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose a color (should default blue):\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  red\x1b[0m\r\n", buf)
+	expect("\x1b[1;36m❯ blue\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  green\x1b[0m\r\n", buf)
+	expect("\x1b[?25l", buf)
+	fh.Write([]byte("\r"))
+	expect("\x1b[?25h\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose a color (should default blue):\x1b[0m\x1b[36m blue\x1b[0m\r\n", buf)
+	expect("Answered blue.\r\n", buf)
+	expect("---------------------\r\n", buf)
+	expect("one\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose one:\x1b[0m\r\n", buf)
+	expect("\x1b[1;36m❯ hello\x1b[0m\r\n", buf)
+	expect("\x1b[?25l", buf)
+	fh.Write([]byte("\r"))
+	expect("\x1b[?25h\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose one:\x1b[0m\x1b[36m hello\x1b[0m\r\n", buf)
+	expect("Answered hello.\r\n", buf)
+	expect("---------------------\r\n", buf)
+	expect("no help, type ?\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose a color:\x1b[0m\r\n", buf)
+	expect("\x1b[1;36m❯ red\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  blue\x1b[0m\r\n", buf)
+	expect("\x1b[?25l", buf)
+	fh.Write([]byte("\r"))
+	expect("\x1b[?25h\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose a color:\x1b[0m\x1b[36m red\x1b[0m\r\n", buf)
+	expect("Answered red.\r\n", buf)
+	expect("---------------------\r\n", buf)
+	expect("passes through bottom\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose one:\x1b[0m\r\n", buf)
+	expect("\x1b[1;36m❯ red\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  blue\x1b[0m\r\n", buf)
+	expect("\x1b[?25l", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose one:\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  red\x1b[0m\r\n", buf)
+	expect("\x1b[1;36m❯ blue\x1b[0m\r\n", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose one:\x1b[0m\r\n", buf)
+	expect("\x1b[1;36m❯ red\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  blue\x1b[0m\r\n", buf)
+	fh.Write([]byte("\r"))
+	expect("\x1b[?25h\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose one:\x1b[0m\x1b[36m red\x1b[0m\r\n", buf)
+	expect("Answered red.\r\n", buf)
+	expect("---------------------\r\n", buf)
+	expect("passes through top\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose one:\x1b[0m\r\n", buf)
+	expect("\x1b[1;36m❯ red\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  blue\x1b[0m\r\n", buf)
+	expect("\x1b[?25l", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("A"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose one:\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  red\x1b[0m\r\n", buf)
+	expect("\x1b[1;36m❯ blue\x1b[0m\r\n", buf)
+	fh.Write([]byte("\r"))
+	expect("\x1b[?25h\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose one:\x1b[0m\x1b[36m blue\x1b[0m\r\n", buf)
+	expect("Answered blue.\r\n", buf)
+	expect("---------------------\r\n", buf)
+	expect("no options\r\n", buf)
+
+	c.Wait()
+	tty.Close()
+	fh.Close()
+}
+
+func expect(expected string, buf *bufio.Reader) {
+	sofar := []rune{}
+	for _, r := range expected {
+		got, _, _ := buf.ReadRune()
+		sofar = append(sofar, got)
+		if got != r {
+			fmt.Fprintln(os.Stderr, RESET)
+
+			// we want to quote the string but we also want to make the unexpected character RED
+			// so we use the strconv.Quote function but trim off the quoted characters so we can
+			// merge multiple quoted strings into one.
+			expStart := strings.TrimSuffix(strconv.Quote(expected[:len(sofar)-1]), "\"")
+			expMiss := strings.TrimSuffix(strings.TrimPrefix(strconv.Quote(string(expected[len(sofar)-1])), "\""), "\"")
+			expEnd := strings.TrimPrefix(strconv.Quote(expected[len(sofar):]), "\"")
+
+			fmt.Fprintf(os.Stderr, "Expected: %s%s%s%s%s\n", expStart, RED, expMiss, RESET, expEnd)
+
+			// read the rest of the buffer
+			p := make([]byte, buf.Buffered())
+			buf.Read(p)
+
+			gotStart := strings.TrimSuffix(strconv.Quote(string(sofar[:len(sofar)-1])), "\"")
+			gotMiss := strings.TrimSuffix(strings.TrimPrefix(strconv.Quote(string(sofar[len(sofar)-1])), "\""), "\"")
+			gotEnd := strings.TrimPrefix(strconv.Quote(string(p)), "\"")
+
+			fmt.Fprintf(os.Stderr, "Got:      %s%s%s%s%s\n", gotStart, RED, gotMiss, RESET, gotEnd)
+			panic(fmt.Errorf("Unexpected Rune %q, Expected %q\n", got, r))
+		} else {
+			fmt.Printf("%c", r)
+		}
+	}
+}

vendor/github.com/AlecAivazis/survey/tests/autoplay/selectThenInput.go

@@ -0,0 +1,114 @@
+////////////////////////////////////////////////////////////////////////////////
+//                          DO NOT MODIFY THIS FILE!
+//
+//  This file was automatically generated via the commands:
+//
+//      go get github.com/coryb/autoplay
+//      autoplay -n autoplay/selectThenInput.go go run selectThenInput.go
+//
+////////////////////////////////////////////////////////////////////////////////
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"github.com/kr/pty"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+)
+
+const (
+	RED   = "\033[31m"
+	RESET = "\033[0m"
+)
+
+func main() {
+	fh, tty, _ := pty.Open()
+	defer tty.Close()
+	defer fh.Close()
+	c := exec.Command("go", "run", "selectThenInput.go")
+	c.Stdin = tty
+	c.Stdout = tty
+	c.Stderr = tty
+	c.Start()
+	buf := bufio.NewReaderSize(fh, 1024)
+
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose a color:\x1b[0m\r\n", buf)
+	expect("\x1b[1;36m❯ red\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  blue\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  green\x1b[0m\r\n", buf)
+	expect("\x1b[?25l", buf)
+	fh.Write([]byte("\x1b"))
+	fh.Write([]byte("["))
+	fh.Write([]byte("B"))
+	expect("\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose a color:\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  red\x1b[0m\r\n", buf)
+	expect("\x1b[1;36m❯ blue\x1b[0m\r\n", buf)
+	expect("\x1b[1;99m  green\x1b[0m\r\n", buf)
+	fh.Write([]byte("\r"))
+	expect("\x1b[?25h\x1b[0G\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1F\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mChoose a color:\x1b[0m\x1b[36m blue\x1b[0m\r\n", buf)
+	expect("\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat is your name? \x1b[0m", buf)
+	fh.Write([]byte("L"))
+	expect("L", buf)
+	fh.Write([]byte("a"))
+	expect("a", buf)
+	fh.Write([]byte("r"))
+	expect("r", buf)
+	fh.Write([]byte("r"))
+	expect("r", buf)
+	fh.Write([]byte("y"))
+	expect("y", buf)
+	fh.Write([]byte(" "))
+	expect(" ", buf)
+	fh.Write([]byte("W"))
+	expect("W", buf)
+	fh.Write([]byte("a"))
+	expect("a", buf)
+	fh.Write([]byte("l"))
+	expect("l", buf)
+	fh.Write([]byte("l"))
+	expect("l", buf)
+	fh.Write([]byte("\r"))
+	expect("\r\r\n", buf)
+	expect("\x1b[1F\x1b[0G\x1b[2K\x1b[1;92m? \x1b[0m\x1b[1;99mWhat is your name? \x1b[0m\x1b[36mLarry Wall\x1b[0m\r\n", buf)
+	expect("Larry Wall chose blue.\r\n", buf)
+
+	c.Wait()
+	tty.Close()
+	fh.Close()
+}
+
+func expect(expected string, buf *bufio.Reader) {
+	sofar := []rune{}
+	for _, r := range expected {
+		got, _, _ := buf.ReadRune()
+		sofar = append(sofar, got)
+		if got != r {
+			fmt.Fprintln(os.Stderr, RESET)
+
+			// we want to quote the string but we also want to make the unexpected character RED
+			// so we use the strconv.Quote function but trim off the quoted characters so we can
+			// merge multiple quoted strings into one.
+			expStart := strings.TrimSuffix(strconv.Quote(expected[:len(sofar)-1]), "\"")
+			expMiss := strings.TrimSuffix(strings.TrimPrefix(strconv.Quote(string(expected[len(sofar)-1])), "\""), "\"")
+			expEnd := strings.TrimPrefix(strconv.Quote(expected[len(sofar):]), "\"")
+
+			fmt.Fprintf(os.Stderr, "Expected: %s%s%s%s%s\n", expStart, RED, expMiss, RESET, expEnd)
+
+			// read the rest of the buffer
+			p := make([]byte, buf.Buffered())
+			buf.Read(p)
+
+			gotStart := strings.TrimSuffix(strconv.Quote(string(sofar[:len(sofar)-1])), "\"")
+			gotMiss := strings.TrimSuffix(strings.TrimPrefix(strconv.Quote(string(sofar[len(sofar)-1])), "\""), "\"")
+			gotEnd := strings.TrimPrefix(strconv.Quote(string(p)), "\"")
+
+			fmt.Fprintf(os.Stderr, "Got:      %s%s%s%s%s\n", gotStart, RED, gotMiss, RESET, gotEnd)
+			panic(fmt.Errorf("Unexpected Rune %q, Expected %q\n", got, r))
+		} else {
+			fmt.Printf("%c", r)
+		}
+	}
+}

vendor/github.com/AlecAivazis/survey/tests/confirm.go

@@ -0,0 +1,43 @@
+package main
+
+import (
+	"github.com/AlecAivazis/survey"
+	"github.com/AlecAivazis/survey/tests/util"
+)
+
+var answer = false
+
+var goodTable = []TestUtil.TestTableEntry{
+	{
+		"Enter 'yes'", &survey.Confirm{
+			Message: "yes:",
+		}, &answer,
+	},
+	{
+		"Enter 'no'", &survey.Confirm{
+			Message: "yes:",
+		}, &answer,
+	},
+	{
+		"default", &survey.Confirm{
+			Message: "yes:",
+			Default: true,
+		}, &answer,
+	},
+	{
+		"not recognized (enter random letter)", &survey.Confirm{
+			Message: "yes:",
+			Default: true,
+		}, &answer,
+	},
+	{
+		"no help - type '?'", &survey.Confirm{
+			Message: "yes:",
+			Default: true,
+		}, &answer,
+	},
+}
+
+func main() {
+	TestUtil.RunTable(goodTable)
+}

vendor/github.com/AlecAivazis/survey/tests/doubleSelect.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/AlecAivazis/survey"
+)
+
+var simpleQs = []*survey.Question{
+	{
+		Name: "color",
+		Prompt: &survey.Select{
+			Message: "select1:",
+			Options: []string{"red", "blue", "green"},
+		},
+		Validate: survey.Required,
+	},
+	{
+		Name: "color2",
+		Prompt: &survey.Select{
+			Message: "select2:",
+			Options: []string{"red", "blue", "green"},
+		},
+		Validate: survey.Required,
+	},
+}
+
+func main() {
+	answers := struct {
+		Color  string
+		Color2 string
+	}{}
+	// ask the question
+	err := survey.Ask(simpleQs, &answers)
+
+	if err != nil {
+		fmt.Println(err.Error())
+		return
+	}
+	// print the answers
+	fmt.Printf("%s and %s.\n", answers.Color, answers.Color2)
+}

vendor/github.com/AlecAivazis/survey/tests/help.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+	"github.com/AlecAivazis/survey"
+	"github.com/AlecAivazis/survey/tests/util"
+)
+
+var (
+	confirmAns     = false
+	inputAns       = ""
+	multiselectAns = []string{}
+	selectAns      = ""
+	passwordAns    = ""
+)
+
+var goodTable = []TestUtil.TestTableEntry{
+	{
+		"confirm", &survey.Confirm{
+			Message: "Is it raining?",
+			Help:    "Go outside, if your head becomes wet the answer is probably 'yes'",
+		}, &confirmAns,
+	},
+	{
+		"input", &survey.Input{
+			Message: "What is your phone number:",
+			Help:    "Phone number should include the area code, parentheses optional",
+		}, &inputAns,
+	},
+	{
+		"select", &survey.MultiSelect{
+			Message: "What days are you available:",
+			Help:    "We are closed weekends and avaibility is limited on Wednesday",
+			Options: []string{"Monday", "Tuesday", "Wednesday", "Thursday", "Friday"},
+			Default: []string{"Monday", "Tuesday", "Thursday", "Friday"},
+		}, &multiselectAns,
+	},
+	{
+		"select", &survey.Select{
+			Message: "Choose a color:",
+			Help:    "Blue is the best color, but it is your choice",
+			Options: []string{"red", "blue", "green"},
+			Default: "blue",
+		}, &selectAns,
+	},
+	{
+		"password", &survey.Password{
+			Message: "Enter a secret:",
+			Help:    "Don't really enter a secret, this is just for testing",
+		}, &passwordAns,
+	},
+}
+
+func main() {
+	TestUtil.RunTable(goodTable)
+}

vendor/github.com/AlecAivazis/survey/tests/input.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"github.com/AlecAivazis/survey"
+	"github.com/AlecAivazis/survey/tests/util"
+)
+
+var val = ""
+
+var table = []TestUtil.TestTableEntry{
+	{
+		"no default", &survey.Input{Message: "Hello world"}, &val,
+	},
+	{
+		"default", &survey.Input{Message: "Hello world", Default: "default"}, &val,
+	},
+	{
+		"no help, send '?'", &survey.Input{Message: "Hello world"}, &val,
+	},
+	{
+		"input text in random location", &survey.Input{Message: "Hello"}, &val,
+	},
+}
+
+func main() {
+	TestUtil.RunTable(table)
+}

vendor/github.com/AlecAivazis/survey/tests/longSelect.go

@@ -0,0 +1,23 @@
+package main
+
+import "github.com/AlecAivazis/survey"
+
+func main() {
+	color := ""
+	prompt := &survey.Select{
+		Message: "Choose a color:",
+		Options: []string{
+			"a",
+			"b",
+			"c",
+			"d",
+			"e",
+			"f",
+			"g",
+			"h",
+			"i",
+			"j",
+		},
+	}
+	survey.AskOne(prompt, &color, nil)
+}

vendor/github.com/AlecAivazis/survey/tests/multiselect.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"github.com/AlecAivazis/survey"
+	"github.com/AlecAivazis/survey/tests/util"
+)
+
+var answer = []string{}
+
+var table = []TestUtil.TestTableEntry{
+	{
+		"standard", &survey.MultiSelect{
+			Message: "What days do you prefer:",
+			Options: []string{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"},
+		}, &answer,
+	},
+	{
+		"default (sunday, tuesday)", &survey.MultiSelect{
+			Message: "What days do you prefer:",
+			Options: []string{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"},
+			Default: []string{"Sunday", "Tuesday"},
+		}, &answer,
+	},
+	{
+		"default not found", &survey.MultiSelect{
+			Message: "What days do you prefer:",
+			Options: []string{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"},
+			Default: []string{"Sundayaa"},
+		}, &answer,
+	},
+	{
+		"no help - type ?", &survey.MultiSelect{
+			Message: "What days do you prefer:",
+			Options: []string{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"},
+			Default: []string{"Sundayaa"},
+		}, &answer,
+	},
+}
+
+func main() {
+	TestUtil.RunTable(table)
+}

vendor/github.com/AlecAivazis/survey/tests/password.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"github.com/AlecAivazis/survey"
+	"github.com/AlecAivazis/survey/tests/util"
+)
+
+var value = ""
+
+var table = []TestUtil.TestTableEntry{
+	{
+		"standard", &survey.Password{Message: "Please type your password:"}, &value,
+	},
+	{
+		"please make sure paste works", &survey.Password{Message: "Please paste your password:"}, &value,
+	},
+	{
+		"no help, send '?'", &survey.Password{Message: "Please type your password:"}, &value,
+	},
+}
+
+func main() {
+	TestUtil.RunTable(table)
+}

vendor/github.com/AlecAivazis/survey/tests/select.go

@@ -0,0 +1,67 @@
+package main
+
+import (
+	"github.com/AlecAivazis/survey"
+	"github.com/AlecAivazis/survey/tests/util"
+)
+
+var answer = ""
+
+var goodTable = []TestUtil.TestTableEntry{
+	{
+		"standard", &survey.Select{
+			Message: "Choose a color:",
+			Options: []string{"red", "blue", "green"},
+		}, &answer,
+	},
+	{
+		"short", &survey.Select{
+			Message: "Choose a color:",
+			Options: []string{"red", "blue"},
+		}, &answer,
+	},
+	{
+		"default", &survey.Select{
+			Message: "Choose a color (should default blue):",
+			Options: []string{"red", "blue", "green"},
+			Default: "blue",
+		}, &answer,
+	},
+	{
+		"one", &survey.Select{
+			Message: "Choose one:",
+			Options: []string{"hello"},
+		}, &answer,
+	},
+	{
+		"no help, type ?", &survey.Select{
+			Message: "Choose a color:",
+			Options: []string{"red", "blue"},
+		}, &answer,
+	},
+	{
+		"passes through bottom", &survey.Select{
+			Message: "Choose one:",
+			Options: []string{"red", "blue"},
+		}, &answer,
+	},
+	{
+		"passes through top", &survey.Select{
+			Message: "Choose one:",
+			Options: []string{"red", "blue"},
+		}, &answer,
+	},
+}
+
+var badTable = []TestUtil.TestTableEntry{
+	{
+		"no options", &survey.Select{
+			Message: "Choose one:",
+		}, &answer,
+	},
+}
+
+func main() {
+	TestUtil.RunTable(goodTable)
+	TestUtil.RunErrorTable(badTable)
+}

vendor/github.com/AlecAivazis/survey/tests/selectThenInput.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/AlecAivazis/survey"
+)
+
+// the questions to ask
+var simpleQs = []*survey.Question{
+	{
+		Name: "color",
+		Prompt: &survey.Select{
+			Message: "Choose a color:",
+			Options: []string{"red", "blue", "green"},
+		},
+		Validate: survey.Required,
+	},
+	{
+		Name: "name",
+		Prompt: &survey.Input{
+			Message: "What is your name?",
+		},
+		Validate: survey.Required,
+	},
+}
+
+func main() {
+	answers := struct {
+		Color string
+		Name  string
+	}{}
+	// ask the question
+	err := survey.Ask(simpleQs, &answers)
+
+	if err != nil {
+		fmt.Println(err.Error())
+		return
+	}
+	// print the answers
+	fmt.Printf("%s chose %s.\n", answers.Name, answers.Color)
+}

vendor/github.com/AlecAivazis/survey/tests/util/test.go

@@ -0,0 +1,50 @@
+package TestUtil
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/AlecAivazis/survey"
+)
+
+type TestTableEntry struct {
+	Name   string
+	Prompt survey.Prompt
+	Value  interface{}
+}
+
+func formatAnswer(ans interface{}) {
+	// show the answer to the user
+	fmt.Printf("Answered %v.\n", reflect.ValueOf(ans).Elem())
+	fmt.Println("---------------------")
+}
+
+func RunTable(table []TestTableEntry) {
+	// go over every entry in the table
+	for _, entry := range table {
+		// tell the user what we are going to ask them
+		fmt.Println(entry.Name)
+		// perform the ask
+		err := survey.AskOne(entry.Prompt, entry.Value, nil)
+		if err != nil {
+			fmt.Printf("AskOne on %v's prompt failed: %v.", entry.Name, err.Error())
+			break
+		}
+		// show the answer to the user
+		formatAnswer(entry.Value)
+	}
+}
+
+func RunErrorTable(table []TestTableEntry) {
+	// go over every entry in the table
+	for _, entry := range table {
+		// tell the user what we are going to ask them
+		fmt.Println(entry.Name)
+		// perform the ask
+		err := survey.AskOne(entry.Prompt, entry.Value, nil)
+		if err == nil {
+			fmt.Printf("AskOne on %v's prompt didn't fail.", entry.Name)
+			break
+		}
+	}
+}

vendor/github.com/AlecAivazis/survey/validate.go

@@ -0,0 +1,84 @@
+package survey
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+)
+
+// Required does not allow an empty value
+func Required(val interface{}) error {
+	// if the value passed in is the zero value of the appropriate type
+	if isZero(reflect.ValueOf(val)) {
+		return errors.New("Value is required")
+	}
+	return nil
+}
+
+// MaxLength requires that the string is no longer than the specified value
+func MaxLength(length int) Validator {
+	// return a validator that checks the length of the string
+	return func(val interface{}) error {
+		if str, ok := val.(string); ok {
+			// if the string is longer than the given value
+			if len(str) > length {
+				// yell loudly
+				return fmt.Errorf("value is too long. Max length is %v", length)
+			}
+		} else {
+			// otherwise we cannot convert the value into a string and cannot enforce length
+			return fmt.Errorf("cannot enforce length on response of type %v", reflect.TypeOf(val).Name())
+		}
+
+		// the input is fine
+		return nil
+	}
+}
+
+// MinLength requires that the string is longer or equal in length to the specified value
+func MinLength(length int) Validator {
+	// return a validator that checks the length of the string
+	return func(val interface{}) error {
+		if str, ok := val.(string); ok {
+			// if the string is shorter than the given value
+			if len(str) < length {
+				// yell loudly
+				return fmt.Errorf("value is too short. Min length is %v", length)
+			}
+		} else {
+			// otherwise we cannot convert the value into a string and cannot enforce length
+			return fmt.Errorf("cannot enforce length on response of type %v", reflect.TypeOf(val).Name())
+		}
+
+		// the input is fine
+		return nil
+	}
+}
+
+// ComposeValidators is a variadic function used to create one validator from many.
+func ComposeValidators(validators ...Validator) Validator {
+	// return a validator that calls each one sequentially
+	return func(val interface{}) error {
+		// execute each validator
+		for _, validator := range validators {
+			// if the string is not valid
+			if err := validator(val); err != nil {
+				// return the error
+				return err
+			}
+		}
+		// we passed all validators, the string is valid
+		return nil
+	}
+}
+
+// isZero returns true if the passed value is the zero object
+func isZero(v reflect.Value) bool {
+	switch v.Kind() {
+	case reflect.Slice, reflect.Map:
+		return v.Len() == 0
+	}
+
+	// compare the types directly with more general coverage
+	return reflect.DeepEqual(v.Interface(), reflect.Zero(v.Type()).Interface())
+}

vendor/github.com/AlecAivazis/survey/validate_test.go

@@ -0,0 +1,151 @@
+package survey
+
+import (
+	"math/rand"
+	"testing"
+)
+
+func TestRequired_canSucceedOnPrimitiveTypes(t *testing.T) {
+	// a string to test
+	str := "hello"
+	// if the string is not valid
+	if valid := Required(str); valid != nil {
+		//
+		t.Error("Non null returned an error when one wasn't expected.")
+	}
+}
+
+func TestRequired_canFailOnPrimitiveTypes(t *testing.T) {
+	// a string to test
+	str := ""
+	// if the string is valid
+	if notValid := Required(str); notValid == nil {
+		//
+		t.Error("Non null did not return an error when one was expected.")
+	}
+}
+
+func TestRequired_canSucceedOnMap(t *testing.T) {
+	// an non-empty map to test
+	val := map[string]int{"hello": 1}
+	// if the string is not valid
+	if valid := Required(val); valid != nil {
+		//
+		t.Error("Non null returned an error when one wasn't expected.")
+	}
+}
+
+func TestRequired_canFailOnMap(t *testing.T) {
+	// an non-empty map to test
+	val := map[string]int{}
+	// if the string is valid
+	if notValid := Required(val); notValid == nil {
+		//
+		t.Error("Non null did not return an error when one was expected.")
+	}
+}
+
+func TestRequired_canSucceedOnLists(t *testing.T) {
+	// a string to test
+	str := []string{"hello"}
+	// if the string is not valid
+	if valid := Required(str); valid != nil {
+		//
+		t.Error("Non null returned an error when one wasn't expected.")
+	}
+}
+
+func TestRequired_canFailOnLists(t *testing.T) {
+	// a string to test
+	str := []string{}
+	// if the string is not valid
+	if notValid := Required(str); notValid == nil {
+		//
+		t.Error("Non null did not return an error when one was expected.")
+	}
+}
+
+const letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+func randString(n int) string {
+	b := make([]byte, n)
+	for i := range b {
+		b[i] = letterBytes[rand.Int63()%int64(len(letterBytes))]
+	}
+	return string(b)
+}
+
+func TestMaxLength(t *testing.T) {
+	// the string to test
+	testStr := randString(150)
+	// validate the string
+	if err := MaxLength(140)(testStr); err == nil {
+		t.Error("No error returned with input greater than 150 characters.")
+	}
+}
+
+func TestMinLength(t *testing.T) {
+	// validate the string
+	if err := MinLength(12)(randString(10)); err == nil {
+		t.Error("No error returned with input less than 12 characters.")
+	}
+}
+
+func TestMinLength_onInt(t *testing.T) {
+	// validate the string
+	if err := MinLength(12)(1); err == nil {
+		t.Error("No error returned when enforcing length on int.")
+	}
+}
+
+func TestMaxLength_onInt(t *testing.T) {
+	// validate the string
+	if err := MaxLength(12)(1); err == nil {
+		t.Error("No error returned when enforcing length on int.")
+	}
+}
+
+func TestComposeValidators_passes(t *testing.T) {
+	// create a validator that requires a string of no more than 10 characters
+	valid := ComposeValidators(
+		Required,
+		MaxLength(10),
+	)
+
+	str := randString(12)
+	// if a valid string fails
+	if err := valid(str); err == nil {
+		// the test failed
+		t.Error("Composed validator did not pass. Wanted string less than 10 chars, passed in", str)
+	}
+
+}
+
+func TestComposeValidators_failsOnFirstError(t *testing.T) {
+	// create a validator that requires a string of no more than 10 characters
+	valid := ComposeValidators(
+		Required,
+		MaxLength(10),
+	)
+
+	// if an empty string passes
+	if err := valid(""); err == nil {
+		// the test failed
+		t.Error("Composed validator did not fail on first test like expected.")
+	}
+}
+
+func TestComposeValidators_failsOnSubsequentValidators(t *testing.T) {
+	// create a validator that requires a string of no more than 10 characters
+	valid := ComposeValidators(
+		Required,
+		MaxLength(10),
+	)
+
+	str := randString(12)
+	// if a string longer than 10 passes
+	if err := valid(str); err == nil {
+		// the test failed
+		t.Error("Composed validator did not fail on second first test like expected. Should fail max length > 10 :", str)
+	}
+}

vendor/github.com/alecthomas/template/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2012 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/github.com/alecthomas/template/README.md

@@ -0,0 +1,25 @@
+# Go's `text/template` package with newline elision
+
+This is a fork of Go 1.4's [text/template](http://golang.org/pkg/text/template/) package with one addition: a backslash immediately after a closing delimiter will delete all subsequent newlines until a non-newline.
+
+eg.
+
+```
+{{if true}}\
+hello
+{{end}}\
+```
+
+Will result in:
+
+```
+hello\n
+```
+
+Rather than:
+
+```
+\n
+hello\n
+\n
+```

vendor/github.com/alecthomas/template/doc.go

@@ -0,0 +1,406 @@
+// 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.
+
+/*
+Package template implements data-driven templates for generating textual output.
+
+To generate HTML output, see package html/template, which has the same interface
+as this package but automatically secures HTML output against certain attacks.
+
+Templates are executed by applying them to a data structure. Annotations in the
+template refer to elements of the data structure (typically a field of a struct
+or a key in a map) to control execution and derive values to be displayed.
+Execution of the template walks the structure and sets the cursor, represented
+by a period '.' and called "dot", to the value at the current location in the
+structure as execution proceeds.
+
+The input text for a template is UTF-8-encoded text in any format.
+"Actions"--data evaluations or control structures--are delimited by
+"{{" and "}}"; all text outside actions is copied to the output unchanged.
+Actions may not span newlines, although comments can.
+
+Once parsed, a template may be executed safely in parallel.
+
+Here is a trivial example that prints "17 items are made of wool".
+
+	type Inventory struct {
+		Material string
+		Count    uint
+	}
+	sweaters := Inventory{"wool", 17}
+	tmpl, err := template.New("test").Parse("{{.Count}} items are made of {{.Material}}")
+	if err != nil { panic(err) }
+	err = tmpl.Execute(os.Stdout, sweaters)
+	if err != nil { panic(err) }
+
+More intricate examples appear below.
+
+Actions
+
+Here is the list of actions. "Arguments" and "pipelines" are evaluations of
+data, defined in detail below.
+
+*/
+//	{{/* a comment */}}
+//		A comment; discarded. May contain newlines.
+//		Comments do not nest and must start and end at the
+//		delimiters, as shown here.
+/*
+
+	{{pipeline}}
+		The default textual representation of the value of the pipeline
+		is copied to the output.
+
+	{{if pipeline}} T1 {{end}}
+		If the value of the pipeline is empty, no output is generated;
+		otherwise, T1 is executed.  The empty values are false, 0, any
+		nil pointer or interface value, and any array, slice, map, or
+		string of length zero.
+		Dot is unaffected.
+
+	{{if pipeline}} T1 {{else}} T0 {{end}}
+		If the value of the pipeline is empty, T0 is executed;
+		otherwise, T1 is executed.  Dot is unaffected.
+
+	{{if pipeline}} T1 {{else if pipeline}} T0 {{end}}
+		To simplify the appearance of if-else chains, the else action
+		of an if may include another if directly; the effect is exactly
+		the same as writing
+			{{if pipeline}} T1 {{else}}{{if pipeline}} T0 {{end}}{{end}}
+
+	{{range pipeline}} T1 {{end}}
+		The value of the pipeline must be an array, slice, map, or channel.
+		If the value of the pipeline has length zero, nothing is output;
+		otherwise, dot is set to the successive elements of the array,
+		slice, or map and T1 is executed. If the value is a map and the
+		keys are of basic type with a defined order ("comparable"), the
+		elements will be visited in sorted key order.
+
+	{{range pipeline}} T1 {{else}} T0 {{end}}
+		The value of the pipeline must be an array, slice, map, or channel.
+		If the value of the pipeline has length zero, dot is unaffected and
+		T0 is executed; otherwise, dot is set to the successive elements
+		of the array, slice, or map and T1 is executed.
+
+	{{template "name"}}
+		The template with the specified name is executed with nil data.
+
+	{{template "name" pipeline}}
+		The template with the specified name is executed with dot set
+		to the value of the pipeline.
+
+	{{with pipeline}} T1 {{end}}
+		If the value of the pipeline is empty, no output is generated;
+		otherwise, dot is set to the value of the pipeline and T1 is
+		executed.
+
+	{{with pipeline}} T1 {{else}} T0 {{end}}
+		If the value of the pipeline is empty, dot is unaffected and T0
+		is executed; otherwise, dot is set to the value of the pipeline
+		and T1 is executed.
+
+Arguments
+
+An argument is a simple value, denoted by one of the following.
+
+	- A boolean, string, character, integer, floating-point, imaginary
+	  or complex constant in Go syntax. These behave like Go's untyped
+	  constants, although raw strings may not span newlines.
+	- The keyword nil, representing an untyped Go nil.
+	- The character '.' (period):
+		.
+	  The result is the value of dot.
+	- A variable name, which is a (possibly empty) alphanumeric string
+	  preceded by a dollar sign, such as
+		$piOver2
+	  or
+		$
+	  The result is the value of the variable.
+	  Variables are described below.
+	- The name of a field of the data, which must be a struct, preceded
+	  by a period, such as
+		.Field
+	  The result is the value of the field. Field invocations may be
+	  chained:
+	    .Field1.Field2
+	  Fields can also be evaluated on variables, including chaining:
+	    $x.Field1.Field2
+	- The name of a key of the data, which must be a map, preceded
+	  by a period, such as
+		.Key
+	  The result is the map element value indexed by the key.
+	  Key invocations may be chained and combined with fields to any
+	  depth:
+	    .Field1.Key1.Field2.Key2
+	  Although the key must be an alphanumeric identifier, unlike with
+	  field names they do not need to start with an upper case letter.
+	  Keys can also be evaluated on variables, including chaining:
+	    $x.key1.key2
+	- The name of a niladic method of the data, preceded by a period,
+	  such as
+		.Method
+	  The result is the value of invoking the method with dot as the
+	  receiver, dot.Method(). Such a method must have one return value (of
+	  any type) or two return values, the second of which is an error.
+	  If it has two and the returned error is non-nil, execution terminates
+	  and an error is returned to the caller as the value of Execute.
+	  Method invocations may be chained and combined with fields and keys
+	  to any depth:
+	    .Field1.Key1.Method1.Field2.Key2.Method2
+	  Methods can also be evaluated on variables, including chaining:
+	    $x.Method1.Field
+	- The name of a niladic function, such as
+		fun
+	  The result is the value of invoking the function, fun(). The return
+	  types and values behave as in methods. Functions and function
+	  names are described below.
+	- A parenthesized instance of one the above, for grouping. The result
+	  may be accessed by a field or map key invocation.
+		print (.F1 arg1) (.F2 arg2)
+		(.StructValuedMethod "arg").Field
+
+Arguments may evaluate to any type; if they are pointers the implementation
+automatically indirects to the base type when required.
+If an evaluation yields a function value, such as a function-valued
+field of a struct, the function is not invoked automatically, but it
+can be used as a truth value for an if action and the like. To invoke
+it, use the call function, defined below.
+
+A pipeline is a possibly chained sequence of "commands". A command is a simple
+value (argument) or a function or method call, possibly with multiple arguments:
+
+	Argument
+		The result is the value of evaluating the argument.
+	.Method [Argument...]
+		The method can be alone or the last element of a chain but,
+		unlike methods in the middle of a chain, it can take arguments.
+		The result is the value of calling the method with the
+		arguments:
+			dot.Method(Argument1, etc.)
+	functionName [Argument...]
+		The result is the value of calling the function associated
+		with the name:
+			function(Argument1, etc.)
+		Functions and function names are described below.
+
+Pipelines
+
+A pipeline may be "chained" by separating a sequence of commands with pipeline
+characters '|'. In a chained pipeline, the result of the each command is
+passed as the last argument of the following command. The output of the final
+command in the pipeline is the value of the pipeline.
+
+The output of a command will be either one value or two values, the second of
+which has type error. If that second value is present and evaluates to
+non-nil, execution terminates and the error is returned to the caller of
+Execute.
+
+Variables
+
+A pipeline inside an action may initialize a variable to capture the result.
+The initialization has syntax
+
+	$variable := pipeline
+
+where $variable is the name of the variable. An action that declares a
+variable produces no output.
+
+If a "range" action initializes a variable, the variable is set to the
+successive elements of the iteration.  Also, a "range" may declare two
+variables, separated by a comma:
+
+	range $index, $element := pipeline
+
+in which case $index and $element are set to the successive values of the
+array/slice index or map key and element, respectively.  Note that if there is
+only one variable, it is assigned the element; this is opposite to the
+convention in Go range clauses.
+
+A variable's scope extends to the "end" action of the control structure ("if",
+"with", or "range") in which it is declared, or to the end of the template if
+there is no such control structure.  A template invocation does not inherit
+variables from the point of its invocation.
+
+When execution begins, $ is set to the data argument passed to Execute, that is,
+to the starting value of dot.
+
+Examples
+
+Here are some example one-line templates demonstrating pipelines and variables.
+All produce the quoted word "output":
+
+	{{"\"output\""}}
+		A string constant.
+	{{`"output"`}}
+		A raw string constant.
+	{{printf "%q" "output"}}
+		A function call.
+	{{"output" | printf "%q"}}
+		A function call whose final argument comes from the previous
+		command.
+	{{printf "%q" (print "out" "put")}}
+		A parenthesized argument.
+	{{"put" | printf "%s%s" "out" | printf "%q"}}
+		A more elaborate call.
+	{{"output" | printf "%s" | printf "%q"}}
+		A longer chain.
+	{{with "output"}}{{printf "%q" .}}{{end}}
+		A with action using dot.
+	{{with $x := "output" | printf "%q"}}{{$x}}{{end}}
+		A with action that creates and uses a variable.
+	{{with $x := "output"}}{{printf "%q" $x}}{{end}}
+		A with action that uses the variable in another action.
+	{{with $x := "output"}}{{$x | printf "%q"}}{{end}}
+		The same, but pipelined.
+
+Functions
+
+During execution functions are found in two function maps: first in the
+template, then in the global function map. By default, no functions are defined
+in the template but the Funcs method can be used to add them.
+
+Predefined global functions are named as follows.
+
+	and
+		Returns the boolean AND of its arguments by returning the
+		first empty argument or the last argument, that is,
+		"and x y" behaves as "if x then y else x". All the
+		arguments are evaluated.
+	call
+		Returns the result of calling the first argument, which
+		must be a function, with the remaining arguments as parameters.
+		Thus "call .X.Y 1 2" is, in Go notation, dot.X.Y(1, 2) where
+		Y is a func-valued field, map entry, or the like.
+		The first argument must be the result of an evaluation
+		that yields a value of function type (as distinct from
+		a predefined function such as print). The function must
+		return either one or two result values, the second of which
+		is of type error. If the arguments don't match the function
+		or the returned error value is non-nil, execution stops.
+	html
+		Returns the escaped HTML equivalent of the textual
+		representation of its arguments.
+	index
+		Returns the result of indexing its first argument by the
+		following arguments. Thus "index x 1 2 3" is, in Go syntax,
+		x[1][2][3]. Each indexed item must be a map, slice, or array.
+	js
+		Returns the escaped JavaScript equivalent of the textual
+		representation of its arguments.
+	len
+		Returns the integer length of its argument.
+	not
+		Returns the boolean negation of its single argument.
+	or
+		Returns the boolean OR of its arguments by returning the
+		first non-empty argument or the last argument, that is,
+		"or x y" behaves as "if x then x else y". All the
+		arguments are evaluated.
+	print
+		An alias for fmt.Sprint
+	printf
+		An alias for fmt.Sprintf
+	println
+		An alias for fmt.Sprintln
+	urlquery
+		Returns the escaped value of the textual representation of
+		its arguments in a form suitable for embedding in a URL query.
+
+The boolean functions take any zero value to be false and a non-zero
+value to be true.
+
+There is also a set of binary comparison operators defined as
+functions:
+
+	eq
+		Returns the boolean truth of arg1 == arg2
+	ne
+		Returns the boolean truth of arg1 != arg2
+	lt
+		Returns the boolean truth of arg1 < arg2
+	le
+		Returns the boolean truth of arg1 <= arg2
+	gt
+		Returns the boolean truth of arg1 > arg2
+	ge
+		Returns the boolean truth of arg1 >= arg2
+
+For simpler multi-way equality tests, eq (only) accepts two or more
+arguments and compares the second and subsequent to the first,
+returning in effect
+
+	arg1==arg2 || arg1==arg3 || arg1==arg4 ...
+
+(Unlike with || in Go, however, eq is a function call and all the
+arguments will be evaluated.)
+
+The comparison functions work on basic types only (or named basic
+types, such as "type Celsius float32"). They implement the Go rules
+for comparison of values, except that size and exact type are
+ignored, so any integer value, signed or unsigned, may be compared
+with any other integer value. (The arithmetic value is compared,
+not the bit pattern, so all negative integers are less than all
+unsigned integers.) However, as usual, one may not compare an int
+with a float32 and so on.
+
+Associated templates
+
+Each template is named by a string specified when it is created. Also, each
+template is associated with zero or more other templates that it may invoke by
+name; such associations are transitive and form a name space of templates.
+
+A template may use a template invocation to instantiate another associated
+template; see the explanation of the "template" action above. The name must be
+that of a template associated with the template that contains the invocation.
+
+Nested template definitions
+
+When parsing a template, another template may be defined and associated with the
+template being parsed. Template definitions must appear at the top level of the
+template, much like global variables in a Go program.
+
+The syntax of such definitions is to surround each template declaration with a
+"define" and "end" action.
+
+The define action names the template being created by providing a string
+constant. Here is a simple example:
+
+	`{{define "T1"}}ONE{{end}}
+	{{define "T2"}}TWO{{end}}
+	{{define "T3"}}{{template "T1"}} {{template "T2"}}{{end}}
+	{{template "T3"}}`
+
+This defines two templates, T1 and T2, and a third T3 that invokes the other two
+when it is executed. Finally it invokes T3. If executed this template will
+produce the text
+
+	ONE TWO
+
+By construction, a template may reside in only one association. If it's
+necessary to have a template addressable from multiple associations, the
+template definition must be parsed multiple times to create distinct *Template
+values, or must be copied with the Clone or AddParseTree method.
+
+Parse may be called multiple times to assemble the various associated templates;
+see the ParseFiles and ParseGlob functions and methods for simple ways to parse
+related templates stored in files.
+
+A template may be executed directly or through ExecuteTemplate, which executes
+an associated template identified by name. To invoke our example above, we
+might write,
+
+	err := tmpl.Execute(os.Stdout, "no data needed")
+	if err != nil {
+		log.Fatalf("execution failed: %s", err)
+	}
+
+or to invoke a particular template explicitly by name,
+
+	err := tmpl.ExecuteTemplate(os.Stdout, "T2", "no data needed")
+	if err != nil {
+		log.Fatalf("execution failed: %s", err)
+	}
+
+*/
+package template

vendor/github.com/alecthomas/template/example_test.go

@@ -0,0 +1,72 @@
+// 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.
+
+package template_test
+
+import (
+	"log"
+	"os"
+
+	"github.com/alecthomas/template"
+)
+
+func ExampleTemplate() {
+	// Define a template.
+	const letter = `
+Dear {{.Name}},
+{{if .Attended}}
+It was a pleasure to see you at the wedding.{{else}}
+It is a shame you couldn't make it to the wedding.{{end}}
+{{with .Gift}}Thank you for the lovely {{.}}.
+{{end}}
+Best wishes,
+Josie
+`
+
+	// Prepare some data to insert into the template.
+	type Recipient struct {
+		Name, Gift string
+		Attended   bool
+	}
+	var recipients = []Recipient{
+		{"Aunt Mildred", "bone china tea set", true},
+		{"Uncle John", "moleskin pants", false},
+		{"Cousin Rodney", "", false},
+	}
+
+	// Create a new template and parse the letter into it.
+	t := template.Must(template.New("letter").Parse(letter))
+
+	// Execute the template for each recipient.
+	for _, r := range recipients {
+		err := t.Execute(os.Stdout, r)
+		if err != nil {
+			log.Println("executing template:", err)
+		}
+	}
+
+	// Output:
+	// Dear Aunt Mildred,
+	//
+	// It was a pleasure to see you at the wedding.
+	// Thank you for the lovely bone china tea set.
+	//
+	// Best wishes,
+	// Josie
+	//
+	// Dear Uncle John,
+	//
+	// It is a shame you couldn't make it to the wedding.
+	// Thank you for the lovely moleskin pants.
+	//
+	// Best wishes,
+	// Josie
+	//
+	// Dear Cousin Rodney,
+	//
+	// It is a shame you couldn't make it to the wedding.
+	//
+	// Best wishes,
+	// Josie
+}

vendor/github.com/alecthomas/template/examplefiles_test.go

@@ -0,0 +1,183 @@
+// Copyright 2012 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.
+
+package template_test
+
+import (
+	"io"
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+
+	"github.com/alecthomas/template"
+)
+
+// templateFile defines the contents of a template to be stored in a file, for testing.
+type templateFile struct {
+	name     string
+	contents string
+}
+
+func createTestDir(files []templateFile) string {
+	dir, err := ioutil.TempDir("", "template")
+	if err != nil {
+		log.Fatal(err)
+	}
+	for _, file := range files {
+		f, err := os.Create(filepath.Join(dir, file.name))
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer f.Close()
+		_, err = io.WriteString(f, file.contents)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+	return dir
+}
+
+// Here we demonstrate loading a set of templates from a directory.
+func ExampleTemplate_glob() {
+	// Here we create a temporary directory and populate it with our sample
+	// template definition files; usually the template files would already
+	// exist in some location known to the program.
+	dir := createTestDir([]templateFile{
+		// T0.tmpl is a plain template file that just invokes T1.
+		{"T0.tmpl", `T0 invokes T1: ({{template "T1"}})`},
+		// T1.tmpl defines a template, T1 that invokes T2.
+		{"T1.tmpl", `{{define "T1"}}T1 invokes T2: ({{template "T2"}}){{end}}`},
+		// T2.tmpl defines a template T2.
+		{"T2.tmpl", `{{define "T2"}}This is T2{{end}}`},
+	})
+	// Clean up after the test; another quirk of running as an example.
+	defer os.RemoveAll(dir)
+
+	// pattern is the glob pattern used to find all the template files.
+	pattern := filepath.Join(dir, "*.tmpl")
+
+	// Here starts the example proper.
+	// T0.tmpl is the first name matched, so it becomes the starting template,
+	// the value returned by ParseGlob.
+	tmpl := template.Must(template.ParseGlob(pattern))
+
+	err := tmpl.Execute(os.Stdout, nil)
+	if err != nil {
+		log.Fatalf("template execution: %s", err)
+	}
+	// Output:
+	// T0 invokes T1: (T1 invokes T2: (This is T2))
+}
+
+// This example demonstrates one way to share some templates
+// and use them in different contexts. In this variant we add multiple driver
+// templates by hand to an existing bundle of templates.
+func ExampleTemplate_helpers() {
+	// Here we create a temporary directory and populate it with our sample
+	// template definition files; usually the template files would already
+	// exist in some location known to the program.
+	dir := createTestDir([]templateFile{
+		// T1.tmpl defines a template, T1 that invokes T2.
+		{"T1.tmpl", `{{define "T1"}}T1 invokes T2: ({{template "T2"}}){{end}}`},
+		// T2.tmpl defines a template T2.
+		{"T2.tmpl", `{{define "T2"}}This is T2{{end}}`},
+	})
+	// Clean up after the test; another quirk of running as an example.
+	defer os.RemoveAll(dir)
+
+	// pattern is the glob pattern used to find all the template files.
+	pattern := filepath.Join(dir, "*.tmpl")
+
+	// Here starts the example proper.
+	// Load the helpers.
+	templates := template.Must(template.ParseGlob(pattern))
+	// Add one driver template to the bunch; we do this with an explicit template definition.
+	_, err := templates.Parse("{{define `driver1`}}Driver 1 calls T1: ({{template `T1`}})\n{{end}}")
+	if err != nil {
+		log.Fatal("parsing driver1: ", err)
+	}
+	// Add another driver template.
+	_, err = templates.Parse("{{define `driver2`}}Driver 2 calls T2: ({{template `T2`}})\n{{end}}")
+	if err != nil {
+		log.Fatal("parsing driver2: ", err)
+	}
+	// We load all the templates before execution. This package does not require
+	// that behavior but html/template's escaping does, so it's a good habit.
+	err = templates.ExecuteTemplate(os.Stdout, "driver1", nil)
+	if err != nil {
+		log.Fatalf("driver1 execution: %s", err)
+	}
+	err = templates.ExecuteTemplate(os.Stdout, "driver2", nil)
+	if err != nil {
+		log.Fatalf("driver2 execution: %s", err)
+	}
+	// Output:
+	// Driver 1 calls T1: (T1 invokes T2: (This is T2))
+	// Driver 2 calls T2: (This is T2)
+}
+
+// This example demonstrates how to use one group of driver
+// templates with distinct sets of helper templates.
+func ExampleTemplate_share() {
+	// Here we create a temporary directory and populate it with our sample
+	// template definition files; usually the template files would already
+	// exist in some location known to the program.
+	dir := createTestDir([]templateFile{
+		// T0.tmpl is a plain template file that just invokes T1.
+		{"T0.tmpl", "T0 ({{.}} version) invokes T1: ({{template `T1`}})\n"},
+		// T1.tmpl defines a template, T1 that invokes T2. Note T2 is not defined
+		{"T1.tmpl", `{{define "T1"}}T1 invokes T2: ({{template "T2"}}){{end}}`},
+	})
+	// Clean up after the test; another quirk of running as an example.
+	defer os.RemoveAll(dir)
+
+	// pattern is the glob pattern used to find all the template files.
+	pattern := filepath.Join(dir, "*.tmpl")
+
+	// Here starts the example proper.
+	// Load the drivers.
+	drivers := template.Must(template.ParseGlob(pattern))
+
+	// We must define an implementation of the T2 template. First we clone
+	// the drivers, then add a definition of T2 to the template name space.
+
+	// 1. Clone the helper set to create a new name space from which to run them.
+	first, err := drivers.Clone()
+	if err != nil {
+		log.Fatal("cloning helpers: ", err)
+	}
+	// 2. Define T2, version A, and parse it.
+	_, err = first.Parse("{{define `T2`}}T2, version A{{end}}")
+	if err != nil {
+		log.Fatal("parsing T2: ", err)
+	}
+
+	// Now repeat the whole thing, using a different version of T2.
+	// 1. Clone the drivers.
+	second, err := drivers.Clone()
+	if err != nil {
+		log.Fatal("cloning drivers: ", err)
+	}
+	// 2. Define T2, version B, and parse it.
+	_, err = second.Parse("{{define `T2`}}T2, version B{{end}}")
+	if err != nil {
+		log.Fatal("parsing T2: ", err)
+	}
+
+	// Execute the templates in the reverse order to verify the
+	// first is unaffected by the second.
+	err = second.ExecuteTemplate(os.Stdout, "T0.tmpl", "second")
+	if err != nil {
+		log.Fatalf("second execution: %s", err)
+	}
+	err = first.ExecuteTemplate(os.Stdout, "T0.tmpl", "first")
+	if err != nil {
+		log.Fatalf("first: execution: %s", err)
+	}
+
+	// Output:
+	// T0 (second version) invokes T1: (T1 invokes T2: (T2, version B))
+	// T0 (first version) invokes T1: (T1 invokes T2: (T2, version A))
+}

vendor/github.com/alecthomas/template/examplefunc_test.go

@@ -0,0 +1,55 @@
+// Copyright 2012 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.
+
+package template_test
+
+import (
+	"log"
+	"os"
+	"strings"
+
+	"github.com/alecthomas/template"
+)
+
+// This example demonstrates a custom function to process template text.
+// It installs the strings.Title function and uses it to
+// Make Title Text Look Good In Our Template's Output.
+func ExampleTemplate_func() {
+	// First we create a FuncMap with which to register the function.
+	funcMap := template.FuncMap{
+		// The name "title" is what the function will be called in the template text.
+		"title": strings.Title,
+	}
+
+	// A simple template definition to test our function.
+	// We print the input text several ways:
+	// - the original
+	// - title-cased
+	// - title-cased and then printed with %q
+	// - printed with %q and then title-cased.
+	const templateText = `
+Input: {{printf "%q" .}}
+Output 0: {{title .}}
+Output 1: {{title . | printf "%q"}}
+Output 2: {{printf "%q" . | title}}
+`
+
+	// Create a template, add the function map, and parse the text.
+	tmpl, err := template.New("titleTest").Funcs(funcMap).Parse(templateText)
+	if err != nil {
+		log.Fatalf("parsing: %s", err)
+	}
+
+	// Run the template to verify the output.
+	err = tmpl.Execute(os.Stdout, "the go programming language")
+	if err != nil {
+		log.Fatalf("execution: %s", err)
+	}
+
+	// Output:
+	// Input: "the go programming language"
+	// Output 0: The Go Programming Language
+	// Output 1: "The Go Programming Language"
+	// Output 2: "The Go Programming Language"
+}

vendor/github.com/alecthomas/template/exec.go

@@ -0,0 +1,845 @@
+// 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.
+
+package template
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"reflect"
+	"runtime"
+	"sort"
+	"strings"
+
+	"github.com/alecthomas/template/parse"
+)
+
+// state represents the state of an execution. It's not part of the
+// template so that multiple executions of the same template
+// can execute in parallel.
+type state struct {
+	tmpl *Template
+	wr   io.Writer
+	node parse.Node // current node, for errors
+	vars []variable // push-down stack of variable values.
+}
+
+// variable holds the dynamic value of a variable such as $, $x etc.
+type variable struct {
+	name  string
+	value reflect.Value
+}
+
+// push pushes a new variable on the stack.
+func (s *state) push(name string, value reflect.Value) {
+	s.vars = append(s.vars, variable{name, value})
+}
+
+// mark returns the length of the variable stack.
+func (s *state) mark() int {
+	return len(s.vars)
+}
+
+// pop pops the variable stack up to the mark.
+func (s *state) pop(mark int) {
+	s.vars = s.vars[0:mark]
+}
+
+// setVar overwrites the top-nth variable on the stack. Used by range iterations.
+func (s *state) setVar(n int, value reflect.Value) {
+	s.vars[len(s.vars)-n].value = value
+}
+
+// varValue returns the value of the named variable.
+func (s *state) varValue(name string) reflect.Value {
+	for i := s.mark() - 1; i >= 0; i-- {
+		if s.vars[i].name == name {
+			return s.vars[i].value
+		}
+	}
+	s.errorf("undefined variable: %s", name)
+	return zero
+}
+
+var zero reflect.Value
+
+// at marks the state to be on node n, for error reporting.
+func (s *state) at(node parse.Node) {
+	s.node = node
+}
+
+// doublePercent returns the string with %'s replaced by %%, if necessary,
+// so it can be used safely inside a Printf format string.
+func doublePercent(str string) string {
+	if strings.Contains(str, "%") {
+		str = strings.Replace(str, "%", "%%", -1)
+	}
+	return str
+}
+
+// errorf formats the error and terminates processing.
+func (s *state) errorf(format string, args ...interface{}) {
+	name := doublePercent(s.tmpl.Name())
+	if s.node == nil {
+		format = fmt.Sprintf("template: %s: %s", name, format)
+	} else {
+		location, context := s.tmpl.ErrorContext(s.node)
+		format = fmt.Sprintf("template: %s: executing %q at <%s>: %s", location, name, doublePercent(context), format)
+	}
+	panic(fmt.Errorf(format, args...))
+}
+
+// errRecover is the handler that turns panics into returns from the top
+// level of Parse.
+func errRecover(errp *error) {
+	e := recover()
+	if e != nil {
+		switch err := e.(type) {
+		case runtime.Error:
+			panic(e)
+		case error:
+			*errp = err
+		default:
+			panic(e)
+		}
+	}
+}
+
+// ExecuteTemplate applies the template associated with t that has the given name
+// to the specified data object and writes the output to wr.
+// If an error occurs executing the template or writing its output,
+// execution stops, but partial results may already have been written to
+// the output writer.
+// A template may be executed safely in parallel.
+func (t *Template) ExecuteTemplate(wr io.Writer, name string, data interface{}) error {
+	tmpl := t.tmpl[name]
+	if tmpl == nil {
+		return fmt.Errorf("template: no template %q associated with template %q", name, t.name)
+	}
+	return tmpl.Execute(wr, data)
+}
+
+// Execute applies a parsed template to the specified data object,
+// and writes the output to wr.
+// If an error occurs executing the template or writing its output,
+// execution stops, but partial results may already have been written to
+// the output writer.
+// A template may be executed safely in parallel.
+func (t *Template) Execute(wr io.Writer, data interface{}) (err error) {
+	defer errRecover(&err)
+	value := reflect.ValueOf(data)
+	state := &state{
+		tmpl: t,
+		wr:   wr,
+		vars: []variable{{"$", value}},
+	}
+	t.init()
+	if t.Tree == nil || t.Root == nil {
+		var b bytes.Buffer
+		for name, tmpl := range t.tmpl {
+			if tmpl.Tree == nil || tmpl.Root == nil {
+				continue
+			}
+			if b.Len() > 0 {
+				b.WriteString(", ")
+			}
+			fmt.Fprintf(&b, "%q", name)
+		}
+		var s string
+		if b.Len() > 0 {
+			s = "; defined templates are: " + b.String()
+		}
+		state.errorf("%q is an incomplete or empty template%s", t.Name(), s)
+	}
+	state.walk(value, t.Root)
+	return
+}
+
+// Walk functions step through the major pieces of the template structure,
+// generating output as they go.
+func (s *state) walk(dot reflect.Value, node parse.Node) {
+	s.at(node)
+	switch node := node.(type) {
+	case *parse.ActionNode:
+		// Do not pop variables so they persist until next end.
+		// Also, if the action declares variables, don't print the result.
+		val := s.evalPipeline(dot, node.Pipe)
+		if len(node.Pipe.Decl) == 0 {
+			s.printValue(node, val)
+		}
+	case *parse.IfNode:
+		s.walkIfOrWith(parse.NodeIf, dot, node.Pipe, node.List, node.ElseList)
+	case *parse.ListNode:
+		for _, node := range node.Nodes {
+			s.walk(dot, node)
+		}
+	case *parse.RangeNode:
+		s.walkRange(dot, node)
+	case *parse.TemplateNode:
+		s.walkTemplate(dot, node)
+	case *parse.TextNode:
+		if _, err := s.wr.Write(node.Text); err != nil {
+			s.errorf("%s", err)
+		}
+	case *parse.WithNode:
+		s.walkIfOrWith(parse.NodeWith, dot, node.Pipe, node.List, node.ElseList)
+	default:
+		s.errorf("unknown node: %s", node)
+	}
+}
+
+// walkIfOrWith walks an 'if' or 'with' node. The two control structures
+// are identical in behavior except that 'with' sets dot.
+func (s *state) walkIfOrWith(typ parse.NodeType, dot reflect.Value, pipe *parse.PipeNode, list, elseList *parse.ListNode) {
+	defer s.pop(s.mark())
+	val := s.evalPipeline(dot, pipe)
+	truth, ok := isTrue(val)
+	if !ok {
+		s.errorf("if/with can't use %v", val)
+	}
+	if truth {
+		if typ == parse.NodeWith {
+			s.walk(val, list)
+		} else {
+			s.walk(dot, list)
+		}
+	} else if elseList != nil {
+		s.walk(dot, elseList)
+	}
+}
+
+// isTrue reports whether the value is 'true', in the sense of not the zero of its type,
+// and whether the value has a meaningful truth value.
+func isTrue(val reflect.Value) (truth, ok bool) {
+	if !val.IsValid() {
+		// Something like var x interface{}, never set. It's a form of nil.
+		return false, true
+	}
+	switch val.Kind() {
+	case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
+		truth = val.Len() > 0
+	case reflect.Bool:
+		truth = val.Bool()
+	case reflect.Complex64, reflect.Complex128:
+		truth = val.Complex() != 0
+	case reflect.Chan, reflect.Func, reflect.Ptr, reflect.Interface:
+		truth = !val.IsNil()
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		truth = val.Int() != 0
+	case reflect.Float32, reflect.Float64:
+		truth = val.Float() != 0
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		truth = val.Uint() != 0
+	case reflect.Struct:
+		truth = true // Struct values are always true.
+	default:
+		return
+	}
+	return truth, true
+}
+
+func (s *state) walkRange(dot reflect.Value, r *parse.RangeNode) {
+	s.at(r)
+	defer s.pop(s.mark())
+	val, _ := indirect(s.evalPipeline(dot, r.Pipe))
+	// mark top of stack before any variables in the body are pushed.
+	mark := s.mark()
+	oneIteration := func(index, elem reflect.Value) {
+		// Set top var (lexically the second if there are two) to the element.
+		if len(r.Pipe.Decl) > 0 {
+			s.setVar(1, elem)
+		}
+		// Set next var (lexically the first if there are two) to the index.
+		if len(r.Pipe.Decl) > 1 {
+			s.setVar(2, index)
+		}
+		s.walk(elem, r.List)
+		s.pop(mark)
+	}
+	switch val.Kind() {
+	case reflect.Array, reflect.Slice:
+		if val.Len() == 0 {
+			break
+		}
+		for i := 0; i < val.Len(); i++ {
+			oneIteration(reflect.ValueOf(i), val.Index(i))
+		}
+		return
+	case reflect.Map:
+		if val.Len() == 0 {
+			break
+		}
+		for _, key := range sortKeys(val.MapKeys()) {
+			oneIteration(key, val.MapIndex(key))
+		}
+		return
+	case reflect.Chan:
+		if val.IsNil() {
+			break
+		}
+		i := 0
+		for ; ; i++ {
+			elem, ok := val.Recv()
+			if !ok {
+				break
+			}
+			oneIteration(reflect.ValueOf(i), elem)
+		}
+		if i == 0 {
+			break
+		}
+		return
+	case reflect.Invalid:
+		break // An invalid value is likely a nil map, etc. and acts like an empty map.
+	default:
+		s.errorf("range can't iterate over %v", val)
+	}
+	if r.ElseList != nil {
+		s.walk(dot, r.ElseList)
+	}
+}
+
+func (s *state) walkTemplate(dot reflect.Value, t *parse.TemplateNode) {
+	s.at(t)
+	tmpl := s.tmpl.tmpl[t.Name]
+	if tmpl == nil {
+		s.errorf("template %q not defined", t.Name)
+	}
+	// Variables declared by the pipeline persist.
+	dot = s.evalPipeline(dot, t.Pipe)
+	newState := *s
+	newState.tmpl = tmpl
+	// No dynamic scoping: template invocations inherit no variables.
+	newState.vars = []variable{{"$", dot}}
+	newState.walk(dot, tmpl.Root)
+}
+
+// Eval functions evaluate pipelines, commands, and their elements and extract
+// values from the data structure by examining fields, calling methods, and so on.
+// The printing of those values happens only through walk functions.
+
+// evalPipeline returns the value acquired by evaluating a pipeline. If the
+// pipeline has a variable declaration, the variable will be pushed on the
+// stack. Callers should therefore pop the stack after they are finished
+// executing commands depending on the pipeline value.
+func (s *state) evalPipeline(dot reflect.Value, pipe *parse.PipeNode) (value reflect.Value) {
+	if pipe == nil {
+		return
+	}
+	s.at(pipe)
+	for _, cmd := range pipe.Cmds {
+		value = s.evalCommand(dot, cmd, value) // previous value is this one's final arg.
+		// If the object has type interface{}, dig down one level to the thing inside.
+		if value.Kind() == reflect.Interface && value.Type().NumMethod() == 0 {
+			value = reflect.ValueOf(value.Interface()) // lovely!
+		}
+	}
+	for _, variable := range pipe.Decl {
+		s.push(variable.Ident[0], value)
+	}
+	return value
+}
+
+func (s *state) notAFunction(args []parse.Node, final reflect.Value) {
+	if len(args) > 1 || final.IsValid() {
+		s.errorf("can't give argument to non-function %s", args[0])
+	}
+}
+
+func (s *state) evalCommand(dot reflect.Value, cmd *parse.CommandNode, final reflect.Value) reflect.Value {
+	firstWord := cmd.Args[0]
+	switch n := firstWord.(type) {
+	case *parse.FieldNode:
+		return s.evalFieldNode(dot, n, cmd.Args, final)
+	case *parse.ChainNode:
+		return s.evalChainNode(dot, n, cmd.Args, final)
+	case *parse.IdentifierNode:
+		// Must be a function.
+		return s.evalFunction(dot, n, cmd, cmd.Args, final)
+	case *parse.PipeNode:
+		// Parenthesized pipeline. The arguments are all inside the pipeline; final is ignored.
+		return s.evalPipeline(dot, n)
+	case *parse.VariableNode:
+		return s.evalVariableNode(dot, n, cmd.Args, final)
+	}
+	s.at(firstWord)
+	s.notAFunction(cmd.Args, final)
+	switch word := firstWord.(type) {
+	case *parse.BoolNode:
+		return reflect.ValueOf(word.True)
+	case *parse.DotNode:
+		return dot
+	case *parse.NilNode:
+		s.errorf("nil is not a command")
+	case *parse.NumberNode:
+		return s.idealConstant(word)
+	case *parse.StringNode:
+		return reflect.ValueOf(word.Text)
+	}
+	s.errorf("can't evaluate command %q", firstWord)
+	panic("not reached")
+}
+
+// idealConstant is called to return the value of a number in a context where
+// we don't know the type. In that case, the syntax of the number tells us
+// its type, and we use Go rules to resolve.  Note there is no such thing as
+// a uint ideal constant in this situation - the value must be of int type.
+func (s *state) idealConstant(constant *parse.NumberNode) reflect.Value {
+	// These are ideal constants but we don't know the type
+	// and we have no context.  (If it was a method argument,
+	// we'd know what we need.) The syntax guides us to some extent.
+	s.at(constant)
+	switch {
+	case constant.IsComplex:
+		return reflect.ValueOf(constant.Complex128) // incontrovertible.
+	case constant.IsFloat && !isHexConstant(constant.Text) && strings.IndexAny(constant.Text, ".eE") >= 0:
+		return reflect.ValueOf(constant.Float64)
+	case constant.IsInt:
+		n := int(constant.Int64)
+		if int64(n) != constant.Int64 {
+			s.errorf("%s overflows int", constant.Text)
+		}
+		return reflect.ValueOf(n)
+	case constant.IsUint:
+		s.errorf("%s overflows int", constant.Text)
+	}
+	return zero
+}
+
+func isHexConstant(s string) bool {
+	return len(s) > 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X')
+}
+
+func (s *state) evalFieldNode(dot reflect.Value, field *parse.FieldNode, args []parse.Node, final reflect.Value) reflect.Value {
+	s.at(field)
+	return s.evalFieldChain(dot, dot, field, field.Ident, args, final)
+}
+
+func (s *state) evalChainNode(dot reflect.Value, chain *parse.ChainNode, args []parse.Node, final reflect.Value) reflect.Value {
+	s.at(chain)
+	// (pipe).Field1.Field2 has pipe as .Node, fields as .Field. Eval the pipeline, then the fields.
+	pipe := s.evalArg(dot, nil, chain.Node)
+	if len(chain.Field) == 0 {
+		s.errorf("internal error: no fields in evalChainNode")
+	}
+	return s.evalFieldChain(dot, pipe, chain, chain.Field, args, final)
+}
+
+func (s *state) evalVariableNode(dot reflect.Value, variable *parse.VariableNode, args []parse.Node, final reflect.Value) reflect.Value {
+	// $x.Field has $x as the first ident, Field as the second. Eval the var, then the fields.
+	s.at(variable)
+	value := s.varValue(variable.Ident[0])
+	if len(variable.Ident) == 1 {
+		s.notAFunction(args, final)
+		return value
+	}
+	return s.evalFieldChain(dot, value, variable, variable.Ident[1:], args, final)
+}
+
+// evalFieldChain evaluates .X.Y.Z possibly followed by arguments.
+// dot is the environment in which to evaluate arguments, while
+// receiver is the value being walked along the chain.
+func (s *state) evalFieldChain(dot, receiver reflect.Value, node parse.Node, ident []string, args []parse.Node, final reflect.Value) reflect.Value {
+	n := len(ident)
+	for i := 0; i < n-1; i++ {
+		receiver = s.evalField(dot, ident[i], node, nil, zero, receiver)
+	}
+	// Now if it's a method, it gets the arguments.
+	return s.evalField(dot, ident[n-1], node, args, final, receiver)
+}
+
+func (s *state) evalFunction(dot reflect.Value, node *parse.IdentifierNode, cmd parse.Node, args []parse.Node, final reflect.Value) reflect.Value {
+	s.at(node)
+	name := node.Ident
+	function, ok := findFunction(name, s.tmpl)
+	if !ok {
+		s.errorf("%q is not a defined function", name)
+	}
+	return s.evalCall(dot, function, cmd, name, args, final)
+}
+
+// evalField evaluates an expression like (.Field) or (.Field arg1 arg2).
+// The 'final' argument represents the return value from the preceding
+// value of the pipeline, if any.
+func (s *state) evalField(dot reflect.Value, fieldName string, node parse.Node, args []parse.Node, final, receiver reflect.Value) reflect.Value {
+	if !receiver.IsValid() {
+		return zero
+	}
+	typ := receiver.Type()
+	receiver, _ = indirect(receiver)
+	// Unless it's an interface, need to get to a value of type *T to guarantee
+	// we see all methods of T and *T.
+	ptr := receiver
+	if ptr.Kind() != reflect.Interface && ptr.CanAddr() {
+		ptr = ptr.Addr()
+	}
+	if method := ptr.MethodByName(fieldName); method.IsValid() {
+		return s.evalCall(dot, method, node, fieldName, args, final)
+	}
+	hasArgs := len(args) > 1 || final.IsValid()
+	// It's not a method; must be a field of a struct or an element of a map. The receiver must not be nil.
+	receiver, isNil := indirect(receiver)
+	if isNil {
+		s.errorf("nil pointer evaluating %s.%s", typ, fieldName)
+	}
+	switch receiver.Kind() {
+	case reflect.Struct:
+		tField, ok := receiver.Type().FieldByName(fieldName)
+		if ok {
+			field := receiver.FieldByIndex(tField.Index)
+			if tField.PkgPath != "" { // field is unexported
+				s.errorf("%s is an unexported field of struct type %s", fieldName, typ)
+			}
+			// If it's a function, we must call it.
+			if hasArgs {
+				s.errorf("%s has arguments but cannot be invoked as function", fieldName)
+			}
+			return field
+		}
+		s.errorf("%s is not a field of struct type %s", fieldName, typ)
+	case reflect.Map:
+		// If it's a map, attempt to use the field name as a key.
+		nameVal := reflect.ValueOf(fieldName)
+		if nameVal.Type().AssignableTo(receiver.Type().Key()) {
+			if hasArgs {
+				s.errorf("%s is not a method but has arguments", fieldName)
+			}
+			return receiver.MapIndex(nameVal)
+		}
+	}
+	s.errorf("can't evaluate field %s in type %s", fieldName, typ)
+	panic("not reached")
+}
+
+var (
+	errorType       = reflect.TypeOf((*error)(nil)).Elem()
+	fmtStringerType = reflect.TypeOf((*fmt.Stringer)(nil)).Elem()
+)
+
+// evalCall executes a function or method call. If it's a method, fun already has the receiver bound, so
+// it looks just like a function call.  The arg list, if non-nil, includes (in the manner of the shell), arg[0]
+// as the function itself.
+func (s *state) evalCall(dot, fun reflect.Value, node parse.Node, name string, args []parse.Node, final reflect.Value) reflect.Value {
+	if args != nil {
+		args = args[1:] // Zeroth arg is function name/node; not passed to function.
+	}
+	typ := fun.Type()
+	numIn := len(args)
+	if final.IsValid() {
+		numIn++
+	}
+	numFixed := len(args)
+	if typ.IsVariadic() {
+		numFixed = typ.NumIn() - 1 // last arg is the variadic one.
+		if numIn < numFixed {
+			s.errorf("wrong number of args for %s: want at least %d got %d", name, typ.NumIn()-1, len(args))
+		}
+	} else if numIn < typ.NumIn()-1 || !typ.IsVariadic() && numIn != typ.NumIn() {
+		s.errorf("wrong number of args for %s: want %d got %d", name, typ.NumIn(), len(args))
+	}
+	if !goodFunc(typ) {
+		// TODO: This could still be a confusing error; maybe goodFunc should provide info.
+		s.errorf("can't call method/function %q with %d results", name, typ.NumOut())
+	}
+	// Build the arg list.
+	argv := make([]reflect.Value, numIn)
+	// Args must be evaluated. Fixed args first.
+	i := 0
+	for ; i < numFixed && i < len(args); i++ {
+		argv[i] = s.evalArg(dot, typ.In(i), args[i])
+	}
+	// Now the ... args.
+	if typ.IsVariadic() {
+		argType := typ.In(typ.NumIn() - 1).Elem() // Argument is a slice.
+		for ; i < len(args); i++ {
+			argv[i] = s.evalArg(dot, argType, args[i])
+		}
+	}
+	// Add final value if necessary.
+	if final.IsValid() {
+		t := typ.In(typ.NumIn() - 1)
+		if typ.IsVariadic() {
+			t = t.Elem()
+		}
+		argv[i] = s.validateType(final, t)
+	}
+	result := fun.Call(argv)
+	// If we have an error that is not nil, stop execution and return that error to the caller.
+	if len(result) == 2 && !result[1].IsNil() {
+		s.at(node)
+		s.errorf("error calling %s: %s", name, result[1].Interface().(error))
+	}
+	return result[0]
+}
+
+// canBeNil reports whether an untyped nil can be assigned to the type. See reflect.Zero.
+func canBeNil(typ reflect.Type) bool {
+	switch typ.Kind() {
+	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
+		return true
+	}
+	return false
+}
+
+// validateType guarantees that the value is valid and assignable to the type.
+func (s *state) validateType(value reflect.Value, typ reflect.Type) reflect.Value {
+	if !value.IsValid() {
+		if typ == nil || canBeNil(typ) {
+			// An untyped nil interface{}. Accept as a proper nil value.
+			return reflect.Zero(typ)
+		}
+		s.errorf("invalid value; expected %s", typ)
+	}
+	if typ != nil && !value.Type().AssignableTo(typ) {
+		if value.Kind() == reflect.Interface && !value.IsNil() {
+			value = value.Elem()
+			if value.Type().AssignableTo(typ) {
+				return value
+			}
+			// fallthrough
+		}
+		// Does one dereference or indirection work? We could do more, as we
+		// do with method receivers, but that gets messy and method receivers
+		// are much more constrained, so it makes more sense there than here.
+		// Besides, one is almost always all you need.
+		switch {
+		case value.Kind() == reflect.Ptr && value.Type().Elem().AssignableTo(typ):
+			value = value.Elem()
+			if !value.IsValid() {
+				s.errorf("dereference of nil pointer of type %s", typ)
+			}
+		case reflect.PtrTo(value.Type()).AssignableTo(typ) && value.CanAddr():
+			value = value.Addr()
+		default:
+			s.errorf("wrong type for value; expected %s; got %s", typ, value.Type())
+		}
+	}
+	return value
+}
+
+func (s *state) evalArg(dot reflect.Value, typ reflect.Type, n parse.Node) reflect.Value {
+	s.at(n)
+	switch arg := n.(type) {
+	case *parse.DotNode:
+		return s.validateType(dot, typ)
+	case *parse.NilNode:
+		if canBeNil(typ) {
+			return reflect.Zero(typ)
+		}
+		s.errorf("cannot assign nil to %s", typ)
+	case *parse.FieldNode:
+		return s.validateType(s.evalFieldNode(dot, arg, []parse.Node{n}, zero), typ)
+	case *parse.VariableNode:
+		return s.validateType(s.evalVariableNode(dot, arg, nil, zero), typ)
+	case *parse.PipeNode:
+		return s.validateType(s.evalPipeline(dot, arg), typ)
+	case *parse.IdentifierNode:
+		return s.evalFunction(dot, arg, arg, nil, zero)
+	case *parse.ChainNode:
+		return s.validateType(s.evalChainNode(dot, arg, nil, zero), typ)
+	}
+	switch typ.Kind() {
+	case reflect.Bool:
+		return s.evalBool(typ, n)
+	case reflect.Complex64, reflect.Complex128:
+		return s.evalComplex(typ, n)
+	case reflect.Float32, reflect.Float64:
+		return s.evalFloat(typ, n)
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return s.evalInteger(typ, n)
+	case reflect.Interface:
+		if typ.NumMethod() == 0 {
+			return s.evalEmptyInterface(dot, n)
+		}
+	case reflect.String:
+		return s.evalString(typ, n)
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return s.evalUnsignedInteger(typ, n)
+	}
+	s.errorf("can't handle %s for arg of type %s", n, typ)
+	panic("not reached")
+}
+
+func (s *state) evalBool(typ reflect.Type, n parse.Node) reflect.Value {
+	s.at(n)
+	if n, ok := n.(*parse.BoolNode); ok {
+		value := reflect.New(typ).Elem()
+		value.SetBool(n.True)
+		return value
+	}
+	s.errorf("expected bool; found %s", n)
+	panic("not reached")
+}
+
+func (s *state) evalString(typ reflect.Type, n parse.Node) reflect.Value {
+	s.at(n)
+	if n, ok := n.(*parse.StringNode); ok {
+		value := reflect.New(typ).Elem()
+		value.SetString(n.Text)
+		return value
+	}
+	s.errorf("expected string; found %s", n)
+	panic("not reached")
+}
+
+func (s *state) evalInteger(typ reflect.Type, n parse.Node) reflect.Value {
+	s.at(n)
+	if n, ok := n.(*parse.NumberNode); ok && n.IsInt {
+		value := reflect.New(typ).Elem()
+		value.SetInt(n.Int64)
+		return value
+	}
+	s.errorf("expected integer; found %s", n)
+	panic("not reached")
+}
+
+func (s *state) evalUnsignedInteger(typ reflect.Type, n parse.Node) reflect.Value {
+	s.at(n)
+	if n, ok := n.(*parse.NumberNode); ok && n.IsUint {
+		value := reflect.New(typ).Elem()
+		value.SetUint(n.Uint64)
+		return value
+	}
+	s.errorf("expected unsigned integer; found %s", n)
+	panic("not reached")
+}
+
+func (s *state) evalFloat(typ reflect.Type, n parse.Node) reflect.Value {
+	s.at(n)
+	if n, ok := n.(*parse.NumberNode); ok && n.IsFloat {
+		value := reflect.New(typ).Elem()
+		value.SetFloat(n.Float64)
+		return value
+	}
+	s.errorf("expected float; found %s", n)
+	panic("not reached")
+}
+
+func (s *state) evalComplex(typ reflect.Type, n parse.Node) reflect.Value {
+	if n, ok := n.(*parse.NumberNode); ok && n.IsComplex {
+		value := reflect.New(typ).Elem()
+		value.SetComplex(n.Complex128)
+		return value
+	}
+	s.errorf("expected complex; found %s", n)
+	panic("not reached")
+}
+
+func (s *state) evalEmptyInterface(dot reflect.Value, n parse.Node) reflect.Value {
+	s.at(n)
+	switch n := n.(type) {
+	case *parse.BoolNode:
+		return reflect.ValueOf(n.True)
+	case *parse.DotNode:
+		return dot
+	case *parse.FieldNode:
+		return s.evalFieldNode(dot, n, nil, zero)
+	case *parse.IdentifierNode:
+		return s.evalFunction(dot, n, n, nil, zero)
+	case *parse.NilNode:
+		// NilNode is handled in evalArg, the only place that calls here.
+		s.errorf("evalEmptyInterface: nil (can't happen)")
+	case *parse.NumberNode:
+		return s.idealConstant(n)
+	case *parse.StringNode:
+		return reflect.ValueOf(n.Text)
+	case *parse.VariableNode:
+		return s.evalVariableNode(dot, n, nil, zero)
+	case *parse.PipeNode:
+		return s.evalPipeline(dot, n)
+	}
+	s.errorf("can't handle assignment of %s to empty interface argument", n)
+	panic("not reached")
+}
+
+// indirect returns the item at the end of indirection, and a bool to indicate if it's nil.
+// We indirect through pointers and empty interfaces (only) because
+// non-empty interfaces have methods we might need.
+func indirect(v reflect.Value) (rv reflect.Value, isNil bool) {
+	for ; v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface; v = v.Elem() {
+		if v.IsNil() {
+			return v, true
+		}
+		if v.Kind() == reflect.Interface && v.NumMethod() > 0 {
+			break
+		}
+	}
+	return v, false
+}
+
+// printValue writes the textual representation of the value to the output of
+// the template.
+func (s *state) printValue(n parse.Node, v reflect.Value) {
+	s.at(n)
+	iface, ok := printableValue(v)
+	if !ok {
+		s.errorf("can't print %s of type %s", n, v.Type())
+	}
+	fmt.Fprint(s.wr, iface)
+}
+
+// printableValue returns the, possibly indirected, interface value inside v that
+// is best for a call to formatted printer.
+func printableValue(v reflect.Value) (interface{}, bool) {
+	if v.Kind() == reflect.Ptr {
+		v, _ = indirect(v) // fmt.Fprint handles nil.
+	}
+	if !v.IsValid() {
+		return "<no value>", true
+	}
+
+	if !v.Type().Implements(errorType) && !v.Type().Implements(fmtStringerType) {
+		if v.CanAddr() && (reflect.PtrTo(v.Type()).Implements(errorType) || reflect.PtrTo(v.Type()).Implements(fmtStringerType)) {
+			v = v.Addr()
+		} else {
+			switch v.Kind() {
+			case reflect.Chan, reflect.Func:
+				return nil, false
+			}
+		}
+	}
+	return v.Interface(), true
+}
+
+// Types to help sort the keys in a map for reproducible output.
+
+type rvs []reflect.Value
+
+func (x rvs) Len() int      { return len(x) }
+func (x rvs) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
+
+type rvInts struct{ rvs }
+
+func (x rvInts) Less(i, j int) bool { return x.rvs[i].Int() < x.rvs[j].Int() }
+
+type rvUints struct{ rvs }
+
+func (x rvUints) Less(i, j int) bool { return x.rvs[i].Uint() < x.rvs[j].Uint() }
+
+type rvFloats struct{ rvs }
+
+func (x rvFloats) Less(i, j int) bool { return x.rvs[i].Float() < x.rvs[j].Float() }
+
+type rvStrings struct{ rvs }
+
+func (x rvStrings) Less(i, j int) bool { return x.rvs[i].String() < x.rvs[j].String() }
+
+// sortKeys sorts (if it can) the slice of reflect.Values, which is a slice of map keys.
+func sortKeys(v []reflect.Value) []reflect.Value {
+	if len(v) <= 1 {
+		return v
+	}
+	switch v[0].Kind() {
+	case reflect.Float32, reflect.Float64:
+		sort.Sort(rvFloats{v})
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		sort.Sort(rvInts{v})
+	case reflect.String:
+		sort.Sort(rvStrings{v})
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		sort.Sort(rvUints{v})
+	}
+	return v
+}

vendor/github.com/alecthomas/template/funcs.go

@@ -0,0 +1,598 @@
+// 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.
+
+package template
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"net/url"
+	"reflect"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+)
+
+// FuncMap is the type of the map defining the mapping from names to functions.
+// Each function must have either a single return value, or two return values of
+// which the second has type error. In that case, if the second (error)
+// return value evaluates to non-nil during execution, execution terminates and
+// Execute returns that error.
+type FuncMap map[string]interface{}
+
+var builtins = FuncMap{
+	"and":      and,
+	"call":     call,
+	"html":     HTMLEscaper,
+	"index":    index,
+	"js":       JSEscaper,
+	"len":      length,
+	"not":      not,
+	"or":       or,
+	"print":    fmt.Sprint,
+	"printf":   fmt.Sprintf,
+	"println":  fmt.Sprintln,
+	"urlquery": URLQueryEscaper,
+
+	// Comparisons
+	"eq": eq, // ==
+	"ge": ge, // >=
+	"gt": gt, // >
+	"le": le, // <=
+	"lt": lt, // <
+	"ne": ne, // !=
+}
+
+var builtinFuncs = createValueFuncs(builtins)
+
+// createValueFuncs turns a FuncMap into a map[string]reflect.Value
+func createValueFuncs(funcMap FuncMap) map[string]reflect.Value {
+	m := make(map[string]reflect.Value)
+	addValueFuncs(m, funcMap)
+	return m
+}
+
+// addValueFuncs adds to values the functions in funcs, converting them to reflect.Values.
+func addValueFuncs(out map[string]reflect.Value, in FuncMap) {
+	for name, fn := range in {
+		v := reflect.ValueOf(fn)
+		if v.Kind() != reflect.Func {
+			panic("value for " + name + " not a function")
+		}
+		if !goodFunc(v.Type()) {
+			panic(fmt.Errorf("can't install method/function %q with %d results", name, v.Type().NumOut()))
+		}
+		out[name] = v
+	}
+}
+
+// addFuncs adds to values the functions in funcs. It does no checking of the input -
+// call addValueFuncs first.
+func addFuncs(out, in FuncMap) {
+	for name, fn := range in {
+		out[name] = fn
+	}
+}
+
+// goodFunc checks that the function or method has the right result signature.
+func goodFunc(typ reflect.Type) bool {
+	// We allow functions with 1 result or 2 results where the second is an error.
+	switch {
+	case typ.NumOut() == 1:
+		return true
+	case typ.NumOut() == 2 && typ.Out(1) == errorType:
+		return true
+	}
+	return false
+}
+
+// findFunction looks for a function in the template, and global map.
+func findFunction(name string, tmpl *Template) (reflect.Value, bool) {
+	if tmpl != nil && tmpl.common != nil {
+		if fn := tmpl.execFuncs[name]; fn.IsValid() {
+			return fn, true
+		}
+	}
+	if fn := builtinFuncs[name]; fn.IsValid() {
+		return fn, true
+	}
+	return reflect.Value{}, false
+}
+
+// Indexing.
+
+// index returns the result of indexing its first argument by the following
+// arguments.  Thus "index x 1 2 3" is, in Go syntax, x[1][2][3]. Each
+// indexed item must be a map, slice, or array.
+func index(item interface{}, indices ...interface{}) (interface{}, error) {
+	v := reflect.ValueOf(item)
+	for _, i := range indices {
+		index := reflect.ValueOf(i)
+		var isNil bool
+		if v, isNil = indirect(v); isNil {
+			return nil, fmt.Errorf("index of nil pointer")
+		}
+		switch v.Kind() {
+		case reflect.Array, reflect.Slice, reflect.String:
+			var x int64
+			switch index.Kind() {
+			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+				x = index.Int()
+			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+				x = int64(index.Uint())
+			default:
+				return nil, fmt.Errorf("cannot index slice/array with type %s", index.Type())
+			}
+			if x < 0 || x >= int64(v.Len()) {
+				return nil, fmt.Errorf("index out of range: %d", x)
+			}
+			v = v.Index(int(x))
+		case reflect.Map:
+			if !index.IsValid() {
+				index = reflect.Zero(v.Type().Key())
+			}
+			if !index.Type().AssignableTo(v.Type().Key()) {
+				return nil, fmt.Errorf("%s is not index type for %s", index.Type(), v.Type())
+			}
+			if x := v.MapIndex(index); x.IsValid() {
+				v = x
+			} else {
+				v = reflect.Zero(v.Type().Elem())
+			}
+		default:
+			return nil, fmt.Errorf("can't index item of type %s", v.Type())
+		}
+	}
+	return v.Interface(), nil
+}
+
+// Length
+
+// length returns the length of the item, with an error if it has no defined length.
+func length(item interface{}) (int, error) {
+	v, isNil := indirect(reflect.ValueOf(item))
+	if isNil {
+		return 0, fmt.Errorf("len of nil pointer")
+	}
+	switch v.Kind() {
+	case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice, reflect.String:
+		return v.Len(), nil
+	}
+	return 0, fmt.Errorf("len of type %s", v.Type())
+}
+
+// Function invocation
+
+// call returns the result of evaluating the first argument as a function.
+// The function must return 1 result, or 2 results, the second of which is an error.
+func call(fn interface{}, args ...interface{}) (interface{}, error) {
+	v := reflect.ValueOf(fn)
+	typ := v.Type()
+	if typ.Kind() != reflect.Func {
+		return nil, fmt.Errorf("non-function of type %s", typ)
+	}
+	if !goodFunc(typ) {
+		return nil, fmt.Errorf("function called with %d args; should be 1 or 2", typ.NumOut())
+	}
+	numIn := typ.NumIn()
+	var dddType reflect.Type
+	if typ.IsVariadic() {
+		if len(args) < numIn-1 {
+			return nil, fmt.Errorf("wrong number of args: got %d want at least %d", len(args), numIn-1)
+		}
+		dddType = typ.In(numIn - 1).Elem()
+	} else {
+		if len(args) != numIn {
+			return nil, fmt.Errorf("wrong number of args: got %d want %d", len(args), numIn)
+		}
+	}
+	argv := make([]reflect.Value, len(args))
+	for i, arg := range args {
+		value := reflect.ValueOf(arg)
+		// Compute the expected type. Clumsy because of variadics.
+		var argType reflect.Type
+		if !typ.IsVariadic() || i < numIn-1 {
+			argType = typ.In(i)
+		} else {
+			argType = dddType
+		}
+		if !value.IsValid() && canBeNil(argType) {
+			value = reflect.Zero(argType)
+		}
+		if !value.Type().AssignableTo(argType) {
+			return nil, fmt.Errorf("arg %d has type %s; should be %s", i, value.Type(), argType)
+		}
+		argv[i] = value
+	}
+	result := v.Call(argv)
+	if len(result) == 2 && !result[1].IsNil() {
+		return result[0].Interface(), result[1].Interface().(error)
+	}
+	return result[0].Interface(), nil
+}
+
+// Boolean logic.
+
+func truth(a interface{}) bool {
+	t, _ := isTrue(reflect.ValueOf(a))
+	return t
+}
+
+// and computes the Boolean AND of its arguments, returning
+// the first false argument it encounters, or the last argument.
+func and(arg0 interface{}, args ...interface{}) interface{} {
+	if !truth(arg0) {
+		return arg0
+	}
+	for i := range args {
+		arg0 = args[i]
+		if !truth(arg0) {
+			break
+		}
+	}
+	return arg0
+}
+
+// or computes the Boolean OR of its arguments, returning
+// the first true argument it encounters, or the last argument.
+func or(arg0 interface{}, args ...interface{}) interface{} {
+	if truth(arg0) {
+		return arg0
+	}
+	for i := range args {
+		arg0 = args[i]
+		if truth(arg0) {
+			break
+		}
+	}
+	return arg0
+}
+
+// not returns the Boolean negation of its argument.
+func not(arg interface{}) (truth bool) {
+	truth, _ = isTrue(reflect.ValueOf(arg))
+	return !truth
+}
+
+// Comparison.
+
+// TODO: Perhaps allow comparison between signed and unsigned integers.
+
+var (
+	errBadComparisonType = errors.New("invalid type for comparison")
+	errBadComparison     = errors.New("incompatible types for comparison")
+	errNoComparison      = errors.New("missing argument for comparison")
+)
+
+type kind int
+
+const (
+	invalidKind kind = iota
+	boolKind
+	complexKind
+	intKind
+	floatKind
+	integerKind
+	stringKind
+	uintKind
+)
+
+func basicKind(v reflect.Value) (kind, error) {
+	switch v.Kind() {
+	case reflect.Bool:
+		return boolKind, nil
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return intKind, nil
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return uintKind, nil
+	case reflect.Float32, reflect.Float64:
+		return floatKind, nil
+	case reflect.Complex64, reflect.Complex128:
+		return complexKind, nil
+	case reflect.String:
+		return stringKind, nil
+	}
+	return invalidKind, errBadComparisonType
+}
+
+// eq evaluates the comparison a == b || a == c || ...
+func eq(arg1 interface{}, arg2 ...interface{}) (bool, error) {
+	v1 := reflect.ValueOf(arg1)
+	k1, err := basicKind(v1)
+	if err != nil {
+		return false, err
+	}
+	if len(arg2) == 0 {
+		return false, errNoComparison
+	}
+	for _, arg := range arg2 {
+		v2 := reflect.ValueOf(arg)
+		k2, err := basicKind(v2)
+		if err != nil {
+			return false, err
+		}
+		truth := false
+		if k1 != k2 {
+			// Special case: Can compare integer values regardless of type's sign.
+			switch {
+			case k1 == intKind && k2 == uintKind:
+				truth = v1.Int() >= 0 && uint64(v1.Int()) == v2.Uint()
+			case k1 == uintKind && k2 == intKind:
+				truth = v2.Int() >= 0 && v1.Uint() == uint64(v2.Int())
+			default:
+				return false, errBadComparison
+			}
+		} else {
+			switch k1 {
+			case boolKind:
+				truth = v1.Bool() == v2.Bool()
+			case complexKind:
+				truth = v1.Complex() == v2.Complex()
+			case floatKind:
+				truth = v1.Float() == v2.Float()
+			case intKind:
+				truth = v1.Int() == v2.Int()
+			case stringKind:
+				truth = v1.String() == v2.String()
+			case uintKind:
+				truth = v1.Uint() == v2.Uint()
+			default:
+				panic("invalid kind")
+			}
+		}
+		if truth {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
+// ne evaluates the comparison a != b.
+func ne(arg1, arg2 interface{}) (bool, error) {
+	// != is the inverse of ==.
+	equal, err := eq(arg1, arg2)
+	return !equal, err
+}
+
+// lt evaluates the comparison a < b.
+func lt(arg1, arg2 interface{}) (bool, error) {
+	v1 := reflect.ValueOf(arg1)
+	k1, err := basicKind(v1)
+	if err != nil {
+		return false, err
+	}
+	v2 := reflect.ValueOf(arg2)
+	k2, err := basicKind(v2)
+	if err != nil {
+		return false, err
+	}
+	truth := false
+	if k1 != k2 {
+		// Special case: Can compare integer values regardless of type's sign.
+		switch {
+		case k1 == intKind && k2 == uintKind:
+			truth = v1.Int() < 0 || uint64(v1.Int()) < v2.Uint()
+		case k1 == uintKind && k2 == intKind:
+			truth = v2.Int() >= 0 && v1.Uint() < uint64(v2.Int())
+		default:
+			return false, errBadComparison
+		}
+	} else {
+		switch k1 {
+		case boolKind, complexKind:
+			return false, errBadComparisonType
+		case floatKind:
+			truth = v1.Float() < v2.Float()
+		case intKind:
+			truth = v1.Int() < v2.Int()
+		case stringKind:
+			truth = v1.String() < v2.String()
+		case uintKind:
+			truth = v1.Uint() < v2.Uint()
+		default:
+			panic("invalid kind")
+		}
+	}
+	return truth, nil
+}
+
+// le evaluates the comparison <= b.
+func le(arg1, arg2 interface{}) (bool, error) {
+	// <= is < or ==.
+	lessThan, err := lt(arg1, arg2)
+	if lessThan || err != nil {
+		return lessThan, err
+	}
+	return eq(arg1, arg2)
+}
+
+// gt evaluates the comparison a > b.
+func gt(arg1, arg2 interface{}) (bool, error) {
+	// > is the inverse of <=.
+	lessOrEqual, err := le(arg1, arg2)
+	if err != nil {
+		return false, err
+	}
+	return !lessOrEqual, nil
+}
+
+// ge evaluates the comparison a >= b.
+func ge(arg1, arg2 interface{}) (bool, error) {
+	// >= is the inverse of <.
+	lessThan, err := lt(arg1, arg2)
+	if err != nil {
+		return false, err
+	}
+	return !lessThan, nil
+}
+
+// HTML escaping.
+
+var (
+	htmlQuot = []byte("&#34;") // shorter than "&quot;"
+	htmlApos = []byte("&#39;") // shorter than "&apos;" and apos was not in HTML until HTML5
+	htmlAmp  = []byte("&amp;")
+	htmlLt   = []byte("&lt;")
+	htmlGt   = []byte("&gt;")
+)
+
+// HTMLEscape writes to w the escaped HTML equivalent of the plain text data b.
+func HTMLEscape(w io.Writer, b []byte) {
+	last := 0
+	for i, c := range b {
+		var html []byte
+		switch c {
+		case '"':
+			html = htmlQuot
+		case '\'':
+			html = htmlApos
+		case '&':
+			html = htmlAmp
+		case '<':
+			html = htmlLt
+		case '>':
+			html = htmlGt
+		default:
+			continue
+		}
+		w.Write(b[last:i])
+		w.Write(html)
+		last = i + 1
+	}
+	w.Write(b[last:])
+}
+
+// HTMLEscapeString returns the escaped HTML equivalent of the plain text data s.
+func HTMLEscapeString(s string) string {
+	// Avoid allocation if we can.
+	if strings.IndexAny(s, `'"&<>`) < 0 {
+		return s
+	}
+	var b bytes.Buffer
+	HTMLEscape(&b, []byte(s))
+	return b.String()
+}
+
+// HTMLEscaper returns the escaped HTML equivalent of the textual
+// representation of its arguments.
+func HTMLEscaper(args ...interface{}) string {
+	return HTMLEscapeString(evalArgs(args))
+}
+
+// JavaScript escaping.
+
+var (
+	jsLowUni = []byte(`\u00`)
+	hex      = []byte("0123456789ABCDEF")
+
+	jsBackslash = []byte(`\\`)
+	jsApos      = []byte(`\'`)
+	jsQuot      = []byte(`\"`)
+	jsLt        = []byte(`\x3C`)
+	jsGt        = []byte(`\x3E`)
+)
+
+// JSEscape writes to w the escaped JavaScript equivalent of the plain text data b.
+func JSEscape(w io.Writer, b []byte) {
+	last := 0
+	for i := 0; i < len(b); i++ {
+		c := b[i]
+
+		if !jsIsSpecial(rune(c)) {
+			// fast path: nothing to do
+			continue
+		}
+		w.Write(b[last:i])
+
+		if c < utf8.RuneSelf {
+			// Quotes, slashes and angle brackets get quoted.
+			// Control characters get written as \u00XX.
+			switch c {
+			case '\\':
+				w.Write(jsBackslash)
+			case '\'':
+				w.Write(jsApos)
+			case '"':
+				w.Write(jsQuot)
+			case '<':
+				w.Write(jsLt)
+			case '>':
+				w.Write(jsGt)
+			default:
+				w.Write(jsLowUni)
+				t, b := c>>4, c&0x0f
+				w.Write(hex[t : t+1])
+				w.Write(hex[b : b+1])
+			}
+		} else {
+			// Unicode rune.
+			r, size := utf8.DecodeRune(b[i:])
+			if unicode.IsPrint(r) {
+				w.Write(b[i : i+size])
+			} else {
+				fmt.Fprintf(w, "\\u%04X", r)
+			}
+			i += size - 1
+		}
+		last = i + 1
+	}
+	w.Write(b[last:])
+}
+
+// JSEscapeString returns the escaped JavaScript equivalent of the plain text data s.
+func JSEscapeString(s string) string {
+	// Avoid allocation if we can.
+	if strings.IndexFunc(s, jsIsSpecial) < 0 {
+		return s
+	}
+	var b bytes.Buffer
+	JSEscape(&b, []byte(s))
+	return b.String()
+}
+
+func jsIsSpecial(r rune) bool {
+	switch r {
+	case '\\', '\'', '"', '<', '>':
+		return true
+	}
+	return r < ' ' || utf8.RuneSelf <= r
+}
+
+// JSEscaper returns the escaped JavaScript equivalent of the textual
+// representation of its arguments.
+func JSEscaper(args ...interface{}) string {
+	return JSEscapeString(evalArgs(args))
+}
+
+// URLQueryEscaper returns the escaped value of the textual representation of
+// its arguments in a form suitable for embedding in a URL query.
+func URLQueryEscaper(args ...interface{}) string {
+	return url.QueryEscape(evalArgs(args))
+}
+
+// evalArgs formats the list of arguments into a string. It is therefore equivalent to
+//	fmt.Sprint(args...)
+// except that each argument is indirected (if a pointer), as required,
+// using the same rules as the default string evaluation during template
+// execution.
+func evalArgs(args []interface{}) string {
+	ok := false
+	var s string
+	// Fast path for simple common case.
+	if len(args) == 1 {
+		s, ok = args[0].(string)
+	}
+	if !ok {
+		for i, arg := range args {
+			a, ok := printableValue(reflect.ValueOf(arg))
+			if ok {
+				args[i] = a
+			} // else left fmt do its thing
+		}
+		s = fmt.Sprint(args...)
+	}
+	return s
+}

vendor/github.com/alecthomas/template/helper.go

@@ -0,0 +1,108 @@
+// 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.
+
+// Helper functions to make constructing templates easier.
+
+package template
+
+import (
+	"fmt"
+	"io/ioutil"
+	"path/filepath"
+)
+
+// Functions and methods to parse templates.
+
+// Must is a helper that wraps a call to a function returning (*Template, error)
+// and panics if the error is non-nil. It is intended for use in variable
+// initializations such as
+//	var t = template.Must(template.New("name").Parse("text"))
+func Must(t *Template, err error) *Template {
+	if err != nil {
+		panic(err)
+	}
+	return t
+}
+
+// ParseFiles creates a new Template and parses the template definitions from
+// the named files. The returned template's name will have the (base) name and
+// (parsed) contents of the first file. There must be at least one file.
+// If an error occurs, parsing stops and the returned *Template is nil.
+func ParseFiles(filenames ...string) (*Template, error) {
+	return parseFiles(nil, filenames...)
+}
+
+// ParseFiles parses the named files and associates the resulting templates with
+// t. If an error occurs, parsing stops and the returned template is nil;
+// otherwise it is t. There must be at least one file.
+func (t *Template) ParseFiles(filenames ...string) (*Template, error) {
+	return parseFiles(t, filenames...)
+}
+
+// parseFiles is the helper for the method and function. If the argument
+// template is nil, it is created from the first file.
+func parseFiles(t *Template, filenames ...string) (*Template, error) {
+	if len(filenames) == 0 {
+		// Not really a problem, but be consistent.
+		return nil, fmt.Errorf("template: no files named in call to ParseFiles")
+	}
+	for _, filename := range filenames {
+		b, err := ioutil.ReadFile(filename)
+		if err != nil {
+			return nil, err
+		}
+		s := string(b)
+		name := filepath.Base(filename)
+		// First template becomes return value if not already defined,
+		// and we use that one for subsequent New calls to associate
+		// all the templates together. Also, if this file has the same name
+		// as t, this file becomes the contents of t, so
+		//  t, err := New(name).Funcs(xxx).ParseFiles(name)
+		// works. Otherwise we create a new template associated with t.
+		var tmpl *Template
+		if t == nil {
+			t = New(name)
+		}
+		if name == t.Name() {
+			tmpl = t
+		} else {
+			tmpl = t.New(name)
+		}
+		_, err = tmpl.Parse(s)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return t, nil
+}
+
+// ParseGlob creates a new Template and parses the template definitions from the
+// files identified by the pattern, which must match at least one file. The
+// returned template will have the (base) name and (parsed) contents of the
+// first file matched by the pattern. ParseGlob is equivalent to calling
+// ParseFiles with the list of files matched by the pattern.
+func ParseGlob(pattern string) (*Template, error) {
+	return parseGlob(nil, pattern)
+}
+
+// ParseGlob parses the template definitions in the files identified by the
+// pattern and associates the resulting templates with t. The pattern is
+// processed by filepath.Glob and must match at least one file. ParseGlob is
+// equivalent to calling t.ParseFiles with the list of files matched by the
+// pattern.
+func (t *Template) ParseGlob(pattern string) (*Template, error) {
+	return parseGlob(t, pattern)
+}
+
+// parseGlob is the implementation of the function and method ParseGlob.
+func parseGlob(t *Template, pattern string) (*Template, error) {
+	filenames, err := filepath.Glob(pattern)
+	if err != nil {
+		return nil, err
+	}
+	if len(filenames) == 0 {
+		return nil, fmt.Errorf("template: pattern matches no files: %#q", pattern)
+	}
+	return parseFiles(t, filenames...)
+}

vendor/github.com/alecthomas/template/multi_test.go

@@ -0,0 +1,293 @@
+// 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.
+
+package template
+
+// Tests for mulitple-template parsing and execution.
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/alecthomas/template/parse"
+)
+
+const (
+	noError  = true
+	hasError = false
+)
+
+type multiParseTest struct {
+	name    string
+	input   string
+	ok      bool
+	names   []string
+	results []string
+}
+
+var multiParseTests = []multiParseTest{
+	{"empty", "", noError,
+		nil,
+		nil},
+	{"one", `{{define "foo"}} FOO {{end}}`, noError,
+		[]string{"foo"},
+		[]string{" FOO "}},
+	{"two", `{{define "foo"}} FOO {{end}}{{define "bar"}} BAR {{end}}`, noError,
+		[]string{"foo", "bar"},
+		[]string{" FOO ", " BAR "}},
+	// errors
+	{"missing end", `{{define "foo"}} FOO `, hasError,
+		nil,
+		nil},
+	{"malformed name", `{{define "foo}} FOO `, hasError,
+		nil,
+		nil},
+}
+
+func TestMultiParse(t *testing.T) {
+	for _, test := range multiParseTests {
+		template, err := New("root").Parse(test.input)
+		switch {
+		case err == nil && !test.ok:
+			t.Errorf("%q: expected error; got none", test.name)
+			continue
+		case err != nil && test.ok:
+			t.Errorf("%q: unexpected error: %v", test.name, err)
+			continue
+		case err != nil && !test.ok:
+			// expected error, got one
+			if *debug {
+				fmt.Printf("%s: %s\n\t%s\n", test.name, test.input, err)
+			}
+			continue
+		}
+		if template == nil {
+			continue
+		}
+		if len(template.tmpl) != len(test.names)+1 { // +1 for root
+			t.Errorf("%s: wrong number of templates; wanted %d got %d", test.name, len(test.names), len(template.tmpl))
+			continue
+		}
+		for i, name := range test.names {
+			tmpl, ok := template.tmpl[name]
+			if !ok {
+				t.Errorf("%s: can't find template %q", test.name, name)
+				continue
+			}
+			result := tmpl.Root.String()
+			if result != test.results[i] {
+				t.Errorf("%s=(%q): got\n\t%v\nexpected\n\t%v", test.name, test.input, result, test.results[i])
+			}
+		}
+	}
+}
+
+var multiExecTests = []execTest{
+	{"empty", "", "", nil, true},
+	{"text", "some text", "some text", nil, true},
+	{"invoke x", `{{template "x" .SI}}`, "TEXT", tVal, true},
+	{"invoke x no args", `{{template "x"}}`, "TEXT", tVal, true},
+	{"invoke dot int", `{{template "dot" .I}}`, "17", tVal, true},
+	{"invoke dot []int", `{{template "dot" .SI}}`, "[3 4 5]", tVal, true},
+	{"invoke dotV", `{{template "dotV" .U}}`, "v", tVal, true},
+	{"invoke nested int", `{{template "nested" .I}}`, "17", tVal, true},
+	{"variable declared by template", `{{template "nested" $x:=.SI}},{{index $x 1}}`, "[3 4 5],4", tVal, true},
+
+	// User-defined function: test argument evaluator.
+	{"testFunc literal", `{{oneArg "joe"}}`, "oneArg=joe", tVal, true},
+	{"testFunc .", `{{oneArg .}}`, "oneArg=joe", "joe", true},
+}
+
+// These strings are also in testdata/*.
+const multiText1 = `
+	{{define "x"}}TEXT{{end}}
+	{{define "dotV"}}{{.V}}{{end}}
+`
+
+const multiText2 = `
+	{{define "dot"}}{{.}}{{end}}
+	{{define "nested"}}{{template "dot" .}}{{end}}
+`
+
+func TestMultiExecute(t *testing.T) {
+	// Declare a couple of templates first.
+	template, err := New("root").Parse(multiText1)
+	if err != nil {
+		t.Fatalf("parse error for 1: %s", err)
+	}
+	_, err = template.Parse(multiText2)
+	if err != nil {
+		t.Fatalf("parse error for 2: %s", err)
+	}
+	testExecute(multiExecTests, template, t)
+}
+
+func TestParseFiles(t *testing.T) {
+	_, err := ParseFiles("DOES NOT EXIST")
+	if err == nil {
+		t.Error("expected error for non-existent file; got none")
+	}
+	template := New("root")
+	_, err = template.ParseFiles("testdata/file1.tmpl", "testdata/file2.tmpl")
+	if err != nil {
+		t.Fatalf("error parsing files: %v", err)
+	}
+	testExecute(multiExecTests, template, t)
+}
+
+func TestParseGlob(t *testing.T) {
+	_, err := ParseGlob("DOES NOT EXIST")
+	if err == nil {
+		t.Error("expected error for non-existent file; got none")
+	}
+	_, err = New("error").ParseGlob("[x")
+	if err == nil {
+		t.Error("expected error for bad pattern; got none")
+	}
+	template := New("root")
+	_, err = template.ParseGlob("testdata/file*.tmpl")
+	if err != nil {
+		t.Fatalf("error parsing files: %v", err)
+	}
+	testExecute(multiExecTests, template, t)
+}
+
+// In these tests, actual content (not just template definitions) comes from the parsed files.
+
+var templateFileExecTests = []execTest{
+	{"test", `{{template "tmpl1.tmpl"}}{{template "tmpl2.tmpl"}}`, "template1\n\ny\ntemplate2\n\nx\n", 0, true},
+}
+
+func TestParseFilesWithData(t *testing.T) {
+	template, err := New("root").ParseFiles("testdata/tmpl1.tmpl", "testdata/tmpl2.tmpl")
+	if err != nil {
+		t.Fatalf("error parsing files: %v", err)
+	}
+	testExecute(templateFileExecTests, template, t)
+}
+
+func TestParseGlobWithData(t *testing.T) {
+	template, err := New("root").ParseGlob("testdata/tmpl*.tmpl")
+	if err != nil {
+		t.Fatalf("error parsing files: %v", err)
+	}
+	testExecute(templateFileExecTests, template, t)
+}
+
+const (
+	cloneText1 = `{{define "a"}}{{template "b"}}{{template "c"}}{{end}}`
+	cloneText2 = `{{define "b"}}b{{end}}`
+	cloneText3 = `{{define "c"}}root{{end}}`
+	cloneText4 = `{{define "c"}}clone{{end}}`
+)
+
+func TestClone(t *testing.T) {
+	// Create some templates and clone the root.
+	root, err := New("root").Parse(cloneText1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = root.Parse(cloneText2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	clone := Must(root.Clone())
+	// Add variants to both.
+	_, err = root.Parse(cloneText3)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = clone.Parse(cloneText4)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Verify that the clone is self-consistent.
+	for k, v := range clone.tmpl {
+		if k == clone.name && v.tmpl[k] != clone {
+			t.Error("clone does not contain root")
+		}
+		if v != v.tmpl[v.name] {
+			t.Errorf("clone does not contain self for %q", k)
+		}
+	}
+	// Execute root.
+	var b bytes.Buffer
+	err = root.ExecuteTemplate(&b, "a", 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if b.String() != "broot" {
+		t.Errorf("expected %q got %q", "broot", b.String())
+	}
+	// Execute copy.
+	b.Reset()
+	err = clone.ExecuteTemplate(&b, "a", 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if b.String() != "bclone" {
+		t.Errorf("expected %q got %q", "bclone", b.String())
+	}
+}
+
+func TestAddParseTree(t *testing.T) {
+	// Create some templates.
+	root, err := New("root").Parse(cloneText1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = root.Parse(cloneText2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Add a new parse tree.
+	tree, err := parse.Parse("cloneText3", cloneText3, "", "", nil, builtins)
+	if err != nil {
+		t.Fatal(err)
+	}
+	added, err := root.AddParseTree("c", tree["c"])
+	// Execute.
+	var b bytes.Buffer
+	err = added.ExecuteTemplate(&b, "a", 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if b.String() != "broot" {
+		t.Errorf("expected %q got %q", "broot", b.String())
+	}
+}
+
+// Issue 7032
+func TestAddParseTreeToUnparsedTemplate(t *testing.T) {
+	master := "{{define \"master\"}}{{end}}"
+	tmpl := New("master")
+	tree, err := parse.Parse("master", master, "", "", nil)
+	if err != nil {
+		t.Fatalf("unexpected parse err: %v", err)
+	}
+	masterTree := tree["master"]
+	tmpl.AddParseTree("master", masterTree) // used to panic
+}
+
+func TestRedefinition(t *testing.T) {
+	var tmpl *Template
+	var err error
+	if tmpl, err = New("tmpl1").Parse(`{{define "test"}}foo{{end}}`); err != nil {
+		t.Fatalf("parse 1: %v", err)
+	}
+	if _, err = tmpl.Parse(`{{define "test"}}bar{{end}}`); err == nil {
+		t.Fatal("expected error")
+	}
+	if !strings.Contains(err.Error(), "redefinition") {
+		t.Fatalf("expected redefinition error; got %v", err)
+	}
+	if _, err = tmpl.New("tmpl2").Parse(`{{define "test"}}bar{{end}}`); err == nil {
+		t.Fatal("expected error")
+	}
+	if !strings.Contains(err.Error(), "redefinition") {
+		t.Fatalf("expected redefinition error; got %v", err)
+	}
+}

vendor/github.com/alecthomas/template/parse/lex.go

@@ -0,0 +1,556 @@
+// 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.
+
+package parse
+
+import (
+	"fmt"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+)
+
+// item represents a token or text string returned from the scanner.
+type item struct {
+	typ itemType // The type of this item.
+	pos Pos      // The starting position, in bytes, of this item in the input string.
+	val string   // The value of this item.
+}
+
+func (i item) String() string {
+	switch {
+	case i.typ == itemEOF:
+		return "EOF"
+	case i.typ == itemError:
+		return i.val
+	case i.typ > itemKeyword:
+		return fmt.Sprintf("<%s>", i.val)
+	case len(i.val) > 10:
+		return fmt.Sprintf("%.10q...", i.val)
+	}
+	return fmt.Sprintf("%q", i.val)
+}
+
+// itemType identifies the type of lex items.
+type itemType int
+
+const (
+	itemError        itemType = iota // error occurred; value is text of error
+	itemBool                         // boolean constant
+	itemChar                         // printable ASCII character; grab bag for comma etc.
+	itemCharConstant                 // character constant
+	itemComplex                      // complex constant (1+2i); imaginary is just a number
+	itemColonEquals                  // colon-equals (':=') introducing a declaration
+	itemEOF
+	itemField        // alphanumeric identifier starting with '.'
+	itemIdentifier   // alphanumeric identifier not starting with '.'
+	itemLeftDelim    // left action delimiter
+	itemLeftParen    // '(' inside action
+	itemNumber       // simple number, including imaginary
+	itemPipe         // pipe symbol
+	itemRawString    // raw quoted string (includes quotes)
+	itemRightDelim   // right action delimiter
+	itemElideNewline // elide newline after right delim
+	itemRightParen   // ')' inside action
+	itemSpace        // run of spaces separating arguments
+	itemString       // quoted string (includes quotes)
+	itemText         // plain text
+	itemVariable     // variable starting with '$', such as '$' or  '$1' or '$hello'
+	// Keywords appear after all the rest.
+	itemKeyword  // used only to delimit the keywords
+	itemDot      // the cursor, spelled '.'
+	itemDefine   // define keyword
+	itemElse     // else keyword
+	itemEnd      // end keyword
+	itemIf       // if keyword
+	itemNil      // the untyped nil constant, easiest to treat as a keyword
+	itemRange    // range keyword
+	itemTemplate // template keyword
+	itemWith     // with keyword
+)
+
+var key = map[string]itemType{
+	".":        itemDot,
+	"define":   itemDefine,
+	"else":     itemElse,
+	"end":      itemEnd,
+	"if":       itemIf,
+	"range":    itemRange,
+	"nil":      itemNil,
+	"template": itemTemplate,
+	"with":     itemWith,
+}
+
+const eof = -1
+
+// stateFn represents the state of the scanner as a function that returns the next state.
+type stateFn func(*lexer) stateFn
+
+// lexer holds the state of the scanner.
+type lexer struct {
+	name       string    // the name of the input; used only for error reports
+	input      string    // the string being scanned
+	leftDelim  string    // start of action
+	rightDelim string    // end of action
+	state      stateFn   // the next lexing function to enter
+	pos        Pos       // current position in the input
+	start      Pos       // start position of this item
+	width      Pos       // width of last rune read from input
+	lastPos    Pos       // position of most recent item returned by nextItem
+	items      chan item // channel of scanned items
+	parenDepth int       // nesting depth of ( ) exprs
+}
+
+// next returns the next rune in the input.
+func (l *lexer) next() rune {
+	if int(l.pos) >= len(l.input) {
+		l.width = 0
+		return eof
+	}
+	r, w := utf8.DecodeRuneInString(l.input[l.pos:])
+	l.width = Pos(w)
+	l.pos += l.width
+	return r
+}
+
+// peek returns but does not consume the next rune in the input.
+func (l *lexer) peek() rune {
+	r := l.next()
+	l.backup()
+	return r
+}
+
+// backup steps back one rune. Can only be called once per call of next.
+func (l *lexer) backup() {
+	l.pos -= l.width
+}
+
+// emit passes an item back to the client.
+func (l *lexer) emit(t itemType) {
+	l.items <- item{t, l.start, l.input[l.start:l.pos]}
+	l.start = l.pos
+}
+
+// ignore skips over the pending input before this point.
+func (l *lexer) ignore() {
+	l.start = l.pos
+}
+
+// accept consumes the next rune if it's from the valid set.
+func (l *lexer) accept(valid string) bool {
+	if strings.IndexRune(valid, l.next()) >= 0 {
+		return true
+	}
+	l.backup()
+	return false
+}
+
+// acceptRun consumes a run of runes from the valid set.
+func (l *lexer) acceptRun(valid string) {
+	for strings.IndexRune(valid, l.next()) >= 0 {
+	}
+	l.backup()
+}
+
+// lineNumber reports which line we're on, based on the position of
+// the previous item returned by nextItem. Doing it this way
+// means we don't have to worry about peek double counting.
+func (l *lexer) lineNumber() int {
+	return 1 + strings.Count(l.input[:l.lastPos], "\n")
+}
+
+// errorf returns an error token and terminates the scan by passing
+// back a nil pointer that will be the next state, terminating l.nextItem.
+func (l *lexer) errorf(format string, args ...interface{}) stateFn {
+	l.items <- item{itemError, l.start, fmt.Sprintf(format, args...)}
+	return nil
+}
+
+// nextItem returns the next item from the input.
+func (l *lexer) nextItem() item {
+	item := <-l.items
+	l.lastPos = item.pos
+	return item
+}
+
+// lex creates a new scanner for the input string.
+func lex(name, input, left, right string) *lexer {
+	if left == "" {
+		left = leftDelim
+	}
+	if right == "" {
+		right = rightDelim
+	}
+	l := &lexer{
+		name:       name,
+		input:      input,
+		leftDelim:  left,
+		rightDelim: right,
+		items:      make(chan item),
+	}
+	go l.run()
+	return l
+}
+
+// run runs the state machine for the lexer.
+func (l *lexer) run() {
+	for l.state = lexText; l.state != nil; {
+		l.state = l.state(l)
+	}
+}
+
+// state functions
+
+const (
+	leftDelim    = "{{"
+	rightDelim   = "}}"
+	leftComment  = "/*"
+	rightComment = "*/"
+)
+
+// lexText scans until an opening action delimiter, "{{".
+func lexText(l *lexer) stateFn {
+	for {
+		if strings.HasPrefix(l.input[l.pos:], l.leftDelim) {
+			if l.pos > l.start {
+				l.emit(itemText)
+			}
+			return lexLeftDelim
+		}
+		if l.next() == eof {
+			break
+		}
+	}
+	// Correctly reached EOF.
+	if l.pos > l.start {
+		l.emit(itemText)
+	}
+	l.emit(itemEOF)
+	return nil
+}
+
+// lexLeftDelim scans the left delimiter, which is known to be present.
+func lexLeftDelim(l *lexer) stateFn {
+	l.pos += Pos(len(l.leftDelim))
+	if strings.HasPrefix(l.input[l.pos:], leftComment) {
+		return lexComment
+	}
+	l.emit(itemLeftDelim)
+	l.parenDepth = 0
+	return lexInsideAction
+}
+
+// lexComment scans a comment. The left comment marker is known to be present.
+func lexComment(l *lexer) stateFn {
+	l.pos += Pos(len(leftComment))
+	i := strings.Index(l.input[l.pos:], rightComment)
+	if i < 0 {
+		return l.errorf("unclosed comment")
+	}
+	l.pos += Pos(i + len(rightComment))
+	if !strings.HasPrefix(l.input[l.pos:], l.rightDelim) {
+		return l.errorf("comment ends before closing delimiter")
+
+	}
+	l.pos += Pos(len(l.rightDelim))
+	l.ignore()
+	return lexText
+}
+
+// lexRightDelim scans the right delimiter, which is known to be present.
+func lexRightDelim(l *lexer) stateFn {
+	l.pos += Pos(len(l.rightDelim))
+	l.emit(itemRightDelim)
+	if l.peek() == '\\' {
+		l.pos++
+		l.emit(itemElideNewline)
+	}
+	return lexText
+}
+
+// lexInsideAction scans the elements inside action delimiters.
+func lexInsideAction(l *lexer) stateFn {
+	// Either number, quoted string, or identifier.
+	// Spaces separate arguments; runs of spaces turn into itemSpace.
+	// Pipe symbols separate and are emitted.
+	if strings.HasPrefix(l.input[l.pos:], l.rightDelim+"\\") || strings.HasPrefix(l.input[l.pos:], l.rightDelim) {
+		if l.parenDepth == 0 {
+			return lexRightDelim
+		}
+		return l.errorf("unclosed left paren")
+	}
+	switch r := l.next(); {
+	case r == eof || isEndOfLine(r):
+		return l.errorf("unclosed action")
+	case isSpace(r):
+		return lexSpace
+	case r == ':':
+		if l.next() != '=' {
+			return l.errorf("expected :=")
+		}
+		l.emit(itemColonEquals)
+	case r == '|':
+		l.emit(itemPipe)
+	case r == '"':
+		return lexQuote
+	case r == '`':
+		return lexRawQuote
+	case r == '$':
+		return lexVariable
+	case r == '\'':
+		return lexChar
+	case r == '.':
+		// special look-ahead for ".field" so we don't break l.backup().
+		if l.pos < Pos(len(l.input)) {
+			r := l.input[l.pos]
+			if r < '0' || '9' < r {
+				return lexField
+			}
+		}
+		fallthrough // '.' can start a number.
+	case r == '+' || r == '-' || ('0' <= r && r <= '9'):
+		l.backup()
+		return lexNumber
+	case isAlphaNumeric(r):
+		l.backup()
+		return lexIdentifier
+	case r == '(':
+		l.emit(itemLeftParen)
+		l.parenDepth++
+		return lexInsideAction
+	case r == ')':
+		l.emit(itemRightParen)
+		l.parenDepth--
+		if l.parenDepth < 0 {
+			return l.errorf("unexpected right paren %#U", r)
+		}
+		return lexInsideAction
+	case r <= unicode.MaxASCII && unicode.IsPrint(r):
+		l.emit(itemChar)
+		return lexInsideAction
+	default:
+		return l.errorf("unrecognized character in action: %#U", r)
+	}
+	return lexInsideAction
+}
+
+// lexSpace scans a run of space characters.
+// One space has already been seen.
+func lexSpace(l *lexer) stateFn {
+	for isSpace(l.peek()) {
+		l.next()
+	}
+	l.emit(itemSpace)
+	return lexInsideAction
+}
+
+// lexIdentifier scans an alphanumeric.
+func lexIdentifier(l *lexer) stateFn {
+Loop:
+	for {
+		switch r := l.next(); {
+		case isAlphaNumeric(r):
+			// absorb.
+		default:
+			l.backup()
+			word := l.input[l.start:l.pos]
+			if !l.atTerminator() {
+				return l.errorf("bad character %#U", r)
+			}
+			switch {
+			case key[word] > itemKeyword:
+				l.emit(key[word])
+			case word[0] == '.':
+				l.emit(itemField)
+			case word == "true", word == "false":
+				l.emit(itemBool)
+			default:
+				l.emit(itemIdentifier)
+			}
+			break Loop
+		}
+	}
+	return lexInsideAction
+}
+
+// lexField scans a field: .Alphanumeric.
+// The . has been scanned.
+func lexField(l *lexer) stateFn {
+	return lexFieldOrVariable(l, itemField)
+}
+
+// lexVariable scans a Variable: $Alphanumeric.
+// The $ has been scanned.
+func lexVariable(l *lexer) stateFn {
+	if l.atTerminator() { // Nothing interesting follows -> "$".
+		l.emit(itemVariable)
+		return lexInsideAction
+	}
+	return lexFieldOrVariable(l, itemVariable)
+}
+
+// lexVariable scans a field or variable: [.$]Alphanumeric.
+// The . or $ has been scanned.
+func lexFieldOrVariable(l *lexer, typ itemType) stateFn {
+	if l.atTerminator() { // Nothing interesting follows -> "." or "$".
+		if typ == itemVariable {
+			l.emit(itemVariable)
+		} else {
+			l.emit(itemDot)
+		}
+		return lexInsideAction
+	}
+	var r rune
+	for {
+		r = l.next()
+		if !isAlphaNumeric(r) {
+			l.backup()
+			break
+		}
+	}
+	if !l.atTerminator() {
+		return l.errorf("bad character %#U", r)
+	}
+	l.emit(typ)
+	return lexInsideAction
+}
+
+// atTerminator reports whether the input is at valid termination character to
+// appear after an identifier. Breaks .X.Y into two pieces. Also catches cases
+// like "$x+2" not being acceptable without a space, in case we decide one
+// day to implement arithmetic.
+func (l *lexer) atTerminator() bool {
+	r := l.peek()
+	if isSpace(r) || isEndOfLine(r) {
+		return true
+	}
+	switch r {
+	case eof, '.', ',', '|', ':', ')', '(':
+		return true
+	}
+	// Does r start the delimiter? This can be ambiguous (with delim=="//", $x/2 will
+	// succeed but should fail) but only in extremely rare cases caused by willfully
+	// bad choice of delimiter.
+	if rd, _ := utf8.DecodeRuneInString(l.rightDelim); rd == r {
+		return true
+	}
+	return false
+}
+
+// lexChar scans a character constant. The initial quote is already
+// scanned. Syntax checking is done by the parser.
+func lexChar(l *lexer) stateFn {
+Loop:
+	for {
+		switch l.next() {
+		case '\\':
+			if r := l.next(); r != eof && r != '\n' {
+				break
+			}
+			fallthrough
+		case eof, '\n':
+			return l.errorf("unterminated character constant")
+		case '\'':
+			break Loop
+		}
+	}
+	l.emit(itemCharConstant)
+	return lexInsideAction
+}
+
+// lexNumber scans a number: decimal, octal, hex, float, or imaginary. This
+// isn't a perfect number scanner - for instance it accepts "." and "0x0.2"
+// and "089" - but when it's wrong the input is invalid and the parser (via
+// strconv) will notice.
+func lexNumber(l *lexer) stateFn {
+	if !l.scanNumber() {
+		return l.errorf("bad number syntax: %q", l.input[l.start:l.pos])
+	}
+	if sign := l.peek(); sign == '+' || sign == '-' {
+		// Complex: 1+2i. No spaces, must end in 'i'.
+		if !l.scanNumber() || l.input[l.pos-1] != 'i' {
+			return l.errorf("bad number syntax: %q", l.input[l.start:l.pos])
+		}
+		l.emit(itemComplex)
+	} else {
+		l.emit(itemNumber)
+	}
+	return lexInsideAction
+}
+
+func (l *lexer) scanNumber() bool {
+	// Optional leading sign.
+	l.accept("+-")
+	// Is it hex?
+	digits := "0123456789"
+	if l.accept("0") && l.accept("xX") {
+		digits = "0123456789abcdefABCDEF"
+	}
+	l.acceptRun(digits)
+	if l.accept(".") {
+		l.acceptRun(digits)
+	}
+	if l.accept("eE") {
+		l.accept("+-")
+		l.acceptRun("0123456789")
+	}
+	// Is it imaginary?
+	l.accept("i")
+	// Next thing mustn't be alphanumeric.
+	if isAlphaNumeric(l.peek()) {
+		l.next()
+		return false
+	}
+	return true
+}
+
+// lexQuote scans a quoted string.
+func lexQuote(l *lexer) stateFn {
+Loop:
+	for {
+		switch l.next() {
+		case '\\':
+			if r := l.next(); r != eof && r != '\n' {
+				break
+			}
+			fallthrough
+		case eof, '\n':
+			return l.errorf("unterminated quoted string")
+		case '"':
+			break Loop
+		}
+	}
+	l.emit(itemString)
+	return lexInsideAction
+}
+
+// lexRawQuote scans a raw quoted string.
+func lexRawQuote(l *lexer) stateFn {
+Loop:
+	for {
+		switch l.next() {
+		case eof, '\n':
+			return l.errorf("unterminated raw quoted string")
+		case '`':
+			break Loop
+		}
+	}
+	l.emit(itemRawString)
+	return lexInsideAction
+}
+
+// isSpace reports whether r is a space character.
+func isSpace(r rune) bool {
+	return r == ' ' || r == '\t'
+}
+
+// isEndOfLine reports whether r is an end-of-line character.
+func isEndOfLine(r rune) bool {
+	return r == '\r' || r == '\n'
+}
+
+// isAlphaNumeric reports whether r is an alphabetic, digit, or underscore.
+func isAlphaNumeric(r rune) bool {
+	return r == '_' || unicode.IsLetter(r) || unicode.IsDigit(r)
+}

vendor/github.com/alecthomas/template/parse/lex_test.go

@@ -0,0 +1,468 @@
+// 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.
+
+package parse
+
+import (
+	"fmt"
+	"testing"
+)
+
+// Make the types prettyprint.
+var itemName = map[itemType]string{
+	itemError:        "error",
+	itemBool:         "bool",
+	itemChar:         "char",
+	itemCharConstant: "charconst",
+	itemComplex:      "complex",
+	itemColonEquals:  ":=",
+	itemEOF:          "EOF",
+	itemField:        "field",
+	itemIdentifier:   "identifier",
+	itemLeftDelim:    "left delim",
+	itemLeftParen:    "(",
+	itemNumber:       "number",
+	itemPipe:         "pipe",
+	itemRawString:    "raw string",
+	itemRightDelim:   "right delim",
+	itemElideNewline: "elide newline",
+	itemRightParen:   ")",
+	itemSpace:        "space",
+	itemString:       "string",
+	itemVariable:     "variable",
+
+	// keywords
+	itemDot:      ".",
+	itemDefine:   "define",
+	itemElse:     "else",
+	itemIf:       "if",
+	itemEnd:      "end",
+	itemNil:      "nil",
+	itemRange:    "range",
+	itemTemplate: "template",
+	itemWith:     "with",
+}
+
+func (i itemType) String() string {
+	s := itemName[i]
+	if s == "" {
+		return fmt.Sprintf("item%d", int(i))
+	}
+	return s
+}
+
+type lexTest struct {
+	name  string
+	input string
+	items []item
+}
+
+var (
+	tEOF          = item{itemEOF, 0, ""}
+	tFor          = item{itemIdentifier, 0, "for"}
+	tLeft         = item{itemLeftDelim, 0, "{{"}
+	tLpar         = item{itemLeftParen, 0, "("}
+	tPipe         = item{itemPipe, 0, "|"}
+	tQuote        = item{itemString, 0, `"abc \n\t\" "`}
+	tRange        = item{itemRange, 0, "range"}
+	tRight        = item{itemRightDelim, 0, "}}"}
+	tElideNewline = item{itemElideNewline, 0, "\\"}
+	tRpar         = item{itemRightParen, 0, ")"}
+	tSpace        = item{itemSpace, 0, " "}
+	raw           = "`" + `abc\n\t\" ` + "`"
+	tRawQuote     = item{itemRawString, 0, raw}
+)
+
+var lexTests = []lexTest{
+	{"empty", "", []item{tEOF}},
+	{"spaces", " \t\n", []item{{itemText, 0, " \t\n"}, tEOF}},
+	{"text", `now is the time`, []item{{itemText, 0, "now is the time"}, tEOF}},
+	{"elide newline", "{{}}\\", []item{tLeft, tRight, tElideNewline, tEOF}},
+	{"text with comment", "hello-{{/* this is a comment */}}-world", []item{
+		{itemText, 0, "hello-"},
+		{itemText, 0, "-world"},
+		tEOF,
+	}},
+	{"punctuation", "{{,@% }}", []item{
+		tLeft,
+		{itemChar, 0, ","},
+		{itemChar, 0, "@"},
+		{itemChar, 0, "%"},
+		tSpace,
+		tRight,
+		tEOF,
+	}},
+	{"parens", "{{((3))}}", []item{
+		tLeft,
+		tLpar,
+		tLpar,
+		{itemNumber, 0, "3"},
+		tRpar,
+		tRpar,
+		tRight,
+		tEOF,
+	}},
+	{"empty action", `{{}}`, []item{tLeft, tRight, tEOF}},
+	{"for", `{{for}}`, []item{tLeft, tFor, tRight, tEOF}},
+	{"quote", `{{"abc \n\t\" "}}`, []item{tLeft, tQuote, tRight, tEOF}},
+	{"raw quote", "{{" + raw + "}}", []item{tLeft, tRawQuote, tRight, tEOF}},
+	{"numbers", "{{1 02 0x14 -7.2i 1e3 +1.2e-4 4.2i 1+2i}}", []item{
+		tLeft,
+		{itemNumber, 0, "1"},
+		tSpace,
+		{itemNumber, 0, "02"},
+		tSpace,
+		{itemNumber, 0, "0x14"},
+		tSpace,
+		{itemNumber, 0, "-7.2i"},
+		tSpace,
+		{itemNumber, 0, "1e3"},
+		tSpace,
+		{itemNumber, 0, "+1.2e-4"},
+		tSpace,
+		{itemNumber, 0, "4.2i"},
+		tSpace,
+		{itemComplex, 0, "1+2i"},
+		tRight,
+		tEOF,
+	}},
+	{"characters", `{{'a' '\n' '\'' '\\' '\u00FF' '\xFF' '本'}}`, []item{
+		tLeft,
+		{itemCharConstant, 0, `'a'`},
+		tSpace,
+		{itemCharConstant, 0, `'\n'`},
+		tSpace,
+		{itemCharConstant, 0, `'\''`},
+		tSpace,
+		{itemCharConstant, 0, `'\\'`},
+		tSpace,
+		{itemCharConstant, 0, `'\u00FF'`},
+		tSpace,
+		{itemCharConstant, 0, `'\xFF'`},
+		tSpace,
+		{itemCharConstant, 0, `'本'`},
+		tRight,
+		tEOF,
+	}},
+	{"bools", "{{true false}}", []item{
+		tLeft,
+		{itemBool, 0, "true"},
+		tSpace,
+		{itemBool, 0, "false"},
+		tRight,
+		tEOF,
+	}},
+	{"dot", "{{.}}", []item{
+		tLeft,
+		{itemDot, 0, "."},
+		tRight,
+		tEOF,
+	}},
+	{"nil", "{{nil}}", []item{
+		tLeft,
+		{itemNil, 0, "nil"},
+		tRight,
+		tEOF,
+	}},
+	{"dots", "{{.x . .2 .x.y.z}}", []item{
+		tLeft,
+		{itemField, 0, ".x"},
+		tSpace,
+		{itemDot, 0, "."},
+		tSpace,
+		{itemNumber, 0, ".2"},
+		tSpace,
+		{itemField, 0, ".x"},
+		{itemField, 0, ".y"},
+		{itemField, 0, ".z"},
+		tRight,
+		tEOF,
+	}},
+	{"keywords", "{{range if else end with}}", []item{
+		tLeft,
+		{itemRange, 0, "range"},
+		tSpace,
+		{itemIf, 0, "if"},
+		tSpace,
+		{itemElse, 0, "else"},
+		tSpace,
+		{itemEnd, 0, "end"},
+		tSpace,
+		{itemWith, 0, "with"},
+		tRight,
+		tEOF,
+	}},
+	{"variables", "{{$c := printf $ $hello $23 $ $var.Field .Method}}", []item{
+		tLeft,
+		{itemVariable, 0, "$c"},
+		tSpace,
+		{itemColonEquals, 0, ":="},
+		tSpace,
+		{itemIdentifier, 0, "printf"},
+		tSpace,
+		{itemVariable, 0, "$"},
+		tSpace,
+		{itemVariable, 0, "$hello"},
+		tSpace,
+		{itemVariable, 0, "$23"},
+		tSpace,
+		{itemVariable, 0, "$"},
+		tSpace,
+		{itemVariable, 0, "$var"},
+		{itemField, 0, ".Field"},
+		tSpace,
+		{itemField, 0, ".Method"},
+		tRight,
+		tEOF,
+	}},
+	{"variable invocation", "{{$x 23}}", []item{
+		tLeft,
+		{itemVariable, 0, "$x"},
+		tSpace,
+		{itemNumber, 0, "23"},
+		tRight,
+		tEOF,
+	}},
+	{"pipeline", `intro {{echo hi 1.2 |noargs|args 1 "hi"}} outro`, []item{
+		{itemText, 0, "intro "},
+		tLeft,
+		{itemIdentifier, 0, "echo"},
+		tSpace,
+		{itemIdentifier, 0, "hi"},
+		tSpace,
+		{itemNumber, 0, "1.2"},
+		tSpace,
+		tPipe,
+		{itemIdentifier, 0, "noargs"},
+		tPipe,
+		{itemIdentifier, 0, "args"},
+		tSpace,
+		{itemNumber, 0, "1"},
+		tSpace,
+		{itemString, 0, `"hi"`},
+		tRight,
+		{itemText, 0, " outro"},
+		tEOF,
+	}},
+	{"declaration", "{{$v := 3}}", []item{
+		tLeft,
+		{itemVariable, 0, "$v"},
+		tSpace,
+		{itemColonEquals, 0, ":="},
+		tSpace,
+		{itemNumber, 0, "3"},
+		tRight,
+		tEOF,
+	}},
+	{"2 declarations", "{{$v , $w := 3}}", []item{
+		tLeft,
+		{itemVariable, 0, "$v"},
+		tSpace,
+		{itemChar, 0, ","},
+		tSpace,
+		{itemVariable, 0, "$w"},
+		tSpace,
+		{itemColonEquals, 0, ":="},
+		tSpace,
+		{itemNumber, 0, "3"},
+		tRight,
+		tEOF,
+	}},
+	{"field of parenthesized expression", "{{(.X).Y}}", []item{
+		tLeft,
+		tLpar,
+		{itemField, 0, ".X"},
+		tRpar,
+		{itemField, 0, ".Y"},
+		tRight,
+		tEOF,
+	}},
+	// errors
+	{"badchar", "#{{\x01}}", []item{
+		{itemText, 0, "#"},
+		tLeft,
+		{itemError, 0, "unrecognized character in action: U+0001"},
+	}},
+	{"unclosed action", "{{\n}}", []item{
+		tLeft,
+		{itemError, 0, "unclosed action"},
+	}},
+	{"EOF in action", "{{range", []item{
+		tLeft,
+		tRange,
+		{itemError, 0, "unclosed action"},
+	}},
+	{"unclosed quote", "{{\"\n\"}}", []item{
+		tLeft,
+		{itemError, 0, "unterminated quoted string"},
+	}},
+	{"unclosed raw quote", "{{`xx\n`}}", []item{
+		tLeft,
+		{itemError, 0, "unterminated raw quoted string"},
+	}},
+	{"unclosed char constant", "{{'\n}}", []item{
+		tLeft,
+		{itemError, 0, "unterminated character constant"},
+	}},
+	{"bad number", "{{3k}}", []item{
+		tLeft,
+		{itemError, 0, `bad number syntax: "3k"`},
+	}},
+	{"unclosed paren", "{{(3}}", []item{
+		tLeft,
+		tLpar,
+		{itemNumber, 0, "3"},
+		{itemError, 0, `unclosed left paren`},
+	}},
+	{"extra right paren", "{{3)}}", []item{
+		tLeft,
+		{itemNumber, 0, "3"},
+		tRpar,
+		{itemError, 0, `unexpected right paren U+0029 ')'`},
+	}},
+
+	// Fixed bugs
+	// Many elements in an action blew the lookahead until
+	// we made lexInsideAction not loop.
+	{"long pipeline deadlock", "{{|||||}}", []item{
+		tLeft,
+		tPipe,
+		tPipe,
+		tPipe,
+		tPipe,
+		tPipe,
+		tRight,
+		tEOF,
+	}},
+	{"text with bad comment", "hello-{{/*/}}-world", []item{
+		{itemText, 0, "hello-"},
+		{itemError, 0, `unclosed comment`},
+	}},
+	{"text with comment close separted from delim", "hello-{{/* */ }}-world", []item{
+		{itemText, 0, "hello-"},
+		{itemError, 0, `comment ends before closing delimiter`},
+	}},
+	// This one is an error that we can't catch because it breaks templates with
+	// minimized JavaScript. Should have fixed it before Go 1.1.
+	{"unmatched right delimiter", "hello-{.}}-world", []item{
+		{itemText, 0, "hello-{.}}-world"},
+		tEOF,
+	}},
+}
+
+// collect gathers the emitted items into a slice.
+func collect(t *lexTest, left, right string) (items []item) {
+	l := lex(t.name, t.input, left, right)
+	for {
+		item := l.nextItem()
+		items = append(items, item)
+		if item.typ == itemEOF || item.typ == itemError {
+			break
+		}
+	}
+	return
+}
+
+func equal(i1, i2 []item, checkPos bool) bool {
+	if len(i1) != len(i2) {
+		return false
+	}
+	for k := range i1 {
+		if i1[k].typ != i2[k].typ {
+			return false
+		}
+		if i1[k].val != i2[k].val {
+			return false
+		}
+		if checkPos && i1[k].pos != i2[k].pos {
+			return false
+		}
+	}
+	return true
+}
+
+func TestLex(t *testing.T) {
+	for _, test := range lexTests {
+		items := collect(&test, "", "")
+		if !equal(items, test.items, false) {
+			t.Errorf("%s: got\n\t%+v\nexpected\n\t%v", test.name, items, test.items)
+		}
+	}
+}
+
+// Some easy cases from above, but with delimiters $$ and @@
+var lexDelimTests = []lexTest{
+	{"punctuation", "$$,@%{{}}@@", []item{
+		tLeftDelim,
+		{itemChar, 0, ","},
+		{itemChar, 0, "@"},
+		{itemChar, 0, "%"},
+		{itemChar, 0, "{"},
+		{itemChar, 0, "{"},
+		{itemChar, 0, "}"},
+		{itemChar, 0, "}"},
+		tRightDelim,
+		tEOF,
+	}},
+	{"empty action", `$$@@`, []item{tLeftDelim, tRightDelim, tEOF}},
+	{"for", `$$for@@`, []item{tLeftDelim, tFor, tRightDelim, tEOF}},
+	{"quote", `$$"abc \n\t\" "@@`, []item{tLeftDelim, tQuote, tRightDelim, tEOF}},
+	{"raw quote", "$$" + raw + "@@", []item{tLeftDelim, tRawQuote, tRightDelim, tEOF}},
+}
+
+var (
+	tLeftDelim  = item{itemLeftDelim, 0, "$$"}
+	tRightDelim = item{itemRightDelim, 0, "@@"}
+)
+
+func TestDelims(t *testing.T) {
+	for _, test := range lexDelimTests {
+		items := collect(&test, "$$", "@@")
+		if !equal(items, test.items, false) {
+			t.Errorf("%s: got\n\t%v\nexpected\n\t%v", test.name, items, test.items)
+		}
+	}
+}
+
+var lexPosTests = []lexTest{
+	{"empty", "", []item{tEOF}},
+	{"punctuation", "{{,@%#}}", []item{
+		{itemLeftDelim, 0, "{{"},
+		{itemChar, 2, ","},
+		{itemChar, 3, "@"},
+		{itemChar, 4, "%"},
+		{itemChar, 5, "#"},
+		{itemRightDelim, 6, "}}"},
+		{itemEOF, 8, ""},
+	}},
+	{"sample", "0123{{hello}}xyz", []item{
+		{itemText, 0, "0123"},
+		{itemLeftDelim, 4, "{{"},
+		{itemIdentifier, 6, "hello"},
+		{itemRightDelim, 11, "}}"},
+		{itemText, 13, "xyz"},
+		{itemEOF, 16, ""},
+	}},
+}
+
+// The other tests don't check position, to make the test cases easier to construct.
+// This one does.
+func TestPos(t *testing.T) {
+	for _, test := range lexPosTests {
+		items := collect(&test, "", "")
+		if !equal(items, test.items, true) {
+			t.Errorf("%s: got\n\t%v\nexpected\n\t%v", test.name, items, test.items)
+			if len(items) == len(test.items) {
+				// Detailed print; avoid item.String() to expose the position value.
+				for i := range items {
+					if !equal(items[i:i+1], test.items[i:i+1], true) {
+						i1 := items[i]
+						i2 := test.items[i]
+						t.Errorf("\t#%d: got {%v %d %q} expected  {%v %d %q}", i, i1.typ, i1.pos, i1.val, i2.typ, i2.pos, i2.val)
+					}
+				}
+			}
+		}
+	}
+}

vendor/github.com/alecthomas/template/parse/node.go

@@ -0,0 +1,834 @@
+// 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.
+
+// Parse nodes.
+
+package parse
+
+import (
+	"bytes"
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+var textFormat = "%s" // Changed to "%q" in tests for better error messages.
+
+// A Node is an element in the parse tree. The interface is trivial.
+// The interface contains an unexported method so that only
+// types local to this package can satisfy it.
+type Node interface {
+	Type() NodeType
+	String() string
+	// Copy does a deep copy of the Node and all its components.
+	// To avoid type assertions, some XxxNodes also have specialized
+	// CopyXxx methods that return *XxxNode.
+	Copy() Node
+	Position() Pos // byte position of start of node in full original input string
+	// tree returns the containing *Tree.
+	// It is unexported so all implementations of Node are in this package.
+	tree() *Tree
+}
+
+// NodeType identifies the type of a parse tree node.
+type NodeType int
+
+// Pos represents a byte position in the original input text from which
+// this template was parsed.
+type Pos int
+
+func (p Pos) Position() Pos {
+	return p
+}
+
+// Type returns itself and provides an easy default implementation
+// for embedding in a Node. Embedded in all non-trivial Nodes.
+func (t NodeType) Type() NodeType {
+	return t
+}
+
+const (
+	NodeText       NodeType = iota // Plain text.
+	NodeAction                     // A non-control action such as a field evaluation.
+	NodeBool                       // A boolean constant.
+	NodeChain                      // A sequence of field accesses.
+	NodeCommand                    // An element of a pipeline.
+	NodeDot                        // The cursor, dot.
+	nodeElse                       // An else action. Not added to tree.
+	nodeEnd                        // An end action. Not added to tree.
+	NodeField                      // A field or method name.
+	NodeIdentifier                 // An identifier; always a function name.
+	NodeIf                         // An if action.
+	NodeList                       // A list of Nodes.
+	NodeNil                        // An untyped nil constant.
+	NodeNumber                     // A numerical constant.
+	NodePipe                       // A pipeline of commands.
+	NodeRange                      // A range action.
+	NodeString                     // A string constant.
+	NodeTemplate                   // A template invocation action.
+	NodeVariable                   // A $ variable.
+	NodeWith                       // A with action.
+)
+
+// Nodes.
+
+// ListNode holds a sequence of nodes.
+type ListNode struct {
+	NodeType
+	Pos
+	tr    *Tree
+	Nodes []Node // The element nodes in lexical order.
+}
+
+func (t *Tree) newList(pos Pos) *ListNode {
+	return &ListNode{tr: t, NodeType: NodeList, Pos: pos}
+}
+
+func (l *ListNode) append(n Node) {
+	l.Nodes = append(l.Nodes, n)
+}
+
+func (l *ListNode) tree() *Tree {
+	return l.tr
+}
+
+func (l *ListNode) String() string {
+	b := new(bytes.Buffer)
+	for _, n := range l.Nodes {
+		fmt.Fprint(b, n)
+	}
+	return b.String()
+}
+
+func (l *ListNode) CopyList() *ListNode {
+	if l == nil {
+		return l
+	}
+	n := l.tr.newList(l.Pos)
+	for _, elem := range l.Nodes {
+		n.append(elem.Copy())
+	}
+	return n
+}
+
+func (l *ListNode) Copy() Node {
+	return l.CopyList()
+}
+
+// TextNode holds plain text.
+type TextNode struct {
+	NodeType
+	Pos
+	tr   *Tree
+	Text []byte // The text; may span newlines.
+}
+
+func (t *Tree) newText(pos Pos, text string) *TextNode {
+	return &TextNode{tr: t, NodeType: NodeText, Pos: pos, Text: []byte(text)}
+}
+
+func (t *TextNode) String() string {
+	return fmt.Sprintf(textFormat, t.Text)
+}
+
+func (t *TextNode) tree() *Tree {
+	return t.tr
+}
+
+func (t *TextNode) Copy() Node {
+	return &TextNode{tr: t.tr, NodeType: NodeText, Pos: t.Pos, Text: append([]byte{}, t.Text...)}
+}
+
+// PipeNode holds a pipeline with optional declaration
+type PipeNode struct {
+	NodeType
+	Pos
+	tr   *Tree
+	Line int             // The line number in the input (deprecated; kept for compatibility)
+	Decl []*VariableNode // Variable declarations in lexical order.
+	Cmds []*CommandNode  // The commands in lexical order.
+}
+
+func (t *Tree) newPipeline(pos Pos, line int, decl []*VariableNode) *PipeNode {
+	return &PipeNode{tr: t, NodeType: NodePipe, Pos: pos, Line: line, Decl: decl}
+}
+
+func (p *PipeNode) append(command *CommandNode) {
+	p.Cmds = append(p.Cmds, command)
+}
+
+func (p *PipeNode) String() string {
+	s := ""
+	if len(p.Decl) > 0 {
+		for i, v := range p.Decl {
+			if i > 0 {
+				s += ", "
+			}
+			s += v.String()
+		}
+		s += " := "
+	}
+	for i, c := range p.Cmds {
+		if i > 0 {
+			s += " | "
+		}
+		s += c.String()
+	}
+	return s
+}
+
+func (p *PipeNode) tree() *Tree {
+	return p.tr
+}
+
+func (p *PipeNode) CopyPipe() *PipeNode {
+	if p == nil {
+		return p
+	}
+	var decl []*VariableNode
+	for _, d := range p.Decl {
+		decl = append(decl, d.Copy().(*VariableNode))
+	}
+	n := p.tr.newPipeline(p.Pos, p.Line, decl)
+	for _, c := range p.Cmds {
+		n.append(c.Copy().(*CommandNode))
+	}
+	return n
+}
+
+func (p *PipeNode) Copy() Node {
+	return p.CopyPipe()
+}
+
+// ActionNode holds an action (something bounded by delimiters).
+// Control actions have their own nodes; ActionNode represents simple
+// ones such as field evaluations and parenthesized pipelines.
+type ActionNode struct {
+	NodeType
+	Pos
+	tr   *Tree
+	Line int       // The line number in the input (deprecated; kept for compatibility)
+	Pipe *PipeNode // The pipeline in the action.
+}
+
+func (t *Tree) newAction(pos Pos, line int, pipe *PipeNode) *ActionNode {
+	return &ActionNode{tr: t, NodeType: NodeAction, Pos: pos, Line: line, Pipe: pipe}
+}
+
+func (a *ActionNode) String() string {
+	return fmt.Sprintf("{{%s}}", a.Pipe)
+
+}
+
+func (a *ActionNode) tree() *Tree {
+	return a.tr
+}
+
+func (a *ActionNode) Copy() Node {
+	return a.tr.newAction(a.Pos, a.Line, a.Pipe.CopyPipe())
+
+}
+
+// CommandNode holds a command (a pipeline inside an evaluating action).
+type CommandNode struct {
+	NodeType
+	Pos
+	tr   *Tree
+	Args []Node // Arguments in lexical order: Identifier, field, or constant.
+}
+
+func (t *Tree) newCommand(pos Pos) *CommandNode {
+	return &CommandNode{tr: t, NodeType: NodeCommand, Pos: pos}
+}
+
+func (c *CommandNode) append(arg Node) {
+	c.Args = append(c.Args, arg)
+}
+
+func (c *CommandNode) String() string {
+	s := ""
+	for i, arg := range c.Args {
+		if i > 0 {
+			s += " "
+		}
+		if arg, ok := arg.(*PipeNode); ok {
+			s += "(" + arg.String() + ")"
+			continue
+		}
+		s += arg.String()
+	}
+	return s
+}
+
+func (c *CommandNode) tree() *Tree {
+	return c.tr
+}
+
+func (c *CommandNode) Copy() Node {
+	if c == nil {
+		return c
+	}
+	n := c.tr.newCommand(c.Pos)
+	for _, c := range c.Args {
+		n.append(c.Copy())
+	}
+	return n
+}
+
+// IdentifierNode holds an identifier.
+type IdentifierNode struct {
+	NodeType
+	Pos
+	tr    *Tree
+	Ident string // The identifier's name.
+}
+
+// NewIdentifier returns a new IdentifierNode with the given identifier name.
+func NewIdentifier(ident string) *IdentifierNode {
+	return &IdentifierNode{NodeType: NodeIdentifier, Ident: ident}
+}
+
+// SetPos sets the position. NewIdentifier is a public method so we can't modify its signature.
+// Chained for convenience.
+// TODO: fix one day?
+func (i *IdentifierNode) SetPos(pos Pos) *IdentifierNode {
+	i.Pos = pos
+	return i
+}
+
+// SetTree sets the parent tree for the node. NewIdentifier is a public method so we can't modify its signature.
+// Chained for convenience.
+// TODO: fix one day?
+func (i *IdentifierNode) SetTree(t *Tree) *IdentifierNode {
+	i.tr = t
+	return i
+}
+
+func (i *IdentifierNode) String() string {
+	return i.Ident
+}
+
+func (i *IdentifierNode) tree() *Tree {
+	return i.tr
+}
+
+func (i *IdentifierNode) Copy() Node {
+	return NewIdentifier(i.Ident).SetTree(i.tr).SetPos(i.Pos)
+}
+
+// VariableNode holds a list of variable names, possibly with chained field
+// accesses. The dollar sign is part of the (first) name.
+type VariableNode struct {
+	NodeType
+	Pos
+	tr    *Tree
+	Ident []string // Variable name and fields in lexical order.
+}
+
+func (t *Tree) newVariable(pos Pos, ident string) *VariableNode {
+	return &VariableNode{tr: t, NodeType: NodeVariable, Pos: pos, Ident: strings.Split(ident, ".")}
+}
+
+func (v *VariableNode) String() string {
+	s := ""
+	for i, id := range v.Ident {
+		if i > 0 {
+			s += "."
+		}
+		s += id
+	}
+	return s
+}
+
+func (v *VariableNode) tree() *Tree {
+	return v.tr
+}
+
+func (v *VariableNode) Copy() Node {
+	return &VariableNode{tr: v.tr, NodeType: NodeVariable, Pos: v.Pos, Ident: append([]string{}, v.Ident...)}
+}
+
+// DotNode holds the special identifier '.'.
+type DotNode struct {
+	NodeType
+	Pos
+	tr *Tree
+}
+
+func (t *Tree) newDot(pos Pos) *DotNode {
+	return &DotNode{tr: t, NodeType: NodeDot, Pos: pos}
+}
+
+func (d *DotNode) Type() NodeType {
+	// Override method on embedded NodeType for API compatibility.
+	// TODO: Not really a problem; could change API without effect but
+	// api tool complains.
+	return NodeDot
+}
+
+func (d *DotNode) String() string {
+	return "."
+}
+
+func (d *DotNode) tree() *Tree {
+	return d.tr
+}
+
+func (d *DotNode) Copy() Node {
+	return d.tr.newDot(d.Pos)
+}
+
+// NilNode holds the special identifier 'nil' representing an untyped nil constant.
+type NilNode struct {
+	NodeType
+	Pos
+	tr *Tree
+}
+
+func (t *Tree) newNil(pos Pos) *NilNode {
+	return &NilNode{tr: t, NodeType: NodeNil, Pos: pos}
+}
+
+func (n *NilNode) Type() NodeType {
+	// Override method on embedded NodeType for API compatibility.
+	// TODO: Not really a problem; could change API without effect but
+	// api tool complains.
+	return NodeNil
+}
+
+func (n *NilNode) String() string {
+	return "nil"
+}
+
+func (n *NilNode) tree() *Tree {
+	return n.tr
+}
+
+func (n *NilNode) Copy() Node {
+	return n.tr.newNil(n.Pos)
+}
+
+// FieldNode holds a field (identifier starting with '.').
+// The names may be chained ('.x.y').
+// The period is dropped from each ident.
+type FieldNode struct {
+	NodeType
+	Pos
+	tr    *Tree
+	Ident []string // The identifiers in lexical order.
+}
+
+func (t *Tree) newField(pos Pos, ident string) *FieldNode {
+	return &FieldNode{tr: t, NodeType: NodeField, Pos: pos, Ident: strings.Split(ident[1:], ".")} // [1:] to drop leading period
+}
+
+func (f *FieldNode) String() string {
+	s := ""
+	for _, id := range f.Ident {
+		s += "." + id
+	}
+	return s
+}
+
+func (f *FieldNode) tree() *Tree {
+	return f.tr
+}
+
+func (f *FieldNode) Copy() Node {
+	return &FieldNode{tr: f.tr, NodeType: NodeField, Pos: f.Pos, Ident: append([]string{}, f.Ident...)}
+}
+
+// ChainNode holds a term followed by a chain of field accesses (identifier starting with '.').
+// The names may be chained ('.x.y').
+// The periods are dropped from each ident.
+type ChainNode struct {
+	NodeType
+	Pos
+	tr    *Tree
+	Node  Node
+	Field []string // The identifiers in lexical order.
+}
+
+func (t *Tree) newChain(pos Pos, node Node) *ChainNode {
+	return &ChainNode{tr: t, NodeType: NodeChain, Pos: pos, Node: node}
+}
+
+// Add adds the named field (which should start with a period) to the end of the chain.
+func (c *ChainNode) Add(field string) {
+	if len(field) == 0 || field[0] != '.' {
+		panic("no dot in field")
+	}
+	field = field[1:] // Remove leading dot.
+	if field == "" {
+		panic("empty field")
+	}
+	c.Field = append(c.Field, field)
+}
+
+func (c *ChainNode) String() string {
+	s := c.Node.String()
+	if _, ok := c.Node.(*PipeNode); ok {
+		s = "(" + s + ")"
+	}
+	for _, field := range c.Field {
+		s += "." + field
+	}
+	return s
+}
+
+func (c *ChainNode) tree() *Tree {
+	return c.tr
+}
+
+func (c *ChainNode) Copy() Node {
+	return &ChainNode{tr: c.tr, NodeType: NodeChain, Pos: c.Pos, Node: c.Node, Field: append([]string{}, c.Field...)}
+}
+
+// BoolNode holds a boolean constant.
+type BoolNode struct {
+	NodeType
+	Pos
+	tr   *Tree
+	True bool // The value of the boolean constant.
+}
+
+func (t *Tree) newBool(pos Pos, true bool) *BoolNode {
+	return &BoolNode{tr: t, NodeType: NodeBool, Pos: pos, True: true}
+}
+
+func (b *BoolNode) String() string {
+	if b.True {
+		return "true"
+	}
+	return "false"
+}
+
+func (b *BoolNode) tree() *Tree {
+	return b.tr
+}
+
+func (b *BoolNode) Copy() Node {
+	return b.tr.newBool(b.Pos, b.True)
+}
+
+// NumberNode holds a number: signed or unsigned integer, float, or complex.
+// The value is parsed and stored under all the types that can represent the value.
+// This simulates in a small amount of code the behavior of Go's ideal constants.
+type NumberNode struct {
+	NodeType
+	Pos
+	tr         *Tree
+	IsInt      bool       // Number has an integral value.
+	IsUint     bool       // Number has an unsigned integral value.
+	IsFloat    bool       // Number has a floating-point value.
+	IsComplex  bool       // Number is complex.
+	Int64      int64      // The signed integer value.
+	Uint64     uint64     // The unsigned integer value.
+	Float64    float64    // The floating-point value.
+	Complex128 complex128 // The complex value.
+	Text       string     // The original textual representation from the input.
+}
+
+func (t *Tree) newNumber(pos Pos, text string, typ itemType) (*NumberNode, error) {
+	n := &NumberNode{tr: t, NodeType: NodeNumber, Pos: pos, Text: text}
+	switch typ {
+	case itemCharConstant:
+		rune, _, tail, err := strconv.UnquoteChar(text[1:], text[0])
+		if err != nil {
+			return nil, err
+		}
+		if tail != "'" {
+			return nil, fmt.Errorf("malformed character constant: %s", text)
+		}
+		n.Int64 = int64(rune)
+		n.IsInt = true
+		n.Uint64 = uint64(rune)
+		n.IsUint = true
+		n.Float64 = float64(rune) // odd but those are the rules.
+		n.IsFloat = true
+		return n, nil
+	case itemComplex:
+		// fmt.Sscan can parse the pair, so let it do the work.
+		if _, err := fmt.Sscan(text, &n.Complex128); err != nil {
+			return nil, err
+		}
+		n.IsComplex = true
+		n.simplifyComplex()
+		return n, nil
+	}
+	// Imaginary constants can only be complex unless they are zero.
+	if len(text) > 0 && text[len(text)-1] == 'i' {
+		f, err := strconv.ParseFloat(text[:len(text)-1], 64)
+		if err == nil {
+			n.IsComplex = true
+			n.Complex128 = complex(0, f)
+			n.simplifyComplex()
+			return n, nil
+		}
+	}
+	// Do integer test first so we get 0x123 etc.
+	u, err := strconv.ParseUint(text, 0, 64) // will fail for -0; fixed below.
+	if err == nil {
+		n.IsUint = true
+		n.Uint64 = u
+	}
+	i, err := strconv.ParseInt(text, 0, 64)
+	if err == nil {
+		n.IsInt = true
+		n.Int64 = i
+		if i == 0 {
+			n.IsUint = true // in case of -0.
+			n.Uint64 = u
+		}
+	}
+	// If an integer extraction succeeded, promote the float.
+	if n.IsInt {
+		n.IsFloat = true
+		n.Float64 = float64(n.Int64)
+	} else if n.IsUint {
+		n.IsFloat = true
+		n.Float64 = float64(n.Uint64)
+	} else {
+		f, err := strconv.ParseFloat(text, 64)
+		if err == nil {
+			n.IsFloat = true
+			n.Float64 = f
+			// If a floating-point extraction succeeded, extract the int if needed.
+			if !n.IsInt && float64(int64(f)) == f {
+				n.IsInt = true
+				n.Int64 = int64(f)
+			}
+			if !n.IsUint && float64(uint64(f)) == f {
+				n.IsUint = true
+				n.Uint64 = uint64(f)
+			}
+		}
+	}
+	if !n.IsInt && !n.IsUint && !n.IsFloat {
+		return nil, fmt.Errorf("illegal number syntax: %q", text)
+	}
+	return n, nil
+}
+
+// simplifyComplex pulls out any other types that are represented by the complex number.
+// These all require that the imaginary part be zero.
+func (n *NumberNode) simplifyComplex() {
+	n.IsFloat = imag(n.Complex128) == 0
+	if n.IsFloat {
+		n.Float64 = real(n.Complex128)
+		n.IsInt = float64(int64(n.Float64)) == n.Float64
+		if n.IsInt {
+			n.Int64 = int64(n.Float64)
+		}
+		n.IsUint = float64(uint64(n.Float64)) == n.Float64
+		if n.IsUint {
+			n.Uint64 = uint64(n.Float64)
+		}
+	}
+}
+
+func (n *NumberNode) String() string {
+	return n.Text
+}
+
+func (n *NumberNode) tree() *Tree {
+	return n.tr
+}
+
+func (n *NumberNode) Copy() Node {
+	nn := new(NumberNode)
+	*nn = *n // Easy, fast, correct.
+	return nn
+}
+
+// StringNode holds a string constant. The value has been "unquoted".
+type StringNode struct {
+	NodeType
+	Pos
+	tr     *Tree
+	Quoted string // The original text of the string, with quotes.
+	Text   string // The string, after quote processing.
+}
+
+func (t *Tree) newString(pos Pos, orig, text string) *StringNode {
+	return &StringNode{tr: t, NodeType: NodeString, Pos: pos, Quoted: orig, Text: text}
+}
+
+func (s *StringNode) String() string {
+	return s.Quoted
+}
+
+func (s *StringNode) tree() *Tree {
+	return s.tr
+}
+
+func (s *StringNode) Copy() Node {
+	return s.tr.newString(s.Pos, s.Quoted, s.Text)
+}
+
+// endNode represents an {{end}} action.
+// It does not appear in the final parse tree.
+type endNode struct {
+	NodeType
+	Pos
+	tr *Tree
+}
+
+func (t *Tree) newEnd(pos Pos) *endNode {
+	return &endNode{tr: t, NodeType: nodeEnd, Pos: pos}
+}
+
+func (e *endNode) String() string {
+	return "{{end}}"
+}
+
+func (e *endNode) tree() *Tree {
+	return e.tr
+}
+
+func (e *endNode) Copy() Node {
+	return e.tr.newEnd(e.Pos)
+}
+
+// elseNode represents an {{else}} action. Does not appear in the final tree.
+type elseNode struct {
+	NodeType
+	Pos
+	tr   *Tree
+	Line int // The line number in the input (deprecated; kept for compatibility)
+}
+
+func (t *Tree) newElse(pos Pos, line int) *elseNode {
+	return &elseNode{tr: t, NodeType: nodeElse, Pos: pos, Line: line}
+}
+
+func (e *elseNode) Type() NodeType {
+	return nodeElse
+}
+
+func (e *elseNode) String() string {
+	return "{{else}}"
+}
+
+func (e *elseNode) tree() *Tree {
+	return e.tr
+}
+
+func (e *elseNode) Copy() Node {
+	return e.tr.newElse(e.Pos, e.Line)
+}
+
+// BranchNode is the common representation of if, range, and with.
+type BranchNode struct {
+	NodeType
+	Pos
+	tr       *Tree
+	Line     int       // The line number in the input (deprecated; kept for compatibility)
+	Pipe     *PipeNode // The pipeline to be evaluated.
+	List     *ListNode // What to execute if the value is non-empty.
+	ElseList *ListNode // What to execute if the value is empty (nil if absent).
+}
+
+func (b *BranchNode) String() string {
+	name := ""
+	switch b.NodeType {
+	case NodeIf:
+		name = "if"
+	case NodeRange:
+		name = "range"
+	case NodeWith:
+		name = "with"
+	default:
+		panic("unknown branch type")
+	}
+	if b.ElseList != nil {
+		return fmt.Sprintf("{{%s %s}}%s{{else}}%s{{end}}", name, b.Pipe, b.List, b.ElseList)
+	}
+	return fmt.Sprintf("{{%s %s}}%s{{end}}", name, b.Pipe, b.List)
+}
+
+func (b *BranchNode) tree() *Tree {
+	return b.tr
+}
+
+func (b *BranchNode) Copy() Node {
+	switch b.NodeType {
+	case NodeIf:
+		return b.tr.newIf(b.Pos, b.Line, b.Pipe, b.List, b.ElseList)
+	case NodeRange:
+		return b.tr.newRange(b.Pos, b.Line, b.Pipe, b.List, b.ElseList)
+	case NodeWith:
+		return b.tr.newWith(b.Pos, b.Line, b.Pipe, b.List, b.ElseList)
+	default:
+		panic("unknown branch type")
+	}
+}
+
+// IfNode represents an {{if}} action and its commands.
+type IfNode struct {
+	BranchNode
+}
+
+func (t *Tree) newIf(pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) *IfNode {
+	return &IfNode{BranchNode{tr: t, NodeType: NodeIf, Pos: pos, Line: line, Pipe: pipe, List: list, ElseList: elseList}}
+}
+
+func (i *IfNode) Copy() Node {
+	return i.tr.newIf(i.Pos, i.Line, i.Pipe.CopyPipe(), i.List.CopyList(), i.ElseList.CopyList())
+}
+
+// RangeNode represents a {{range}} action and its commands.
+type RangeNode struct {
+	BranchNode
+}
+
+func (t *Tree) newRange(pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) *RangeNode {
+	return &RangeNode{BranchNode{tr: t, NodeType: NodeRange, Pos: pos, Line: line, Pipe: pipe, List: list, ElseList: elseList}}
+}
+
+func (r *RangeNode) Copy() Node {
+	return r.tr.newRange(r.Pos, r.Line, r.Pipe.CopyPipe(), r.List.CopyList(), r.ElseList.CopyList())
+}
+
+// WithNode represents a {{with}} action and its commands.
+type WithNode struct {
+	BranchNode
+}
+
+func (t *Tree) newWith(pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) *WithNode {
+	return &WithNode{BranchNode{tr: t, NodeType: NodeWith, Pos: pos, Line: line, Pipe: pipe, List: list, ElseList: elseList}}
+}
+
+func (w *WithNode) Copy() Node {
+	return w.tr.newWith(w.Pos, w.Line, w.Pipe.CopyPipe(), w.List.CopyList(), w.ElseList.CopyList())
+}
+
+// TemplateNode represents a {{template}} action.
+type TemplateNode struct {
+	NodeType
+	Pos
+	tr   *Tree
+	Line int       // The line number in the input (deprecated; kept for compatibility)
+	Name string    // The name of the template (unquoted).
+	Pipe *PipeNode // The command to evaluate as dot for the template.
+}
+
+func (t *Tree) newTemplate(pos Pos, line int, name string, pipe *PipeNode) *TemplateNode {
+	return &TemplateNode{tr: t, NodeType: NodeTemplate, Pos: pos, Line: line, Name: name, Pipe: pipe}
+}
+
+func (t *TemplateNode) String() string {
+	if t.Pipe == nil {
+		return fmt.Sprintf("{{template %q}}", t.Name)
+	}
+	return fmt.Sprintf("{{template %q %s}}", t.Name, t.Pipe)
+}
+
+func (t *TemplateNode) tree() *Tree {
+	return t.tr
+}
+
+func (t *TemplateNode) Copy() Node {
+	return t.tr.newTemplate(t.Pos, t.Line, t.Name, t.Pipe.CopyPipe())
+}

vendor/github.com/alecthomas/template/parse/parse.go

@@ -0,0 +1,700 @@
+// 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.
+
+// Package parse builds parse trees for templates as defined by text/template
+// and html/template. Clients should use those packages to construct templates
+// rather than this one, which provides shared internal data structures not
+// intended for general use.
+package parse
+
+import (
+	"bytes"
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+)
+
+// Tree is the representation of a single parsed template.
+type Tree struct {
+	Name      string    // name of the template represented by the tree.
+	ParseName string    // name of the top-level template during parsing, for error messages.
+	Root      *ListNode // top-level root of the tree.
+	text      string    // text parsed to create the template (or its parent)
+	// Parsing only; cleared after parse.
+	funcs     []map[string]interface{}
+	lex       *lexer
+	token     [3]item // three-token lookahead for parser.
+	peekCount int
+	vars      []string // variables defined at the moment.
+}
+
+// Copy returns a copy of the Tree. Any parsing state is discarded.
+func (t *Tree) Copy() *Tree {
+	if t == nil {
+		return nil
+	}
+	return &Tree{
+		Name:      t.Name,
+		ParseName: t.ParseName,
+		Root:      t.Root.CopyList(),
+		text:      t.text,
+	}
+}
+
+// Parse returns a map from template name to parse.Tree, created by parsing the
+// templates described in the argument string. The top-level template will be
+// given the specified name. If an error is encountered, parsing stops and an
+// empty map is returned with the error.
+func Parse(name, text, leftDelim, rightDelim string, funcs ...map[string]interface{}) (treeSet map[string]*Tree, err error) {
+	treeSet = make(map[string]*Tree)
+	t := New(name)
+	t.text = text
+	_, err = t.Parse(text, leftDelim, rightDelim, treeSet, funcs...)
+	return
+}
+
+// next returns the next token.
+func (t *Tree) next() item {
+	if t.peekCount > 0 {
+		t.peekCount--
+	} else {
+		t.token[0] = t.lex.nextItem()
+	}
+	return t.token[t.peekCount]
+}
+
+// backup backs the input stream up one token.
+func (t *Tree) backup() {
+	t.peekCount++
+}
+
+// backup2 backs the input stream up two tokens.
+// The zeroth token is already there.
+func (t *Tree) backup2(t1 item) {
+	t.token[1] = t1
+	t.peekCount = 2
+}
+
+// backup3 backs the input stream up three tokens
+// The zeroth token is already there.
+func (t *Tree) backup3(t2, t1 item) { // Reverse order: we're pushing back.
+	t.token[1] = t1
+	t.token[2] = t2
+	t.peekCount = 3
+}
+
+// peek returns but does not consume the next token.
+func (t *Tree) peek() item {
+	if t.peekCount > 0 {
+		return t.token[t.peekCount-1]
+	}
+	t.peekCount = 1
+	t.token[0] = t.lex.nextItem()
+	return t.token[0]
+}
+
+// nextNonSpace returns the next non-space token.
+func (t *Tree) nextNonSpace() (token item) {
+	for {
+		token = t.next()
+		if token.typ != itemSpace {
+			break
+		}
+	}
+	return token
+}
+
+// peekNonSpace returns but does not consume the next non-space token.
+func (t *Tree) peekNonSpace() (token item) {
+	for {
+		token = t.next()
+		if token.typ != itemSpace {
+			break
+		}
+	}
+	t.backup()
+	return token
+}
+
+// Parsing.
+
+// New allocates a new parse tree with the given name.
+func New(name string, funcs ...map[string]interface{}) *Tree {
+	return &Tree{
+		Name:  name,
+		funcs: funcs,
+	}
+}
+
+// ErrorContext returns a textual representation of the location of the node in the input text.
+// The receiver is only used when the node does not have a pointer to the tree inside,
+// which can occur in old code.
+func (t *Tree) ErrorContext(n Node) (location, context string) {
+	pos := int(n.Position())
+	tree := n.tree()
+	if tree == nil {
+		tree = t
+	}
+	text := tree.text[:pos]
+	byteNum := strings.LastIndex(text, "\n")
+	if byteNum == -1 {
+		byteNum = pos // On first line.
+	} else {
+		byteNum++ // After the newline.
+		byteNum = pos - byteNum
+	}
+	lineNum := 1 + strings.Count(text, "\n")
+	context = n.String()
+	if len(context) > 20 {
+		context = fmt.Sprintf("%.20s...", context)
+	}
+	return fmt.Sprintf("%s:%d:%d", tree.ParseName, lineNum, byteNum), context
+}
+
+// errorf formats the error and terminates processing.
+func (t *Tree) errorf(format string, args ...interface{}) {
+	t.Root = nil
+	format = fmt.Sprintf("template: %s:%d: %s", t.ParseName, t.lex.lineNumber(), format)
+	panic(fmt.Errorf(format, args...))
+}
+
+// error terminates processing.
+func (t *Tree) error(err error) {
+	t.errorf("%s", err)
+}
+
+// expect consumes the next token and guarantees it has the required type.
+func (t *Tree) expect(expected itemType, context string) item {
+	token := t.nextNonSpace()
+	if token.typ != expected {
+		t.unexpected(token, context)
+	}
+	return token
+}
+
+// expectOneOf consumes the next token and guarantees it has one of the required types.
+func (t *Tree) expectOneOf(expected1, expected2 itemType, context string) item {
+	token := t.nextNonSpace()
+	if token.typ != expected1 && token.typ != expected2 {
+		t.unexpected(token, context)
+	}
+	return token
+}
+
+// unexpected complains about the token and terminates processing.
+func (t *Tree) unexpected(token item, context string) {
+	t.errorf("unexpected %s in %s", token, context)
+}
+
+// recover is the handler that turns panics into returns from the top level of Parse.
+func (t *Tree) recover(errp *error) {
+	e := recover()
+	if e != nil {
+		if _, ok := e.(runtime.Error); ok {
+			panic(e)
+		}
+		if t != nil {
+			t.stopParse()
+		}
+		*errp = e.(error)
+	}
+	return
+}
+
+// startParse initializes the parser, using the lexer.
+func (t *Tree) startParse(funcs []map[string]interface{}, lex *lexer) {
+	t.Root = nil
+	t.lex = lex
+	t.vars = []string{"$"}
+	t.funcs = funcs
+}
+
+// stopParse terminates parsing.
+func (t *Tree) stopParse() {
+	t.lex = nil
+	t.vars = nil
+	t.funcs = nil
+}
+
+// Parse parses the template definition string to construct a representation of
+// the template for execution. If either action delimiter string is empty, the
+// default ("{{" or "}}") is used. Embedded template definitions are added to
+// the treeSet map.
+func (t *Tree) Parse(text, leftDelim, rightDelim string, treeSet map[string]*Tree, funcs ...map[string]interface{}) (tree *Tree, err error) {
+	defer t.recover(&err)
+	t.ParseName = t.Name
+	t.startParse(funcs, lex(t.Name, text, leftDelim, rightDelim))
+	t.text = text
+	t.parse(treeSet)
+	t.add(treeSet)
+	t.stopParse()
+	return t, nil
+}
+
+// add adds tree to the treeSet.
+func (t *Tree) add(treeSet map[string]*Tree) {
+	tree := treeSet[t.Name]
+	if tree == nil || IsEmptyTree(tree.Root) {
+		treeSet[t.Name] = t
+		return
+	}
+	if !IsEmptyTree(t.Root) {
+		t.errorf("template: multiple definition of template %q", t.Name)
+	}
+}
+
+// IsEmptyTree reports whether this tree (node) is empty of everything but space.
+func IsEmptyTree(n Node) bool {
+	switch n := n.(type) {
+	case nil:
+		return true
+	case *ActionNode:
+	case *IfNode:
+	case *ListNode:
+		for _, node := range n.Nodes {
+			if !IsEmptyTree(node) {
+				return false
+			}
+		}
+		return true
+	case *RangeNode:
+	case *TemplateNode:
+	case *TextNode:
+		return len(bytes.TrimSpace(n.Text)) == 0
+	case *WithNode:
+	default:
+		panic("unknown node: " + n.String())
+	}
+	return false
+}
+
+// parse is the top-level parser for a template, essentially the same
+// as itemList except it also parses {{define}} actions.
+// It runs to EOF.
+func (t *Tree) parse(treeSet map[string]*Tree) (next Node) {
+	t.Root = t.newList(t.peek().pos)
+	for t.peek().typ != itemEOF {
+		if t.peek().typ == itemLeftDelim {
+			delim := t.next()
+			if t.nextNonSpace().typ == itemDefine {
+				newT := New("definition") // name will be updated once we know it.
+				newT.text = t.text
+				newT.ParseName = t.ParseName
+				newT.startParse(t.funcs, t.lex)
+				newT.parseDefinition(treeSet)
+				continue
+			}
+			t.backup2(delim)
+		}
+		n := t.textOrAction()
+		if n.Type() == nodeEnd {
+			t.errorf("unexpected %s", n)
+		}
+		t.Root.append(n)
+	}
+	return nil
+}
+
+// parseDefinition parses a {{define}} ...  {{end}} template definition and
+// installs the definition in the treeSet map.  The "define" keyword has already
+// been scanned.
+func (t *Tree) parseDefinition(treeSet map[string]*Tree) {
+	const context = "define clause"
+	name := t.expectOneOf(itemString, itemRawString, context)
+	var err error
+	t.Name, err = strconv.Unquote(name.val)
+	if err != nil {
+		t.error(err)
+	}
+	t.expect(itemRightDelim, context)
+	var end Node
+	t.Root, end = t.itemList()
+	if end.Type() != nodeEnd {
+		t.errorf("unexpected %s in %s", end, context)
+	}
+	t.add(treeSet)
+	t.stopParse()
+}
+
+// itemList:
+//	textOrAction*
+// Terminates at {{end}} or {{else}}, returned separately.
+func (t *Tree) itemList() (list *ListNode, next Node) {
+	list = t.newList(t.peekNonSpace().pos)
+	for t.peekNonSpace().typ != itemEOF {
+		n := t.textOrAction()
+		switch n.Type() {
+		case nodeEnd, nodeElse:
+			return list, n
+		}
+		list.append(n)
+	}
+	t.errorf("unexpected EOF")
+	return
+}
+
+// textOrAction:
+//	text | action
+func (t *Tree) textOrAction() Node {
+	switch token := t.nextNonSpace(); token.typ {
+	case itemElideNewline:
+		return t.elideNewline()
+	case itemText:
+		return t.newText(token.pos, token.val)
+	case itemLeftDelim:
+		return t.action()
+	default:
+		t.unexpected(token, "input")
+	}
+	return nil
+}
+
+// elideNewline:
+// Remove newlines trailing rightDelim if \\ is present.
+func (t *Tree) elideNewline() Node {
+	token := t.peek()
+	if token.typ != itemText {
+		t.unexpected(token, "input")
+		return nil
+	}
+
+	t.next()
+	stripped := strings.TrimLeft(token.val, "\n\r")
+	diff := len(token.val) - len(stripped)
+	if diff > 0 {
+		// This is a bit nasty. We mutate the token in-place to remove
+		// preceding newlines.
+		token.pos += Pos(diff)
+		token.val = stripped
+	}
+	return t.newText(token.pos, token.val)
+}
+
+// Action:
+//	control
+//	command ("|" command)*
+// Left delim is past. Now get actions.
+// First word could be a keyword such as range.
+func (t *Tree) action() (n Node) {
+	switch token := t.nextNonSpace(); token.typ {
+	case itemElse:
+		return t.elseControl()
+	case itemEnd:
+		return t.endControl()
+	case itemIf:
+		return t.ifControl()
+	case itemRange:
+		return t.rangeControl()
+	case itemTemplate:
+		return t.templateControl()
+	case itemWith:
+		return t.withControl()
+	}
+	t.backup()
+	// Do not pop variables; they persist until "end".
+	return t.newAction(t.peek().pos, t.lex.lineNumber(), t.pipeline("command"))
+}
+
+// Pipeline:
+//	declarations? command ('|' command)*
+func (t *Tree) pipeline(context string) (pipe *PipeNode) {
+	var decl []*VariableNode
+	pos := t.peekNonSpace().pos
+	// Are there declarations?
+	for {
+		if v := t.peekNonSpace(); v.typ == itemVariable {
+			t.next()
+			// Since space is a token, we need 3-token look-ahead here in the worst case:
+			// in "$x foo" we need to read "foo" (as opposed to ":=") to know that $x is an
+			// argument variable rather than a declaration. So remember the token
+			// adjacent to the variable so we can push it back if necessary.
+			tokenAfterVariable := t.peek()
+			if next := t.peekNonSpace(); next.typ == itemColonEquals || (next.typ == itemChar && next.val == ",") {
+				t.nextNonSpace()
+				variable := t.newVariable(v.pos, v.val)
+				decl = append(decl, variable)
+				t.vars = append(t.vars, v.val)
+				if next.typ == itemChar && next.val == "," {
+					if context == "range" && len(decl) < 2 {
+						continue
+					}
+					t.errorf("too many declarations in %s", context)
+				}
+			} else if tokenAfterVariable.typ == itemSpace {
+				t.backup3(v, tokenAfterVariable)
+			} else {
+				t.backup2(v)
+			}
+		}
+		break
+	}
+	pipe = t.newPipeline(pos, t.lex.lineNumber(), decl)
+	for {
+		switch token := t.nextNonSpace(); token.typ {
+		case itemRightDelim, itemRightParen:
+			if len(pipe.Cmds) == 0 {
+				t.errorf("missing value for %s", context)
+			}
+			if token.typ == itemRightParen {
+				t.backup()
+			}
+			return
+		case itemBool, itemCharConstant, itemComplex, itemDot, itemField, itemIdentifier,
+			itemNumber, itemNil, itemRawString, itemString, itemVariable, itemLeftParen:
+			t.backup()
+			pipe.append(t.command())
+		default:
+			t.unexpected(token, context)
+		}
+	}
+}
+
+func (t *Tree) parseControl(allowElseIf bool, context string) (pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) {
+	defer t.popVars(len(t.vars))
+	line = t.lex.lineNumber()
+	pipe = t.pipeline(context)
+	var next Node
+	list, next = t.itemList()
+	switch next.Type() {
+	case nodeEnd: //done
+	case nodeElse:
+		if allowElseIf {
+			// Special case for "else if". If the "else" is followed immediately by an "if",
+			// the elseControl will have left the "if" token pending. Treat
+			//	{{if a}}_{{else if b}}_{{end}}
+			// as
+			//	{{if a}}_{{else}}{{if b}}_{{end}}{{end}}.
+			// To do this, parse the if as usual and stop at it {{end}}; the subsequent{{end}}
+			// is assumed. This technique works even for long if-else-if chains.
+			// TODO: Should we allow else-if in with and range?
+			if t.peek().typ == itemIf {
+				t.next() // Consume the "if" token.
+				elseList = t.newList(next.Position())
+				elseList.append(t.ifControl())
+				// Do not consume the next item - only one {{end}} required.
+				break
+			}
+		}
+		elseList, next = t.itemList()
+		if next.Type() != nodeEnd {
+			t.errorf("expected end; found %s", next)
+		}
+	}
+	return pipe.Position(), line, pipe, list, elseList
+}
+
+// If:
+//	{{if pipeline}} itemList {{end}}
+//	{{if pipeline}} itemList {{else}} itemList {{end}}
+// If keyword is past.
+func (t *Tree) ifControl() Node {
+	return t.newIf(t.parseControl(true, "if"))
+}
+
+// Range:
+//	{{range pipeline}} itemList {{end}}
+//	{{range pipeline}} itemList {{else}} itemList {{end}}
+// Range keyword is past.
+func (t *Tree) rangeControl() Node {
+	return t.newRange(t.parseControl(false, "range"))
+}
+
+// With:
+//	{{with pipeline}} itemList {{end}}
+//	{{with pipeline}} itemList {{else}} itemList {{end}}
+// If keyword is past.
+func (t *Tree) withControl() Node {
+	return t.newWith(t.parseControl(false, "with"))
+}
+
+// End:
+//	{{end}}
+// End keyword is past.
+func (t *Tree) endControl() Node {
+	return t.newEnd(t.expect(itemRightDelim, "end").pos)
+}
+
+// Else:
+//	{{else}}
+// Else keyword is past.
+func (t *Tree) elseControl() Node {
+	// Special case for "else if".
+	peek := t.peekNonSpace()
+	if peek.typ == itemIf {
+		// We see "{{else if ... " but in effect rewrite it to {{else}}{{if ... ".
+		return t.newElse(peek.pos, t.lex.lineNumber())
+	}
+	return t.newElse(t.expect(itemRightDelim, "else").pos, t.lex.lineNumber())
+}
+
+// Template:
+//	{{template stringValue pipeline}}
+// Template keyword is past.  The name must be something that can evaluate
+// to a string.
+func (t *Tree) templateControl() Node {
+	var name string
+	token := t.nextNonSpace()
+	switch token.typ {
+	case itemString, itemRawString:
+		s, err := strconv.Unquote(token.val)
+		if err != nil {
+			t.error(err)
+		}
+		name = s
+	default:
+		t.unexpected(token, "template invocation")
+	}
+	var pipe *PipeNode
+	if t.nextNonSpace().typ != itemRightDelim {
+		t.backup()
+		// Do not pop variables; they persist until "end".
+		pipe = t.pipeline("template")
+	}
+	return t.newTemplate(token.pos, t.lex.lineNumber(), name, pipe)
+}
+
+// command:
+//	operand (space operand)*
+// space-separated arguments up to a pipeline character or right delimiter.
+// we consume the pipe character but leave the right delim to terminate the action.
+func (t *Tree) command() *CommandNode {
+	cmd := t.newCommand(t.peekNonSpace().pos)
+	for {
+		t.peekNonSpace() // skip leading spaces.
+		operand := t.operand()
+		if operand != nil {
+			cmd.append(operand)
+		}
+		switch token := t.next(); token.typ {
+		case itemSpace:
+			continue
+		case itemError:
+			t.errorf("%s", token.val)
+		case itemRightDelim, itemRightParen:
+			t.backup()
+		case itemPipe:
+		default:
+			t.errorf("unexpected %s in operand; missing space?", token)
+		}
+		break
+	}
+	if len(cmd.Args) == 0 {
+		t.errorf("empty command")
+	}
+	return cmd
+}
+
+// operand:
+//	term .Field*
+// An operand is a space-separated component of a command,
+// a term possibly followed by field accesses.
+// A nil return means the next item is not an operand.
+func (t *Tree) operand() Node {
+	node := t.term()
+	if node == nil {
+		return nil
+	}
+	if t.peek().typ == itemField {
+		chain := t.newChain(t.peek().pos, node)
+		for t.peek().typ == itemField {
+			chain.Add(t.next().val)
+		}
+		// Compatibility with original API: If the term is of type NodeField
+		// or NodeVariable, just put more fields on the original.
+		// Otherwise, keep the Chain node.
+		// TODO: Switch to Chains always when we can.
+		switch node.Type() {
+		case NodeField:
+			node = t.newField(chain.Position(), chain.String())
+		case NodeVariable:
+			node = t.newVariable(chain.Position(), chain.String())
+		default:
+			node = chain
+		}
+	}
+	return node
+}
+
+// term:
+//	literal (number, string, nil, boolean)
+//	function (identifier)
+//	.
+//	.Field
+//	$
+//	'(' pipeline ')'
+// A term is a simple "expression".
+// A nil return means the next item is not a term.
+func (t *Tree) term() Node {
+	switch token := t.nextNonSpace(); token.typ {
+	case itemError:
+		t.errorf("%s", token.val)
+	case itemIdentifier:
+		if !t.hasFunction(token.val) {
+			t.errorf("function %q not defined", token.val)
+		}
+		return NewIdentifier(token.val).SetTree(t).SetPos(token.pos)
+	case itemDot:
+		return t.newDot(token.pos)
+	case itemNil:
+		return t.newNil(token.pos)
+	case itemVariable:
+		return t.useVar(token.pos, token.val)
+	case itemField:
+		return t.newField(token.pos, token.val)
+	case itemBool:
+		return t.newBool(token.pos, token.val == "true")
+	case itemCharConstant, itemComplex, itemNumber:
+		number, err := t.newNumber(token.pos, token.val, token.typ)
+		if err != nil {
+			t.error(err)
+		}
+		return number
+	case itemLeftParen:
+		pipe := t.pipeline("parenthesized pipeline")
+		if token := t.next(); token.typ != itemRightParen {
+			t.errorf("unclosed right paren: unexpected %s", token)
+		}
+		return pipe
+	case itemString, itemRawString:
+		s, err := strconv.Unquote(token.val)
+		if err != nil {
+			t.error(err)
+		}
+		return t.newString(token.pos, token.val, s)
+	}
+	t.backup()
+	return nil
+}
+
+// hasFunction reports if a function name exists in the Tree's maps.
+func (t *Tree) hasFunction(name string) bool {
+	for _, funcMap := range t.funcs {
+		if funcMap == nil {
+			continue
+		}
+		if funcMap[name] != nil {
+			return true
+		}
+	}
+	return false
+}
+
+// popVars trims the variable list to the specified length
+func (t *Tree) popVars(n int) {
+	t.vars = t.vars[:n]
+}
+
+// useVar returns a node for a variable reference. It errors if the
+// variable is not defined.
+func (t *Tree) useVar(pos Pos, name string) Node {
+	v := t.newVariable(pos, name)
+	for _, varName := range t.vars {
+		if varName == v.Ident[0] {
+			return v
+		}
+	}
+	t.errorf("undefined variable %q", v.Ident[0])
+	return nil
+}

vendor/github.com/alecthomas/template/parse/parse_test.go

@@ -0,0 +1,426 @@
+// 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.
+
+package parse
+
+import (
+	"flag"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+var debug = flag.Bool("debug", false, "show the errors produced by the main tests")
+
+type numberTest struct {
+	text      string
+	isInt     bool
+	isUint    bool
+	isFloat   bool
+	isComplex bool
+	int64
+	uint64
+	float64
+	complex128
+}
+
+var numberTests = []numberTest{
+	// basics
+	{"0", true, true, true, false, 0, 0, 0, 0},
+	{"-0", true, true, true, false, 0, 0, 0, 0}, // check that -0 is a uint.
+	{"73", true, true, true, false, 73, 73, 73, 0},
+	{"073", true, true, true, false, 073, 073, 073, 0},
+	{"0x73", true, true, true, false, 0x73, 0x73, 0x73, 0},
+	{"-73", true, false, true, false, -73, 0, -73, 0},
+	{"+73", true, false, true, false, 73, 0, 73, 0},
+	{"100", true, true, true, false, 100, 100, 100, 0},
+	{"1e9", true, true, true, false, 1e9, 1e9, 1e9, 0},
+	{"-1e9", true, false, true, false, -1e9, 0, -1e9, 0},
+	{"-1.2", false, false, true, false, 0, 0, -1.2, 0},
+	{"1e19", false, true, true, false, 0, 1e19, 1e19, 0},
+	{"-1e19", false, false, true, false, 0, 0, -1e19, 0},
+	{"4i", false, false, false, true, 0, 0, 0, 4i},
+	{"-1.2+4.2i", false, false, false, true, 0, 0, 0, -1.2 + 4.2i},
+	{"073i", false, false, false, true, 0, 0, 0, 73i}, // not octal!
+	// complex with 0 imaginary are float (and maybe integer)
+	{"0i", true, true, true, true, 0, 0, 0, 0},
+	{"-1.2+0i", false, false, true, true, 0, 0, -1.2, -1.2},
+	{"-12+0i", true, false, true, true, -12, 0, -12, -12},
+	{"13+0i", true, true, true, true, 13, 13, 13, 13},
+	// funny bases
+	{"0123", true, true, true, false, 0123, 0123, 0123, 0},
+	{"-0x0", true, true, true, false, 0, 0, 0, 0},
+	{"0xdeadbeef", true, true, true, false, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0},
+	// character constants
+	{`'a'`, true, true, true, false, 'a', 'a', 'a', 0},
+	{`'\n'`, true, true, true, false, '\n', '\n', '\n', 0},
+	{`'\\'`, true, true, true, false, '\\', '\\', '\\', 0},
+	{`'\''`, true, true, true, false, '\'', '\'', '\'', 0},
+	{`'\xFF'`, true, true, true, false, 0xFF, 0xFF, 0xFF, 0},
+	{`'パ'`, true, true, true, false, 0x30d1, 0x30d1, 0x30d1, 0},
+	{`'\u30d1'`, true, true, true, false, 0x30d1, 0x30d1, 0x30d1, 0},
+	{`'\U000030d1'`, true, true, true, false, 0x30d1, 0x30d1, 0x30d1, 0},
+	// some broken syntax
+	{text: "+-2"},
+	{text: "0x123."},
+	{text: "1e."},
+	{text: "0xi."},
+	{text: "1+2."},
+	{text: "'x"},
+	{text: "'xx'"},
+	// Issue 8622 - 0xe parsed as floating point. Very embarrassing.
+	{"0xef", true, true, true, false, 0xef, 0xef, 0xef, 0},
+}
+
+func TestNumberParse(t *testing.T) {
+	for _, test := range numberTests {
+		// If fmt.Sscan thinks it's complex, it's complex.  We can't trust the output
+		// because imaginary comes out as a number.
+		var c complex128
+		typ := itemNumber
+		var tree *Tree
+		if test.text[0] == '\'' {
+			typ = itemCharConstant
+		} else {
+			_, err := fmt.Sscan(test.text, &c)
+			if err == nil {
+				typ = itemComplex
+			}
+		}
+		n, err := tree.newNumber(0, test.text, typ)
+		ok := test.isInt || test.isUint || test.isFloat || test.isComplex
+		if ok && err != nil {
+			t.Errorf("unexpected error for %q: %s", test.text, err)
+			continue
+		}
+		if !ok && err == nil {
+			t.Errorf("expected error for %q", test.text)
+			continue
+		}
+		if !ok {
+			if *debug {
+				fmt.Printf("%s\n\t%s\n", test.text, err)
+			}
+			continue
+		}
+		if n.IsComplex != test.isComplex {
+			t.Errorf("complex incorrect for %q; should be %t", test.text, test.isComplex)
+		}
+		if test.isInt {
+			if !n.IsInt {
+				t.Errorf("expected integer for %q", test.text)
+			}
+			if n.Int64 != test.int64 {
+				t.Errorf("int64 for %q should be %d Is %d", test.text, test.int64, n.Int64)
+			}
+		} else if n.IsInt {
+			t.Errorf("did not expect integer for %q", test.text)
+		}
+		if test.isUint {
+			if !n.IsUint {
+				t.Errorf("expected unsigned integer for %q", test.text)
+			}
+			if n.Uint64 != test.uint64 {
+				t.Errorf("uint64 for %q should be %d Is %d", test.text, test.uint64, n.Uint64)
+			}
+		} else if n.IsUint {
+			t.Errorf("did not expect unsigned integer for %q", test.text)
+		}
+		if test.isFloat {
+			if !n.IsFloat {
+				t.Errorf("expected float for %q", test.text)
+			}
+			if n.Float64 != test.float64 {
+				t.Errorf("float64 for %q should be %g Is %g", test.text, test.float64, n.Float64)
+			}
+		} else if n.IsFloat {
+			t.Errorf("did not expect float for %q", test.text)
+		}
+		if test.isComplex {
+			if !n.IsComplex {
+				t.Errorf("expected complex for %q", test.text)
+			}
+			if n.Complex128 != test.complex128 {
+				t.Errorf("complex128 for %q should be %g Is %g", test.text, test.complex128, n.Complex128)
+			}
+		} else if n.IsComplex {
+			t.Errorf("did not expect complex for %q", test.text)
+		}
+	}
+}
+
+type parseTest struct {
+	name   string
+	input  string
+	ok     bool
+	result string // what the user would see in an error message.
+}
+
+const (
+	noError  = true
+	hasError = false
+)
+
+var parseTests = []parseTest{
+	{"empty", "", noError,
+		``},
+	{"comment", "{{/*\n\n\n*/}}", noError,
+		``},
+	{"spaces", " \t\n", noError,
+		`" \t\n"`},
+	{"text", "some text", noError,
+		`"some text"`},
+	{"emptyAction", "{{}}", hasError,
+		`{{}}`},
+	{"field", "{{.X}}", noError,
+		`{{.X}}`},
+	{"simple command", "{{printf}}", noError,
+		`{{printf}}`},
+	{"$ invocation", "{{$}}", noError,
+		"{{$}}"},
+	{"variable invocation", "{{with $x := 3}}{{$x 23}}{{end}}", noError,
+		"{{with $x := 3}}{{$x 23}}{{end}}"},
+	{"variable with fields", "{{$.I}}", noError,
+		"{{$.I}}"},
+	{"multi-word command", "{{printf `%d` 23}}", noError,
+		"{{printf `%d` 23}}"},
+	{"pipeline", "{{.X|.Y}}", noError,
+		`{{.X | .Y}}`},
+	{"pipeline with decl", "{{$x := .X|.Y}}", noError,
+		`{{$x := .X | .Y}}`},
+	{"nested pipeline", "{{.X (.Y .Z) (.A | .B .C) (.E)}}", noError,
+		`{{.X (.Y .Z) (.A | .B .C) (.E)}}`},
+	{"field applied to parentheses", "{{(.Y .Z).Field}}", noError,
+		`{{(.Y .Z).Field}}`},
+	{"simple if", "{{if .X}}hello{{end}}", noError,
+		`{{if .X}}"hello"{{end}}`},
+	{"if with else", "{{if .X}}true{{else}}false{{end}}", noError,
+		`{{if .X}}"true"{{else}}"false"{{end}}`},
+	{"if with else if", "{{if .X}}true{{else if .Y}}false{{end}}", noError,
+		`{{if .X}}"true"{{else}}{{if .Y}}"false"{{end}}{{end}}`},
+	{"if else chain", "+{{if .X}}X{{else if .Y}}Y{{else if .Z}}Z{{end}}+", noError,
+		`"+"{{if .X}}"X"{{else}}{{if .Y}}"Y"{{else}}{{if .Z}}"Z"{{end}}{{end}}{{end}}"+"`},
+	{"simple range", "{{range .X}}hello{{end}}", noError,
+		`{{range .X}}"hello"{{end}}`},
+	{"chained field range", "{{range .X.Y.Z}}hello{{end}}", noError,
+		`{{range .X.Y.Z}}"hello"{{end}}`},
+	{"nested range", "{{range .X}}hello{{range .Y}}goodbye{{end}}{{end}}", noError,
+		`{{range .X}}"hello"{{range .Y}}"goodbye"{{end}}{{end}}`},
+	{"range with else", "{{range .X}}true{{else}}false{{end}}", noError,
+		`{{range .X}}"true"{{else}}"false"{{end}}`},
+	{"range over pipeline", "{{range .X|.M}}true{{else}}false{{end}}", noError,
+		`{{range .X | .M}}"true"{{else}}"false"{{end}}`},
+	{"range []int", "{{range .SI}}{{.}}{{end}}", noError,
+		`{{range .SI}}{{.}}{{end}}`},
+	{"range 1 var", "{{range $x := .SI}}{{.}}{{end}}", noError,
+		`{{range $x := .SI}}{{.}}{{end}}`},
+	{"range 2 vars", "{{range $x, $y := .SI}}{{.}}{{end}}", noError,
+		`{{range $x, $y := .SI}}{{.}}{{end}}`},
+	{"constants", "{{range .SI 1 -3.2i true false 'a' nil}}{{end}}", noError,
+		`{{range .SI 1 -3.2i true false 'a' nil}}{{end}}`},
+	{"template", "{{template `x`}}", noError,
+		`{{template "x"}}`},
+	{"template with arg", "{{template `x` .Y}}", noError,
+		`{{template "x" .Y}}`},
+	{"with", "{{with .X}}hello{{end}}", noError,
+		`{{with .X}}"hello"{{end}}`},
+	{"with with else", "{{with .X}}hello{{else}}goodbye{{end}}", noError,
+		`{{with .X}}"hello"{{else}}"goodbye"{{end}}`},
+	{"elide newline", "{{true}}\\\n  ", noError,
+		`{{true}}"  "`},
+	// Errors.
+	{"unclosed action", "hello{{range", hasError, ""},
+	{"unmatched end", "{{end}}", hasError, ""},
+	{"missing end", "hello{{range .x}}", hasError, ""},
+	{"missing end after else", "hello{{range .x}}{{else}}", hasError, ""},
+	{"undefined function", "hello{{undefined}}", hasError, ""},
+	{"undefined variable", "{{$x}}", hasError, ""},
+	{"variable undefined after end", "{{with $x := 4}}{{end}}{{$x}}", hasError, ""},
+	{"variable undefined in template", "{{template $v}}", hasError, ""},
+	{"declare with field", "{{with $x.Y := 4}}{{end}}", hasError, ""},
+	{"template with field ref", "{{template .X}}", hasError, ""},
+	{"template with var", "{{template $v}}", hasError, ""},
+	{"invalid punctuation", "{{printf 3, 4}}", hasError, ""},
+	{"multidecl outside range", "{{with $v, $u := 3}}{{end}}", hasError, ""},
+	{"too many decls in range", "{{range $u, $v, $w := 3}}{{end}}", hasError, ""},
+	{"dot applied to parentheses", "{{printf (printf .).}}", hasError, ""},
+	{"adjacent args", "{{printf 3`x`}}", hasError, ""},
+	{"adjacent args with .", "{{printf `x`.}}", hasError, ""},
+	{"extra end after if", "{{if .X}}a{{else if .Y}}b{{end}}{{end}}", hasError, ""},
+	{"invalid newline elision", "{{true}}\\{{true}}", hasError, ""},
+	// Equals (and other chars) do not assignments make (yet).
+	{"bug0a", "{{$x := 0}}{{$x}}", noError, "{{$x := 0}}{{$x}}"},
+	{"bug0b", "{{$x = 1}}{{$x}}", hasError, ""},
+	{"bug0c", "{{$x ! 2}}{{$x}}", hasError, ""},
+	{"bug0d", "{{$x % 3}}{{$x}}", hasError, ""},
+	// Check the parse fails for := rather than comma.
+	{"bug0e", "{{range $x := $y := 3}}{{end}}", hasError, ""},
+	// Another bug: variable read must ignore following punctuation.
+	{"bug1a", "{{$x:=.}}{{$x!2}}", hasError, ""},                     // ! is just illegal here.
+	{"bug1b", "{{$x:=.}}{{$x+2}}", hasError, ""},                     // $x+2 should not parse as ($x) (+2).
+	{"bug1c", "{{$x:=.}}{{$x +2}}", noError, "{{$x := .}}{{$x +2}}"}, // It's OK with a space.
+}
+
+var builtins = map[string]interface{}{
+	"printf": fmt.Sprintf,
+}
+
+func testParse(doCopy bool, t *testing.T) {
+	textFormat = "%q"
+	defer func() { textFormat = "%s" }()
+	for _, test := range parseTests {
+		tmpl, err := New(test.name).Parse(test.input, "", "", make(map[string]*Tree), builtins)
+		switch {
+		case err == nil && !test.ok:
+			t.Errorf("%q: expected error; got none", test.name)
+			continue
+		case err != nil && test.ok:
+			t.Errorf("%q: unexpected error: %v", test.name, err)
+			continue
+		case err != nil && !test.ok:
+			// expected error, got one
+			if *debug {
+				fmt.Printf("%s: %s\n\t%s\n", test.name, test.input, err)
+			}
+			continue
+		}
+		var result string
+		if doCopy {
+			result = tmpl.Root.Copy().String()
+		} else {
+			result = tmpl.Root.String()
+		}
+		if result != test.result {
+			t.Errorf("%s=(%q): got\n\t%v\nexpected\n\t%v", test.name, test.input, result, test.result)
+		}
+	}
+}
+
+func TestParse(t *testing.T) {
+	testParse(false, t)
+}
+
+// Same as TestParse, but we copy the node first
+func TestParseCopy(t *testing.T) {
+	testParse(true, t)
+}
+
+type isEmptyTest struct {
+	name  string
+	input string
+	empty bool
+}
+
+var isEmptyTests = []isEmptyTest{
+	{"empty", ``, true},
+	{"nonempty", `hello`, false},
+	{"spaces only", " \t\n \t\n", true},
+	{"definition", `{{define "x"}}something{{end}}`, true},
+	{"definitions and space", "{{define `x`}}something{{end}}\n\n{{define `y`}}something{{end}}\n\n", true},
+	{"definitions and text", "{{define `x`}}something{{end}}\nx\n{{define `y`}}something{{end}}\ny\n", false},
+	{"definition and action", "{{define `x`}}something{{end}}{{if 3}}foo{{end}}", false},
+}
+
+func TestIsEmpty(t *testing.T) {
+	if !IsEmptyTree(nil) {
+		t.Errorf("nil tree is not empty")
+	}
+	for _, test := range isEmptyTests {
+		tree, err := New("root").Parse(test.input, "", "", make(map[string]*Tree), nil)
+		if err != nil {
+			t.Errorf("%q: unexpected error: %v", test.name, err)
+			continue
+		}
+		if empty := IsEmptyTree(tree.Root); empty != test.empty {
+			t.Errorf("%q: expected %t got %t", test.name, test.empty, empty)
+		}
+	}
+}
+
+func TestErrorContextWithTreeCopy(t *testing.T) {
+	tree, err := New("root").Parse("{{if true}}{{end}}", "", "", make(map[string]*Tree), nil)
+	if err != nil {
+		t.Fatalf("unexpected tree parse failure: %v", err)
+	}
+	treeCopy := tree.Copy()
+	wantLocation, wantContext := tree.ErrorContext(tree.Root.Nodes[0])
+	gotLocation, gotContext := treeCopy.ErrorContext(treeCopy.Root.Nodes[0])
+	if wantLocation != gotLocation {
+		t.Errorf("wrong error location want %q got %q", wantLocation, gotLocation)
+	}
+	if wantContext != gotContext {
+		t.Errorf("wrong error location want %q got %q", wantContext, gotContext)
+	}
+}
+
+// All failures, and the result is a string that must appear in the error message.
+var errorTests = []parseTest{
+	// Check line numbers are accurate.
+	{"unclosed1",
+		"line1\n{{",
+		hasError, `unclosed1:2: unexpected unclosed action in command`},
+	{"unclosed2",
+		"line1\n{{define `x`}}line2\n{{",
+		hasError, `unclosed2:3: unexpected unclosed action in command`},
+	// Specific errors.
+	{"function",
+		"{{foo}}",
+		hasError, `function "foo" not defined`},
+	{"comment",
+		"{{/*}}",
+		hasError, `unclosed comment`},
+	{"lparen",
+		"{{.X (1 2 3}}",
+		hasError, `unclosed left paren`},
+	{"rparen",
+		"{{.X 1 2 3)}}",
+		hasError, `unexpected ")"`},
+	{"space",
+		"{{`x`3}}",
+		hasError, `missing space?`},
+	{"idchar",
+		"{{a#}}",
+		hasError, `'#'`},
+	{"charconst",
+		"{{'a}}",
+		hasError, `unterminated character constant`},
+	{"stringconst",
+		`{{"a}}`,
+		hasError, `unterminated quoted string`},
+	{"rawstringconst",
+		"{{`a}}",
+		hasError, `unterminated raw quoted string`},
+	{"number",
+		"{{0xi}}",
+		hasError, `number syntax`},
+	{"multidefine",
+		"{{define `a`}}a{{end}}{{define `a`}}b{{end}}",
+		hasError, `multiple definition of template`},
+	{"eof",
+		"{{range .X}}",
+		hasError, `unexpected EOF`},
+	{"variable",
+		// Declare $x so it's defined, to avoid that error, and then check we don't parse a declaration.
+		"{{$x := 23}}{{with $x.y := 3}}{{$x 23}}{{end}}",
+		hasError, `unexpected ":="`},
+	{"multidecl",
+		"{{$a,$b,$c := 23}}",
+		hasError, `too many declarations`},
+	{"undefvar",
+		"{{$a}}",
+		hasError, `undefined variable`},
+}
+
+func TestErrors(t *testing.T) {
+	for _, test := range errorTests {
+		_, err := New(test.name).Parse(test.input, "", "", make(map[string]*Tree))
+		if err == nil {
+			t.Errorf("%q: expected error", test.name)
+			continue
+		}
+		if !strings.Contains(err.Error(), test.result) {
+			t.Errorf("%q: error %q does not contain %q", test.name, err, test.result)
+		}
+	}
+}

vendor/github.com/alecthomas/template/template.go

@@ -0,0 +1,218 @@
+// 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.
+
+package template
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/alecthomas/template/parse"
+)
+
+// common holds the information shared by related templates.
+type common struct {
+	tmpl map[string]*Template
+	// We use two maps, one for parsing and one for execution.
+	// This separation makes the API cleaner since it doesn't
+	// expose reflection to the client.
+	parseFuncs FuncMap
+	execFuncs  map[string]reflect.Value
+}
+
+// Template is the representation of a parsed template. The *parse.Tree
+// field is exported only for use by html/template and should be treated
+// as unexported by all other clients.
+type Template struct {
+	name string
+	*parse.Tree
+	*common
+	leftDelim  string
+	rightDelim string
+}
+
+// New allocates a new template with the given name.
+func New(name string) *Template {
+	return &Template{
+		name: name,
+	}
+}
+
+// Name returns the name of the template.
+func (t *Template) Name() string {
+	return t.name
+}
+
+// New allocates a new template associated with the given one and with the same
+// delimiters. The association, which is transitive, allows one template to
+// invoke another with a {{template}} action.
+func (t *Template) New(name string) *Template {
+	t.init()
+	return &Template{
+		name:       name,
+		common:     t.common,
+		leftDelim:  t.leftDelim,
+		rightDelim: t.rightDelim,
+	}
+}
+
+func (t *Template) init() {
+	if t.common == nil {
+		t.common = new(common)
+		t.tmpl = make(map[string]*Template)
+		t.parseFuncs = make(FuncMap)
+		t.execFuncs = make(map[string]reflect.Value)
+	}
+}
+
+// Clone returns a duplicate of the template, including all associated
+// templates. The actual representation is not copied, but the name space of
+// associated templates is, so further calls to Parse in the copy will add
+// templates to the copy but not to the original. Clone can be used to prepare
+// common templates and use them with variant definitions for other templates
+// by adding the variants after the clone is made.
+func (t *Template) Clone() (*Template, error) {
+	nt := t.copy(nil)
+	nt.init()
+	nt.tmpl[t.name] = nt
+	for k, v := range t.tmpl {
+		if k == t.name { // Already installed.
+			continue
+		}
+		// The associated templates share nt's common structure.
+		tmpl := v.copy(nt.common)
+		nt.tmpl[k] = tmpl
+	}
+	for k, v := range t.parseFuncs {
+		nt.parseFuncs[k] = v
+	}
+	for k, v := range t.execFuncs {
+		nt.execFuncs[k] = v
+	}
+	return nt, nil
+}
+
+// copy returns a shallow copy of t, with common set to the argument.
+func (t *Template) copy(c *common) *Template {
+	nt := New(t.name)
+	nt.Tree = t.Tree
+	nt.common = c
+	nt.leftDelim = t.leftDelim
+	nt.rightDelim = t.rightDelim
+	return nt
+}
+
+// AddParseTree creates a new template with the name and parse tree
+// and associates it with t.
+func (t *Template) AddParseTree(name string, tree *parse.Tree) (*Template, error) {
+	if t.common != nil && t.tmpl[name] != nil {
+		return nil, fmt.Errorf("template: redefinition of template %q", name)
+	}
+	nt := t.New(name)
+	nt.Tree = tree
+	t.tmpl[name] = nt
+	return nt, nil
+}
+
+// Templates returns a slice of the templates associated with t, including t
+// itself.
+func (t *Template) Templates() []*Template {
+	if t.common == nil {
+		return nil
+	}
+	// Return a slice so we don't expose the map.
+	m := make([]*Template, 0, len(t.tmpl))
+	for _, v := range t.tmpl {
+		m = append(m, v)
+	}
+	return m
+}
+
+// Delims sets the action delimiters to the specified strings, to be used in
+// subsequent calls to Parse, ParseFiles, or ParseGlob. Nested template
+// definitions will inherit the settings. An empty delimiter stands for the
+// corresponding default: {{ or }}.
+// The return value is the template, so calls can be chained.
+func (t *Template) Delims(left, right string) *Template {
+	t.leftDelim = left
+	t.rightDelim = right
+	return t
+}
+
+// Funcs adds the elements of the argument map to the template's function map.
+// It panics if a value in the map is not a function with appropriate return
+// type. However, it is legal to overwrite elements of the map. The return
+// value is the template, so calls can be chained.
+func (t *Template) Funcs(funcMap FuncMap) *Template {
+	t.init()
+	addValueFuncs(t.execFuncs, funcMap)
+	addFuncs(t.parseFuncs, funcMap)
+	return t
+}
+
+// Lookup returns the template with the given name that is associated with t,
+// or nil if there is no such template.
+func (t *Template) Lookup(name string) *Template {
+	if t.common == nil {
+		return nil
+	}
+	return t.tmpl[name]
+}
+
+// Parse parses a string into a template. Nested template definitions will be
+// associated with the top-level template t. Parse may be called multiple times
+// to parse definitions of templates to associate with t. It is an error if a
+// resulting template is non-empty (contains content other than template
+// definitions) and would replace a non-empty template with the same name.
+// (In multiple calls to Parse with the same receiver template, only one call
+// can contain text other than space, comments, and template definitions.)
+func (t *Template) Parse(text string) (*Template, error) {
+	t.init()
+	trees, err := parse.Parse(t.name, text, t.leftDelim, t.rightDelim, t.parseFuncs, builtins)
+	if err != nil {
+		return nil, err
+	}
+	// Add the newly parsed trees, including the one for t, into our common structure.
+	for name, tree := range trees {
+		// If the name we parsed is the name of this template, overwrite this template.
+		// The associate method checks it's not a redefinition.
+		tmpl := t
+		if name != t.name {
+			tmpl = t.New(name)
+		}
+		// Even if t == tmpl, we need to install it in the common.tmpl map.
+		if replace, err := t.associate(tmpl, tree); err != nil {
+			return nil, err
+		} else if replace {
+			tmpl.Tree = tree
+		}
+		tmpl.leftDelim = t.leftDelim
+		tmpl.rightDelim = t.rightDelim
+	}
+	return t, nil
+}
+
+// associate installs the new template into the group of templates associated
+// with t. It is an error to reuse a name except to overwrite an empty
+// template. The two are already known to share the common structure.
+// The boolean return value reports wither to store this tree as t.Tree.
+func (t *Template) associate(new *Template, tree *parse.Tree) (bool, error) {
+	if new.common != t.common {
+		panic("internal error: associate not common")
+	}
+	name := new.name
+	if old := t.tmpl[name]; old != nil {
+		oldIsEmpty := parse.IsEmptyTree(old.Root)
+		newIsEmpty := parse.IsEmptyTree(tree.Root)
+		if newIsEmpty {
+			// Whether old is empty or not, new is empty; no reason to replace old.
+			return false, nil
+		}
+		if !oldIsEmpty {
+			return false, fmt.Errorf("template: redefinition of template %q", name)
+		}
+	}
+	t.tmpl[name] = new
+	return true, nil
+}

vendor/github.com/alecthomas/template/testdata/file1.tmpl

@@ -0,0 +1,2 @@
+{{define "x"}}TEXT{{end}}
+{{define "dotV"}}{{.V}}{{end}}

vendor/github.com/alecthomas/template/testdata/file2.tmpl

@@ -0,0 +1,2 @@
+{{define "dot"}}{{.}}{{end}}
+{{define "nested"}}{{template "dot" .}}{{end}}

vendor/github.com/alecthomas/template/testdata/tmpl1.tmpl

@@ -0,0 +1,3 @@
+template1
+{{define "x"}}x{{end}}
+{{template "y"}}

vendor/github.com/alecthomas/template/testdata/tmpl2.tmpl

@@ -0,0 +1,3 @@
+template2
+{{define "y"}}y{{end}}
+{{template "x"}}

vendor/github.com/alecthomas/units/COPYING

@@ -0,0 +1,19 @@
+Copyright (C) 2014 Alec Thomas
+
+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/alecthomas/units/README.md

@@ -0,0 +1,11 @@
+# Units - Helpful unit multipliers and functions for Go
+
+The goal of this package is to have functionality similar to the [time](http://golang.org/pkg/time/) package.
+
+It allows for code like this:
+
+```go
+n, err := ParseBase2Bytes("1KB")
+// n == 1024
+n = units.Mebibyte * 512
+```

vendor/github.com/alecthomas/units/bytes.go

@@ -0,0 +1,83 @@
+package units
+
+// Base2Bytes is the old non-SI power-of-2 byte scale (1024 bytes in a kilobyte,
+// etc.).
+type Base2Bytes int64
+
+// Base-2 byte units.
+const (
+	Kibibyte Base2Bytes = 1024
+	KiB                 = Kibibyte
+	Mebibyte            = Kibibyte * 1024
+	MiB                 = Mebibyte
+	Gibibyte            = Mebibyte * 1024
+	GiB                 = Gibibyte
+	Tebibyte            = Gibibyte * 1024
+	TiB                 = Tebibyte
+	Pebibyte            = Tebibyte * 1024
+	PiB                 = Pebibyte
+	Exbibyte            = Pebibyte * 1024
+	EiB                 = Exbibyte
+)
+
+var (
+	bytesUnitMap    = MakeUnitMap("iB", "B", 1024)
+	oldBytesUnitMap = MakeUnitMap("B", "B", 1024)
+)
+
+// ParseBase2Bytes supports both iB and B in base-2 multipliers. That is, KB
+// and KiB are both 1024.
+func ParseBase2Bytes(s string) (Base2Bytes, error) {
+	n, err := ParseUnit(s, bytesUnitMap)
+	if err != nil {
+		n, err = ParseUnit(s, oldBytesUnitMap)
+	}
+	return Base2Bytes(n), err
+}
+
+func (b Base2Bytes) String() string {
+	return ToString(int64(b), 1024, "iB", "B")
+}
+
+var (
+	metricBytesUnitMap = MakeUnitMap("B", "B", 1000)
+)
+
+// MetricBytes are SI byte units (1000 bytes in a kilobyte).
+type MetricBytes SI
+
+// SI base-10 byte units.
+const (
+	Kilobyte MetricBytes = 1000
+	KB                   = Kilobyte
+	Megabyte             = Kilobyte * 1000
+	MB                   = Megabyte
+	Gigabyte             = Megabyte * 1000
+	GB                   = Gigabyte
+	Terabyte             = Gigabyte * 1000
+	TB                   = Terabyte
+	Petabyte             = Terabyte * 1000
+	PB                   = Petabyte
+	Exabyte              = Petabyte * 1000
+	EB                   = Exabyte
+)
+
+// ParseMetricBytes parses base-10 metric byte units. That is, KB is 1000 bytes.
+func ParseMetricBytes(s string) (MetricBytes, error) {
+	n, err := ParseUnit(s, metricBytesUnitMap)
+	return MetricBytes(n), err
+}
+
+func (m MetricBytes) String() string {
+	return ToString(int64(m), 1000, "B", "B")
+}
+
+// ParseStrictBytes supports both iB and B suffixes for base 2 and metric,
+// respectively. That is, KiB represents 1024 and KB represents 1000.
+func ParseStrictBytes(s string) (int64, error) {
+	n, err := ParseUnit(s, bytesUnitMap)
+	if err != nil {
+		n, err = ParseUnit(s, metricBytesUnitMap)
+	}
+	return int64(n), err
+}

vendor/github.com/alecthomas/units/bytes_test.go

@@ -0,0 +1,49 @@
+package units
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBase2BytesString(t *testing.T) {
+	assert.Equal(t, Base2Bytes(0).String(), "0B")
+	assert.Equal(t, Base2Bytes(1025).String(), "1KiB1B")
+	assert.Equal(t, Base2Bytes(1048577).String(), "1MiB1B")
+}
+
+func TestParseBase2Bytes(t *testing.T) {
+	n, err := ParseBase2Bytes("0B")
+	assert.NoError(t, err)
+	assert.Equal(t, 0, int(n))
+	n, err = ParseBase2Bytes("1KB")
+	assert.NoError(t, err)
+	assert.Equal(t, 1024, int(n))
+	n, err = ParseBase2Bytes("1MB1KB25B")
+	assert.NoError(t, err)
+	assert.Equal(t, 1049625, int(n))
+	n, err = ParseBase2Bytes("1.5MB")
+	assert.NoError(t, err)
+	assert.Equal(t, 1572864, int(n))
+}
+
+func TestMetricBytesString(t *testing.T) {
+	assert.Equal(t, MetricBytes(0).String(), "0B")
+	assert.Equal(t, MetricBytes(1001).String(), "1KB1B")
+	assert.Equal(t, MetricBytes(1001025).String(), "1MB1KB25B")
+}
+
+func TestParseMetricBytes(t *testing.T) {
+	n, err := ParseMetricBytes("0B")
+	assert.NoError(t, err)
+	assert.Equal(t, 0, int(n))
+	n, err = ParseMetricBytes("1KB1B")
+	assert.NoError(t, err)
+	assert.Equal(t, 1001, int(n))
+	n, err = ParseMetricBytes("1MB1KB25B")
+	assert.NoError(t, err)
+	assert.Equal(t, 1001025, int(n))
+	n, err = ParseMetricBytes("1.5MB")
+	assert.NoError(t, err)
+	assert.Equal(t, 1500000, int(n))
+}

vendor/github.com/alecthomas/units/doc.go

@@ -0,0 +1,13 @@
+// Package units provides helpful unit multipliers and functions for Go.
+//
+// The goal of this package is to have functionality similar to the time [1] package.
+//
+//
+// [1] http://golang.org/pkg/time/
+//
+// It allows for code like this:
+//
+//     n, err := ParseBase2Bytes("1KB")
+//     // n == 1024
+//     n = units.Mebibyte * 512
+package units

vendor/github.com/alecthomas/units/si.go

@@ -0,0 +1,26 @@
+package units
+
+// SI units.
+type SI int64
+
+// SI unit multiples.
+const (
+	Kilo SI = 1000
+	Mega    = Kilo * 1000
+	Giga    = Mega * 1000
+	Tera    = Giga * 1000
+	Peta    = Tera * 1000
+	Exa     = Peta * 1000
+)
+
+func MakeUnitMap(suffix, shortSuffix string, scale int64) map[string]float64 {
+	return map[string]float64{
+		shortSuffix:  1,
+		"K" + suffix: float64(scale),
+		"M" + suffix: float64(scale * scale),
+		"G" + suffix: float64(scale * scale * scale),
+		"T" + suffix: float64(scale * scale * scale * scale),
+		"P" + suffix: float64(scale * scale * scale * scale * scale),
+		"E" + suffix: float64(scale * scale * scale * scale * scale * scale),
+	}
+}

vendor/github.com/alecthomas/units/util.go

@@ -0,0 +1,138 @@
+package units
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+)
+
+var (
+	siUnits = []string{"", "K", "M", "G", "T", "P", "E"}
+)
+
+func ToString(n int64, scale int64, suffix, baseSuffix string) string {
+	mn := len(siUnits)
+	out := make([]string, mn)
+	for i, m := range siUnits {
+		if n%scale != 0 || i == 0 && n == 0 {
+			s := suffix
+			if i == 0 {
+				s = baseSuffix
+			}
+			out[mn-1-i] = fmt.Sprintf("%d%s%s", n%scale, m, s)
+		}
+		n /= scale
+		if n == 0 {
+			break
+		}
+	}
+	return strings.Join(out, "")
+}
+
+// Below code ripped straight from http://golang.org/src/pkg/time/format.go?s=33392:33438#L1123
+var errLeadingInt = errors.New("units: bad [0-9]*") // never printed
+
+// leadingInt consumes the leading [0-9]* from s.
+func leadingInt(s string) (x int64, rem string, err error) {
+	i := 0
+	for ; i < len(s); i++ {
+		c := s[i]
+		if c < '0' || c > '9' {
+			break
+		}
+		if x >= (1<<63-10)/10 {
+			// overflow
+			return 0, "", errLeadingInt
+		}
+		x = x*10 + int64(c) - '0'
+	}
+	return x, s[i:], nil
+}
+
+func ParseUnit(s string, unitMap map[string]float64) (int64, error) {
+	// [-+]?([0-9]*(\.[0-9]*)?[a-z]+)+
+	orig := s
+	f := float64(0)
+	neg := false
+
+	// Consume [-+]?
+	if s != "" {
+		c := s[0]
+		if c == '-' || c == '+' {
+			neg = c == '-'
+			s = s[1:]
+		}
+	}
+	// Special case: if all that is left is "0", this is zero.
+	if s == "0" {
+		return 0, nil
+	}
+	if s == "" {
+		return 0, errors.New("units: invalid " + orig)
+	}
+	for s != "" {
+		g := float64(0) // this element of the sequence
+
+		var x int64
+		var err error
+
+		// The next character must be [0-9.]
+		if !(s[0] == '.' || ('0' <= s[0] && s[0] <= '9')) {
+			return 0, errors.New("units: invalid " + orig)
+		}
+		// Consume [0-9]*
+		pl := len(s)
+		x, s, err = leadingInt(s)
+		if err != nil {
+			return 0, errors.New("units: invalid " + orig)
+		}
+		g = float64(x)
+		pre := pl != len(s) // whether we consumed anything before a period
+
+		// Consume (\.[0-9]*)?
+		post := false
+		if s != "" && s[0] == '.' {
+			s = s[1:]
+			pl := len(s)
+			x, s, err = leadingInt(s)
+			if err != nil {
+				return 0, errors.New("units: invalid " + orig)
+			}
+			scale := 1.0
+			for n := pl - len(s); n > 0; n-- {
+				scale *= 10
+			}
+			g += float64(x) / scale
+			post = pl != len(s)
+		}
+		if !pre && !post {
+			// no digits (e.g. ".s" or "-.s")
+			return 0, errors.New("units: invalid " + orig)
+		}
+
+		// Consume unit.
+		i := 0
+		for ; i < len(s); i++ {
+			c := s[i]
+			if c == '.' || ('0' <= c && c <= '9') {
+				break
+			}
+		}
+		u := s[:i]
+		s = s[i:]
+		unit, ok := unitMap[u]
+		if !ok {
+			return 0, errors.New("units: unknown unit " + u + " in " + orig)
+		}
+
+		f += g * unit
+	}
+
+	if neg {
+		f = -f
+	}
+	if f < float64(-1<<63) || f > float64(1<<63-1) {
+		return 0, errors.New("units: overflow parsing unit")
+	}
+	return int64(f), nil
+}

vendor/github.com/cheekybits/genny/.gitignore

@@ -0,0 +1,26 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
+*.prof
+
+genny

vendor/github.com/cheekybits/genny/.travis.yml

@@ -0,0 +1,10 @@
+language: go
+
+go:
+  # - 1.0
+  # - 1.1
+  - 1.2
+  - 1.3
+  - 1.4
+  - 1.5
+  - 1.6

vendor/github.com/cheekybits/genny/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 cheekybits
+
+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/cheekybits/genny/README.md

@@ -0,0 +1,245 @@
+# genny - Generics for Go
+
+[![Build Status](https://travis-ci.org/cheekybits/genny.svg?branch=master)](https://travis-ci.org/cheekybits/genny) [![GoDoc](https://godoc.org/github.com/cheekybits/genny/parse?status.png)](http://godoc.org/github.com/cheekybits/genny/parse)
+
+Install:
+
+```
+go get github.com/cheekybits/genny
+```
+
+=====
+
+(pron. Jenny) by Mat Ryer ([@matryer](https://twitter.com/matryer)) and Tyler Bunnell ([@TylerJBunnell](https://twitter.com/TylerJBunnell)).
+
+Until the Go core team include support for [generics in Go](http://golang.org/doc/faq#generics), `genny` is a code-generation generics solution. It allows you write normal buildable and testable Go code which, when processed by the `genny gen` tool, will replace the generics with specific types.
+
+  * Generic code is valid Go code
+  * Generic code compiles and can be tested
+  * Use `stdin` and `stdout` or specify in and out files
+  * Supports Go 1.4's [go generate](http://tip.golang.org/doc/go1.4#gogenerate)
+  * Multiple specific types will generate every permutation
+  * Use `BUILTINS` and `NUMBERS` wildtype to generate specific code for all built-in (and number) Go types
+  * Function names and comments also get updated
+
+## Library
+
+We have started building a [library of common things](https://github.com/cheekybits/gennylib), and you can use `genny get` to generate the specific versions you need.
+
+For example: `genny get maps/concurrentmap.go "KeyType=BUILTINS ValueType=BUILTINS"` will print out generated code for all types for a concurrent map. Any file in the library may be generated locally in this way using all the same options given to `genny gen`.
+
+## Usage
+
+```
+genny [{flags}] gen "{types}"
+
+gen - generates type specific code from generic code.
+get <package/file> - fetch a generic template from the online library and gen it.
+
+{types}  - (optional) Command line flags (see below)
+{types}  - (required) Specific types for each generic type in the source
+{types} format:  {generic}={specific}[,another][ {generic2}={specific2}]
+
+Examples:
+  Generic=Specific
+  Generic1=Specific1 Generic2=Specific2
+  Generic1=Specific1,Specific2 Generic2=Specific3,Specific4
+
+Flags:
+  -in="": file to parse instead of stdin
+  -out="": file to save output to instead of stdout
+  -pkg="": package name for generated files
+```
+
+  * Comma separated type lists will generate code for each type
+
+### Flags
+
+  * `-in` - specify the input file (rather than using stdin)
+  * `-out` - specify the output file (rather than using stdout)
+
+### go generate
+
+To use Go 1.4's `go generate` capability, insert the following comment in your source code file:
+
+```
+//go:generate genny -in=$GOFILE -out=gen-$GOFILE gen "KeyType=string,int ValueType=string,int"
+```
+
+  * Start the line with `//go:generate `
+  * Use the `-in` and `-out` flags to specify the files to work on
+  * Use the `genny` command as usual after the flags
+
+Now, running `go generate` (in a shell) for the package will cause the generic versions of the files to be generated.
+
+  * The output file will be overwritten, so it's safe to call `go generate` many times
+  * Use `$GOFILE` to refer to the current file
+  * The `//go:generate` line will be removed from the output
+
+To see a real example of how to use `genny` with `go generate`, look in the [example/go-generate directory](https://github.com/cheekybits/genny/tree/master/examples/go-generate).
+
+## How it works
+
+Define your generic types using the special `generic.Type` placeholder type:
+
+```go
+type KeyType generic.Type
+type ValueType generic.Type
+```
+
+  * You can use as many as you like
+  * Give them meaningful names
+
+Then write the generic code referencing the types as your normally would:
+
+```go
+func SetValueTypeForKeyType(key KeyType, value ValueType) { /* ... */ }
+```
+
+  * Generic type names will also be replaced in comments and function names (see Real example below)
+
+Since `generic.Type` is a real Go type, your code will compile, and you can even write unit tests against your generic code.
+
+#### Generating specific versions
+
+Pass the file through the `genny gen` tool with the specific types as the argument:
+
+```
+cat generic.go | genny gen "KeyType=string ValueType=interface{}"
+```
+
+The output will be the complete Go source file with the generic types replaced with the types specified in the arguments.
+
+## Real example
+
+Given [this generic Go code](https://github.com/cheekybits/genny/tree/master/examples/queue) which compiles and is tested:
+
+```go
+package queue
+
+import "github.com/cheekybits/genny/generic"
+
+// NOTE: this is how easy it is to define a generic type
+type Something generic.Type
+
+// SomethingQueue is a queue of Somethings.
+type SomethingQueue struct {
+  items []Something
+}
+
+func NewSomethingQueue() *SomethingQueue {
+  return &SomethingQueue{items: make([]Something, 0)}
+}
+func (q *SomethingQueue) Push(item Something) {
+  q.items = append(q.items, item)
+}
+func (q *SomethingQueue) Pop() Something {
+  item := q.items[0]
+  q.items = q.items[1:]
+  return item
+}
+```
+
+When `genny gen` is invoked like this:
+
+```
+cat source.go | genny gen "Something=string"
+```
+
+It outputs:
+
+```go
+// This file was automatically generated by genny.
+// Any changes will be lost if this file is regenerated.
+// see https://github.com/cheekybits/genny
+
+package queue
+
+// StringQueue is a queue of Strings.
+type StringQueue struct {
+  items []string
+}
+
+func NewStringQueue() *StringQueue {
+  return &StringQueue{items: make([]string, 0)}
+}
+func (q *StringQueue) Push(item string) {
+  q.items = append(q.items, item)
+}
+func (q *StringQueue) Pop() string {
+  item := q.items[0]
+  q.items = q.items[1:]
+  return item
+}
+```
+
+To get a _something_ for every built-in Go type plus one of your own types, you could run:
+
+```
+cat source.go | genny gen "Something=BUILTINS,*MyType"
+```
+
+#### More examples
+
+Check out the [test code files](https://github.com/cheekybits/genny/tree/master/parse/test) for more real examples.
+
+## Writing test code
+
+Once you have defined a generic type with some code worth testing:
+
+```go
+package slice
+
+import (
+  "log"
+  "reflect"
+
+  "github.com/stretchr/gogen/generic"
+)
+
+type MyType generic.Type
+
+func EnsureMyTypeSlice(objectOrSlice interface{}) []MyType {
+  log.Printf("%v", reflect.TypeOf(objectOrSlice))
+  switch obj := objectOrSlice.(type) {
+  case []MyType:
+    log.Println("  returning it untouched")
+    return obj
+  case MyType:
+    log.Println("  wrapping in slice")
+    return []MyType{obj}
+  default:
+    panic("ensure slice needs MyType or []MyType")
+  }
+}
+```
+
+You can treat it like any normal Go type in your test code:
+
+```go
+func TestEnsureMyTypeSlice(t *testing.T) {
+
+  myType := new(MyType)
+  slice := EnsureMyTypeSlice(myType)
+  if assert.NotNil(t, slice) {
+    assert.Equal(t, slice[0], myType)
+  }
+
+  slice = EnsureMyTypeSlice(slice)
+  log.Printf("%#v", slice[0])
+  if assert.NotNil(t, slice) {
+    assert.Equal(t, slice[0], myType)
+  }
+
+}
+```
+
+### Understanding what `generic.Type` is
+
+Because `generic.Type` is an empty interface type (literally `interface{}`) every other type will be considered to be a `generic.Type` if you are switching on the type of an object. Of course, once the specific versions are generated, this issue goes away but it's worth knowing when you are writing your tests against generic code.
+
+### Contributions
+
+  * See the [API documentation for the parse package](http://godoc.org/github.com/cheekybits/genny/parse)
+  * Please do TDD
+  * All input welcome

vendor/github.com/cheekybits/genny/doc.go

@@ -0,0 +1,2 @@
+// Package main is the command line tool for Genny.
+package main

vendor/github.com/cheekybits/genny/examples/davechaney/func_thing.go

@@ -0,0 +1,12 @@
+package math
+
+import "github.com/cheekybits/genny/generic"
+
+type ThisNumberType generic.Number
+
+func ThisNumberTypeMax(fn func(a, b ThisNumberType) bool, a, b ThisNumberType) ThisNumberType {
+	if fn(a, b) {
+		return a
+	}
+	return b
+}

vendor/github.com/cheekybits/genny/examples/davechaney/gen.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+cat ./generic_max.go | ../../genny gen "NumberType=NUMBERS" > numbers_max_get.go
+cat ./func_thing.go | ../../genny gen "ThisNumberType=NUMBERS" > numbers_func_thing.go

vendor/github.com/cheekybits/genny/examples/davechaney/generic_max.go

@@ -0,0 +1,14 @@
+package math
+
+import "github.com/cheekybits/genny/generic"
+
+type NumberType generic.Number
+
+// NumberTypeMax gets the maximum number from the
+// two specified.
+func NumberTypeMax(a, b NumberType) NumberType {
+	if a > b {
+		return a
+	}
+	return b
+}

vendor/github.com/cheekybits/genny/examples/davechaney/max_test.go

@@ -0,0 +1,27 @@
+package math_test
+
+import (
+	"testing"
+
+	"github.com/cheekybits/genny/examples/davechaney"
+)
+
+func TestNumberTypeMax(t *testing.T) {
+
+	var v math.NumberType
+	v = math.NumberTypeMax(10, 20)
+	if v != 20 {
+		t.Errorf("Max of 10 and 20 is 20")
+	}
+
+	v = math.NumberTypeMax(20, 20)
+	if v != 20 {
+		t.Errorf("Max of 20 and 20 is 20")
+	}
+
+	v = math.NumberTypeMax(25, 20)
+	if v != 25 {
+		t.Errorf("Max of 25 and 20 is 25")
+	}
+
+}