Function lift_intent

atomic-canonical/src/lift.rs:39–139

Lift an intent from its frontmatter spine and markdown body.

(frontmatter: &Map<String, Value>, body: &str)

/// Lift an intent from its frontmatter spine and markdown body.
pub fn lift_intent(frontmatter: &Map<String, Value>, body: &str) -> Result<CanonicalNode> {
    directive::check_embedded_directives(body)?;
    let human_key = require_str(frontmatter, "id")?;
    let uid = opt_str(frontmatter, "uid").unwrap_or_else(|| slug(&human_key));
    let node_id = format!("urn:atomic:intent:{uid}");

    let directives = directive::parse(body)?;

    let mut why = None;
    let mut acs = Vec::new();
    let mut tasks = Vec::new();
    let mut scope_in = Vec::new();
    let mut scope_out = Vec::new();
    let mut constraints = Vec::new();
    let mut deps = Vec::new();
    let mut ac_n = 0usize;
    let mut task_n = 0usize;
    let mut scope_in_n = 0usize;
    let mut scope_out_n = 0usize;
    let mut constraint_n = 0usize;

    for d in &directives {
        // Inline (and nested-leaf) `:ref` children of any container sit on the
        // intent's dependency chain, same rules as a top-level `:::ref`. The
        // container prose keeps the inline mention verbatim.
        for child in &d.children {
            if child.name == "ref" {
                deps.push(lift_ref(child)?);
            }
        }
        match d.name.as_str() {
            "why" => {
                // Single authoring site: first `:::why` wins; the reason is
                // unconstrained prose, lifted verbatim, never inspected.
                if why.is_none() {
                    why = Some(d.body.clone());
                }
            }
            "acceptance-criterion" => {
                ac_n += 1;
                acs.push(lift_ac(d, &human_key, ac_n)?);
            }
            "task" => {
                task_n += 1;
                tasks.push(lift_task(d, &human_key, task_n));
            }
            "scope-in" => {
                scope_in_n += 1;
                scope_in.push(lift_scope(d, &human_key, "scope-in", scope_in_n));
            }
            "scope-out" => {
                scope_out_n += 1;
                scope_out.push(lift_scope(d, &human_key, "scope-out", scope_out_n));
            }
            "constraint" => {
                constraint_n += 1;
                constraints.push(lift_constraint(d, &human_key, constraint_n));
            }