callisto-graph 0.3.1

Dependency graph, cascade, aggregation, and config resolution for callisto.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

use std::collections::BTreeMap;
use std::path::PathBuf;

use callisto_changelog::ChangelogInput;
use callisto_format::PreState;
use callisto_model::{
    BumpReason, BumpRecord, CommitSha, ConfigKey, Diagnostic, LockfileRefreshResult, PackageId,
    Severity, Version, VersionReport, SCHEMA_VERSION,
};

use crate::cascade::SpecRewrite;

#[derive(Clone, Debug, Default)]
pub struct VersionPlan {
    pub bumps: Vec<PlannedBump>,
    pub rewrites: Vec<SpecRewrite>,
    pub platform_writes: Vec<PlatformWrite>,
    pub optional_dep_updates: Vec<OptionalDepUpdate>,
    pub changelog_writes: Vec<ChangelogWrite>,
    pub consumed_changesets: Vec<PathBuf>,
    pub pre_state_update: Option<PreState>,
    pub delete_pre_json: bool,
    pub pre_cursor_updates: Vec<(PackageId, CommitSha)>,
    pub observed_versions: BTreeMap<PackageId, Version>,
    pub diagnostics: Vec<Diagnostic>,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct PlannedBump {
    pub package: PackageId,
    pub from: Version,
    pub to: Version,
    pub severity: Severity,
    pub governed_by: Option<ConfigKey>,
    pub reason: Option<BumpReason>,
    pub writes: Vec<VersionWriteTarget>,
}

#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum VersionWriteTarget {
    Manifest(PathBuf),
    CargoWorkspacePackage { root_manifest: PathBuf },
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct PlatformWrite {
    pub manifest: PathBuf,
    pub version: Version,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct OptionalDepUpdate {
    pub manifest: PathBuf,
    pub updates: Vec<(String, Version)>,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ChangelogWrite {
    pub changelog_path: PathBuf,
    pub input: ChangelogInput,
}

impl VersionPlan {
    pub fn to_report(&self, lockfiles: Option<Vec<LockfileRefreshResult>>) -> VersionReport {
        let mut bumps = Vec::new();
        for b in &self.bumps {
            bumps.push(BumpRecord {
                package: b.package.clone(),
                from: b.from.clone(),
                to: b.to.clone(),
                severity: b.severity,
                governed_by: b.governed_by.clone(),
                reason: b.reason.clone(),
            });
        }

        VersionReport {
            schema_version: SCHEMA_VERSION,
            bumps,
            lockfile_refresh_results: lockfiles,
            diagnostics: self.diagnostics.clone(),
        }
    }
}