mellie - v2.0.1

mellie

Values

attr

</> 
pub fn attr(
  el: element.ElementTree,
  key: String,
) -> Result(String, Nil)

attribute

</> 
pub fn attribute(name: a, value: b) -> #(a, b)

attrs

</> 
pub fn attrs(
  tree: element.ElementTree,
) -> List(#(String, String))

Gets attributes of the given element. TextNodes will return []

children

</> 
pub fn children(
  tree: element.ElementTree,
) -> List(element.ElementTree)

Gets the children of an element. TextNodes will return []

data_attr

</> 
pub fn data_attr(
  el: element.ElementTree,
  data_key: String,
) -> Result(String, Nil)

element

</> 
pub fn element(
  tag: String,
  attributes: List(#(String, String)),
  children: List(element.ElementTree),
) -> element.ElementTree

element_to_string

</> 
pub fn element_to_string(el: element.ElementTree) -> String

element_to_string_pretty

</> 
pub fn element_to_string_pretty(
  el: element.ElementTree,
) -> String

This is useful for tests but is not context dependant and may be incorrect in cases where internal HTML depends on formatting (e.g. pre > span). Uses presentable_soup under the hood

element_to_xml_document_string

</> 
pub fn element_to_xml_document_string(
  el: element.ElementTree,
) -> String

element_to_xml_string

</> 
pub fn element_to_xml_string(el: element.ElementTree) -> String

elements_to_string

</> 
pub fn elements_to_string(
  el: List(element.ElementTree),
) -> String

elements_to_string_pretty

</> 
pub fn elements_to_string_pretty(
  el: List(element.ElementTree),
) -> String

This is useful for tests but is not context dependant and may be incorrect in cases where internal HTML depends on formatting (e.g. pre > span). Uses presentable_soup under the hood

find_all

</> 
pub fn find_all(
  from in: a,
  with fun: fn(a) -> List(a),
) -> List(a)

Runs the given function recursively over the result until it no longer results in items. Returns the found nodes from every level

find_leaf

</> 
pub fn find_leaf(
  from in: a,
  with fun: fn(a) -> List(a),
) -> List(a)

Runs the given function recursively over the result until it no longer returns items. Returns only the deepest matching nodes

get_child_by_tag

</> 
pub fn get_child_by_tag(
  tree: element.ElementTree,
  tag: String,
) -> Result(element.ElementTree, Nil)

get_children_by_tag

</> 
pub fn get_children_by_tag(
  tree: element.ElementTree,
  tag: String,
) -> List(element.ElementTree)

Gets children with the given tag up to one level of results. Use with find_all to recurse further into returned elements

has_tag

</> 
pub fn has_tag(tree: element.ElementTree, tag: String) -> Bool

inner_text

</> 
pub fn inner_text(el: element.ElementTree) -> String

Recursively get all text from given element

parse

</> 
pub fn parse(
  html str: String,
) -> Result(element.ElementTree, String)

Parses the given HTML into a full document (containing html, head, and body tags)

If the given HTML does not contain an html or head, they will be automatically added and the given content will be put into the body

remove_attribute

</> 
pub fn remove_attribute(
  el: element.ElementTree,
  attr: String,
) -> element.ElementTree

Removes attribute on an ElementNode, does not modify a TextNode

remove_attributes

</> 
pub fn remove_attributes(
  el: element.ElementTree,
  attrs: List(String),
) -> element.ElementTree

Removes attributes on an ElementNode, does not modify a TextNode

set_attribute

</> 
pub fn set_attribute(
  el: element.ElementTree,
  attr: #(String, String),
) -> element.ElementTree

Sets attributes on an ElementNode, does not modify a TextNode

set_attributes

</> 
pub fn set_attributes(
  el: element.ElementTree,
  attr: List(#(String, String)),
) -> element.ElementTree

Sets attributes on an ElementNode, does not modify a TextNode

tag

</> 
pub fn tag(tree: element.ElementTree) -> option.Option(String)

Gets tag of the given element. TextNodes will return None

text

</> 
pub fn text(text: String) -> element.ElementTree

to_document_string

</> 
pub fn to_document_string(el: element.ElementTree) -> String

transform_tree

</> 
pub fn transform_tree(
  tree: element.ElementTree,
  elem: fn(String, List(#(String, String)), List(a)) -> a,
  text: fn(String) -> a,
) -> a

Transforms a tree recursively using the given element and text conversion functions

update_where

</> 
pub fn update_where(
  from in: element.ElementTree,
  where should_visit: fn(element.ElementTree) -> Bool,
  with update: fn(element.ElementTree) -> element.ElementTree,
) -> element.ElementTree

update_where_tag

</> 
pub fn update_where_tag(
  from in: element.ElementTree,
  tag tag: String,
  with update: fn(element.ElementTree) -> element.ElementTree,
) -> element.ElementTree
✨ Search Document