logparse_pretty_print/providers/

mod.rs

use crate::{PrettyPrint, PrettyTree, Text};
use alloc::rc::Rc;
use color_ansi::AnsiStyle;
use core::fmt::{Debug, Formatter};

/// Represents a pretty-printable tree provider.
pub struct PrettyProvider {
    width: usize,
    keyword: Rc<AnsiStyle>,
    string: Rc<AnsiStyle>,
    number: Rc<AnsiStyle>,
    macros: Rc<AnsiStyle>,
    argument: Rc<AnsiStyle>,
    argument_mut: Rc<AnsiStyle>,
    local: Rc<AnsiStyle>,
    local_mut: Rc<AnsiStyle>,
    operator: Rc<AnsiStyle>,
    structure: Rc<AnsiStyle>,
    variant: Rc<AnsiStyle>,
    interface: Rc<AnsiStyle>,
}

impl Debug for PrettyProvider {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("PrettyProvider").finish()
    }
}

impl PrettyProvider {
    /// Creates a new pretty-printable tree provider.
    pub fn new(width: usize) -> Self {
        Self {
            width,
            keyword: AnsiStyle::rgb(197, 119, 207).into(),
            string: AnsiStyle::rgb(152, 195, 121).into(),
            number: AnsiStyle::rgb(206, 153, 100).into(),
            macros: AnsiStyle::rgb(87, 182, 194).into(),
            argument: AnsiStyle::rgb(239, 112, 117).into(),
            argument_mut: AnsiStyle::rgb(239, 112, 117).with_underline().into(),
            local: AnsiStyle::rgb(152, 195, 121).into(),
            local_mut: AnsiStyle::rgb(152, 195, 121).with_underline().into(),
            operator: AnsiStyle::rgb(90, 173, 238).into(),
            structure: AnsiStyle::rgb(197, 119, 207).into(),
            variant: AnsiStyle::rgb(239, 112, 117).into(),
            interface: AnsiStyle::rgb(197, 119, 207).into(),
        }
    }
}

impl PrettyProvider {
    /// Gets the width of the document.
    pub fn get_width(&self) -> usize {
        self.width
    }
    /// Sets the width of the document.
    pub fn set_width(&mut self, width: usize) {
        self.width = width;
    }
    /// Gets the width of the document.
    pub fn text<'a, S, T>(&self, text: S) -> PrettyTree<'a, T>
    where
        S: Into<T>,
    {
        PrettyTree::text(text)
    }
    /// Gets the width of the document.
    pub fn custom<'a, S, T: Text<'a>>(&self, text: S, style: Rc<AnsiStyle>) -> PrettyTree<'a, T>
    where
        S: Into<T>,
    {
        PrettyTree::text(text).annotate(style)
    }
    /// Allocate a document containing the given text.
    pub fn keyword<'a, S, T: Text<'a>>(&self, text: S) -> PrettyTree<'a, T>
    where
        S: Into<T>,
    {
        PrettyTree::text(text).annotate(self.keyword.clone())
    }
    /// Allocate a document containing the given text.
    pub fn identifier<'a, S, T: Text<'a>>(&self, text: S) -> PrettyTree<'a, T>
    where
        S: Into<T>,
    {
        PrettyTree::text(text).annotate(self.operator.clone())
    }
    /// Allocate a document containing the given text.
    pub fn generic<'a, S, T: Text<'a>>(&self, text: S) -> PrettyTree<'a, T>
    where
        S: Into<T>,
    {
        PrettyTree::text(text).annotate(self.macros.clone())
    }

