Function plan_view_sync

atomic-cli/src/commands/push/helpers.rs:180–263

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,
)

/// Identity mismatches (scope/parent) are never forced — they are
/// structural, and the server would reject them regardless.
pub fn plan_view_sync(
    local: &ViewManifest,
    remote: Option<&ViewManifest>,
    force: 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,
            });
        }
        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),
        });
    }

    // Prefix rule.
    let diverged = if remote.changes.len() > local.changes.len() {
        Some(ViewSyncConflict::Diverged {
            first_mismatch: None,
            local_len: local.changes.len(),
            remote_len: remote.changes.len(),
        })
    } else {
        remote
            .changes
            .iter()
            .zip(local.changes.iter())
            .position(|(r, l)| r != l)
            .map(|i| ViewSyncConflict::Diverged {
                first_mismatch: Some(i),
                local_len: local.changes.len(),
                remote_len: remote.changes.len(),
            })
    };

    if let Some(conflict) = diverged {
        if !force {
            return Err(conflict);