lunar-lib 0.11.0

Common utilities for lunar applications
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

use std::{borrow::Cow, fmt::Display};

pub trait ChoicePrompter {
    /// Tells the prompter to start a multiple option prompt
    ///
    /// This prompt requires the user to pick a single option from any of the given options
    ///
    /// This function should return [`None`] if the result couldn't be parsed
    fn choose<C: Display>(&self, msg: ChoicePrompt<'_, C>) -> Option<C>;
}

pub struct Choice<'a, C: Display> {
    pub option: C,
    pub format: Option<Cow<'a, str>>,
}

impl<C: Display> Choice<'_, C> {
    pub fn into_value(self) -> C {
        self.option
    }
}

impl<C: Display> Display for Choice<'_, C> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if let Some(cow) = &self.format {
            cow.fmt(f)
        } else {
            self.option.fmt(f)
        }
    }
}

impl<'a, C: Display> Choice<'a, C> {
    pub fn new(option: C) -> Self {
        Self {
            option,
            format: None,
        }
    }

    /// Overides the display, displaying the format string instead of the [`Display`] implementation of `C`
    pub fn with_format(mut self, format: impl Into<Cow<'a, str>>) -> Self {
        self.format = Some(format.into());
        self
    }
}

impl<T: Display> From<T> for Choice<'_, T> {
    fn from(value: T) -> Self {
        Choice {
            option: value,
            format: None,
        }
    }
}

pub struct ChoicePrompt<'a, C: Display> {
    pub prompt: Cow<'a, str>,
    pub options: Vec<Choice<'a, C>>,
    pub default: usize,
}

impl<'a, C: Display> ChoicePrompt<'a, C> {
    #[must_use] 
    pub fn new(prompt: Cow<'a, str>) -> Self {
        Self {
            prompt,
            options: Vec::new(),
            default: 0,
        }
    }

    /// Replaces the options in the prompt
    pub fn with_options<I>(mut self, options: I) -> Self
    where
        I: IntoIterator,
        I::Item: Into<Choice<'a, C>>,
    {
        self.options = options.into_iter().map(Into::into).collect();
        self
    }

    /// Adds a option to the prompt
    pub fn with_added_option(mut self, option: impl Into<Choice<'a, C>>) -> Self {
        self.options.push(option.into());
        self
    }

    /// Sets the index of default option. This will always default to 0 if unset
    ///
    /// Out of bounds indices are entirely up to the caller to handle, even if that means panics
    #[must_use] 
    pub fn with_default_index(mut self, index: usize) -> Self {
        self.default = index;
        self
    }
}