Struct may_clack::multi_input::MultiInput

pub struct MultiInput<M: Display> { /* private fields */ }

Implementations

impl<M: Display> MultiInput<M>

pub fn new(message: M) -> Self

Creates a new MultiInput struct.

Has a shorthand version in multi_input()

Examples

use may_clack::{multi_input, multi_input::MultiInput};

// these two are equivalent
let question = MultiInput::new("message");
let question = multi_input("message");

pub fn placeholder(&mut self) -> &mut Self

Todo

pub fn initial_value<S: Into<String>>(&mut self, initial_value: S) -> &mut Self

Specify the initial value.

Examples

use may_clack::multi_input;

let answers = multi_input("message").initial_value("initial_value").interact();
println!("answers {:?}", answers);

pub fn min(&mut self, min: u16) -> &mut Self

Specify the minimum amount of answers.

use may_clack::multi_input;

let answers = multi_input("message").min(2).interact();
println!("answers {:?}", answers)

pub fn max(&mut self, max: u16) -> &mut Self

Specify the maximum amount of answers. Will automatically submit when that amount is reached.

Examples

use may_clack::multi_input;

let answers = multi_input("message").max(4).interact();
println!("answers {:?}", answers);

Examples found in repository

examples/full.rs (line 15)

fn main() -> Result<(), ClackError> {
	println!();
	intro(style(" full ").reverse());

	let do_input = input("input")
		.default_value("default")
		.cancel(do_cancel)
		.interact()?;
	let do_multi_input = multi_input("multi input")
		.max(4)
		.cancel(do_cancel)
		.interact()?;
	let do_confirm = confirm("confirm").prompts("true", "false").interact()?;
	let do_multi_select = multi_select("multi select")
		.option("opt1", "option 1")
		.option("opt2", "option 2")
		.option_hint("opt3", "option 3", "hint")
		.interact()?;
	let do_select = select("select")
		.option("val1", "value 1")
		.option("val2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.interact()?;

	outro("");

	println!("input {:?}", do_input);
	println!("confirm {:?}", do_confirm);
	println!("multi_input {:?}", do_multi_input);
	println!("multi_select {:?}", do_multi_select);
	println!("select {:?}", do_select);

	Ok(())
}

pub fn validate<F>(&mut self, validate: F) -> &mut Selfwhere F: Fn(&str) -> Option<&'static str> + 'static,

Specify a validation function.

On a successful validation, return a None from the closure, and on an unsuccessful validation return a Some<&'static str> with the error message.

Examples

use may_clack::multi_input;

let answers = multi_input("message")
    .validate(|x| (!x.is_ascii()).then_some("only use ascii characters"))
    .interact();
println!("answers {:?}", answers);

Examples found in repository

examples/validate.rs (line 13)

fn main() -> Result<(), ClackError> {
	println!();
	intro(style(" test ").reverse());

	let do_validate_input = input("validate single")
		.validate(|x| (!x.is_ascii()).then_some("only use ascii characters"))
		.cancel(do_cancel)
		.required();
	let do_validate_multi_input = multi_input("validate multi")
		.validate(|x| x.parse::<u32>().err().map(|_| "invalid u32"))
		.cancel(do_cancel)
		.interact();

	outro("");

	println!("single {:?}", do_validate_input);
	println!("multi {:?}", do_validate_multi_input);

	Ok(())
}

pub fn cancel<F>(&mut self, cancel: F) -> &mut Selfwhere F: Fn() + 'static,

Specify function to call on cancel.

Examples

use may_clack::{multi_input, cancel};

let answers = multi_input("message").cancel(do_cancel).interact();
println!("answers {:?}", answers);

fn do_cancel() {
    cancel("operation cancelled");
    panic!("operation cancelled");
}

Examples found in repository

examples/validate.rs (line 14)

fn main() -> Result<(), ClackError> {
	println!();
	intro(style(" test ").reverse());

	let do_validate_input = input("validate single")
		.validate(|x| (!x.is_ascii()).then_some("only use ascii characters"))
		.cancel(do_cancel)
		.required();
	let do_validate_multi_input = multi_input("validate multi")
		.validate(|x| x.parse::<u32>().err().map(|_| "invalid u32"))
		.cancel(do_cancel)
		.interact();

	outro("");

	println!("single {:?}", do_validate_input);
	println!("multi {:?}", do_validate_multi_input);

	Ok(())
}

examples/full.rs (line 16)

fn main() -> Result<(), ClackError> {
	println!();
	intro(style(" full ").reverse());

	let do_input = input("input")
		.default_value("default")
		.cancel(do_cancel)
		.interact()?;
	let do_multi_input = multi_input("multi input")
		.max(4)
		.cancel(do_cancel)
		.interact()?;
	let do_confirm = confirm("confirm").prompts("true", "false").interact()?;
	let do_multi_select = multi_select("multi select")
		.option("opt1", "option 1")
		.option("opt2", "option 2")
		.option_hint("opt3", "option 3", "hint")
		.interact()?;
	let do_select = select("select")
		.option("val1", "value 1")
		.option("val2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.interact()?;

	outro("");

	println!("input {:?}", do_input);
	println!("confirm {:?}", do_confirm);
	println!("multi_input {:?}", do_multi_input);
	println!("multi_select {:?}", do_multi_select);
	println!("select {:?}", do_select);

	Ok(())
}

pub fn interact(&self) -> Result<Vec<String>, ClackError>

Waits for the user to submit a line of text.

Returns None on an empty line and Some::<String> otherwise.

Examples

use may_clack::{multi_input, cancel};

let answers = multi_input("message")
    .validate(|x| x.parse::<u32>().err().map(|_| "invalid u32"))
    .cancel(do_cancel)
    .interact();
println!("answers {:?}", answers);

fn do_cancel() {
    cancel("operation cancelled");
    std::process::exit(1);
}

Examples found in repository

examples/generic.rs (line 8)

fn main() -> Result<(), ClackError> {
	intro("generic messages");

	let number = confirm(20).interact()?;
	let styled = multi_input(style("style").on_cyan()).interact()?;

	outro("");

	println!("number {:?}", number);
	println!("styled {:?}", styled);

	Ok(())
}

examples/validate.rs (line 15)

fn main() -> Result<(), ClackError> {
	println!();
	intro(style(" test ").reverse());

	let do_validate_input = input("validate single")
		.validate(|x| (!x.is_ascii()).then_some("only use ascii characters"))
		.cancel(do_cancel)
		.required();
	let do_validate_multi_input = multi_input("validate multi")
		.validate(|x| x.parse::<u32>().err().map(|_| "invalid u32"))
		.cancel(do_cancel)
		.interact();

	outro("");

	println!("single {:?}", do_validate_input);
	println!("multi {:?}", do_validate_multi_input);

	Ok(())
}

examples/full.rs (line 17)

fn main() -> Result<(), ClackError> {
	println!();
	intro(style(" full ").reverse());

	let do_input = input("input")
		.default_value("default")
		.cancel(do_cancel)
		.interact()?;
	let do_multi_input = multi_input("multi input")
		.max(4)
		.cancel(do_cancel)
		.interact()?;
	let do_confirm = confirm("confirm").prompts("true", "false").interact()?;
	let do_multi_select = multi_select("multi select")
		.option("opt1", "option 1")
		.option("opt2", "option 2")
		.option_hint("opt3", "option 3", "hint")
		.interact()?;
	let do_select = select("select")
		.option("val1", "value 1")
		.option("val2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.interact()?;

	outro("");

	println!("input {:?}", do_input);
	println!("confirm {:?}", do_confirm);
	println!("multi_input {:?}", do_multi_input);
	println!("multi_select {:?}", do_multi_select);
	println!("select {:?}", do_select);

	Ok(())
}