Skip to main content

nerdbank_gitversioning/
version_oracle.rs

1// Copyright (c) .NET Foundation and Contributors. All rights reserved.
2// Licensed under the MIT license. See LICENSE file in the project root for full license information.
3
4//! Assembly of calculated version information in the formats exposed by `nbgv`.
5
6use std::collections::BTreeMap;
7
8use chrono::{DateTime, FixedOffset, SecondsFormat};
9use fancy_regex::Regex;
10use serde::Serialize;
11use serde::ser::{SerializeMap, Serializer};
12
13use crate::cloud::CloudBuild;
14use crate::{
15    CloudBuildNumberCommitWhen, CloudBuildNumberCommitWhere, CloudBuildNumberOptions, GitContext,
16    Result, SemanticVersion, Version, VersionFile, VersionOptions, VersionPosition,
17    VersionPrecision, calculate_version_height, get_id_as_version,
18};
19
20/// The complete set of version values calculated for a project.
21///
22/// Values that depend on public-release state or caller-supplied identifiers are exposed as
23/// methods because [`public_release`](Self::public_release), [`build_metadata`](Self::build_metadata),
24/// and [`extra_prerelease_identifiers`](Self::extra_prerelease_identifiers) remain mutable.
25#[derive(Clone, Debug)]
26pub struct VersionOracle {
27    version_options: Option<VersionOptions>,
28    committed_version: Option<VersionOptions>,
29    working_version: Option<VersionOptions>,
30    cloud_build_number_options: CloudBuildNumberOptions,
31    version_git_commit_id_short: Option<String>,
32    assembly_informational_version: Version,
33    assembly_informational_version_component_count: usize,
34    git_commit_date: Option<DateTime<FixedOffset>>,
35    git_commit_author_date: Option<DateTime<FixedOffset>>,
36
37    /// Whether the calculated version is a public release.
38    pub public_release: bool,
39    /// Additional build metadata identifiers.
40    pub build_metadata: Vec<String>,
41    /// Additional prerelease identifiers.
42    pub extra_prerelease_identifiers: Vec<String>,
43    /// The ref (branch or tag) being built.
44    pub building_ref: Option<String>,
45    /// Canonical tag refs that point at the selected commit.
46    pub tags: Option<Vec<String>>,
47    /// The encoded numeric version.
48    pub version: Version,
49    /// The full selected commit ID, optionally suffixed by `-dirty`.
50    pub git_commit_id: Option<String>,
51    /// The abbreviated selected commit ID, optionally suffixed by `-dirty`.
52    pub git_commit_id_short: Option<String>,
53    /// The calculated version height.
54    pub version_height: u32,
55}
56
57impl VersionOracle {
58    /// Calculates version information from a Git context and optional cloud provider.
59    pub fn new(context: &GitContext, cloud_build: Option<&dyn CloudBuild>) -> Result<Self> {
60        Self::new_with_height_offset(context, cloud_build, None)
61    }
62
63    /// Calculates version information with an explicit version-height offset override.
64    pub fn new_with_height_offset(
65        context: &GitContext,
66        cloud_build: Option<&dyn CloudBuild>,
67        override_version_height_offset: Option<i32>,
68    ) -> Result<Self> {
69        let raw_git_commit_id = context
70            .git_commit_id()
71            .map(|id| id.to_string())
72            .or_else(|| cloud_build.and_then(CloudBuild::git_commit_id));
73
74        let mut committed_version = VersionFile::new(context).get_version(Default::default())?.0;
75        let mut working_version = if context.is_head()? {
76            VersionFile::new(context)
77                .get_working_copy_version(Default::default())?
78                .0
79        } else {
80            committed_version.clone()
81        };
82        if let Some(offset) = override_version_height_offset {
83            if let Some(options) = &mut committed_version {
84                options.version_height_offset = Some(offset);
85            }
86            if let Some(options) = &mut working_version {
87                options.version_height_offset = Some(offset);
88            }
89        }
90
91        let building_ref = cloud_build
92            .and_then(CloudBuild::building_tag)
93            .or_else(|| cloud_build.and_then(CloudBuild::building_branch))
94            .or(context.head_canonical_name()?);
95        let version_height = calculate_version_height(
96            context,
97            committed_version.as_ref(),
98            working_version.as_ref(),
99        )?;
100        let version_git_commit_id = version_height
101            .commit_id
102            .map(|id| id.to_string())
103            .or_else(|| raw_git_commit_id.clone());
104        let version_options = committed_version
105            .clone()
106            .or_else(|| working_version.clone());
107        let dirty = context.is_head()?
108            && version_options
109                .as_ref()
110                .is_some_and(VersionOptions::git_commit_id_include_dirty_or_default)
111            && context.is_working_tree_dirty()?;
112        let git_commit_id = raw_git_commit_id.as_ref().map(|id| {
113            if dirty {
114                format!("{id}-dirty")
115            } else {
116                id.clone()
117            }
118        });
119
120        let base_version = version_options
121            .as_ref()
122            .and_then(|options| options.version.as_ref())
123            .map(|version| version.version)
124            .unwrap_or_default();
125        let component_count = if version_options.as_ref().is_some_and(|options| {
126            options.version_height_position() == Some(VersionPosition::Revision)
127        }) {
128            4
129        } else {
130            3
131        };
132        let (version, assembly_informational_version) = if context.is_repository() {
133            let version = get_id_as_version(
134                context,
135                committed_version.as_ref(),
136                working_version.as_ref(),
137                version_height,
138            )?;
139            let head_height = crate::VersionHeightCalculation {
140                height: version_height.height,
141                commit_id: context.git_commit_id(),
142            };
143            let informational = get_id_as_version(
144                context,
145                committed_version.as_ref(),
146                working_version.as_ref(),
147                head_height,
148            )?;
149            (version, informational)
150        } else {
151            (base_version, base_version)
152        };
153
154        let short_id = |id: &str, selected: bool| -> Result<String> {
155            let fixed = version_options.as_ref().map_or(
156                10,
157                VersionOptions::git_commit_id_short_fixed_length_or_default,
158            ) as usize;
159            let automatic = version_options.as_ref().map_or(
160                0,
161                VersionOptions::git_commit_id_short_auto_minimum_or_default,
162            ) as usize;
163            if automatic > 0 {
164                if selected {
165                    context.short_unique_commit_id(automatic)
166                } else {
167                    let oid = git2::Oid::from_str(id).map_err(crate::Error::Git)?;
168                    context.short_unique_id(oid, automatic)
169                }
170            } else {
171                id.get(..fixed).map(str::to_owned).ok_or_else(|| {
172                    crate::Error::InvalidOperation(format!(
173                        "Git commit ID '{id}' is shorter than the configured length {fixed}."
174                    ))
175                })
176            }
177        };
178        let git_commit_id_short = raw_git_commit_id
179            .as_deref()
180            .map(|id| short_id(id, true))
181            .transpose()?
182            .map(|id| if dirty { format!("{id}-dirty") } else { id });
183        let version_git_commit_id_short = version_git_commit_id
184            .as_deref()
185            .map(|id| {
186                short_id(
187                    id,
188                    context
189                        .git_commit_id()
190                        .is_some_and(|selected| selected.to_string() == id),
191                )
192            })
193            .transpose()?;
194
195        let tags = context.head_tags()?;
196        let mut public_release = false;
197        if let Some(options) = &version_options
198            && let Some(specs) = &options.public_release_ref_spec
199        {
200            if let Some(reference) = &building_ref {
201                let expressions = specs
202                    .iter()
203                    .map(|expression| Regex::new(expression))
204                    .collect::<std::result::Result<Vec<_>, _>>()
205                    .map_err(|error| crate::Error::InvalidFormat(error.to_string()))?;
206                for expression in expressions {
207                    if expression
208                        .is_match(reference)
209                        .map_err(|error| crate::Error::InvalidFormat(error.to_string()))?
210                    {
211                        public_release = true;
212                        break;
213                    }
214                }
215            }
216            if !public_release
217                && specs
218                    .iter()
219                    .any(|expression| expression.starts_with("^refs/tags/"))
220                && let Some(tags) = &tags
221            {
222                for expression in specs {
223                    let expression = Regex::new(expression)
224                        .map_err(|error| crate::Error::InvalidFormat(error.to_string()))?;
225                    for tag in tags {
226                        if expression
227                            .is_match(tag)
228                            .map_err(|error| crate::Error::InvalidFormat(error.to_string()))?
229                        {
230                            public_release = true;
231                            break;
232                        }
233                    }
234                    if public_release {
235                        break;
236                    }
237                }
238            }
239        }
240        let dates = context.git_commit_dates()?;
241
242        Ok(Self {
243            cloud_build_number_options: version_options
244                .as_ref()
245                .map(VersionOptions::cloud_build_or_default)
246                .map(|options| options.build_number_or_default())
247                .unwrap_or_default(),
248            version_options,
249            committed_version,
250            working_version,
251            version_git_commit_id_short,
252            assembly_informational_version,
253            assembly_informational_version_component_count: component_count,
254            git_commit_date: dates.map(|dates| dates.committer),
255            git_commit_author_date: dates.map(|dates| dates.author),
256            public_release,
257            build_metadata: Vec::new(),
258            extra_prerelease_identifiers: Vec::new(),
259            building_ref,
260            tags,
261            version,
262            git_commit_id,
263            git_commit_id_short,
264            version_height: version_height.height,
265        })
266    }
267
268    /// Gets the options selected by the oracle.
269    pub fn version_options(&self) -> Option<&VersionOptions> {
270        self.version_options.as_ref()
271    }
272
273    /// Gets the committed options.
274    pub fn committed_version(&self) -> Option<&VersionOptions> {
275        self.committed_version.as_ref()
276    }
277
278    /// Gets the working-copy options.
279    pub fn working_version(&self) -> Option<&VersionOptions> {
280        self.working_version.as_ref()
281    }
282
283    /// Gets whether a version file was found.
284    pub fn version_file_found(&self) -> bool {
285        self.version_options.is_some()
286    }
287
288    /// Gets the effective height offset.
289    pub fn version_height_offset(&self) -> i32 {
290        self.version_options
291            .as_ref()
292            .map_or(0, VersionOptions::effective_version_height_offset)
293    }
294
295    /// Gets the height including its effective offset.
296    pub fn version_height_with_offset(&self) -> i64 {
297        i64::from(self.version_height) + i64::from(self.version_height_offset())
298    }
299
300    /// Gets the assembly version.
301    pub fn assembly_version(&self) -> Version {
302        let version = self
303            .version
304            .ensure_non_negative_components(4)
305            .expect("four fields");
306        let assembly = self
307            .version_options
308            .as_ref()
309            .map(VersionOptions::assembly_version_or_default);
310        let result = if let Some(explicit) = assembly.as_ref().and_then(|options| options.version) {
311            explicit
312        } else {
313            apply_precision(
314                version,
315                assembly
316                    .as_ref()
317                    .map_or(VersionPrecision::Minor, |options| {
318                        options.precision_or_default()
319                    }),
320            )
321        };
322        result
323            .ensure_non_negative_components(4)
324            .expect("four fields")
325    }
326
327    /// Gets the assembly file version.
328    pub const fn assembly_file_version(&self) -> Version {
329        self.version
330    }
331
332    /// Gets the assembly informational version.
333    pub fn assembly_informational_version(&self) -> String {
334        format!(
335            "{}{}{}",
336            self.assembly_informational_version
337                .to_string_safe(self.assembly_informational_version_component_count)
338                .expect("component count is valid"),
339            self.prerelease_version(),
340            format_build_metadata(self.build_metadata_with_commit_id())
341        )
342    }
343
344    /// Gets the prerelease fragment, including a leading hyphen.
345    pub fn prerelease_version(&self) -> String {
346        let mut result = self
347            .version_options
348            .as_ref()
349            .and_then(|options| options.version.as_ref())
350            .map_or_else(String::new, |version| {
351                self.replace_macros(&version.prerelease)
352            });
353        let semver2 = self
354            .version_options
355            .as_ref()
356            .map(VersionOptions::nuget_package_version_or_default)
357            .is_some_and(|options| options.sem_ver_or_default() >= 2.0);
358        for identifier in &self.extra_prerelease_identifiers {
359            if result.is_empty() {
360                result.push('-');
361            } else {
362                result.push(if semver2 { '.' } else { '-' });
363            }
364            result.push_str(identifier);
365        }
366        result
367    }
368
369    /// Gets the prerelease fragment without leading hyphens.
370    pub fn prerelease_version_no_leading_hyphen(&self) -> String {
371        self.prerelease_version().trim_start_matches('-').to_owned()
372    }
373
374    /// Gets the numeric version without its revision component.
375    pub fn simple_version(&self) -> Version {
376        match self.version.build {
377            Some(build) => Version::new_with_build(self.version.major, self.version.minor, build),
378            None => Version::new(self.version.major, self.version.minor),
379        }
380    }
381
382    /// Gets the third numeric component, treating an unspecified value as zero.
383    pub fn build_number(&self) -> u32 {
384        self.version.build.unwrap_or(0)
385    }
386
387    /// Gets the fourth numeric component using `-1` when unspecified.
388    pub fn version_revision(&self) -> i64 {
389        self.version.revision_or_unspecified()
390    }
391
392    /// Gets the major/minor numeric version.
393    pub const fn major_minor_version(&self) -> Version {
394        Version::new(self.version.major, self.version.minor)
395    }
396
397    /// Gets the selected commit's committer date.
398    pub const fn git_commit_date(&self) -> Option<DateTime<FixedOffset>> {
399        self.git_commit_date
400    }
401
402    /// Gets the selected commit's author date.
403    pub const fn git_commit_author_date(&self) -> Option<DateTime<FixedOffset>> {
404        self.git_commit_author_date
405    }
406
407    /// Gets build metadata with the selected commit ID first.
408    pub fn build_metadata_with_commit_id(&self) -> Vec<String> {
409        self.git_commit_id_short
410            .iter()
411            .cloned()
412            .chain(self.build_metadata.iter().cloned())
413            .collect()
414    }
415
416    fn version_build_metadata_with_commit_id(&self) -> Vec<String> {
417        self.version_git_commit_id_short
418            .iter()
419            .cloned()
420            .chain(self.build_metadata.iter().cloned())
421            .collect()
422    }
423
424    /// Gets the `+`-prefixed build metadata fragment used by calculated versions.
425    pub fn build_metadata_fragment(&self) -> String {
426        format_build_metadata(self.version_build_metadata_with_commit_id())
427    }
428
429    /// Gets the SemVer 1 representation.
430    pub fn sem_ver1(&self) -> String {
431        format!(
432            "{}{}{}",
433            self.version.to_string_safe(3).expect("three fields"),
434            self.prerelease_version_semver1(),
435            if self.public_release {
436                String::new()
437            } else {
438                format!(
439                    "-{}",
440                    self.version_git_commit_id_short.as_deref().unwrap_or("")
441                )
442            }
443        )
444    }
445
446    /// Gets the SemVer 2 representation.
447    pub fn sem_ver2(&self) -> String {
448        format!(
449            "{}{}{}",
450            self.version.to_string_safe(3).expect("three fields"),
451            self.prerelease_version(),
452            self.semver2_build_metadata()
453        )
454    }
455
456    /// Gets the NuGet package version.
457    pub fn nuget_package_version(&self) -> String {
458        if self
459            .version_options
460            .as_ref()
461            .map(VersionOptions::nuget_package_version_or_default)
462            .map_or(1.0, |options| options.sem_ver_or_default())
463            == 1.0
464        {
465            self.nuget_semver1()
466        } else {
467            self.nuget_semver2()
468        }
469    }
470
471    /// Gets the Chocolatey package version.
472    pub fn chocolatey_package_version(&self) -> String {
473        self.nuget_semver1()
474    }
475
476    /// Gets the NPM package version.
477    pub fn npm_package_version(&self) -> String {
478        self.sem_ver2()
479    }
480
481    /// Gets the SemVer 1 numeric-identifier padding.
482    pub fn sem_ver1_numeric_identifier_padding(&self) -> u32 {
483        self.version_options.as_ref().map_or(4, |options| {
484            options.sem_ver1_numeric_identifier_padding_or_default()
485        })
486    }
487
488    /// Gets the cloud build number.
489    pub fn cloud_build_number(&self) -> String {
490        let commit = self
491            .cloud_build_number_options
492            .include_commit_id_or_default();
493        let include = commit.when_or_default() == CloudBuildNumberCommitWhen::Always
494            || (commit.when_or_default() == CloudBuildNumberCommitWhen::NonPublicReleaseOnly
495                && !self.public_release);
496        let metadata_commit =
497            include && commit.where_or_default() == CloudBuildNumberCommitWhere::BuildMetadata;
498        let include_revision = (include
499            && commit.where_or_default() == CloudBuildNumberCommitWhere::FourthVersionComponent)
500            || self
501                .version_options
502                .as_ref()
503                .and_then(|options| options.version.as_ref())
504                .is_some_and(|version| {
505                    version.version_height_position() == Some(VersionPosition::Revision)
506                        || version.version.revision.is_some()
507                });
508        let metadata = if metadata_commit {
509            self.version_build_metadata_with_commit_id()
510        } else {
511            self.build_metadata.clone()
512        };
513        format!(
514            "{}{}{}",
515            if include_revision {
516                self.version.to_string()
517            } else {
518                self.simple_version().to_string()
519            },
520            self.prerelease_version(),
521            format_build_metadata(metadata)
522        )
523    }
524
525    /// Gets whether setting the cloud build number is enabled.
526    pub fn cloud_build_number_enabled(&self) -> bool {
527        self.cloud_build_number_options.enabled_or_default()
528    }
529
530    /// Gets whether all `NBGV_` variables should be set.
531    pub fn cloud_build_all_vars_enabled(&self) -> bool {
532        self.version_options
533            .as_ref()
534            .map(VersionOptions::cloud_build_or_default)
535            .is_some_and(|options| options.set_all_variables_or_default())
536    }
537
538    /// Gets whether common version variables should be set.
539    pub fn cloud_build_version_vars_enabled(&self) -> bool {
540        self.version_options
541            .as_ref()
542            .map(VersionOptions::cloud_build_or_default)
543            .is_none_or(|options| options.set_version_variables_or_default())
544    }
545
546    /// Gets the common cloud-build variables.
547    pub fn cloud_build_version_vars(&self) -> BTreeMap<String, String> {
548        BTreeMap::from([
549            (
550                "GitAssemblyInformationalVersion".to_owned(),
551                self.assembly_informational_version(),
552            ),
553            ("GitBuildVersion".to_owned(), self.version.to_string()),
554            (
555                "GitBuildVersionSimple".to_owned(),
556                self.simple_version().to_string(),
557            ),
558        ])
559    }
560
561    /// Gets every cloud-build variable exposed by the managed oracle.
562    pub fn cloud_build_all_vars(&self) -> BTreeMap<String, String> {
563        let mut values = BTreeMap::new();
564        macro_rules! add {
565            ($name:literal, $value:expr) => {
566                values.insert(concat!("NBGV_", $name).to_owned(), $value);
567            };
568        }
569        add!("CloudBuildNumber", self.cloud_build_number());
570        add!("VersionFileFound", dotnet_bool(self.version_file_found()));
571        add!("AssemblyVersion", self.assembly_version().to_string());
572        add!("AssemblyFileVersion", self.version.to_string());
573        add!(
574            "AssemblyInformationalVersion",
575            self.assembly_informational_version()
576        );
577        add!("PublicRelease", dotnet_bool(self.public_release));
578        add!("PrereleaseVersion", self.prerelease_version());
579        add!(
580            "PrereleaseVersionNoLeadingHyphen",
581            self.prerelease_version_no_leading_hyphen()
582        );
583        add!("SimpleVersion", self.simple_version().to_string());
584        add!("BuildNumber", self.build_number().to_string());
585        add!("VersionRevision", self.version_revision().to_string());
586        add!("MajorMinorVersion", self.major_minor_version().to_string());
587        add!("VersionMajor", self.version.major.to_string());
588        add!("VersionMinor", self.version.minor.to_string());
589        if let Some(value) = &self.git_commit_id {
590            add!("GitCommitId", value.clone());
591        }
592        if let Some(value) = &self.git_commit_id_short {
593            add!("GitCommitIdShort", value.clone());
594        }
595        if let Some(value) = self.git_commit_date {
596            add!("GitCommitDate", dotnet_roundtrip(value));
597        }
598        if let Some(value) = self.git_commit_author_date {
599            add!("GitCommitAuthorDate", dotnet_roundtrip(value));
600        }
601        add!("VersionHeight", self.version_height.to_string());
602        add!(
603            "VersionHeightOffset",
604            self.version_height_offset().to_string()
605        );
606        if let Some(value) = &self.building_ref {
607            add!("BuildingRef", value.clone());
608        }
609        add!("Version", self.version.to_string());
610        add!("BuildMetadataFragment", self.build_metadata_fragment());
611        add!("NuGetPackageVersion", self.nuget_package_version());
612        add!(
613            "ChocolateyPackageVersion",
614            self.chocolatey_package_version()
615        );
616        add!("NpmPackageVersion", self.npm_package_version());
617        add!("SemVer1", self.sem_ver1());
618        add!("SemVer2", self.sem_ver2());
619        add!(
620            "SemVer1NumericIdentifierPadding",
621            self.sem_ver1_numeric_identifier_padding().to_string()
622        );
623        values
624    }
625
626    fn replace_macros(&self, value: &str) -> String {
627        value.replace("{height}", &self.version_height_with_offset().to_string())
628    }
629
630    fn prerelease_version_semver1(&self) -> String {
631        SemanticVersion::make_prerelease_semver1_compliant(
632            &self.prerelease_version(),
633            self.sem_ver1_numeric_identifier_padding() as usize,
634        )
635    }
636
637    fn non_public_commit_prerelease(&self) -> String {
638        format!(
639            "{}{}{}",
640            if self.prerelease_version().is_empty() {
641                "-"
642            } else {
643                "."
644            },
645            self.version_options
646                .as_ref()
647                .and_then(|options| options.git_commit_id_prefix.as_deref())
648                .unwrap_or("g"),
649            self.version_git_commit_id_short.as_deref().unwrap_or("")
650        )
651    }
652
653    fn semver2_build_metadata(&self) -> String {
654        format!(
655            "{}{}",
656            if self.public_release {
657                String::new()
658            } else {
659                self.non_public_commit_prerelease()
660            },
661            format_build_metadata(self.build_metadata.clone())
662        )
663    }
664
665    fn package_version_base(&self) -> (Version, VersionPrecision, usize) {
666        let options = self
667            .version_options
668            .as_ref()
669            .map(VersionOptions::nuget_package_version_or_default)
670            .unwrap_or_default();
671        let precision = options.precision_or_default();
672        let version = apply_precision(
673            self.version
674                .ensure_non_negative_components(4)
675                .expect("four fields"),
676            precision,
677        );
678        let fields = if precision == VersionPrecision::Revision {
679            4
680        } else {
681            3
682        };
683        (version, precision, fields)
684    }
685
686    fn nuget_semver1(&self) -> String {
687        let (version, _, fields) = self.package_version_base();
688        let suffix = if self.public_release {
689            String::new()
690        } else {
691            format!(
692                "-{}{}",
693                self.version_options
694                    .as_ref()
695                    .and_then(|options| options.git_commit_id_prefix.as_deref())
696                    .unwrap_or("g"),
697                self.version_git_commit_id_short.as_deref().unwrap_or("")
698            )
699        };
700        format!(
701            "{}{}{}",
702            version.to_string_safe(fields).expect("field count"),
703            self.prerelease_version_semver1(),
704            suffix
705        )
706    }
707
708    fn nuget_semver2(&self) -> String {
709        let (version, _, fields) = self.package_version_base();
710        format!(
711            "{}{}{}",
712            version.to_string_safe(fields).expect("field count"),
713            self.prerelease_version(),
714            self.semver2_build_metadata()
715        )
716    }
717}
718
719impl Serialize for VersionOracle {
720    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
721    where
722        S: Serializer,
723    {
724        let mut map = serializer.serialize_map(None)?;
725        macro_rules! entry {
726            ($name:literal, $value:expr) => {
727                map.serialize_entry($name, &$value)?;
728            };
729        }
730        entry!("CloudBuildNumber", self.cloud_build_number());
731        entry!("CloudBuildNumberEnabled", self.cloud_build_number_enabled());
732        entry!(
733            "BuildMetadataWithCommitId",
734            self.build_metadata_with_commit_id()
735        );
736        entry!("VersionFileFound", self.version_file_found());
737        entry!("VersionOptions", self.version_options);
738        entry!("AssemblyVersion", self.assembly_version().to_string());
739        entry!("AssemblyFileVersion", self.version.to_string());
740        entry!(
741            "AssemblyInformationalVersion",
742            self.assembly_informational_version()
743        );
744        entry!("PublicRelease", self.public_release);
745        entry!("PrereleaseVersion", self.prerelease_version());
746        entry!(
747            "PrereleaseVersionNoLeadingHyphen",
748            self.prerelease_version_no_leading_hyphen()
749        );
750        entry!("SimpleVersion", self.simple_version().to_string());
751        entry!("BuildNumber", self.build_number());
752        entry!("VersionRevision", self.version_revision());
753        entry!("MajorMinorVersion", self.major_minor_version().to_string());
754        entry!("VersionMajor", self.version.major);
755        entry!("VersionMinor", self.version.minor);
756        entry!("GitCommitId", self.git_commit_id);
757        entry!("GitCommitIdShort", self.git_commit_id_short);
758        entry!("GitCommitDate", self.git_commit_date);
759        entry!("GitCommitAuthorDate", self.git_commit_author_date);
760        entry!("VersionHeight", self.version_height);
761        entry!("VersionHeightOffset", self.version_height_offset());
762        entry!("BuildingRef", self.building_ref);
763        entry!("Tags", self.tags);
764        entry!("Version", self.version.to_string());
765        entry!(
766            "CloudBuildAllVarsEnabled",
767            self.cloud_build_all_vars_enabled()
768        );
769        entry!("CloudBuildAllVars", self.cloud_build_all_vars());
770        entry!(
771            "CloudBuildVersionVarsEnabled",
772            self.cloud_build_version_vars_enabled()
773        );
774        entry!("CloudBuildVersionVars", self.cloud_build_version_vars());
775        entry!("BuildMetadata", self.build_metadata);
776        entry!(
777            "ExtraPrereleaseIdentifiers",
778            self.extra_prerelease_identifiers
779        );
780        entry!("BuildMetadataFragment", self.build_metadata_fragment());
781        entry!("NuGetPackageVersion", self.nuget_package_version());
782        entry!(
783            "ChocolateyPackageVersion",
784            self.chocolatey_package_version()
785        );
786        entry!("NpmPackageVersion", self.npm_package_version());
787        entry!("SemVer1", self.sem_ver1());
788        entry!("SemVer2", self.sem_ver2());
789        entry!(
790            "SemVer1NumericIdentifierPadding",
791            self.sem_ver1_numeric_identifier_padding()
792        );
793        map.end()
794    }
795}
796
797fn apply_precision(version: Version, precision: VersionPrecision) -> Version {
798    Version::new_with_revision(
799        version.major,
800        if precision == VersionPrecision::Major {
801            0
802        } else {
803            version.minor
804        },
805        if matches!(
806            precision,
807            VersionPrecision::Build | VersionPrecision::Revision
808        ) {
809            version.build.unwrap_or(0)
810        } else {
811            0
812        },
813        if precision == VersionPrecision::Revision {
814            version.revision.unwrap_or(0)
815        } else {
816            0
817        },
818    )
819}
820
821fn format_build_metadata(identifiers: impl IntoIterator<Item = String>) -> String {
822    let identifiers: Vec<_> = identifiers.into_iter().collect();
823    if identifiers.is_empty() {
824        String::new()
825    } else {
826        format!("+{}", identifiers.join("."))
827    }
828}
829
830fn dotnet_bool(value: bool) -> String {
831    if value { "True" } else { "False" }.to_owned()
832}
833
834fn dotnet_roundtrip(value: DateTime<FixedOffset>) -> String {
835    let base = value.to_rfc3339_opts(SecondsFormat::Secs, false);
836    let offset = &base[base.len() - 6..];
837    format!("{}.0000000{}", &base[..base.len() - 6], offset)
838}
839
840#[cfg(test)]
841mod tests {
842    use std::fs;
843    use std::path::{Path, PathBuf};
844    use std::sync::atomic::{AtomicU64, Ordering};
845
846    use git2::{IndexAddOption, Oid, Repository, Signature, Time};
847    use serde_json::Value;
848
849    use super::*;
850    use crate::GitEngine;
851
852    static NEXT_REPOSITORY: AtomicU64 = AtomicU64::new(0);
853
854    struct TestRepository {
855        path: PathBuf,
856    }
857
858    impl TestRepository {
859        fn new(version_json: &str) -> Self {
860            let id = NEXT_REPOSITORY.fetch_add(1, Ordering::Relaxed);
861            let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
862                .join("target")
863                .join("test-repositories")
864                .join(format!("oracle-{}-{id}", std::process::id()));
865            let _ = fs::remove_dir_all(&path);
866            fs::create_dir_all(&path).unwrap();
867            Repository::init(&path).unwrap();
868            fs::write(path.join("version.json"), version_json).unwrap();
869            let result = Self { path };
870            result.commit("version");
871            result
872        }
873
874        fn context(&self) -> GitContext {
875            GitContext::create(&self.path, None, GitEngine::ReadOnly).unwrap()
876        }
877
878        fn commit(&self, message: &str) -> Oid {
879            let repository = Repository::open(&self.path).unwrap();
880            let mut index = repository.index().unwrap();
881            index.add_all(["*"], IndexAddOption::DEFAULT, None).unwrap();
882            index.write().unwrap();
883            let tree_id = index.write_tree().unwrap();
884            let tree = repository.find_tree(tree_id).unwrap();
885            let signature =
886                Signature::new("Test", "test@example.com", &Time::new(1_700_000_000, -420))
887                    .unwrap();
888            let parent = repository
889                .head()
890                .ok()
891                .and_then(|head| head.target())
892                .map(|id| repository.find_commit(id).unwrap());
893            repository
894                .commit(
895                    Some("HEAD"),
896                    &signature,
897                    &signature,
898                    message,
899                    &tree,
900                    &parent.iter().collect::<Vec<_>>(),
901                )
902                .unwrap()
903        }
904    }
905
906    impl Drop for TestRepository {
907        fn drop(&mut self) {
908            let _ = fs::remove_dir_all(&self.path);
909        }
910    }
911
912    fn oracle(repository: &TestRepository) -> VersionOracle {
913        VersionOracle::new(&repository.context(), None).unwrap()
914    }
915
916    #[test]
917    fn calculates_core_versions_commit_encoding_and_dates() {
918        let repository = TestRepository::new(r#"{"version":"1.2"}"#);
919        let oracle = oracle(&repository);
920        let commit = repository.context().git_commit_id().unwrap();
921
922        assert_eq!(oracle.version_height, 1);
923        assert_eq!(
924            oracle.version,
925            Version::new_with_revision(1, 2, 1, u32::from(crate::truncated_commit_id(commit)))
926        );
927        assert_eq!(oracle.simple_version().to_string(), "1.2.1");
928        assert_eq!(oracle.assembly_version().to_string(), "1.2.0.0");
929        assert_eq!(oracle.assembly_file_version(), oracle.version);
930        assert_eq!(
931            oracle.git_commit_id_short.as_deref(),
932            Some(&commit.to_string()[..10])
933        );
934        assert_eq!(
935            oracle.git_commit_date().unwrap().to_rfc3339(),
936            "2023-11-14T15:13:20-07:00"
937        );
938        assert!(
939            oracle
940                .assembly_informational_version()
941                .starts_with("1.2.1+")
942        );
943    }
944
945    #[test]
946    fn formats_semver_packages_metadata_and_prerelease_extras() {
947        let repository = TestRepository::new(
948            r#"{"version":"7.8.9-beta.{height}","versionHeightOffset":2,"nugetPackageVersion":{"semVer":2}}"#,
949        );
950        let mut oracle = oracle(&repository);
951        oracle.public_release = true;
952        oracle.build_metadata.extend(["one".into(), "two".into()]);
953        oracle
954            .extra_prerelease_identifiers
955            .extend(["x".into(), "2".into()]);
956
957        assert_eq!(oracle.prerelease_version(), "-beta.3.x.2");
958        assert_eq!(oracle.sem_ver2(), "7.8.9-beta.3.x.2+one.two");
959        assert_eq!(oracle.npm_package_version(), oracle.sem_ver2());
960        assert_eq!(oracle.nuget_package_version(), oracle.sem_ver2());
961        assert!(!oracle.build_metadata_fragment().ends_with("+one.two"));
962        assert!(oracle.build_metadata_fragment().contains(".one.two"));
963
964        oracle.public_release = false;
965        assert!(oracle.nuget_package_version().contains(".g"));
966    }
967
968    #[test]
969    fn semver1_padding_precision_and_custom_assembly_version_match_managed_cases() {
970        let repository = TestRepository::new(
971            r#"{
972                "version":"7.8.9-foo.5.bar.1",
973                "semVer1NumericIdentifierPadding":4,
974                "assemblyVersion":{"precision":"build"},
975                "nugetPackageVersion":{"semVer":1,"precision":"minor"}
976            }"#,
977        );
978        let mut oracle = oracle(&repository);
979        oracle.public_release = true;
980
981        assert_eq!(oracle.sem_ver1(), "7.8.9-foo-0005-bar-0001");
982        assert_eq!(oracle.nuget_package_version(), "7.8.0-foo-0005-bar-0001");
983        assert_eq!(
984            oracle.chocolatey_package_version(),
985            oracle.nuget_package_version()
986        );
987        assert_eq!(oracle.assembly_version().to_string(), "7.8.9.0");
988    }
989
990    #[test]
991    fn dirty_ids_and_working_version_are_observed_only_at_head() {
992        let repository = TestRepository::new(r#"{"version":"1.2","gitCommitIdIncludeDirty":true}"#);
993        fs::write(repository.path.join("tracked.txt"), "second commit").unwrap();
994        repository.commit("second");
995        fs::write(
996            repository.path.join("version.json"),
997            r#"{"version":"1.3","gitCommitIdIncludeDirty":true}"#,
998        )
999        .unwrap();
1000        let oracle = oracle(&repository);
1001
1002        assert_eq!(oracle.major_minor_version().to_string(), "1.3");
1003        assert_eq!(oracle.version_height, 0);
1004        assert!(oracle.git_commit_id.as_deref().unwrap().ends_with("-dirty"));
1005        assert!(
1006            oracle
1007                .git_commit_id_short
1008                .as_deref()
1009                .unwrap()
1010                .ends_with("-dirty")
1011        );
1012
1013        let historical =
1014            GitContext::create(&repository.path, Some("HEAD~1"), GitEngine::ReadOnly).unwrap();
1015        let historical = VersionOracle::new(&historical, None).unwrap();
1016        assert_eq!(historical.major_minor_version().to_string(), "1.2");
1017        assert!(
1018            !historical
1019                .git_commit_id
1020                .as_deref()
1021                .unwrap()
1022                .ends_with("-dirty")
1023        );
1024    }
1025
1026    #[test]
1027    fn dirty_tracking_matches_managed_tracked_untracked_and_ignored_cases() {
1028        let default = TestRepository::new(r#"{"version":"1.2"}"#);
1029        fs::write(default.path.join("untracked.txt"), "content").unwrap();
1030        assert!(
1031            !oracle(&default)
1032                .git_commit_id
1033                .as_deref()
1034                .unwrap()
1035                .ends_with("-dirty")
1036        );
1037
1038        let enabled = TestRepository::new(r#"{"version":"1.2","gitCommitIdIncludeDirty":true}"#);
1039        fs::write(enabled.path.join("untracked.txt"), "content").unwrap();
1040        assert!(
1041            oracle(&enabled)
1042                .git_commit_id
1043                .as_deref()
1044                .unwrap()
1045                .ends_with("-dirty")
1046        );
1047
1048        let ignored = TestRepository::new(r#"{"version":"1.2","gitCommitIdIncludeDirty":true}"#);
1049        fs::write(ignored.path.join(".gitignore"), "ignored.txt\n").unwrap();
1050        {
1051            let repository = Repository::open(&ignored.path).unwrap();
1052            let mut index = repository.index().unwrap();
1053            index.add_path(Path::new(".gitignore")).unwrap();
1054            index.write().unwrap();
1055        }
1056        ignored.commit("ignore rules");
1057        fs::write(ignored.path.join("ignored.txt"), "content").unwrap();
1058        assert!(
1059            ignored
1060                .context()
1061                .is_ignored(ignored.path.join("ignored.txt"))
1062                .unwrap()
1063        );
1064        assert!(
1065            !oracle(&ignored)
1066                .git_commit_id
1067                .as_deref()
1068                .unwrap()
1069                .ends_with("-dirty")
1070        );
1071    }
1072
1073    #[test]
1074    fn public_release_matches_branch_and_tags() {
1075        let repository =
1076            TestRepository::new(r#"{"version":"1.2","publicReleaseRefSpec":["^refs/tags/v"]}"#);
1077        let git = Repository::open(&repository.path).unwrap();
1078        let commit = git.head().unwrap().peel_to_commit().unwrap();
1079        git.tag_lightweight("v1.2", commit.as_object(), false)
1080            .unwrap();
1081        assert!(oracle(&repository).public_release);
1082    }
1083
1084    #[test]
1085    fn public_release_ref_spec_supports_lookaround_and_backreferences() {
1086        let lookaround = TestRepository::new(
1087            r#"{"version":"1.2","publicReleaseRefSpec":["^refs/heads/(?=master$)master$"]}"#,
1088        );
1089        assert!(oracle(&lookaround).public_release);
1090
1091        let backreference = TestRepository::new(
1092            r#"{"version":"1.2","publicReleaseRefSpec":["^refs/heads/(release)-\\1$"]}"#,
1093        );
1094        let git = Repository::open(&backreference.path).unwrap();
1095        let commit_id = git.head().unwrap().peel_to_commit().unwrap().id();
1096        git.reference("refs/heads/release-release", commit_id, true, "test")
1097            .unwrap();
1098        git.set_head("refs/heads/release-release").unwrap();
1099        drop(git);
1100        assert!(oracle(&backreference).public_release);
1101    }
1102
1103    #[test]
1104    fn cloud_numbers_cover_metadata_and_fourth_component() {
1105        let metadata = TestRepository::new(
1106            r#"{"version":"1.2-alpha","cloudBuild":{"buildNumber":{"includeCommitId":{"when":"always","where":"buildMetadata"}}}}"#,
1107        );
1108        let metadata_oracle = oracle(&metadata);
1109        assert_eq!(
1110            metadata_oracle.cloud_build_number(),
1111            format!(
1112                "1.2.1-alpha+{}",
1113                metadata_oracle.git_commit_id_short.as_deref().unwrap()
1114            )
1115        );
1116
1117        let fourth = TestRepository::new(
1118            r#"{"version":"1.2-alpha","cloudBuild":{"buildNumber":{"includeCommitId":{"when":"always","where":"fourthVersionComponent"}}}}"#,
1119        );
1120        let fourth_oracle = oracle(&fourth);
1121        assert_eq!(
1122            fourth_oracle.cloud_build_number(),
1123            format!("{}-alpha", fourth_oracle.version)
1124        );
1125    }
1126
1127    #[test]
1128    fn all_variables_and_json_use_stable_managed_property_names() {
1129        let repository = TestRepository::new(r#"{"version":"1.2"}"#);
1130        let oracle = oracle(&repository);
1131        let variables = oracle.cloud_build_all_vars();
1132        assert_eq!(variables["NBGV_VersionFileFound"], "True");
1133        assert_eq!(variables["NBGV_Version"], oracle.version.to_string());
1134        assert!(!variables.contains_key("NBGV_Tags"));
1135        assert_eq!(
1136            oracle.cloud_build_version_vars()["GitBuildVersion"],
1137            oracle.version.to_string()
1138        );
1139
1140        let value: Value = serde_json::to_value(&oracle).unwrap();
1141        for property in [
1142            "CloudBuildNumber",
1143            "VersionFileFound",
1144            "AssemblyInformationalVersion",
1145            "NuGetPackageVersion",
1146            "GitCommitDate",
1147            "CloudBuildAllVars",
1148        ] {
1149            assert!(value.get(property).is_some(), "{property}");
1150        }
1151        assert!(value.get("cloudBuildNumber").is_none());
1152    }
1153
1154    #[test]
1155    fn no_repository_still_produces_zero_versions() {
1156        let path = Path::new(env!("CARGO_MANIFEST_DIR"))
1157            .join("target")
1158            .join("not-a-repository");
1159        let _ = fs::remove_dir_all(&path);
1160        fs::create_dir_all(&path).unwrap();
1161        let context = GitContext::create(&path, None, GitEngine::Disabled).unwrap();
1162        let oracle = VersionOracle::new(&context, None).unwrap();
1163        assert_eq!(oracle.version_height, 0);
1164        assert_eq!(oracle.version.major, 0);
1165        assert_eq!(oracle.version.minor, 0);
1166        let _ = fs::remove_dir_all(path);
1167    }
1168}