prettyless 0.3.0

Wadler-style pretty-printing combinators in Rust with more features.
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

use std::{borrow::Cow, fmt, ops::Deref};

#[cfg(feature = "small-text")]
type SmallText = arrayvec::ArrayString<[u8; 22]>;

#[derive(Clone)]
pub enum Text<'a> {
    Owned(Box<str>),
    Borrowed(&'a str),
    #[cfg(feature = "small-text")]
    Small(SmallText),
}

impl Text<'_> {
    /// Create a text from [`std::fmt::Display`] string.
    /// It may use `SmallText` with `small-text` feature enabled.
    pub fn from_display(value: impl fmt::Display) -> Result<Self, fmt::Error> {
        use std::fmt::Write;

        #[cfg(feature = "small-text")]
        {
            let mut buf = FmtText::Small(SmallText::new());
            write!(buf, "{value}")?;
            Ok(match buf {
                FmtText::Small(b) => Self::Small(b),
                FmtText::Large(b) => Self::Owned(b.into()),
            })
        }

        #[cfg(not(feature = "small-text"))]
        {
            let mut buf = String::new();
            write!(buf, "{value}")?;
            Ok(Self::Owned(buf.into()))
        }
    }

    pub fn as_str(&self) -> &str {
        match self {
            Self::Owned(s) => s,
            Self::Borrowed(s) => s,
            #[cfg(feature = "small-text")]
            Self::Small(s) => s,
        }
    }
}

impl fmt::Debug for Text<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.as_str().fmt(f)
    }
}

impl Deref for Text<'_> {
    type Target = str;

    fn deref(&self) -> &Self::Target {
        match self {
            Self::Owned(s) => s,
            Self::Borrowed(s) => s,
            #[cfg(feature = "small-text")]
            Self::Small(s) => s,
        }
    }
}

impl<'a> From<Cow<'a, str>> for Text<'a> {
    fn from(value: Cow<'a, str>) -> Self {
        match value {
            Cow::Owned(t) => Self::Owned(t.into()),
            Cow::Borrowed(t) => Self::Borrowed(t),
        }
    }
}

#[cfg(feature = "small-text")]
enum FmtText {
    Small(SmallText),
    Large(String),
}

#[cfg(feature = "small-text")]
impl fmt::Write for FmtText {
    fn write_str(&mut self, s: &str) -> fmt::Result {
        match self {
            FmtText::Small(buf) => {
                if buf.try_push_str(s).is_err() {
                    let mut new_str = String::with_capacity(buf.len() + s.len());
                    new_str.push_str(buf);
                    new_str.push_str(s);
                    *self = FmtText::Large(new_str);
                }
            }
            FmtText::Large(buf) => buf.push_str(s),
        }
        Ok(())
    }
}

macro_rules! make_spaces {
    () => { "" };
    ($s: tt $($t: tt)*) => { concat!("          ", make_spaces!($($t)*)) };
}

pub(crate) const SPACES: &str = make_spaces!(,,,,,,,,,,);