joanna/moonfeed/src/atom does not have a README file

    ParseError

    pub(all) suberror ParseError {
    InvalidXml(String)
    InvalidAtomRoot(String)
    InvalidRequiredField(String, String)
    InvalidDateTime(String,
    DateTimeError
    )
    } derive(Eq,
    Debug
    )

    ParseError::equal

    fn ParseError::equal(self : ParseError, other : ParseError) -> Bool

    ParseError::not_equal

    fn ParseError::not_equal(self : ParseError, other : ParseError) -> Bool

    ParseError::to_repr

    AtomCategory

    pub(all) struct AtomCategory {
    term : String
    scheme : IriReference?
    label : String?
    raw : Markup
    }

    AtomContent

    pub(all) struct AtomContent {
    media_type : String?
    value : String
    decoded_bytes : Array[Byte]?
    src : IriReference?
    markup : Array[MarkupContent]
    raw : Markup
    language : String?
    base_uri : String?
    }

    AtomDate

    pub(all) struct AtomDate {
    raw : String
    unix_seconds : Int64
    fractional_digits : String?
    leap_second : Bool
    unknown_local_offset : Bool
    }

    RFC 3339 source precision and offset/leap conventions are retained explicitly.

    AtomDocument

    pub(all) enum AtomDocument {
    FeedDocument(AtomFeed)
    EntryDocument(AtomEntry)
    }

    Feed and Entry Documents remain distinct; no synthetic feed is constructed.

    AtomEntry

    pub(all) struct AtomEntry {
    metadata : AtomMetadata
    published : AtomDate?
    summary : AtomText?
    content : AtomContent?
    source : AtomMetadata?
    effective_authors : Array[AtomPerson]
    effective_rights : AtomText?
    }

    AtomFeed

    pub(all) struct AtomFeed {
    metadata : AtomMetadata
    entries : Array[AtomEntry]
    }

    AtomGenerator

    pub(all) struct AtomGenerator {
    value : String
    uri : IriReference?
    version : String?
    }

    pub(all) struct AtomLink {
    href : IriReference
    rel : String
    media_type : String?
    hreflang : String?
    title : String?
    length : UInt64?
    length_raw : String?
    raw : Markup
    }

    AtomMetadata

    pub(all) struct AtomMetadata {
    id : String?
    title : AtomText?
    updated : AtomDate?
    authors : Array[AtomPerson]
    contributors : Array[AtomPerson]
    categories : Array[AtomCategory]
    links : Array[AtomLink]
    rights : AtomText?
    subtitle : AtomText?
    generator : AtomGenerator?
    icon : IriReference?
    logo : IriReference?
    raw : Markup
    }

    Feed/source/entry metadata. Source may omit id, title and updated.

    AtomPerson

    pub(all) struct AtomPerson {
    name : String
    uri : IriReference?
    email : String?
    raw : Markup
    }

    AtomText

    pub(all) struct AtomText {
    kind : String
    value : String
    xhtml : Markup?
    language : String?
    base_uri : String?
    }

    IriReference

    pub(all) struct IriReference {
    raw : String
    resolved : String
    is_absolute : Bool
    }

    Original IRI reference and its RFC 3986 resolved form. Without an absolute XML/document base, a relative result remains relative and is marked explicitly.

    Markup

    pub(all) struct Markup {
    namespace_uri : String?
    local_name : String
    attributes : Array[MarkupAttribute]
    content : Array[MarkupContent]
    base_uri : String?
    language : String?
    }

    Expanded-name XML infoset retained for XHTML, XML content and extensions.

    MarkupAttribute

    pub(all) struct MarkupAttribute {
    namespace_uri : String?
    local_name : String
    value : String
    }

    MarkupContent

    pub(all) enum MarkupContent {
    Text(String)
    Element(Markup)
    }

    parse

    fn parse(input : String) ->
    Feed
    raise ParseError

    Parse and normalize an Atom 1.0 feed. Original date strings remain available; successfully parsed dates also carry normalized UTC instants. Invalid required updated dates return typed errors.

    parse_document

    fn parse_document(input : String) -> AtomDocument raise ParseError

    Strict Atom document API. Feed and standalone Entry retain distinct types.

    parse_document_with_base

    fn parse_document_with_base(input : String, document_uri : String) -> AtomDocument raise ParseError

    Use the retrieval URI when XML Base does not supply an absolute base.

    resolve_reference

    fn resolve_reference(base : String?, reference : String) -> IriReference raise ParseError

    Resolve by component parsing, path merging and dot-segment removal (RFC 3986 §5).