sidoc_html5/

owned.rs

//! A variant of `Element` that doesn't work with references.

enum AttrType {
  KV(String, String),
  Bool(String),
  Data(String, String),
  BoolData(String)
}

pub struct Element {
  tag: String,
  classes: Vec<String>,
  alst: Vec<AttrType>
}

impl Element {
  #[must_use]
  #[allow(clippy::needless_pass_by_value)]
  pub fn new(tag: impl ToString) -> Self {
    Self {
      tag: tag.to_string(),
      classes: Vec::new(),
      alst: Vec::new()
    }
  }

  #[must_use]
  #[allow(clippy::needless_pass_by_value)]
  pub fn class(mut self, cls: impl ToString) -> Self {
    self.class_r(cls);
    self
  }

  #[allow(clippy::needless_pass_by_value)]
  pub fn class_r(&mut self, cls: impl ToString) -> &mut Self {
    self.classes.push(cls.to_string());
    self
  }

  #[must_use]
  #[allow(clippy::needless_pass_by_value)]
  pub fn flag(mut self, key: impl ToString) -> Self {
    self.flag_r(key);
    self
  }

  #[allow(clippy::needless_pass_by_value)]
  pub fn flag_r(&mut self, key: impl ToString) -> &mut Self {
    self.alst.push(AttrType::Bool(key.to_string()));
    self
  }

  #[must_use]
  pub fn attr(mut self, key: impl ToString, value: impl AsRef<str>) -> Self {
    self.attr_r(key, value);
    self
  }

  #[allow(clippy::needless_pass_by_value)]
  pub fn attr_r(
    &mut self,
    key: impl ToString,
    value: impl AsRef<str>
  ) -> &mut Self {
    let key = key.to_string();
    debug_assert!(
      key != "class",
      "Use the dedicated .class() method to add classes to elements"
    );
    self.alst.push(AttrType::KV(
      key,
      html_escape::encode_double_quoted_attribute(value.as_ref()).to_string()
    ));
    self
  }

  #[must_use]
  #[allow(clippy::needless_pass_by_value)]
  pub fn data_attr(
    mut self,
    key: impl ToString,
    value: impl AsRef<str>
  ) -> Self {
    self.data_attr_r(key, value);
    self
  }

  #[allow(clippy::needless_pass_by_value)]
  pub fn data_attr_r(
    &mut self,
    key: impl ToString,
    value: impl AsRef<str>
  ) -> &mut Self {
    let key = key.to_string();
    self.alst.push(AttrType::Data(
      key,
      html_escape::encode_double_quoted_attribute(value.as_ref()).to_string()
    ));
    self
  }

  #[must_use]
  #[allow(clippy::needless_pass_by_value)]
  pub fn data_flag(mut self, key: impl ToString) -> Self {
    self.data_flag_r(key);
    self
  }

  #[allow(clippy::needless_pass_by_value)]
  pub fn data_flag_r(&mut self, key: impl ToString) -> &mut Self {
    self.alst.push(AttrType::BoolData(key.to_string()));
    self
  }
}

impl Element {
  #[must_use]
  #[allow(clippy::needless_pass_by_value)]
  pub fn raw_attr(mut self, key: impl ToString, value: impl ToString) -> Self {
    self.raw_attr_r(key, value);
    self
  }

  #[allow(clippy::needless_pass_by_value)]
  pub fn raw_attr_r(
    &mut self,
    key: impl ToString,
    value: impl ToString
  ) -> &mut Self {
    let key = key.to_string();
    debug_assert!(
      key != "class",
      "Use the dedicated .class() method to add classes to elements"
    );
    self.alst.push(AttrType::KV(key, value.to_string()));
    self
  }
}

impl Element {
  /// Conditionally call a closure to map `self` if a predicate is true.
  ///
  /// ```
  /// use sidoc_html5::owned::Element;
  /// let someval = 42;
  /// Element::new("body")
  ///   .map_if(someval == 42, |obj| obj.flag("selected"));
  /// ```
  #[must_use]
  pub fn map_if<F>(self, flag: bool, f: F) -> Self
  where
    F: FnOnce(Self) -> Self
  {
    if flag {
      f(self)
    } else {
      self
    }
  }

