governor-application 2.0.3

Application use cases and machine contracts for cargo-governor
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! Ports used by application use cases.

use async_trait::async_trait;
use governor_core::domain::changelog::Changelog;
use governor_core::domain::version::SemanticVersion;
use governor_owners::{PackageOwnersConfig, WorkspaceOwnersConfig};
use serde::{Deserialize, Serialize};
use std::path::{Path, PathBuf};

use crate::error::ApplicationResult;

/// Release workspace snapshot loaded from Cargo metadata and manifests.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ReleaseWorkspace {
    /// Absolute workspace root.
    pub root: PathBuf,
    /// Human-readable workspace name.
    pub name: String,
    /// Shared workspace version.
    pub current_version: SemanticVersion,
    /// Workspace packages.
    pub packages: Vec<ReleasePackage>,
}

/// Package info needed by release orchestration.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ReleasePackage {
    /// Crate name.
    pub name: String,
    /// Crate version.
    pub version: SemanticVersion,
    /// Cargo.toml path for the crate.
    pub manifest_path: PathBuf,
    /// Internal workspace dependencies.
    pub dependencies: Vec<String>,
    /// Whether the crate should be published.
    pub publish: bool,
}

/// Owners workspace snapshot loaded from Cargo metadata and package manifests.
#[derive(Debug, Clone)]
pub struct OwnersWorkspace {
    /// Absolute workspace root.
    pub root: PathBuf,
    /// Workspace-level owners config.
    pub workspace: Option<WorkspaceOwnersConfig>,
    /// Package configs.
    pub packages: Vec<OwnerPackage>,
}

/// Package owners config.
#[derive(Debug, Clone)]
pub struct OwnerPackage {
    /// Crate name.
    pub name: String,
    /// Package-level owners config.
    pub owners: Option<PackageOwnersConfig>,
}

/// Result of updating Cargo manifests.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VersionUpdate {
    /// Files touched by the update.
    pub modified_files: Vec<String>,
}

/// Result of updating changelog.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChangelogUpdate {
    /// Whether the changelog was updated.
    pub updated: bool,
    /// Changed files.
    pub modified_files: Vec<String>,
}

/// Result of running a local command.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CommandReport {
    /// Logical check or command name.
    pub name: String,
    /// Exit status.
    pub success: bool,
    /// Exit code when available.
    pub exit_code: Option<i32>,
    /// Captured stdout.
    pub stdout: String,
    /// Captured stderr.
    pub stderr: String,
}

/// Port for workspace inspection and mutation.
#[async_trait]
pub trait WorkspacePort: Send + Sync {
    /// Name of the adapter.
    fn name(&self) -> &str;

    /// Load workspace release metadata.
    async fn load_release_workspace(
        &self,
        workspace_path: &Path,
    ) -> ApplicationResult<ReleaseWorkspace>;

    /// Load workspace owners metadata.
    async fn load_owners_workspace(
        &self,
        workspace_path: &Path,
    ) -> ApplicationResult<OwnersWorkspace>;

    /// Update shared workspace version and optional lockfile.
    async fn update_workspace_version(
        &self,
        workspace_path: &Path,
        version: &SemanticVersion,
        dry_run: bool,
    ) -> ApplicationResult<VersionUpdate>;

    /// Update CHANGELOG.md using the target version.
    async fn update_changelog(
        &self,
        workspace_path: &Path,
        changelog: &Changelog,
        dry_run: bool,
    ) -> ApplicationResult<ChangelogUpdate>;
}

/// Port for local cargo/build checks.
#[async_trait]
pub trait CommandPort: Send + Sync {
    /// Name of the adapter.
    fn name(&self) -> &str;

    /// Run a named pre-publish check inside the workspace.
    async fn run_check(
        &self,
        workspace_path: &Path,
        check: &str,
        capture_output: bool,
    ) -> ApplicationResult<CommandReport>;
}