doist 0.4.0

doist is an unofficial command line app for interacting with the Todoist API
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

use std::collections::HashMap;

use crate::{
    api::rest::{FullLabel, Label},
    interactive,
};
use color_eyre::{Result, eyre::eyre};

use crate::api::rest::LabelID;

#[derive(clap::Args, Debug, Default)]
pub struct LabelSelect {
    /// Uses the label with the closest name, if possible. Does fuzzy matching for the name. Can
    /// be used multiple times to use more labels.
    #[arg(short = 'L', long = "label")]
    label_names: Option<Vec<String>>,
    /// Uses the label with the given ID. Can be used multiple times to use more labels.
    #[arg(long = "label_id")]
    label_ids: Option<Vec<LabelID>>,
}

/// Selection changes the selection mode of [`LabelSelect::labels`].
#[derive(PartialEq, Eq)]
pub enum Selection {
    /// If no labels were chosen, an empty vector is returned
    AllowEmpty,
    /// If no labels were chosen, a selection of one label must be made.
    MustChoose,
}

impl LabelSelect {
    pub fn is_empty(&self) -> bool {
        self.label_ids.is_none() && self.label_names.is_none()
    }

    pub fn labels(&self, labels: &[Label], selection: Selection) -> Result<Vec<Label>> {
        let label_ids = self.label_ids.clone().unwrap_or_default();
        let mut all_labels = labels
            .iter()
            .map(|l| (l.id.clone(), l.to_owned()))
            .collect::<HashMap<_, _>>();
        let label_list = all_labels
            .values()
            .map(ToOwned::to_owned)
            .collect::<Vec<_>>();

        let mut found_labels = label_ids
            .into_iter()
            .map(|l| {
                all_labels
                    .get(&l)
                    .ok_or_else(|| eyre!("could not find label with id {}", l))
            })
            .collect::<Result<Vec<_>>>()?
            .iter()
            .map(|&l| l.to_owned())
            .collect::<Vec<_>>();

        if self.label_names.is_none() {
            if found_labels.is_empty() && selection == Selection::MustChoose {
                return Ok(vec![
                    all_labels
                        .remove(
                            &label_list[interactive::select(
                                "Select label",
                                &label_list.iter().map(FullLabel).collect::<Vec<_>>(),
                            )?
                            .ok_or_else(|| eyre!("no labels selected"))?]
                            .id,
                        )
                        .unwrap(),
                ]);
            }
            return Ok(found_labels);
        }

        found_labels.extend(
            self.label_names
                .as_ref()
                .unwrap()
                .iter()
                .map(|label| {
                    interactive::fuzz_select(&label_list, label)
                        .map(|label| all_labels.remove(&label.id).unwrap())
                })
                .collect::<Result<Vec<_>>>()?,
        );
        Ok(found_labels)
    }
}