Struct Publication 

pub struct Publication {
    pub kinds: Vec<PublishedKind>,
    pub base_url: Option<String>,
}

A repository’s publication declaration, with the base URL its site is built for.

Read from PUBLICATION and the site’s base_url at request time, never compiled in: this executable supervises repositories that have no site at all, and for those Publication::read answers None and every entity’s documentation is null.

The declaration is the small TOML subset the site generator reads with awk: # comment lines, one [[kinds]] table per kind, and key = value lines whose string values are double-quoted. Anything else is ignored rather than guessed at, exactly as the generator ignores it.

use majordomus_cli::entity::Publication;

let p = Publication::parse(
    "[[kinds]]\nkind = \"adr\"\nprojection = \"entity\"\nroute = \"/adrs/\"\n",
    Some("base_url = \"https://example.invalid\"\n"),
);
assert_eq!(p.kinds.len(), 1);
assert_eq!(p.base_url.as_deref(), Some("https://example.invalid"));
// with no site configuration, the routes stand and no URL is invented
assert_eq!(Publication::parse("", None), Publication::default());

Fields

kinds: Vec<PublishedKind>

Every declared kind, in the file’s order.

base_url: Option<String>

The site’s base_url without a trailing slash, when the site configuration has one.

Implementations

impl Publication

pub fn parse(declaration: &str, site_config: Option<&str>) -> Publication

Parse a publication declaration and, when there is one, the site configuration its base_url is read from (a top-level key, before the first table).

use majordomus_cli::entity::Publication;

let p = Publication::parse(
    "# comment\n[[kinds]]\nkind = \"prompt\"\nprojection = \"none\"\nreason = \"a \\\"why\\\"\"\n",
    Some("base_url = \"https://example.invalid/\"\n[markdown]\nbase_url = \"no\"\n"),
);
assert_eq!(p.base_url.as_deref(), Some("https://example.invalid"));
assert_eq!(p.kind("prompt").unwrap().reason.as_deref(), Some("a \"why\""));

pub fn read(root: &Path) -> Option<Publication>

Read the declaration of the repository at root, or None when it has none.

use majordomus_cli::entity::{Publication, PUBLICATION};

let root = std::env::temp_dir().join(format!("mj-publication-{}", std::process::id()));
// a repository with no site declares nothing, and nothing is invented for it
assert!(Publication::read(&root.join("absent")).is_none());

std::fs::create_dir_all(root.join("site/data")).unwrap();
std::fs::write(
    root.join(PUBLICATION),
    "[[kinds]]\nkind = \"adr\"\nprojection = \"entity\"\nroute = \"/adrs/\"\n",
)
.unwrap();
let p = Publication::read(&root).unwrap();
assert_eq!(p.kinds.len(), 1);
assert_eq!(p.base_url, None, "no site/config.toml, so no base URL");
std::fs::remove_dir_all(&root).unwrap();

pub fn kind(&self, kind: &str) -> Option<&PublishedKind>

The declaration of one kind, if the file declares it.

use majordomus_cli::entity::Publication;

let p = Publication::parse(
    "[[kinds]]\nkind = \"prompt\"\nprojection = \"none\"\nreason = \"internal\"\n",
    None,
);
assert_eq!(p.kind("prompt").and_then(|k| k.reason.as_deref()), Some("internal"));
assert!(p.kind("adr").is_none());

pub fn documentation(&self, kind: &str, slug: &str) -> Option<Documentation>

The public page of the entity slug of kind: the same function scripts/generate-site-data writes the site’s pages with — route + slug + / for an entity kind, the kind’s route for a section kind, nothing for none. A kind the declaration does not name has no answer, because nothing decided it.

use majordomus_cli::entity::Publication;

let p = Publication::parse(
    "[[kinds]]\nkind = \"adr\"\nprojection = \"entity\"\nroute = \"/adrs/\"\n\
     [[kinds]]\nkind = \"skill\"\nprojection = \"section\"\nroute = \"/skills/\"\n",
    Some("base_url = \"https://example.invalid\"\n"),
);
let adr = p.documentation("adr", "adr-0056").unwrap();
assert_eq!(adr.url.as_deref(), Some("https://example.invalid/adrs/adr-0056/"));
let skill = p.documentation("skill", "commit").unwrap();
assert_eq!(skill.route.as_deref(), Some("/skills/"));
assert!(p.documentation("prompt", "x").is_none());

Trait Implementations

impl Clone for Publication

fn clone(&self) -> Publication

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Publication

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

Formats the value using the given formatter.

impl Default for Publication

fn default() -> Publication

Returns the “default value” for a type.

impl Eq for Publication

impl PartialEq for Publication

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Publication