1 files changed, 39 insertions, 34 deletions

diff --git a/src/formatter/version.rs b/src/formatter/version.rs
index 8d174218b..2b3e8aed1 100644
--- a/src/formatter/version.rs
+++ b/src/formatter/version.rs
@@ -1,5 +1,7 @@
 use super::string_formatter::StringFormatterError;
 use super::StringFormatter;
+use once_cell::sync::Lazy;
+use std::ops::Deref;
 use versions::Versioning;
 
 pub struct VersionFormatter<'a> {
@@ -17,26 +19,32 @@ impl<'a> VersionFormatter<'a> {
         Ok(Self { formatter })
     }
 
+    /// Format version string using provided format
+    pub fn format_version(
+        version: &'a str,
+        format: &'a str,
+    ) -> Result<String, StringFormatterError> {
+        Self::new(format).and_then(|formatter| formatter.format(version))
+    }
+
     /// Formats a version structure into a readable string
-    ///
-    /// No matter what comes in, this will return some usable string
-    pub fn format_version(self, version: &str) -> String {
-        let parsed = Versioning::new(version);
+    pub fn format(self, version: &'a str) -> Result<String, StringFormatterError> {
+        let parsed = Lazy::new(|| Versioning::new(version));
         let formatted = self
             .formatter
             .map(|variable| match variable {
                 "raw" => Some(Ok(version.to_string())),
-                "major" => match parsed.as_ref() {
+                "major" => match parsed.deref().as_ref() {
                     Some(Versioning::Ideal(v)) => Some(Ok(v.major.to_string())),
                     Some(Versioning::General(v)) => Some(Ok(v.nth_lenient(0)?.to_string())),
                     _ => None,
                 },
-                "minor" => match parsed.as_ref() {
+                "minor" => match parsed.deref().as_ref() {
                     Some(Versioning::Ideal(v)) => Some(Ok(v.minor.to_string())),
                     Some(Versioning::General(v)) => Some(Ok(v.nth_lenient(1)?.to_string())),
                     _ => None,
                 },
-                "patch" => match parsed.as_ref() {
+                "patch" => match parsed.deref().as_ref() {
                     Some(Versioning::Ideal(v)) => Some(Ok(v.patch.to_string())),
                     Some(Versioning::General(v)) => Some(Ok(v.nth_lenient(2)?.to_string())),
                     _ => None,
@@ -44,14 +52,13 @@ impl<'a> VersionFormatter<'a> {
                 _ => None,
             })
             .parse(None);
-        match formatted {
-            Ok(segments) => segments
+
+        formatted.map(|segments| {
+            segments
                 .iter()
                 .map(|segment| segment.value.as_str())
-                .collect::<Vec<&str>>()
-                .join(""),
-            Err(_) => version.to_string(),
-        }
+                .collect::<String>()
+        })
     }
 }
 
@@ -59,39 +66,37 @@ impl<'a> VersionFormatter<'a> {
 mod tests {
     use super::*;
 
+    const VERSION_FORMAT: &str = "major:${major} minor:${minor} patch:${patch} raw:${raw}";
+
     #[test]
     fn test_semver_full() {
-        const FORMAT_STR: &str = "major:${major} minor:${minor} patch:${patch} raw:${raw}";
-        let result = VersionFormatter::new(FORMAT_STR)
-            .unwrap()
-            .format_version("1.2.3");
-        assert_eq!(result, "major:1 minor:2 patch:3 raw:1.2.3");
+        assert_eq!(
+            VersionFormatter::format_version("1.2.3", VERSION_FORMAT),
+            Ok("major:1 minor:2 patch:3 raw:1.2.3".to_string())
+        );
     }
 
     #[test]
     fn test_semver_partial() {
-        const FORMAT_STR: &str = "major:${major} minor:${minor} patch:${patch} raw:${raw}";
-        let result = VersionFormatter::new(FORMAT_STR)
-            .unwrap()
-            .format_version("1.2");
-        assert_eq!(result, "major:1 minor:2 patch: raw:1.2");
+        assert_eq!(
+            VersionFormatter::format_version("1.2", VERSION_FORMAT),
+            Ok("major:1 minor:2 patch: raw:1.2".to_string())
+        );
     }
 
     #[test]
     fn test_general() {
-        const FORMAT_STR: &str = "major:${major} minor:${minor} patch:${patch} raw:${raw}";
-        let result = VersionFormatter::new(FORMAT_STR)
-            .unwrap()
-            .format_version("1.2-a.3");
-        assert_eq!(result, "major:1 minor:2 patch: raw:1.2-a.3");
+        assert_eq!(
+            VersionFormatter::format_version("1.2-a.3", VERSION_FORMAT),
+            Ok("major:1 minor:2 patch: raw:1.2-a.3".to_string())
+        );
     }
 
     #[test]
-    fn test_mess() {
-        const FORMAT_STR: &str = "major:${major} minor:${minor} patch:${patch} raw:${raw}";
-        let result = VersionFormatter::new(FORMAT_STR)
-            .unwrap()
-            .format_version("utter junk");
-        assert_eq!(result, "major: minor: patch: raw:utter junk");
+    fn test_dummy() {
+        assert_eq!(
+            VersionFormatter::format_version("dummy version", VERSION_FORMAT),
+            Ok("major: minor: patch: raw:dummy version".to_string())
+        );
     }
 }