  #[must_use]
  pub fn map_opt<T, F>(self, opt: Option<T>, f: F) -> Self
  where
    F: FnOnce(Self, T) -> Self
  {
    if let Some(o) = opt {
      f(self, o)
    } else {
      self
    }
  }

  /// Conditionally call a closure to modify `self`, in-place, if a predicate
  /// is true.
  ///
  /// ```
  /// use sidoc_html5::owned::Element;
  /// let someval = 42;
  /// let mut e = Element::new("body");
  /// e.mod_if(someval == 42, |obj| {
  ///   obj.flag_r("selected");
  /// });
  /// ```
  pub fn mod_if<F>(&mut self, flag: bool, f: F) -> &mut Self
  where
    F: FnOnce(&mut Self)
  {
    if flag {
      f(self);
    }
    self
  }

  pub fn mod_opt<T, F>(&mut self, opt: Option<T>, f: F) -> &mut Self
  where
    F: FnOnce(&mut Self, T)
  {
    if let Some(o) = opt {
      f(self, o);
    }
    self
  }
}

impl Element {
  /// Generate a vector of strings representing each attribute.
  fn gen_attr_list(&self) -> Option<Vec<String>> {
    if self.alst.is_empty() && self.classes.is_empty() {
      None
    } else {
      let mut ret = Vec::new();

      if !self.classes.is_empty() {
        ret.push(format!(r#"class="{}""#, self.classes.join(" ")));
      }

      let it = self.alst.iter().map(|a| match a {
        AttrType::KV(k, v) => {
          format!(r#"{k}="{v}""#)
        }
        AttrType::Bool(a) => a.clone(),
        AttrType::Data(k, v) => {
          format!(r#"data-{k}="{v}""#)
        }
        AttrType::BoolData(a) => {
          format!("data-{a}")
        }
      });

      ret.extend(it);

      Some(ret)
    }
  }
}

impl Element {
  /// Call a closure for adding child nodes.
  ///
  /// ```
  /// use sidoc_html5::owned::Element;
  /// let mut bldr = sidoc::Builder::new();
  /// Element::new("div")
  ///   .sub(&mut bldr, |bldr| {
  ///     Element::new("br")
  ///       .add_empty(bldr);
  /// });
  /// ```
  pub fn sub<F>(self, bldr: &mut sidoc::Builder, f: F)
  where
    F: FnOnce(&mut sidoc::Builder)
  {
    if let Some(lst) = self.gen_attr_list() {
      bldr.scope(
        format!("<{} {}>", self.tag, lst.join(" ")),
        Some(format!("</{}>", self.tag))
      );
    } else {
      let stag = format!("<{}>", self.tag);
      let etag = format!("</{}>", self.tag);
      bldr.scope(stag, Some(etag));
    }

    f(bldr);

    bldr.exit();
  }
}


impl Element {
  /// Consume `self` and add a empty tag representation of element to a sidoc
  /// builder.
  ///
  /// An empty/void tag comes is one which does not have a closing tag:
  /// `<tagname foo="bar">`.
  #[inline]
  pub fn add_empty(self, bldr: &mut sidoc::Builder) {
    let line = if let Some(alst) = self.gen_attr_list() {
      format!("<{} {}>", self.tag, alst.join(" "))
    } else {
      format!("<{}>", self.tag)
    };

    bldr.line(line);
  }

  /// Consume `self` and add a tag containing text content between the opening
  /// and closing tag to the supplied sidoc builder.
  ///
  /// The supplied text is escaped as needed.
  ///
  /// ```
  /// use std::sync::Arc;
  /// use sidoc_html5::owned::Element;
  /// let mut bldr = sidoc::Builder::new();
  /// let elem = Element::new("textarea")
  ///   .raw_attr("rows", 8)
  ///   .raw_attr("cols", 32)
  ///   .add_content("This is the text content", &mut bldr);
  ///
  /// let mut r = sidoc::RenderContext::new();
  /// let doc = bldr.build().unwrap();
  /// r.doc("root", Arc::new(doc));
  /// let buf = r.render("root").unwrap();
  ///
  /// assert_eq!(buf, "<textarea rows=\"8\" cols=\"32\">This is the text content</textarea>\n");
  /// ```
  ///
  /// # Panics
  /// If the `extra-validation` feature is enabled, panic if the tag name is
  /// not a known "void" element.
  #[inline]
  pub fn add_content(self, text: &str, bldr: &mut sidoc::Builder) {
    let line = if let Some(alst) = self.gen_attr_list() {
      format!(
        "<{} {}>{}</{}>",
        self.tag,
        alst.join(" "),
        html_escape::encode_text(text),
        self.tag
      )
    } else {
      format!(
        "<{}>{}</{}>",
        self.tag,
        html_escape::encode_text(text),
        self.tag
      )
    };
    bldr.line(line);
  }

  /// Consume `self` and add a tag containing text content between the opening
  /// and closing tag to the supplied sidoc builder.
  ///
  /// The supplied text is not escaped.
  ///
  /// ```
  /// use std::sync::Arc;
  /// use sidoc_html5::Element;
  /// let mut bldr = sidoc::Builder::new();
  /// let elem = Element::new("button")
  ///   .add_raw_content("Do Stuff", &mut bldr);
  ///
  /// let mut r = sidoc::RenderContext::new();
  /// let doc = bldr.build().unwrap();
  /// r.doc("root", Arc::new(doc));
  /// let buf = r.render("root").unwrap();
  ///
  /// assert_eq!(buf, "<button>Do Stuff</button>\n");
  /// ```
  #[inline]
  pub fn add_raw_content(self, text: &str, bldr: &mut sidoc::Builder) {
    let line = if let Some(alst) = self.gen_attr_list() {
      format!("<{} {}>{}</{}>", self.tag, alst.join(" "), text, self.tag)
    } else {
      format!("<{}>{}</{}>", self.tag, text, self.tag)
    };
    bldr.line(line);
  }

  pub fn add_scope(self, bldr: &mut sidoc::Builder) {
    let line = if let Some(alst) = self.gen_attr_list() {
      format!("<{} {}>", self.tag, alst.join(" "))
    } else {
      format!("<{}>", self.tag)
    };
    bldr.scope(line, Some(format!("</{}>", self.tag)));
  }

  /// ```
  /// use std::sync::Arc;
  /// use sidoc_html5::owned::Element;
  ///
  /// let mut bldr = sidoc::Builder::new();
  /// let elem = Element::new("div")
  ///   .scope(&mut bldr, |bldr| {
  ///     let elem = Element::new("button")
  ///       .add_raw_content("Do Stuff", bldr);
  ///   });
  ///
  /// let mut r = sidoc::RenderContext::new();
  /// let doc = bldr.build().unwrap();
  /// r.doc("root", Arc::new(doc));
  /// let buf = r.render("root").unwrap();
  ///
  /// // Output should be:
  /// // <div>
  /// //   <button>Do Stuff</button>
  /// // </div>
  /// assert_eq!(buf, "<div>\n  <button>Do Stuff</button>\n</div>\n");
  /// ```
  pub fn scope<F>(self, bldr: &mut sidoc::Builder, f: F)
  where
    F: FnOnce(&mut sidoc::Builder)
  {
    let line = if let Some(alst) = self.gen_attr_list() {
      format!("<{} {}>", self.tag, alst.join(" "))
    } else {
      format!("<{}>", self.tag)
    };
    bldr.scope(line, Some(format!("</{}>", self.tag)));
    f(bldr);
    bldr.exit();
  }
}

// vim: set ft=rust et sw=2 ts=2 sts=2 cinoptions=2 tw=79 :