Struct may_clack::input::Input

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

Input struct

Implementations

impl<M: Display> Input<M>

pub fn new(message: M) -> Self

Creates a new Input struct.

Has a shorthand version in input()

Examples

use may_clack::{input, input::Input};

// these two are equivalent
let question = Input::new("message");
let question = input("message");

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

Specify the default value to use, when no input is given.

Useful in combination with Input::required()

Examples

use may_clack::input;

let answer = input("message").default_value("default_value").required();
println!("answer {:?}", answer);

Examples found in repository

examples/full.rs (line 14)

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

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

	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 placeholder(&mut self) -> &mut Self

Todo

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

Specify the initial value.

Examples

use may_clack::input;

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

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::input;

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

Examples found in repository

examples/validate.rs (line 9)

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

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

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

Examples found in repository

examples/validate.rs (line 10)

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 15)

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

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

	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 required(&self) -> Result<String, ClackError>

Like Input::interact(), but does not return an empty line.

Useful when used with Input::default_value(), as that means that there can be no empty value.

Examples

use may_clack::input;

let answer = input("message").default_value("default_value").required();
println!("answer {:?}", answer);

Examples found in repository

examples/validate.rs (line 11)

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 interact(&self) -> Result<Option<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::{input, cancel};

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

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

Examples found in repository

examples/full.rs (line 16)

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

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

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