🥮 mooncakes.io
    Sign in

    atom

    Atom syndication format library

    Download zip
    Version
    0.2.1
    License
    Apache-2.0
    Repository
    Last updated
    3 hours ago
    Downloads
    24

    Dependencies

    #marianoguerra/atom

    An Atom 1.0 (RFC 4287) syndication library for MoonBit: model, parser, writer and validation, built on marianoguerra/xml.

    ///|
    test {
      let feed = try! @atom.Feed::read_from(
        "<?xml version=\"1.0\"?><feed xmlns=\"http://www.w3.org/2005/Atom\"><id>urn:x</id><title>T</title><updated>2026-01-01T00:00:00Z</updated><entry><id>e1</id><title>E1</title><updated>2026-01-02T00:00:00Z</updated></entry></feed>",
      )
      inspect(feed.title.value, content="T")
      assert_true(feed.entries.length() == 1)
      // Re-serialising then parsing yields an equal model.
      let again = try! @atom.Feed::read_from(feed.to_xml())
      assert_true(again == feed)
    }

    Unknown elements are skipped while parsing, which keeps readers forward-compatible with RFC extensions. XHTML text constructs are captured verbatim minus their mandatory div wrapper.

    AtomError

    source
    pub(all) suberror AtomError {
      Xml(err~ : 
    XmlError    )
      UnexpectedRoot(found~ : String)
      MissingElement(path~ : String)
    } derive(Eq, 
    Debug    )

    Errors produced while reading or validating Atom documents.

    Category

    source
    pub(all) struct Category {
      term : String
      scheme : String?
      label : String?
    } derive(Eq, 
    Debug    )

    An Atom category, RFC 4287 §4.2.2.

    Content

    source
    pub(all) enum Content {
      Text(String)
      Html(String)
      Xhtml(String)
      Src(src~ : String, media_type~ : String?)
    } derive(Eq, 
    Debug    )

    Entry content per RFC 4287 §4.1.3.

    Entry

    source
    pub(all) struct Entry {
      id : String
      title : Text
      updated : String
      authors : Array[Person]
      contributors : Array[Person]
      categories : Array[Category]
      links : Array[Link]
      published : String?
      rights : Text?
      summary : Text?
      content : Content?
      source : Source?
    } derive(Eq, 
    Debug    )

    An Atom entry, RFC 4287 §4.1.2.

    Entry::new

    source
    fn Entry::new(id~ : String, title~ : String, updated~ : String) -> Entry

    Create an entry skeleton with the required elements filled and everything else empty.

    Feed

    source
    pub(all) struct Feed {
      id : String
      title : Text
      updated : String
      authors : Array[Person]
      contributors : Array[Person]
      categories : Array[Category]
      links : Array[Link]
      generator : Generator?
      icon : String?
      logo : String?
      rights : Text?
      subtitle : Text?
      entries : Array[Entry]
    } derive(Eq, 
    Debug    )

    A minimal Atom 1.0 feed modelled on RFC 4287.
    impl Show for Feed

    Feed::new

    source
    fn Feed::new(id~ : String, title~ : String, updated~ : String) -> Feed

    Create a feed skeleton with the required elements filled and everything else empty.

    Feed::read_from

    source
    fn Feed::read_from(input : String) -> Feed raise AtomError

    Parse an Atom 1.0 document into a [Feed].

    The root element must be feed. Children are matched by local name; unprefixed children resolve against the feed's default namespace, and the conventional atom: prefix is always accepted. Unknown elements are skipped, which keeps the parser forward-compatible with extensions.

    Feed::to_string

    source
    fn Feed::to_string(self : Feed) -> String

    Feed::to_xml

    source
    fn Feed::to_xml(self : Feed) -> String

    Serialise the feed to an XML string.

    Generator

    source
    pub(all) struct Generator {
      value : String?
      uri : String?
      version : String?
    } derive(Eq, 
    Debug    )

    The software agent that generated the feed.
    pub(all) struct Link {
      href : String
      rel : String?
      media_type : String?
      hreflang : String?
      title : String?
      length : String?
    } derive(Eq, 
    Debug    )

    An Atom link, RFC 4287 §4.2.7.

    Link::alternate

    source
    fn Link::alternate(href : String) -> Link

    Construct an alternate link.

    Link::enclosure

    source
    fn Link::enclosure(href~ : String, media_type~ : String, length~ : String) -> Link

    Construct an enclosure-style link.

    Person

    source
    pub(all) struct Person {
      name : String
      email : String?
      uri : String?
    } derive(Eq, 
    Debug    )

    An Atom person construct, RFC 4287 §3.2.

    Source

    source
    pub(all) struct Source {
      id : String?
      title : Text?
      updated : String?
    } derive(Eq, 
    Debug    )

    Metadata about the original source feed of an entry.

    Text

    source
    pub(all) struct Text {
      typ : TextType
      value : String
    } derive(Eq, 
    Debug    )

    A text construct (title, subtitle, rights, summary).

    Text::html

    source
    fn Text::html(value : String) -> Text

    Construct an HTML text construct.

    Text::plain

    source
    fn Text::plain(value : String) -> Text

    Construct a plain-text construct.

    Text::xhtml

    source
    fn Text::xhtml(value : String) -> Text

    Construct an XHTML text construct.

    TextType

    source
    pub(all) enum TextType {
      Text
      Html
      Xhtml
    } derive(Eq, 
    Debug    )

    How a Text construct is encoded.

    ATOM_NAMESPACE

    source
    let ATOM_NAMESPACE : String

    The Atom namespace URI.

    hello

    source
    fn hello() -> String

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io