survey: github.com/AlecAivazis/survey Index | Files | Directories

package survey

import "github.com/AlecAivazis/survey"

Index

Package Files

confirm.go editor.go filter.go input.go multiline.go multiselect.go password.go renderer.go select.go survey.go transform.go validate.go

Variables

var ConfirmQuestionTemplate = "" /* 573 byte string literal not displayed */

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

var EditorQuestionTemplate = "" /* 658 byte string literal not displayed */

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

var ErrorTemplate = `{{color .Icon.Format }}{{ .Icon.Text }} Sorry, your reply was invalid: {{ .Error.Error }}{{color "reset"}}
`
var InputQuestionTemplate = "" /* 578 byte string literal not displayed */

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

var MultiSelectQuestionTemplate = "" /* 1084 byte string literal not displayed */
var MultilineQuestionTemplate = "" /* 568 byte string literal not displayed */

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

var PasswordQuestionTemplate = "" /* 394 byte string literal not displayed */

PasswordQuestionTemplate is a template with color formatting. See Documentation: https://github.com/mgutz/ansi#style-format

var SelectQuestionTemplate = "" /* 841 byte string literal not displayed */

func Ask Uses

func Ask(qs []*Question, response interface{}, opts ...AskOpt) error

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,
		Transform: survey.Title,
	},
}

answers := struct{ Name string }{}

err := survey.Ask(qs, &answers)

func AskOne Uses

func AskOne(p Prompt, response interface{}, opts ...AskOpt) 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)

func Required Uses

func Required(val interface{}) error

Required does not allow an empty value

func Title Uses

func Title(ans interface{}) interface{}

Title is a `Transformer`. It receives an answer value and returns a copy of the "ans" with all Unicode letters that begin words mapped to their title case.

Note that if "ans" is not a string then it will return a nil value, meaning that the above answer will not be affected by this call at all.

func ToLower Uses

func ToLower(ans interface{}) interface{}

ToLower is a `Transformer`. It receives an answer value and returns a copy of the "ans" with all Unicode letters mapped to their lower case.

Note that if "ans" is not a string then it will return a nil value, meaning that the above answer will not be affected by this call at all.

type AskOpt Uses

type AskOpt func(options *AskOptions) error

AskOpt allows setting optional ask options.

func WithFilter Uses

func WithFilter(filter func(filter string, value string, index int) (include bool)) AskOpt

WithFilter specifies the default filter to use when asking questions.

func WithHelpInput Uses

func WithHelpInput(r rune) AskOpt

WithHelpInput changes the character that prompts look for to give the user helpful information.

func WithIcons Uses

func WithIcons(setIcons func(*IconSet)) AskOpt

WithIcons sets the icons that will be used when prompting the user

func WithPageSize Uses

func WithPageSize(pageSize int) AskOpt

WithPageSize sets the default page size used by prompts

func WithStdio Uses

func WithStdio(in terminal.FileReader, out terminal.FileWriter, err io.Writer) AskOpt

WithStdio specifies the standard input, output and error files survey interacts with. By default, these are os.Stdin, os.Stdout, and os.Stderr.

func WithValidator Uses

func WithValidator(v Validator) AskOpt

WithValidator specifies a validator to use while prompting the user

type AskOptions Uses

type AskOptions struct {
    Stdio        terminal.Stdio
    Validators   []Validator
    PromptConfig PromptConfig
}

AskOptions provides additional options on ask.

type Confirm Uses

type Confirm struct {
    Renderer
    Message string
    Default bool
    Help    string
}

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

func (*Confirm) Cleanup Uses

func (c *Confirm) Cleanup(config *PromptConfig, val interface{}) error

Cleanup overwrite the line with the finalized formatted version

func (*Confirm) Prompt Uses

func (c *Confirm) Prompt(config *PromptConfig) (interface{}, error)

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)

type ConfirmTemplateData Uses

type ConfirmTemplateData struct {
    Confirm
    Answer   string
    ShowHelp bool
    Config   *PromptConfig
}

data available to the templates when processing

type Editor Uses

type Editor struct {
    Renderer
    Message       string
    Default       string
    Help          string
    Editor        string
    HideDefault   bool
    AppendDefault bool
    FileName      string
}

