Struct MultiInput

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

MultiInput struct

Examples

use may_clack::{cancel, multi_input};

let answers = multi_input("message")
    .validate(|x| {
        if x.is_ascii() {
            Ok(())
        } else {
            Err(Cow::Borrowed("only use ascii characters"))
        }
    })
    .cancel(do_cancel)
    .interact()?;
println!("answers {:?}", answers);

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

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 initial_value<S: ToString>(&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 placeholder<S: ToString>(&mut self, placeholder: S) -> &mut Self

Specify a placeholder.

Examples

use may_clack::multi_input;

let answers = multi_input("message")
    .placeholder("placeholder")
    .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 18)

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

	info!("visit the documentation at https://docs.rs/may-clack");

	let do_input = input("input")
		.placeholder("placeholder")
		.cancel(do_cancel)
		.required()?;
	let do_multi_input = multi_input("multi input")
		.max(4)
		.cancel(do_cancel)
		.interact()?;
	let do_confirm = confirm("confirm")
		.prompts("true", "false")
		.cancel(do_cancel)
		.interact()?;
	let do_multi_select = multi_select("multi select")
		.option("opt1", "option 1")
		.option("opt2", "option 2")
		.option_hint("opt3", "option 3", "hint")
		.cancel(do_cancel)
		.interact()?;
	let do_select = select("select")
		.option("val1", "value 1")
		.option("val2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.cancel(do_cancel)
		.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 Self

where F: Fn(&str) -> Result<(), Cow<'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| {
        if x.find(char::is_whitespace).is_some() {
            Err(Cow::Borrowed("whitespace is disallowed"))
        } else {
            Ok(())
        }
    })
    .interact()?;
println!("answers {:?}", answers);

Examples found in repository

examples/validate.rs (lines 20-26)

fn main() -> Result<(), ClackError> {
	println!();
	intro!(" validate ".reversed());

	let do_validate_input = input("validate single (only use ascii)")
		.validate(|x| {
			if x.is_ascii() {
				Ok(())
			} else {
				Err(Cow::Borrowed("only use ascii characters"))
			}
		})
		.cancel(do_cancel)
		.required()?;
	let do_validate_multi_input = multi_input("validate multi (only use lowercase)")
		.validate(|x| {
			if x.find(char::is_uppercase).is_some() {
				Err(Cow::Borrowed("only use lowercase characters"))
			} else {
				Ok(())
			}
		})
		.cancel(do_cancel)
		.interact()?;
	let do_parse_input = input("parse to u8").cancel(do_cancel).parse::<u8>()?;
	let do_maybe_parse = input("maybe parse to ipv4 addr").maybe_parse::<Ipv4Addr>()?;
	let do_parse_multi = multi_input("parse multiple to u8")
		.cancel(do_cancel)
		.parse::<u8>()?;

	outro!();

	println!("single {do_validate_input:?}");
	println!("multi {do_validate_multi_input:?}");
	println!("parse single {do_parse_input:?}");
	println!("maybe parse single {do_maybe_parse:?}");
	println!("parse multi {do_parse_multi:?}");

	Ok(())
}

pub fn cancel<F>(&mut self, cancel: F) -> &mut Self

where 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/generic.rs (line 10)

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

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

	outro!();

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

	Ok(())
}

examples/full.rs (line 19)

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

	info!("visit the documentation at https://docs.rs/may-clack");

	let do_input = input("input")
		.placeholder("placeholder")
		.cancel(do_cancel)
		.required()?;
	let do_multi_input = multi_input("multi input")
		.max(4)
		.cancel(do_cancel)
		.interact()?;
	let do_confirm = confirm("confirm")
		.prompts("true", "false")
		.cancel(do_cancel)
		.interact()?;
	let do_multi_select = multi_select("multi select")
		.option("opt1", "option 1")
		.option("opt2", "option 2")
		.option_hint("opt3", "option 3", "hint")
		.cancel(do_cancel)
		.interact()?;
	let do_select = select("select")
		.option("val1", "value 1")
		.option("val2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.cancel(do_cancel)
		.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(())
}

examples/validate.rs (line 27)

fn main() -> Result<(), ClackError> {
	println!();
	intro!(" validate ".reversed());

	let do_validate_input = input("validate single (only use ascii)")
		.validate(|x| {
			if x.is_ascii() {
				Ok(())
			} else {
				Err(Cow::Borrowed("only use ascii characters"))
			}
		})
		.cancel(do_cancel)
		.required()?;
	let do_validate_multi_input = multi_input("validate multi (only use lowercase)")
		.validate(|x| {
			if x.find(char::is_uppercase).is_some() {
				Err(Cow::Borrowed("only use lowercase characters"))
			} else {
				Ok(())
			}
		})
		.cancel(do_cancel)
		.interact()?;
	let do_parse_input = input("parse to u8").cancel(do_cancel).parse::<u8>()?;
	let do_maybe_parse = input("maybe parse to ipv4 addr").maybe_parse::<Ipv4Addr>()?;
	let do_parse_multi = multi_input("parse multiple to u8")
		.cancel(do_cancel)
		.parse::<u8>()?;

	outro!();

	println!("single {do_validate_input:?}");
	println!("multi {do_validate_multi_input:?}");
	println!("parse single {do_parse_input:?}");
	println!("maybe parse single {do_maybe_parse:?}");
	println!("parse multi {do_parse_multi:?}");

	Ok(())
}

