stylist 0.15.1

Stylist is a CSS-in-Rust styling solution for WebAssembly 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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use crate::ast::Sheet;
use crate::manager::StyleManager;
#[cfg(feature = "yew")]
use crate::Style;

/// A struct that can be used as a source to create a [`Style`](crate::Style) or
/// [`GlobalStyle`](crate::GlobalStyle).
///
/// This struct is usually created by [`css!`](crate::css) macro.
///
/// You can also get a StyleSource instance from a string or a [`Sheet`] by calling `.into()`.
///
/// ```rust
/// use stylist::yew::Global;
/// use stylist::{css, StyleSource};
/// use yew::prelude::*;
///
/// let s: StyleSource = css!("color: red;");
///
/// let rendered = html! {<div class={s.clone()} />};
/// let global_rendered = html! {<Global css={s} />};
/// ```
#[derive(Debug, Clone, PartialEq)]
pub struct StyleSource {
    inner: Sheet,

    manager: Option<StyleManager>,
    #[cfg(all(debug_assertions, feature = "debug_style_locations"))]
    pub(crate) location: String,
}

impl StyleSource {
    #[cfg(all(debug_assertions, feature = "debug_style_locations"))]
    #[track_caller]
    pub(crate) fn get_caller_location() -> String {
        let caller_loc = std::panic::Location::caller();
        // Who cares if this a valid css class name, it's debugging info
        format!(
            "{}:{}:{}",
            caller_loc.file(),
            caller_loc.line(),
            caller_loc.column()
        )
    }

    pub(crate) fn into_sheet(self) -> Sheet {
        self.inner
    }

    #[cfg(feature = "yew")]
    pub(crate) fn into_style(mut self) -> Style {
        use stylist_core::ResultDisplay;
        let manager = self.manager.take().unwrap_or_default();
        Style::new_with_manager(self, manager).expect_display("Failed to create style")
    }

    #[doc(hidden)]
    pub fn with_manager(mut self, manager: StyleManager) -> Self {
        self.manager = Some(manager);

        self
    }
}

impl From<Sheet> for StyleSource {
    #[cfg_attr(all(debug_assertions, feature = "debug_style_locations"), track_caller)]
    fn from(sheet: Sheet) -> StyleSource {
        StyleSource {
            inner: sheet,
            manager: None,
            #[cfg(all(debug_assertions, feature = "debug_style_locations"))]
            location: Self::get_caller_location(),
        }
    }
}

#[cfg(feature = "parser")]
mod feat_parser {
    use super::*;
    use std::borrow::Cow;
    use std::str::FromStr;

    impl TryFrom<String> for StyleSource {
        type Error = crate::Error;
        #[cfg_attr(all(debug_assertions, feature = "debug_style_locations"), track_caller)]
        fn try_from(other: String) -> crate::Result<StyleSource> {
            let sheet = other.parse()?;
            Ok(StyleSource {
                inner: sheet,
                manager: None,
                #[cfg(all(debug_assertions, feature = "debug_style_locations"))]
                location: Self::get_caller_location(),
            })
        }
    }

    impl<'a> TryFrom<&'a str> for StyleSource {
        type Error = crate::Error;
        #[cfg_attr(all(debug_assertions, feature = "debug_style_locations"), track_caller)]
        fn try_from(other: &'a str) -> crate::Result<StyleSource> {
            let sheet = other.parse()?;
            Ok(StyleSource {
                inner: sheet,
                manager: None,
                #[cfg(all(debug_assertions, feature = "debug_style_locations"))]
                location: Self::get_caller_location(),
            })
        }
    }

    impl<'a> TryFrom<Cow<'a, str>> for StyleSource {
        type Error = crate::Error;
        #[cfg_attr(all(debug_assertions, feature = "debug_style_locations"), track_caller)]
        fn try_from(other: Cow<'a, str>) -> crate::Result<StyleSource> {
            let sheet = other.parse()?;
            Ok(StyleSource {
                inner: sheet,
                manager: None,
                #[cfg(all(debug_assertions, feature = "debug_style_locations"))]
                location: Self::get_caller_location(),
            })
        }
    }

    impl FromStr for StyleSource {
        type Err = crate::Error;
        #[cfg_attr(all(debug_assertions, feature = "debug_style_locations"), track_caller)]
        fn from_str(s: &str) -> Result<Self, Self::Err> {
            s.try_into()
        }
    }
}