Struct may_clack::input::Input

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

Input struct

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

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

Specify a placeholder.

Examples

use may_clack::input;

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

Examples found in repository

examples/full.rs (line 14)

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 initial_value<S: Into<String>>(&mut self, initial_value: 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!(" validate ".reversed());

	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()?;
	let do_parse_input = input("parse to u8").cancel(do_cancel).parse::<u8>()?;
	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!("parse multi {:?}", do_parse_multi);

	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!(" validate ".reversed());

	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()?;
	let do_parse_input = input("parse to u8").cancel(do_cancel).parse::<u8>()?;
	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!("parse multi {:?}", do_parse_multi);

	Ok(())
}

examples/full.rs (line 15)

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 parse<T: FromStr + Display>(&self) -> Result<T, ClackError>where T::Err: Display,

Like Input::required(), but parses the value before returning.

Useful for getting number inputs.

Examples

use may_clack::input;

let answer: i32 = input("message").parse::<i32>()?;
println!("answer {:?}", answer);

Examples found in repository

examples/validate.rs (line 16)

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

	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()?;
	let do_parse_input = input("parse to u8").cancel(do_cancel).parse::<u8>()?;
	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!("parse multi {:?}", do_parse_multi);

	Ok(())
}

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

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

Examples

use may_clack::input;

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

Examples found in repository

examples/validate.rs (line 11)

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

	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()?;
	let do_parse_input = input("parse to u8").cancel(do_cancel).parse::<u8>()?;
	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!("parse multi {:?}", do_parse_multi);

	Ok(())
}

examples/full.rs (line 16)

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