ferrflow 5.31.3

Universal semantic versioning for monorepos and classic repos
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

use super::VersionFile;
use crate::error_code::{self, ErrorCodeExt};
use anyhow::{Context, Result};
use regex::Regex;
use std::path::Path;
use std::sync::OnceLock;

pub struct GradleVersionFile;

#[cfg(test)]
mod tests {
    use super::*;
    use std::io::Write;
    use tempfile::NamedTempFile;

    fn write_temp(content: &str) -> NamedTempFile {
        let mut f = NamedTempFile::new().unwrap();
        f.write_all(content.as_bytes()).unwrap();
        f
    }

    #[test]
    fn read_gradle_double_quotes() {
        let f = write_temp("plugins { id 'java' }\nversion = \"1.2.3\"\n");
        assert_eq!(GradleVersionFile.read_version(f.path()).unwrap(), "1.2.3");
    }

    #[test]
    fn read_gradle_single_quotes() {
        let f = write_temp("version = '0.5.0'\n");
        assert_eq!(GradleVersionFile.read_version(f.path()).unwrap(), "0.5.0");
    }

    #[test]
    fn read_gradle_with_spaces() {
        let f = write_temp("version  =  \"1.0.0\"\n");
        assert_eq!(GradleVersionFile.read_version(f.path()).unwrap(), "1.0.0");
    }

    #[test]
    fn read_no_version_fails() {
        let f = write_temp("plugins { id 'java' }\n");
        assert!(GradleVersionFile.read_version(f.path()).is_err());
    }

    #[test]
    fn write_gradle_version() {
        let f = write_temp("version = \"1.0.0\"\n");
        GradleVersionFile.write_version(f.path(), "2.0.0").unwrap();
        assert_eq!(GradleVersionFile.read_version(f.path()).unwrap(), "2.0.0");
    }

    #[test]
    fn write_preserves_quote_style() {
        let f = write_temp("version = '1.0.0'\n");
        GradleVersionFile.write_version(f.path(), "2.0.0").unwrap();
        let content = std::fs::read_to_string(f.path()).unwrap();
        assert!(content.contains("version = '2.0.0'"));
    }
}

static VERSION_RE: OnceLock<Regex> = OnceLock::new();

fn version_re() -> &'static Regex {
    VERSION_RE
        .get_or_init(|| Regex::new(r#"(?m)^(\s*version\s*=\s*)(["'])([^"']+)(["'])"#).unwrap())
}

impl VersionFile for GradleVersionFile {
    fn read_version(&self, file_path: &Path) -> Result<String> {
        let content = std::fs::read_to_string(file_path)
            .with_context(|| format!("Cannot read {}", file_path.display()))
            .error_code(error_code::GRADLE_READ)?;

        version_re()
            .captures(&content)
            .map(|c| c[3].to_string())
            .ok_or_else(|| anyhow::anyhow!("No version field found in {}", file_path.display()))
            .error_code(error_code::GRADLE_VERSION_NOT_FOUND)
    }

    fn write_version(&self, file_path: &Path, version: &str) -> Result<()> {
        super::splice::write_via_splice(self, file_path, version, None)
    }

    fn read_version_from_bytes(&self, content: &[u8], filename: &str) -> Result<String> {
        let text = std::str::from_utf8(content)
            .with_context(|| format!("Invalid UTF-8 in {filename}"))
            .error_code(error_code::GRADLE_INVALID_UTF8)?;
        version_re()
            .captures(text)
            .map(|c| c[3].to_string())
            .ok_or_else(|| anyhow::anyhow!("No version field found in {filename}"))
            .error_code(error_code::GRADLE_VERSION_NOT_FOUND)
    }
}

impl super::splice::FormatPreservingEditor for GradleVersionFile {
    fn locate_version(
        &self,
        content: &str,
        _selector: Option<&str>,
    ) -> Result<std::ops::Range<usize>> {
        version_re()
            .captures(content)
            .map(|c| c.get(3).unwrap().range())
            .ok_or_else(|| anyhow::anyhow!("No version field found to update"))
            .error_code(error_code::GRADLE_VERSION_NOT_FOUND)
    }

    fn read_error(&self) -> crate::error_code::ErrorCode {
        error_code::GRADLE_READ
    }

    fn write_error(&self) -> crate::error_code::ErrorCode {
        error_code::GRADLE_WRITE
    }
}