pub fn parse<T: FromStr + Display>(&self) -> Result<Vec<T>, ClackError>

where T::Err: Error,

Like MultiInput::interact(), but parses the value before returning.

Examples

use may_clack::multi_input;

let answers: Vec<i32> = multi_input("message").min(2).parse::<i32>()?;
println!("answers {:?}", answers);

Examples found in repository

examples/validate.rs (line 33)

fn main() -> Result<(), ClackError> {
	println!();
	intro!(" validate ".reversed());

	let do_validate_input = input("validate single (only use ascii)")
		.validate(|x| {
			if x.is_ascii() {
				Ok(())
			} else {
				Err(Cow::Borrowed("only use ascii characters"))
			}
		})
		.cancel(do_cancel)
		.required()?;
	let do_validate_multi_input = multi_input("validate multi (only use lowercase)")
		.validate(|x| {
			if x.find(char::is_uppercase).is_some() {
				Err(Cow::Borrowed("only use lowercase characters"))
			} else {
				Ok(())
			}
		})
		.cancel(do_cancel)
		.interact()?;
	let do_parse_input = input("parse to u8").cancel(do_cancel).parse::<u8>()?;
	let do_maybe_parse = input("maybe parse to ipv4 addr").maybe_parse::<Ipv4Addr>()?;
	let do_parse_multi = multi_input("parse multiple to u8")
		.cancel(do_cancel)
		.parse::<u8>()?;

	outro!();

	println!("single {do_validate_input:?}");
	println!("multi {do_validate_multi_input:?}");
	println!("parse single {do_parse_input:?}");
	println!("maybe parse single {do_maybe_parse:?}");
	println!("parse multi {do_parse_multi:?}");

	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::{cancel, multi_input};

let answers = multi_input("message")
    .validate(|x| {
        if x.contains('\0') {
            Err(Cow::Borrowed("contains nul byte"))
        } else {
            Ok(())
        }
    })
    .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 11)

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

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

	outro!();

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

	Ok(())
}

examples/full.rs (line 20)

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

	info!("visit the documentation at https://docs.rs/may-clack");

	let do_input = input("input")
		.placeholder("placeholder")
		.cancel(do_cancel)
		.required()?;
	let do_multi_input = multi_input("multi input")
		.max(4)
		.cancel(do_cancel)
		.interact()?;
	let do_confirm = confirm("confirm")
		.prompts("true", "false")
		.cancel(do_cancel)
		.interact()?;
	let do_multi_select = multi_select("multi select")
		.option("opt1", "option 1")
		.option("opt2", "option 2")
		.option_hint("opt3", "option 3", "hint")
		.cancel(do_cancel)
		.interact()?;
	let do_select = select("select")
		.option("val1", "value 1")
		.option("val2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.cancel(do_cancel)
		.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(())
}

examples/validate.rs (line 28)

fn main() -> Result<(), ClackError> {
	println!();
	intro!(" validate ".reversed());

	let do_validate_input = input("validate single (only use ascii)")
		.validate(|x| {
			if x.is_ascii() {
				Ok(())
			} else {
				Err(Cow::Borrowed("only use ascii characters"))
			}
		})
		.cancel(do_cancel)
		.required()?;
	let do_validate_multi_input = multi_input("validate multi (only use lowercase)")
		.validate(|x| {
			if x.find(char::is_uppercase).is_some() {
				Err(Cow::Borrowed("only use lowercase characters"))
			} else {
				Ok(())
			}
		})
		.cancel(do_cancel)
		.interact()?;
	let do_parse_input = input("parse to u8").cancel(do_cancel).parse::<u8>()?;
	let do_maybe_parse = input("maybe parse to ipv4 addr").maybe_parse::<Ipv4Addr>()?;
	let do_parse_multi = multi_input("parse multiple to u8")
		.cancel(do_cancel)
		.parse::<u8>()?;

	outro!();

	println!("single {do_validate_input:?}");
	println!("multi {do_validate_multi_input:?}");
	println!("parse single {do_parse_input:?}");
	println!("maybe parse single {do_maybe_parse:?}");
	println!("parse multi {do_parse_multi:?}");

	Ok(())
}