Struct bloguen::ops::ScriptElement

pub struct ScriptElement { /* fields omitted */ }

A script 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 ScriptContainer {
    pub script: Vec<ScriptElement>,
}

let script_toml =
    "[[script]]
     class = 'link'
     data = '/content/assets/syllable.js'

     [[script]]
     class = 'literal'
     data = 'document.getElementById(\"title\").innerText = \"Наган\";'

     [[script]]
     class = 'file'
     data = 'MathJax-config.js'";

let ScriptContainer { script } = toml::from_str(script_toml).unwrap();
assert_eq!(&script,
           &[ScriptElement::from_link("/content/assets/syllable.js"),
             ScriptElement::from_literal("document.getElementById(\"title\").innerText = \"Наган\";"),
             ScriptElement::from_path("MathJax-config.js")]);

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 ScriptContainer {
    pub scripts: Vec<ScriptElement>,
}

let scripts_toml =
    "scripts = [
         'link:/content/assets/syllable.js',
         'literal:document.getElementById(\"title\").innerText = \"Наган\";',
         'file:MathJax-config.js',
     ]";

let ScriptContainer { scripts } = toml::from_str(scripts_toml).unwrap();
assert_eq!(&scripts,
           &[ScriptElement::from_link("/content/assets/syllable.js"),
             ScriptElement::from_literal("document.getElementById(\"title\").innerText = \"Наган\";"),
             ScriptElement::from_path("MathJax-config.js")]);

Methods

impl ScriptElement

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

Create a script element linking to an external resource.

Examples

let lonk = ScriptElement::from_link("/content/assets/syllable.js");
assert_eq!(
    format!("{}{}{}", lonk.head(), lonk.content(), lonk.foot()),
    "<script type=\"text/javascript\" src=\"/content/assets/syllable.js\"></script>\n")

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

Create a script element including the specified literal literally.

Examples

let lit = ScriptElement::from_literal("document.getElementById(\"title\").innerText = \"Наган\";");
assert_eq!(
    format!("{}{}{}", lit.head(), lit.content(), lit.foot()),
    "<script type=\"text/javascript\">\n\ndocument.getElementById(\"title\").innerText = \"Наган\";\n\n</script>\n")

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

Create a script element pointing to the specified relative path.

Consult load() documentation for more data.

Examples

Given $ROOT/MathJax-config.js containing:

MathJax.Hub.Config({
  jax: ["input/AsciiMath", "output/HTML-CSS"],
  extensions: ["asciimath2jax.js"],
  asciimath2jax: {
    delimiters: [['[​[​', '​]​]']],
    preview: "[[maths]]"
  },
  AsciiMath: {
    decimal: "."
  },
  "HTML-CSS": {
    undefinedFamily: "STIXGeneral,'DejaVu Sans Mono','Arial Unicode MS',serif"
  }
});

The following holds:

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

let mut lit_p = ScriptElement::from_path("MathJax-config.js");
assert_eq!(lit_p.load(&("$ROOT".to_string(), root.clone())), Ok(()));
assert_eq!(format!("{}{}{}", lit_p.head(), lit_p.content(), lit_p.foot()),
"<script type=\"text/javascript\">\n\n\
    MathJax.Hub.Config({\n\
      jax: [\"input/AsciiMath\", \"output/HTML-CSS\"],\n\
      extensions: [\"asciimath2jax.js\"],\n\
      asciimath2jax: {\n\
        delimiters: [['[​[​', '​]​]']],\n\
        preview: \"[[maths]]\"\n\
      },\n\
      AsciiMath: {\n\
        decimal: \".\"\n\
      },\n\
      \"HTML-CSS\": {\n\
        undefinedFamily: \"STIXGeneral,'DejaVu Sans Mono','Arial Unicode MS',serif\"\n\
      }\n\
    });\n\
\n\n</script>\n");

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

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

Examples

Given $ROOT/MathJax-config.js containing:

MathJax.Hub.Config({
  jax: ["input/AsciiMath", "output/HTML-CSS"],
  extensions: ["asciimath2jax.js"],
  asciimath2jax: {
    delimiters: [['[​[​', '​]​]']],
    preview: "[[maths]]"
  },
  AsciiMath: {
    decimal: "."
  },
  "HTML-CSS": {
    undefinedFamily: "STIXGeneral,'DejaVu Sans Mono','Arial Unicode MS',serif"
  }
});

