Function plan_view_sync

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

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 => {
            return Ok(ViewSyncPlan {
                suffix: local.changes.clone(),
                declare: true,
                forced: false,
                shrink: false,
            });
        }
        Some(r) => r,
    };

    // View identity is immutable metadata. Membership is not compared as an
    // ordered prefix: patches are nodes in a causal graph and independently
    // added compatible nodes reconcile by set union.
    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),
        });
    }

    let remote_set: HashSet<Hash> = remote.changes.iter().copied().collect();
    let local_set: HashSet<Hash> = local.changes.iter().copied().collect();
    let suffix = local
        .changes
        .iter()
        .filter(|hash| !remote_set.contains(hash))
        .copied()
        .collect();
    Ok(ViewSyncPlan {
        suffix,
        // Normal sync is monotonic. If the remote already contains every local
        // member, there is nothing to publish even when the remote union is
        // larger. Otherwise the server unions the proposal with its current set.
        declare: !local_set.is_subset(&remote_set),
        forced: false,
        shrink: false,
    })
}

// Manifest Support Detection