1use 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#[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 pub public_release: bool,
39 pub build_metadata: Vec<String>,
41 pub extra_prerelease_identifiers: Vec<String>,
43 pub building_ref: Option<String>,
45 pub tags: Option<Vec<String>>,
47 pub version: Version,
49 pub git_commit_id: Option<String>,
51 pub git_commit_id_short: Option<String>,
53 pub version_height: u32,
55}
56
57impl VersionOracle {
58 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 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 pub fn version_options(&self) -> Option<&VersionOptions> {
270 self.version_options.as_ref()
271 }
272
273 pub fn committed_version(&self) -> Option<&VersionOptions> {
275 self.committed_version.as_ref()
276 }
277
278 pub fn working_version(&self) -> Option<&VersionOptions> {
280 self.working_version.as_ref()
281 }
282
283 pub fn version_file_found(&self) -> bool {
285 self.version_options.is_some()
286 }
287
288 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 pub fn version_height_with_offset(&self) -> i64 {
297 i64::from(self.version_height) + i64::from(self.version_height_offset())
298 }
299
300 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 pub const fn assembly_file_version(&self) -> Version {
329 self.version
330 }
331
332 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 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 pub fn prerelease_version_no_leading_hyphen(&self) -> String {
371 self.prerelease_version().trim_start_matches('-').to_owned()
372 }
373
374 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 pub fn build_number(&self) -> u32 {
384 self.version.build.unwrap_or(0)
385 }
386
387 pub fn version_revision(&self) -> i64 {
389 self.version.revision_or_unspecified()
390 }
391
392 pub const fn major_minor_version(&self) -> Version {
394 Version::new(self.version.major, self.version.minor)
395 }
396
397 pub const fn git_commit_date(&self) -> Option<DateTime<FixedOffset>> {
399 self.git_commit_date
400 }
401
402 pub const fn git_commit_author_date(&self) -> Option<DateTime<FixedOffset>> {
404 self.git_commit_author_date
405 }
406
407 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 pub fn build_metadata_fragment(&self) -> String {
426 format_build_metadata(self.version_build_metadata_with_commit_id())
427 }
428
429 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 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 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 pub fn chocolatey_package_version(&self) -> String {
473 self.nuget_semver1()
474 }
475
476 pub fn npm_package_version(&self) -> String {
478 self.sem_ver2()
479 }
480
481 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 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 pub fn cloud_build_number_enabled(&self) -> bool {
527 self.cloud_build_number_options.enabled_or_default()
528 }
529
530 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 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 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 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}