survey

README

Survey

A library for building interactive prompts. Heavily inspired by the great inquirer.js.

package main

import (
    "fmt"
    "gopkg.in/AlecAivazis/survey.v1"
)

// the questions to ask
var qs = []*survey.Question{
    {
        Name:     "name",
        Prompt:   &survey.Input{"What is your name?", ""},
        Validate: survey.Required,
    },
    {
        Name: "color",
        Prompt: &survey.Select{
            Message: "Choose a color:",
            Options: []string{"red", "blue", "green"},
            Default: "red",
        },
    },
}

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
    }{}

    // 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)
}

Examples

Examples can be found in the examples/ directory. Run them to see basic behavior:

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

name := ""
prompt := &survey.Input{
    Message: "ping",
}
survey.AskOne(prompt, &name, nil)

Password

password := ""
prompt := &survey.Password{
    Message: "Please type your password",
}
survey.AskOne(prompt, &password, nil)

Confirm

name := false
prompt := &survey.Confirm{
    Message: "Do you like pie?",
}
survey.AskOne(prompt, &name, nil)

Select

color := ""
prompt := &survey.Select{
    Message: "Choose a color:",
    Options: []string{"red", "blue", "green"},
}
survey.AskOne(prompt, &color, nil)

MultiSelect

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)

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:

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

Versioning

This project tries to maintain semantic GitHub releases as closely as possible. As such, services like 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

package main

import "gopkg.in/AlecAivazis/survey.v1"

Documentation

Index

• Constants
• Variables
• func Ask(qs []*Question, t interface{}) error
• func AskOne(p Prompt, t interface{}, v Validator) error
• func Required(val interface{}) error
• type Confirm
  • func (c *Confirm) Cleanup(rl *readline.Instance, val interface{}) error
  • func (c *Confirm) Prompt(rl *readline.Instance) (interface{}, error)
• type ConfirmTemplateData
• type Input
  • func (i *Input) Cleanup(rl *readline.Instance, val interface{}) error
  • func (i *Input) Prompt(rl *readline.Instance) (line interface{}, err error)
• type InputTemplateData
• type MultiSelect
  • func (m *MultiSelect) Cleanup(rl *readline.Instance, val interface{}) error
  • func (m *MultiSelect) OnChange(line []rune, pos int, key rune) (newLine []rune, newPos int, ok bool)
  • func (m *MultiSelect) Prompt(rl *readline.Instance) (interface{}, error)
• type MultiSelectTemplateData
• type Password
  • func (prompt *Password) Cleanup(rl *readline.Instance, val interface{}) error
  • func (p *Password) Prompt(rl *readline.Instance) (line interface{}, err error)
• type Prompt
• type Question
• type Select
  • func (s *Select) Cleanup(rl *readline.Instance, val interface{}) error
  • func (s *Select) OnChange(line []rune, pos int, key rune) (newLine []rune, newPos int, ok bool)
  • func (s *Select) Prompt(rl *readline.Instance) (interface{}, error)
• type SelectTemplateData
• type Validator
  • func ComposeValidators(validators ...Validator) Validator
  • func MaxLength(length int) Validator
  • func MinLength(length int) Validator

Constants

const (
	SelectQuestionTemplate = `` /* 167-byte string literal not displayed */

	// the template used to show the list of Selects
	SelectChoicesTemplate = `` /* 176-byte string literal not displayed */

)

Variables

var ConfirmQuestionTemplate = `` /* 268-byte string literal not displayed */

Templates with Color formatting. See Documentation: https://github.com/mgutz/ansi#style-format

var ErrorTemplate = `{{color "red"}}✘ Sorry, your reply was invalid: {{.Error}}{{color "reset"}}
`

var InputQuestionTemplate = `` /* 263-byte string literal not displayed */

Templates with Color formatting. See Documentation: https://github.com/mgutz/ansi#style-format

var MultiSelectOptionsTemplate = `` /* 271-byte string literal not displayed */

var MultiSelectQuestionTemplate = `` /* 167-byte string literal not displayed */

var PasswordQuestionTemplate = `
{{- color "green+hb"}}? {{color "reset"}}
{{- color "default+hb"}}{{ .Message }} {{color "reset"}}`

Templates with Color formatting. See Documentation: https://github.com/mgutz/ansi#style-format

