From 4e6d5026fb4d58f37385cc7bc7f6a165a893f84c Mon Sep 17 00:00:00 2001
From: Vivek R <123vivekr@gmail.com>
Date: Tue, 22 Nov 2022 11:30:36 +0530
Subject: [PATCH] Show git semver in banner

---
 server/src/banner.rs | 108 ++++++++++++++++++++++++++++++-------------
 1 file changed, 76 insertions(+), 32 deletions(-)

diff --git a/server/src/banner.rs b/server/src/banner.rs
index a817aa639..d68cfdcad 100644
--- a/server/src/banner.rs
+++ b/server/src/banner.rs
@@ -48,52 +48,96 @@ pub mod version {
     use chrono::Duration;
     use chrono_humanize::{Accuracy, Tense};
     use crossterm::style::Stylize;
-    use semver::Version;
+    use std::fmt;
 
     use crate::utils::update;
 
+    pub enum ParseableVersion {
+        Version(semver::Version),
+        Prerelease(semver::Prerelease),
+    }
+
+    impl fmt::Display for ParseableVersion {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            match self {
+                ParseableVersion::Version(v) => write!(f, "{}", v),
+                ParseableVersion::Prerelease(p) => write!(f, "{}", p),
+            }
+        }
+    }
+
     pub fn print() {
         // print current version
         let current = current();
-        // not eprintln because if it is old release then time passed with be displayed beside it
-        eprint!(
-            "
+
+        match current {
+            ParseableVersion::Version(current_version) => {
+                // not eprintln because if it is old release then time passed with be displayed beside it
+                eprint!(
+                    "
     {} {} ",
-            "Current Version:".to_string().blue().bold(),
-            current
-        );
-
-        // check for latest release, if it cannot be fetched then print error as warn and return
-        let latest_release = match update::get_latest() {
-            Ok(latest_release) => latest_release,
-            Err(e) => {
-                log::warn!("{}", e);
-                return;
-            }
-        };
+                    "Current Version:".to_string().blue().bold(),
+                    current_version
+                );
 
-        if latest_release.version > current {
-            let time_since_latest_release = chrono::Utc::now() - latest_release.date;
-            let time_since_latest_release = humanize_time(time_since_latest_release);
+                // check for latest release, if it cannot be fetched then print error as warn and return
+                let latest_release = match update::get_latest() {
+                    Ok(latest_release) => latest_release,
+                    Err(e) => {
+                        log::warn!("{}", e);
+                        return;
+                    }
+                };
 
-            let fmt_latest_version = format!(
-                "( v{} released {} ago )",
-                latest_release.version, time_since_latest_release
-            );
+                if latest_release.version > current_version {
+                    let time_since_latest_release = chrono::Utc::now() - latest_release.date;
+                    let time_since_latest_release = humanize_time(time_since_latest_release);
 
-            eprint!("{}", fmt_latest_version.yellow().bold());
-            eprintln!(
-                "
+                    let fmt_latest_version = format!(
+                        "( v{} released {} ago )",
+                        latest_release.version, time_since_latest_release
+                    );
+
+                    eprint!("{}", fmt_latest_version.yellow().bold());
+                    eprintln!(
+                        "
     Download latest version from https://github.com/parseablehq/parseable/releases/latest"
-            );
-        } else {
-            eprintln!();
+                    );
+                } else {
+                    eprintln!();
+                }
+            }
+            ParseableVersion::Prerelease(current_prerelease) => {
+                eprint!(
+                    "
+    {} {} ",
+                    "Current Version:".to_string().blue().bold(),
+                    current_prerelease
+                );
+            }
         }
     }
 
-    pub fn current() -> Version {
-        let current = env!("VERGEN_BUILD_SEMVER");
-        semver::Version::parse(current).expect("VERGEN_BUILD_SEMVER is always valid semver")
+    pub fn current() -> ParseableVersion {
+        let build_semver = env!("VERGEN_BUILD_SEMVER");
+
+        let mut git_semver = env!("VERGEN_GIT_SEMVER");
+
+        if &git_semver[..1] == "v" {
+            git_semver = &git_semver[1..];
+        }
+
+        if build_semver == git_semver {
+            ParseableVersion::Version(
+                semver::Version::parse(build_semver)
+                    .expect("VERGEN_BUILD_SEMVER is always valid semver"),
+            )
+        } else {
+            ParseableVersion::Prerelease(
+                semver::Prerelease::new(git_semver)
+                    .expect("VERGEN_GIT_SEMVER is always valid semver"),
+            )
+        }
     }
 
     fn humanize_time(time_passed: Duration) -> String {