ferrflow 7.13.1

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

use serde::{Deserialize, Serialize};
use std::fmt;

use super::util::pick_higher_semver;
use crate::config::VersionSourcePolicy;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub(in crate::monorepo) enum VersionSource {
    Tag { tag: String },
    File { file: String },
    TagOverFile { tag: String, file: String },
    FileOverTag { file: String, tag: String },
    TagByPolicy { tag: String, file: String },
    FileByPolicy { file: String, tag: String },
    Bootstrap,
}

impl VersionSource {
    pub(in crate::monorepo) fn resolve(
        tag: Option<(String, String)>,
        file: Option<(String, String)>,
        policy: VersionSourcePolicy,
    ) -> (Option<String>, Self) {
        match (tag, file) {
            (Some((tag_name, tag_version)), Some((file_path, file_version))) => match policy {
                VersionSourcePolicy::Tag => (
                    Some(tag_version),
                    Self::TagByPolicy {
                        tag: tag_name,
                        file: file_path,
                    },
                ),
                VersionSourcePolicy::File => (
                    Some(file_version),
                    Self::FileByPolicy {
                        file: file_path,
                        tag: tag_name,
                    },
                ),
                VersionSourcePolicy::Highest => {
                    let winner = pick_higher_semver(&file_version, &tag_version);
                    let source = if winner == tag_version {
                        Self::TagOverFile {
                            tag: tag_name,
                            file: file_path,
                        }
                    } else {
                        Self::FileOverTag {
                            file: file_path,
                            tag: tag_name,
                        }
                    };
                    (Some(winner), source)
                }
            },
            (Some((tag_name, tag_version)), None) => {
                (Some(tag_version), Self::Tag { tag: tag_name })
            }
            (None, Some((file_path, file_version))) => {
                (Some(file_version), Self::File { file: file_path })
            }
            (None, None) => (None, Self::Bootstrap),
        }
    }
}

impl fmt::Display for VersionSource {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Tag { tag } => write!(f, "from tag {tag}"),
            Self::File { file } => write!(f, "from {file}"),
            Self::TagOverFile { tag, file } => write!(f, "from tag {tag}, over {file}"),
            Self::FileOverTag { file, tag } => write!(f, "from {file}, over tag {tag}"),
            Self::TagByPolicy { tag, file } => {
                write!(f, "from tag {tag}, {file} ignored by versionSource: tag")
            }
            Self::FileByPolicy { file, tag } => {
                write!(f, "from {file}, tag {tag} ignored by versionSource: file")
            }
            Self::Bootstrap => write!(f, "bootstrapped"),
        }
    }
}

#[cfg(test)]
mod tests;