    /// Allocate a document containing the given text.
    pub fn variable<'a, S, T: Text<'a>>(&self, text: S, mutable: bool) -> PrettyTree<'a, T>
    where
        S: Into<T>,
    {
        if mutable {
            PrettyTree::text(text).annotate(self.local_mut.clone())
        } else {
            PrettyTree::text(text).annotate(self.local.clone())
        }
    }
    /// Allocate a document containing the given text.
    pub fn argument<'a, S, T: Text<'a>>(&self, text: S, mutable: bool) -> PrettyTree<'a, T>
    where
        S: Into<T>,
    {
        if mutable {
            PrettyTree::text(text).annotate(self.argument_mut.clone())
        } else {
            PrettyTree::text(text).annotate(self.argument.clone())
        }
    }
    /// Allocate a document containing the given text.
    pub fn operator<'a, S, T: Text<'a>>(&self, text: S) -> PrettyTree<'a, T>
    where
        S: Into<T>,
    {
        PrettyTree::text(text).annotate(self.operator.clone())
    }
    /// Allocate a document containing the given text.
    pub fn string<'a, S, T: Text<'a>>(&self, text: S) -> PrettyTree<'a, T>
    where
        S: Into<T>,
    {
        PrettyTree::text(text).annotate(self.string.clone())
    }
    /// Allocate a document containing the given text.
    pub fn annotation<'a, S, T: Text<'a>>(&self, text: S) -> PrettyTree<'a, T>
    where
        S: Into<T>,
    {
        PrettyTree::text(text).annotate(self.macros.clone())
    }
    /// Allocate a document containing the given text.
    pub fn number<'a, S, T: Text<'a>>(&self, text: S) -> PrettyTree<'a, T>
    where
        S: Into<T>,
    {
        PrettyTree::text(text).annotate(self.number.clone())
    }
    /// Allocate a document containing the given text.
    pub fn structure<'a, S, T: Text<'a>>(&self, text: S) -> PrettyTree<'a, T>
    where
        S: Into<T>,
    {
        PrettyTree::text(text).annotate(self.structure.clone())
    }
    /// Allocate a document containing the given text.
    pub fn variant<'a, S, T: Text<'a>>(&self, text: S) -> PrettyTree<'a, T>
    where
        S: Into<T>,
    {
        PrettyTree::text(text).annotate(self.variant.clone())
    }

    /// Allocate a document containing the given text.
    pub fn interface<'a, S, T: Text<'a>>(&self, text: S) -> PrettyTree<'a, T>
    where
        S: Into<T>,
    {
        PrettyTree::text(text).annotate(self.interface.clone())
    }
}

impl PrettyProvider {
    /// Allocate a document containing the given text.
    ///
    /// # Examples
    ///
    /// ```
    /// # use pretty_print::PrettyProvider;
    /// let theme = PrettyProvider::new(80);
    /// theme.join(vec!["a", "b", "c"], ", ");
    /// ```
    pub fn join<'a, I, T1, T2, T: Text<'a>>(&self, iter: I, joint: T2) -> PrettyTree<'a, T>
    where
        I: IntoIterator<Item = T1>,
        T1: PrettyPrint<'a, T>,
        T2: PrettyPrint<'a, T>,
    {
        PrettyTree::join(iter.into_iter().map(|x| x.pretty(self)), joint.pretty(self))
    }
    /// Allocate a document containing the given text.
    ///
    /// # Examples
    ///
    /// ```
    /// # use pretty_print::PrettyProvider;
    /// let theme = PrettyProvider::new(80);
    /// theme.join(&["a", "b", "c"], ", ");
    /// ```
    pub fn join_slice<'a, I, U, T: Text<'a>>(&self, iter: &[I], joint: U) -> PrettyTree<'a, T>
    where
        I: PrettyPrint<'a, T>,
        U: PrettyPrint<'a, T>,
    {
        PrettyTree::join(iter.iter().map(|s| s.pretty(self)), joint.pretty(self))
    }
    /// Allocate a document containing the given text.
    ///
    /// # Examples
    ///
    /// ```
    /// # use pretty_print::PrettyProvider;
    /// let theme = PrettyProvider::new(80);
    /// theme.concat(vec!["1", "2", "3"]);
    /// ```
    pub fn concat<'a, I, U, T: Text<'a>>(&self, iter: I) -> PrettyTree<'a, T>
    where
        I: IntoIterator<Item = U>,
        U: PrettyPrint<'a, T>,
    {
        PrettyTree::concat(iter.into_iter().map(|x| x.pretty(self)))
    }
    /// Allocate a document containing the given text.
    ///
    /// # Examples
    ///
    /// ```
    /// # use pretty_print::PrettyProvider;
    /// let theme = PrettyProvider::new(80);
    /// theme.concat_slice(&["1", "2", "3"]);
    /// ```
    pub fn concat_slice<'a, U, T: Text<'a>>(&self, iter: &[U]) -> PrettyTree<'a, T>
    where
        U: PrettyPrint<'a, T>,
    {
        PrettyTree::concat(iter.iter().map(|s| s.pretty(self)))
    }
}