git-std 0.11.7

Standard git workflow — commits, versioning, hooks
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

//! Project manifest ecosystem.
//!
//! Supports `project.toml`, `project.json`, and `project.yaml` — the
//! driftsys project manifest format. No ecosystem tooling; always uses
//! native string manipulation. No lock file to sync.

use std::path::Path;

use standard_version::{
    ProjectJsonVersionFile, ProjectTomlVersionFile, ProjectYamlVersionFile, VersionFile,
    VersionFileError,
};

use super::{Ecosystem, SyncOutcome, WriteOutcome, native_write};

pub struct Project;

impl Ecosystem for Project {
    fn name(&self) -> &'static str {
        "project"
    }

    fn detect(&self, root: &Path) -> bool {
        root.join("project.toml").exists()
            || root.join("project.json").exists()
            || root.join("project.yaml").exists()
    }

    fn version_files(&self) -> &[&str] {
        &["project.toml", "project.json", "project.yaml"]
    }

    fn write_version(&self, root: &Path, new_version: &str) -> WriteOutcome {
        let engines: [&dyn VersionFile; 3] = [
            &ProjectTomlVersionFile,
            &ProjectJsonVersionFile,
            &ProjectYamlVersionFile,
        ];
        let mut all_results = Vec::new();
        for engine in engines {
            if let WriteOutcome::Fallback { results } = native_write(root, engine, new_version) {
                all_results.extend(results);
            }
        }
        if all_results.is_empty() {
            WriteOutcome::NotDetected
        } else {
            WriteOutcome::Fallback {
                results: all_results,
            }
        }
    }

    fn sync_lock(&self, _root: &Path) -> Vec<SyncOutcome> {
        vec![SyncOutcome::NoLockFile]
    }

    fn version_file_engine(&self) -> Option<Box<dyn VersionFile>> {
        Some(Box::new(ProjectMultiVersionFile))
    }
}

/// Combined version file engine used for dry-run detection across all three
/// project manifest formats.
///
/// Detection and reading dispatch by content, since TOML, JSON, and YAML
/// patterns are mutually exclusive.
struct ProjectMultiVersionFile;

impl VersionFile for ProjectMultiVersionFile {
    fn name(&self) -> &str {
        "project"
    }

    fn filenames(&self) -> &[&str] {
        &["project.toml", "project.json", "project.yaml"]
    }

    fn detect(&self, content: &str) -> bool {
        ProjectTomlVersionFile.detect(content)
            || ProjectJsonVersionFile.detect(content)
            || ProjectYamlVersionFile.detect(content)
    }

    fn read_version(&self, content: &str) -> Option<String> {
        ProjectTomlVersionFile
            .read_version(content)
            .or_else(|| ProjectJsonVersionFile.read_version(content))
            .or_else(|| ProjectYamlVersionFile.read_version(content))
    }

    fn write_version(&self, content: &str, new_version: &str) -> Result<String, VersionFileError> {
        if ProjectTomlVersionFile.detect(content) {
            return ProjectTomlVersionFile.write_version(content, new_version);
        }
        if ProjectJsonVersionFile.detect(content) {
            return ProjectJsonVersionFile.write_version(content, new_version);
        }
        if ProjectYamlVersionFile.detect(content) {
            return ProjectYamlVersionFile.write_version(content, new_version);
        }
        Err(VersionFileError::NoVersionField)
    }
}