Struct bloguen::ops::StyleElement

pub struct StyleElement { /* fields omitted */ }

A style specifier.

Can be a link or a literal, and a literal can be indirectly loaded from a file.

Consult the documentation for load() on handling filesystem interaxion.

Deserialisation

There are two serialised forms, a verbose one:

#[derive(Deserialize, Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
struct StyleContainer {
    pub style: Vec<StyleElement>,
}

let style_toml =
    "[[style]]
     class = 'link'
     data = '//nabijaczleweli.xyz/kaschism/assets/column.css'

     [[style]]
     class = 'literal'
     data = '.indented { text-indent: 1em; }'

     [[style]]
     class = 'file'
     data = 'common.css'";

let StyleContainer { style } = toml::from_str(style_toml).unwrap();
assert_eq!(&style,
           &[StyleElement::from_link("//nabijaczleweli.xyz/kaschism/assets/column.css"),
             StyleElement::from_literal(".indented { text-indent: 1em; }"),
             StyleElement::from_path("common.css")]);

And a compact one (the "literal" tag may be omitted if the content doesn't contain any colons):

#[derive(Deserialize, Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
struct StyleContainer {
    pub styles: Vec<StyleElement>,
}

let styles_toml =
    "styles = [
         'link://nabijaczleweli.xyz/kaschism/assets/column.css',
         'literal:.indented { text-indent: 1em; }',
         'file:common.css',
     ]";

let StyleContainer { styles } = toml::from_str(styles_toml).unwrap();
assert_eq!(&styles,
           &[StyleElement::from_link("//nabijaczleweli.xyz/kaschism/assets/column.css"),
             StyleElement::from_literal(".indented { text-indent: 1em; }"),
             StyleElement::from_path("common.css")]);

Methods

impl StyleElement

pub fn from_link<Dt: Into<Cow<'static, str>>>(link: Dt) -> StyleElement

Create a style element linking to an external resource.

Examples

let lonk = StyleElement::from_link("//nabijaczleweli.xyz/kaschism/assets/column.css");
assert_eq!(
    format!("{}{}{}", lonk.head(), lonk.content(), lonk.foot()),
    "<link href=\"//nabijaczleweli.xyz/kaschism/assets/column.css\" rel=\"stylesheet\" />\n")

pub fn from_literal<Dt: Into<Cow<'static, str>>>(literal: Dt) -> StyleElement

Create a style element including the specified literal literally.

Examples

let lit = StyleElement::from_literal(".indented { text-indent: 1em; }");
assert_eq!(
    format!("{}{}{}", lit.head(), lit.content(), lit.foot()),
    "<style type=\"text/css\">\n\n.indented { text-indent: 1em; }\n\n</style>\n")

pub fn from_path<Dt: Into<Cow<'static, str>>>(path: Dt) -> StyleElement

Create a style element pointing to the specified relative path.

Consult load() documentation for more data.

Examples

Given $ROOT/common.css containing:

ul, ol {
    margin-top: 0;
    margin-bottom: 0;
}

a > i.fa {
    color: black;
}

The following holds:

let root: PathBuf = /* obtained elsewhere */;

let mut lit_p = StyleElement::from_path("common.css");
assert_eq!(lit_p.load(&("$ROOT".to_string(), root.clone())), Ok(()));
assert_eq!(format!("{}{}{}", lit_p.head(), lit_p.content(), lit_p.foot()),
"<style type=\"text/css\">\n\n\
     ul, ol {\n\
         margin-top: 0;\n\
         margin-bottom: 0;\n\
     }\n\
     \n\
     a > i.fa {\n\
         color: black;\n\
     }\n\n\
\n\n</style>\n");

pub fn from_file(path: &(String, PathBuf)) -> Result<StyleElement, Error>

Create a literal style element from the contents of the specified file.

Examples

Given $ROOT/common.css containing:

ul, ol {
    margin-top: 0;
    margin-bottom: 0;
}

a > i.fa {
    color: black;
}

The following holds:

let root: PathBuf = /* obtained elsewhere */;

let lit_p = StyleElement::from_file(&("$ROOT/common.css".to_string(), root.join("common.css"))).unwrap();
assert_eq!(format!("{}{}{}", lit_p.head(), lit_p.content(), lit_p.foot()),
"<style type=\"text/css\">\n\n\
     ul, ol {\n\
         margin-top: 0;\n\
         margin-bottom: 0;\n\
     }\n\
     \n\
     a > i.fa {\n\
         color: black;\n\
     }\n\n\
\n\n</style>\n");

pub fn load(&mut self, base: &(String, PathBuf)) -> Result<(), Error>

Read data from the filesystem, if appropriate.

Path elements are concatenated with the specified root, then read_file()d in, becoming literals.

Non-path elements are unaffected.

Examples

Given the following directory layout:

$ROOT
  common.css
  assets
    effects.css

Given $ROOT/common.css containing:

ul, ol {
    margin-top: 0;
    margin-bottom: 0;
}

a > i.fa {
    color: black;
}

Given $ROOT/assets/effects.css containing:

.ruby {
    /* That's Ruby according to https://en.wikipedia.org/wiki/Ruby_(color). */
    color: #E0115F;
}

The following holds:

let root: PathBuf = /* obtained elsewhere */;

let mut elem = StyleElement::from_path("common.css");
assert_eq!(elem.load(&("$ROOT".to_string(), root.clone())), Ok(()));
assert_eq!(elem, StyleElement::from_literal("\
    ul, ol {\n\
        margin-top: 0;\n\
        margin-bottom: 0;\n\
    }\n\
    \n\
    a > i.fa {\n\
        color: black;\n\
    }\n
"));

let mut elem = StyleElement::from_path("assets/.././assets/effects.css");
assert_eq!(elem.load(&("$ROOT".to_string(), root.clone())), Ok(()));
assert_eq!(elem, StyleElement::from_literal("\
   .ruby {\n\
        /* That's Ruby according to https://en.wikipedia.org/wiki/Ruby_(color). */\n\
        color: #E0115F;\n\
    }\n
"));

let mut elem = StyleElement::from_path("assets/nonexistant.css");
assert_eq!(elem.load(&("$ROOT".to_string(), root.clone())), Err(Error::FileNotFound {
    who: "file style element",
    path: "$ROOT/assets/nonexistant.css".into(),
}));
assert_eq!(elem, StyleElement::from_path("assets/nonexistant.css"));

Trait Implementations

impl WrappedElement for StyleElement

fn head(&self) -> &str

Characters to put before the content.

fn content(&self) -> &str

The content itself.

fn foot(&self) -> &str

Characters to put after the content.

fn head_b(&self) -> &[u8]

Byte representation of pre-content.

fn content_b(&self) -> &[u8]

Byte representation of the content.

fn foot_b(&self) -> &[u8]

Byte representation of post-content.

impl Eq for StyleElement

impl Clone for StyleElement

fn clone(&self) -> StyleElement

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl PartialOrd<StyleElement> for StyleElement

fn partial_cmp(&self, other: &StyleElement) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &StyleElement) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &StyleElement) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &StyleElement) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &StyleElement) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialEq<StyleElement> for StyleElement

fn eq(&self, other: &StyleElement) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &StyleElement) -> bool

This method tests for !=.

impl Ord for StyleElement

fn cmp(&self, other: &StyleElement) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl Hash for StyleElement

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl Debug for StyleElement

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StyleElement

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.