Function plan_view_sync

atomic-cli/src/commands/push/helpers.rs:198–306

Compute the sync plan for one view: what to store and whether to declare. `remote` is the remote's parsed manifest, or `None` if the view does not exist on the remote (the remote log is empty). The fast-forward rule: the remote log must be a prefix of the local log. The suffix (everything beyond the prefix) is what needs storing — its dependencies are either earlier in the log or already on the

(
    local: &ViewManifest,
    remote: Option<&ViewManifest>,
    force: bool,
    is_leaf: bool,
)

/// genuinely ambiguous (local is behind vs. local shrank), so it is left to the
/// prefix/divergence rules, which err toward "pull first, or `--force`".
pub fn plan_view_sync(
    local: &ViewManifest,
    remote: Option<&ViewManifest>,
    force: bool,
    is_leaf: bool,
) -> Result<ViewSyncPlan, ViewSyncConflict> {
    let remote = match remote {
        None => {
            // View absent on remote: the whole log is the suffix.
            return Ok(ViewSyncPlan {
                suffix: local.changes.clone(),
                declare: true,
                forced: false,
                shrink: false,
            });
        }
        Some(r) => r,
    };

    // Identity must match: the manifest declares scope and parent, and the
    // server refuses to mutate an existing view's identity.
    if remote.scope != local.scope {
        return Err(ViewSyncConflict::IdentityMismatch {
            field: "scope",
            local: local.scope.to_string(),
            remote: remote.scope.to_string(),
        });
    }
    if remote.parent != local.parent {
        let show = |p: &Option<String>| p.clone().unwrap_or_else(|| "(none)".to_string());
        return Err(ViewSyncConflict::IdentityMismatch {
            field: "parent",
            local: show(&local.parent),
            remote: show(&remote.parent),
        });
    }

    // Ancestor already satisfied. When this view is NOT the one being pushed (an
    // ancestor pulled in for a descendant) and the remote already holds every
    // local change, there is nothing to do: the remote's set already satisfies
    // the descendant, and pushing a child never implies rewriting a parent. Skip
    // without error — so a child push is never blocked by an ancestor whose
    // remote is merely larger (a local shrink) — and flag `shrink` when the
    // remote is strictly larger so the caller can explain the skip. The leaf
    // falls through to the prefix/divergence rules below, where `local ⊂ remote`
    // is ambiguous and errs toward "pull or --force".
    if !is_leaf {
        let remote_set: HashSet<&Hash> = remote.changes.iter().collect();
        if local.changes.iter().all(|h| remote_set.contains(h)) {
            return Ok(ViewSyncPlan {
                suffix: Vec::new(),
                declare: false,
                forced: false,
                shrink: local.changes.len() != remote.changes.len(),
            });
        }
    }