spaces-printer 0.3.6

A tool for managing sub-processes and showing progress in the terminal
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use crate::Printer;
use std::sync::Arc;

pub struct Markdown<'a> {
    pub printer: &'a mut Printer,
}

pub fn heading(level: u8, content: &str) -> String {
    format!("{} {}\n\n", "#".repeat(level as usize), content)
}

pub fn hline() -> &'static str {
    "\n---\n\n"
}

pub fn list(items: Vec<Arc<str>>) -> String {
    let mut result = String::new();
    for item in items {
        result.push_str(format!("- {item}\n").as_str());
    }
    result.push('\n');
    result
}

pub fn list_item(level: u8, item: &str) -> String {
    let level = if level == 0 { 1_usize } else { level as usize };
    format!("{}- {}\n", " ".repeat(((level) - 1) * 2), item)
}

pub fn bold(content: &str) -> String {
    format!("**{content}**")
}

pub fn hyperlink(show: &str, link: &str) -> String {
    format!("[{show}]({link})")
}

pub fn italic(content: &str) -> String {
    format!("*{content}*")
}

pub fn strikethrough(content: &str) -> String {
    format!("~~{content}~~")
}

pub fn code(content: &str) -> String {
    format!("`{content}`")
}

pub fn code_block(code_type: &str, content: &str) -> String {
    format!("```{code_type}\n{content}\n```\n")
}

pub fn paragraph(content: &str) -> String {
    format!("{content}\n\n")
}

impl<'a> Markdown<'a> {
    pub fn new(printer: &'a mut Printer) -> Self {
        Markdown { printer }
    }

    pub fn heading(&mut self, level: u8, content: &str) -> anyhow::Result<()> {
        self.printer.write(&heading(level, content))?;
        Ok(())
    }

    pub fn write(&mut self, content: &str) -> anyhow::Result<()> {
        self.printer.write(content)
    }

    pub fn hline(&mut self) -> anyhow::Result<()> {
        self.printer.write(hline())
    }

    pub fn list(&mut self, items: Vec<Arc<str>>) -> anyhow::Result<()> {
        self.printer.write(&list(items))
    }

    pub fn list_item(&mut self, level: u8, item: &str) -> anyhow::Result<()> {
        self.printer.write(&list_item(level, item))
    }

    pub fn bold(&mut self, content: &str) -> anyhow::Result<()> {
        self.printer.write(&bold(content))?;
        Ok(())
    }

    pub fn hyperlink(&mut self, show: &str, link: &str) -> anyhow::Result<()> {
        self.printer.write(&hyperlink(show, link))?;
        Ok(())
    }

    pub fn italic(&mut self, content: &str) -> anyhow::Result<()> {
        self.printer.write(&italic(content))?;
        Ok(())
    }

    pub fn strikethrough(&mut self, content: &str) -> anyhow::Result<()> {
        self.printer.write(&strikethrough(content))?;
        Ok(())
    }

    pub fn code(&mut self, content: &str) -> anyhow::Result<()> {
        self.printer.write(&code(content))?;
        Ok(())
    }

    pub fn code_block(&mut self, code_type: &str, content: &str) -> anyhow::Result<()> {
        self.printer.write(&code_block(code_type, content))?;
        Ok(())
    }

    pub fn paragraph(&mut self, content: &str) -> anyhow::Result<()> {
        self.printer.write(&paragraph(content))?;
        Ok(())
    }
}