Struct History 

pub struct History {
    pub entries: Vec<HistoryEntry>,
}

The append-only event log of an issue (data-model.md §8).

Append-only is a hard guarantee of this type: the only mutating operation is History::append. There is deliberately no remove, no reorder, no trim, and no compaction — those are out of scope, but the container is shaped so a future retention policy has a seam.

Fields

entries: Vec<HistoryEntry>

Every line of the section, in file order, which is append order.

Held as an ordered list of entries rather than a flat Vec<HistoryEvent> so an unparseable line keeps its position and its exact text. That is what lets the section round-trip byte-stably without ever dropping or repairing a line a human hand-edited.

Implementations

impl History

pub fn new() -> Self

An empty log.

pub fn append(&mut self, event: HistoryEvent)

Append one event. Never rewrites, reorders, or removes an existing line.

pub fn append_now(&mut self, actor: &str, kind: HistoryEventKind, detail: &str)

Append with the current UTC timestamp.

pub fn events(&self) -> Vec<&HistoryEvent>

The parsed events, in file order.

Unparseable lines are excluded here; see History::unparsed.

pub fn unparsed(&self) -> Vec<&str>

Lines that could not be parsed, verbatim and in file order.

Non-empty means the section was hand-edited into a shape this parser does not accept. tix lint reports each as a history finding; nothing else treats it as an error.

pub fn is_empty(&self) -> bool

Whether the section has no lines at all.

pub fn len(&self) -> usize

How many lines the section holds, parsed or not.

pub fn render(&self) -> String

Render the section, including its heading and the blank line after it.

An empty log renders to the empty string, so the section is omitted from the file entirely rather than written as an empty heading. An unparseable line is re-emitted exactly as it was read, in place, so a read/write cycle is byte-stable whether or not the section is clean.

pub fn parse_front(body: &str) -> (Self, String)

Parse a leading ## History section, returning the log and whatever body text followed it.

Only a section at the front of the body is recognised, matching the position data-model.md §8 pins (immediately after the frontmatter). A ## History heading appearing later in the prose is left alone as ordinary body text.

The section ends at the first line that is neither blank nor a list item, so a blank line between entries does not end it — a blank line inside a list is the most ordinary thing a human or a Markdown formatter produces, and terminating there would silently demote audit entries to body prose and reorder the log. Unparseable list items are kept verbatim rather than failing the file.

Trait Implementations

impl Clone for History

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for History

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

Formats the value using the given formatter.

impl Default for History

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for History

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for History

impl PartialEq for History

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for History

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for History