The following holds:

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

let lit_p = ScriptElement::from_file(&("$ROOT/MathJax-config.js".to_string(), root.join("MathJax-config.js"))).unwrap();
assert_eq!(format!("{}{}{}", lit_p.head(), lit_p.content(), lit_p.foot()),
"<script type=\"text/javascript\">\n\n\
    MathJax.Hub.Config({\n\
      jax: [\"input/AsciiMath\", \"output/HTML-CSS\"],\n\
      extensions: [\"asciimath2jax.js\"],\n\
      asciimath2jax: {\n\
        delimiters: [['[​[​', '​]​]']],\n\
        preview: \"[[maths]]\"\n\
      },\n\
      AsciiMath: {\n\
        decimal: \".\"\n\
      },\n\
      \"HTML-CSS\": {\n\
        undefinedFamily: \"STIXGeneral,'DejaVu Sans Mono','Arial Unicode MS',serif\"\n\
      }\n\
    });\n\
\n\n</script>\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
  MathJax-config.js
  assets
    octicons.js

Given $ROOT/MathJax-config.js containing:

MathJax.Hub.Config({
  jax: ["input/AsciiMath", "output/HTML-CSS"],
  extensions: ["asciimath2jax.js"],
  asciimath2jax: {
    delimiters: [['[​[​', '​]​]']],
    preview: "[[maths]]"
  },
  AsciiMath: {
    decimal: "."
  },
  "HTML-CSS": {
    undefinedFamily: "STIXGeneral,'DejaVu Sans Mono','Arial Unicode MS',serif"
  }
});

Given $ROOT/assets/octicons.js containing:

window.addEventListener("load", function() {
    const PLACEHOLDER = document.getElementById("octicons-placeholder");

    const request = new XMLHttpRequest();
    request.open("GET", "/content/assets/octicons/sprite.octicons.svg");
    request.onload = function(load) {
        PLACEHOLDER.outerHTML = load.target.responseText.replace("<svg", "<svg class=\"hidden\"");
    };
    request.send();
});

The following holds:

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

let mut elem = ScriptElement::from_path("MathJax-config.js");
assert_eq!(elem.load(&("$ROOT".to_string(), root.clone())), Ok(()));
assert_eq!(elem, ScriptElement::from_literal("\
    MathJax.Hub.Config({\n\
      jax: [\"input/AsciiMath\", \"output/HTML-CSS\"],\n\
      extensions: [\"asciimath2jax.js\"],\n\
      asciimath2jax: {\n\
        delimiters: [['[​[​', '​]​]']],\n\
        preview: \"[[maths]]\"\n\
      },\n\
      AsciiMath: {\n\
        decimal: \".\"\n\
      },\n\
      \"HTML-CSS\": {\n\
        undefinedFamily: \"STIXGeneral,'DejaVu Sans Mono','Arial Unicode MS',serif\"\n\
      }\n\
    });\n\
"));

let mut elem = ScriptElement::from_path("assets/.././assets/octicons.js");
assert_eq!(elem.load(&("$ROOT".to_string(), root.clone())), Ok(()));
assert_eq!(elem, ScriptElement::from_literal("\
window.addEventListener(\"load\", function() {\n\
    const PLACEHOLDER = document.getElementById(\"octicons-placeholder\");\n\
    \n\
    const request = new XMLHttpRequest();\n\
    request.open(\"GET\", \"/content/assets/octicons/sprite.octicons.svg\");\n\
    request.onload = function(load) {\n\
        PLACEHOLDER.outerHTML = load.target.responseText.replace(\"<svg\", \"<svg class=\\\"hidden\\\"\");\n\
    };\n\
    request.send();\n\
});\n\
"));

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

Trait Implementations

impl WrappedElement for ScriptElement

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 ScriptElement

impl Clone for ScriptElement

fn clone(&self) -> ScriptElement

Returns a copy of the value.

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

Performs copy-assignment from source.

impl PartialOrd<ScriptElement> for ScriptElement

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

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

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

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

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

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

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

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

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

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

impl PartialEq<ScriptElement> for ScriptElement

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

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

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

This method tests for !=.

impl Ord for ScriptElement

fn cmp(&self, other: &ScriptElement) -> 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 ScriptElement

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 ScriptElement

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ScriptElement

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

Deserialize this value from the given Serde deserializer.