Editor launches an instance of the users preferred editor on a temporary file. The editor to use is determined by reading the $VISUAL or $EDITOR environment variables. If neither of those are present, notepad (on Windows) or vim (others) is used. The launch of the editor is triggered by the enter key. Since the response may be long, it will not be echoed as Input does, instead, it print <Received>. Response type is a string.

message := ""
prompt := &survey.Editor{ Message: "What is your commit message?" }
survey.AskOne(prompt, &message)

func (*Editor) Cleanup Uses

func (e *Editor) Cleanup(config *PromptConfig, val interface{}) error

func (*Editor) Prompt Uses

func (e *Editor) Prompt(config *PromptConfig) (interface{}, error)

func (*Editor) PromptAgain Uses

func (e *Editor) PromptAgain(config *PromptConfig, invalid interface{}, err error) (interface{}, error)

type EditorTemplateData Uses

type EditorTemplateData struct {
    Editor
    Answer     string
    ShowAnswer bool
    ShowHelp   bool
    Config     *PromptConfig
}

data available to the templates when processing

type ErrorTemplateData Uses

type ErrorTemplateData struct {
    Error error
    Icon  Icon
}

type Icon Uses

type Icon struct {
    Text   string
    Format string
}

Icon holds the text and format to show for a particular icon

type IconSet Uses

type IconSet struct {
    HelpInput      Icon
    Error          Icon
    Help           Icon
    Question       Icon
    MarkedOption   Icon
    UnmarkedOption Icon
    SelectFocus    Icon
}

IconSet holds the icons to use for various prompts

type Input Uses