Functions

func Ask

func Ask(qs []*Question, t interface{}) error

Ask performs the prompt loop

func AskOne

func AskOne(p Prompt, t interface{}, v Validator) error

AskOne asks a single question without performing validation on the answer.

func Required

func Required(val interface{}) error

Required does not allow an empty value

Types

type Confirm

type Confirm struct {
	Message string
	Default bool
}

Confirm is a regular text input that accept yes/no answers.

func (*Confirm) Cleanup

func (c *Confirm) Cleanup(rl *readline.Instance, val interface{}) error

Cleanup overwrite the line with the finalized formatted version

func (*Confirm) Prompt

func (c *Confirm) Prompt(rl *readline.Instance) (interface{}, error)

Prompt prompts the user with a simple text field and expects a reply followed by a carriage return.

type ConfirmTemplateData

type ConfirmTemplateData struct {
	Confirm
	Answer string
}

data available to the templates when processing

type Input

type Input struct {
	Message string
	Default string
}

Input is a regular text input that prints each character the user types on the screen and accepts the input with the enter key.

func (*Input) Cleanup

func (i *Input) Cleanup(rl *readline.Instance, val interface{}) error

func (*Input) Prompt

func (i *Input) Prompt(rl *readline.Instance) (line interface{}, err error)

type InputTemplateData

type InputTemplateData struct {
	Input
	Answer string
}

data available to the templates when processing

type MultiSelect

type MultiSelect struct {
	Message string
	Options []string
	Default []string
	// contains filtered or unexported fields
}

MultiSelect is a prompt that presents a list of various options to the user for them to select using the arrow keys and enter.

func (*MultiSelect) Cleanup

func (m *MultiSelect) Cleanup(rl *readline.Instance, val interface{}) error

Cleanup removes the options section, and renders the ask like a normal question.

func (*MultiSelect) OnChange

func (m *MultiSelect) OnChange(line []rune, pos int, key rune) (newLine []rune, newPos int, ok bool)

OnChange is called on every keypress.

func (*MultiSelect) Prompt

func (m *MultiSelect) Prompt(rl *readline.Instance) (interface{}, error)

type MultiSelectTemplateData

type MultiSelectTemplateData struct {
	MultiSelect
	Answer        string
	Checked       map[int]bool
	SelectedIndex int
}

data available to the templates when processing

type Password

type Password struct {
	Message string
}

Password is like a normal Input but the text shows up as *'s and there is no default.

func (*Password) Cleanup

func (prompt *Password) Cleanup(rl *readline.Instance, val interface{}) error

Cleanup hides the string with a fixed number of characters.

func (*Password) Prompt

func (p *Password) Prompt(rl *readline.Instance) (line interface{}, err error)

type Prompt

type Prompt interface {
	Prompt(*readline.Instance) (interface{}, error)
	Cleanup(*readline.Instance, interface{}) error
}

Prompt is the primary interface for the objects that can take user input and return a string value.

type Question

type Question struct {
	Name     string
	Prompt   Prompt
	Validate Validator
}

Question is the core data structure for a survey questionnaire.

type Select

type Select struct {
	Message string
	Options []string
	Default string
	// contains filtered or unexported fields
}

Select is a prompt that presents a list of various options to the user for them to select using the arrow keys and enter.

func (*Select) Cleanup

func (s *Select) Cleanup(rl *readline.Instance, val interface{}) error

func (*Select) OnChange

func (s *Select) OnChange(line []rune, pos int, key rune) (newLine []rune, newPos int, ok bool)

OnChange is called on every keypress.

func (*Select) Prompt

func (s *Select) Prompt(rl *readline.Instance) (interface{}, error)

type SelectTemplateData

type SelectTemplateData struct {
	Select
	SelectedIndex int
	Answer        string
}

the data available to the templates when processing

type Validator

type Validator func(interface{}) error

Validator is a function passed to a Question in order to redefine

func ComposeValidators

func ComposeValidators(validators ...Validator) Validator

ComposeValidators is a variadic function used to create one validator from many.

func MaxLength

func MaxLength(length int) Validator

MaxLength requires that the string is no longer than the specified value

func MinLength

func MinLength(length int) Validator

MinLength requires that the string is longer or equal in length to the specified value