type Input struct {
    Renderer
    Message string
    Default string
    Help    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. Response type is a string.

name := ""
prompt := &survey.Input{ Message: "What is your name?" }
survey.AskOne(prompt, &name)

func (*Input) Cleanup Uses

func (i *Input) Cleanup(config *PromptConfig, val interface{}) error

func (*Input) Prompt Uses

func (i *Input) Prompt(config *PromptConfig) (interface{}, error)

type InputTemplateData Uses

type InputTemplateData struct {
    Input
    Answer     string
    ShowAnswer bool
    ShowHelp   bool
    Config     *PromptConfig
}

data available to the templates when processing

type MultiSelect Uses

type MultiSelect struct {
    Renderer
    Message       string
    Options       []string
    Default       interface{}
    Help          string
    PageSize      int
    VimMode       bool
    FilterMessage string
    Filter        func(filter string, value string, index int) bool
    // 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. 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)

func (*MultiSelect) Cleanup Uses

func (m *MultiSelect) Cleanup(config *PromptConfig, val interface{}) error

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

func (*MultiSelect) OnChange Uses

func (m *MultiSelect) OnChange(key rune, config *PromptConfig)

OnChange is called on every keypress.

func (*MultiSelect) Prompt Uses

func (m *MultiSelect) Prompt(config *PromptConfig) (interface{}, error)

type MultiSelectTemplateData Uses

type MultiSelectTemplateData struct {
    MultiSelect
    Answer        string
    ShowAnswer    bool
    Checked       map[int]bool
    SelectedIndex int
    ShowHelp      bool
    PageEntries   []core.OptionAnswer
    Config        *PromptConfig
}

data available to the templates when processing

type Multiline Uses

type Multiline struct {
    Renderer
    Message string
    Default string
    Help    string
}

func (*Multiline) Cleanup Uses

func (i *Multiline) Cleanup(config *PromptConfig, val interface{}) error

func (*Multiline) Prompt Uses

func (i *Multiline) Prompt(config *PromptConfig) (interface{}, error)

type MultilineTemplateData Uses

type MultilineTemplateData struct {
    Multiline
    Answer     string
    ShowAnswer bool
    ShowHelp   bool
    Config     *PromptConfig
}

data available to the templates when processing

type OptionAnswer Uses

type OptionAnswer = core.OptionAnswer

OptionAnswer is an ergonomic alias for core.OptionAnswer

type Password Uses

type Password struct {
    Renderer
    Message string
    Help    string
}

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)

func (*Password) Cleanup Uses

func (prompt *Password) Cleanup(config *PromptConfig, val interface{}) error

Cleanup hides the string with a fixed number of characters.

func (*Password) Prompt Uses

func (p *Password) Prompt(config *PromptConfig) (line interface{}, err error)

type PasswordTemplateData Uses

type PasswordTemplateData struct {
    Password
    ShowHelp bool
    Config   *PromptConfig
}

type Prompt Uses

type Prompt interface {
    Prompt(config *PromptConfig) (interface{}, error)
    Cleanup(*PromptConfig, interface{}) error
    Error(*PromptConfig, error) error
}

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

type PromptAgainer Uses

type PromptAgainer interface {
    PromptAgain(config *PromptConfig, invalid interface{}, err error) (interface{}, error)
}

PromptAgainer Interface for Prompts that support prompting again after invalid input

type PromptConfig Uses

type PromptConfig struct {
    PageSize  int
    Icons     IconSet
    HelpInput string
    Filter    func(filter string, option string, index int) bool
}

PromptConfig holds the global configuration for a prompt

type Question Uses

type Question struct {
    Name      string
    Prompt    Prompt
    Validate  Validator
    Transform Transformer
}

Question is the core data structure for a survey questionnaire.

type Renderer Uses

type Renderer struct {
    // contains filtered or unexported fields
}

func (*Renderer) Error Uses

func (r *Renderer) Error(config *PromptConfig, invalid error) error

func (*Renderer) NewCursor Uses

func (r *Renderer) NewCursor() *terminal.Cursor

func (*Renderer) NewRuneReader Uses

func (r *Renderer) NewRuneReader() *terminal.RuneReader

func (*Renderer) Render Uses

func (r *Renderer) Render(tmpl string, data interface{}) error

func (*Renderer) Stdio Uses

func (r *Renderer) Stdio() terminal.Stdio

func (*Renderer) WithStdio Uses

func (r *Renderer) WithStdio(stdio terminal.Stdio)

type Select Uses

type Select struct {
    Renderer
    Message       string
    Options       []string
    Default       interface{}
    Help          string
    PageSize      int
    VimMode       bool
    FilterMessage string
    Filter        func(filter string, value string, index int) bool
    // 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. Response type is a string.

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

func (*Select) Cleanup Uses

func (s *Select) Cleanup(config *PromptConfig, val interface{}) error

func (*Select) OnChange Uses

func (s *Select) OnChange(key rune, config *PromptConfig) bool

OnChange is called on every keypress.

func (*Select) Prompt Uses

func (s *Select) Prompt(config *PromptConfig) (interface{}, error)

type SelectTemplateData Uses

type SelectTemplateData struct {
    Select
    PageEntries   []core.OptionAnswer
    SelectedIndex int
    Answer        string
    ShowAnswer    bool
    ShowHelp      bool
    Config        *PromptConfig
}

SelectTemplateData is the data available to the templates when processing

type Transformer Uses

type Transformer func(ans interface{}) (newAns interface{})

Transformer is a function passed to a Question after a user has provided a response. The function can be used to implement a custom logic that will result to return a different representation of the given answer.

Look `TransformString`, `ToLower` `Title` and `ComposeTransformers` for more.

func ComposeTransformers Uses

func ComposeTransformers(transformers ...Transformer) Transformer

ComposeTransformers is a variadic function used to create one transformer from many.

func TransformString Uses

func TransformString(f func(s string) string) Transformer

TransformString returns a `Transformer` based on the "f" function which accepts a string representation of the answer and returns a new one, transformed, answer. Take for example the functions inside the std `strings` package, they can be converted to a compatible `Transformer` by using this function, i.e: `TransformString(strings.Title)`, `TransformString(strings.ToUpper)`.

Note that `TransformString` is just a helper, `Transformer` can be used to transform any type of answer.

type Validator Uses

type Validator func(ans interface{}) error

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.

func ComposeValidators Uses

func ComposeValidators(validators ...Validator) Validator

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

func MaxLength Uses

func MaxLength(length int) Validator

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

func MinLength Uses

func MinLength(length int) Validator

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

Directories

PathSynopsis
core
examples
terminal
tests
tests/util

Package survey imports 14 packages (graph) and is imported by 32 packages. Updated 2019-07-11. Refresh now. Tools for package owners.