3 files changed, 119 insertions, 0 deletions

diff --git a/src/modules/mod.rs b/src/modules/mod.rs
index 1d5eac0e5..b255a7f2a 100644
--- a/src/modules/mod.rs
+++ b/src/modules/mod.rs
@@ -57,6 +57,7 @@ mod username;
 mod utils;
 mod vagrant;
 mod vcsh;
+mod vlang;
 mod zig;
 
 #[cfg(feature = "battery")]
@@ -130,6 +131,7 @@ pub fn handle<'a>(module: &str, context: &'a Context) -> Option<Module<'a>> {
             "time" => time::module(context),
             "crystal" => crystal::module(context),
             "username" => username::module(context),
+            "vlang" => vlang::module(context),
             "vagrant" => vagrant::module(context),
             "vcsh" => vcsh::module(context),
             "zig" => zig::module(context),
@@ -210,6 +212,7 @@ pub fn description(module: &str) -> &'static str {
         "terraform" => "The currently selected terraform workspace and version",
         "time" => "The current local time",
         "username" => "The active user's username",
+        "vlang" => "The currently installed version of V",
         "vagrant" => "The currently installed version of Vagrant",
         "vcsh" => "The currently active VCSH repository",
         "zig" => "The currently installed version of Zig",
diff --git a/src/modules/package.rs b/src/modules/package.rs
index bd7372ca6..1f95a7e0a 100644
--- a/src/modules/package.rs
+++ b/src/modules/package.rs
@@ -54,6 +54,13 @@ fn extract_cargo_version(file_contents: &str) -> Option<String> {
     Some(formatted_version)
 }
 
+fn extract_vlang_version(file_contents: &str) -> Option<String> {
+    let re = Regex::new(r"(?m)^\s*version\s*:\s*'(?P<version>[^']+)'").unwrap();
+    let caps = re.captures(file_contents)?;
+    let formatted_version = format_version(&caps["version"]);
+    Some(formatted_version)
+}
+
 fn extract_package_version(file_contents: &str, display_private: bool) -> Option<String> {
     let package_json: json::Value = json::from_str(file_contents).ok()?;
 
@@ -198,6 +205,8 @@ fn get_package_version(base_dir: &Path, config: &PackageConfig) -> Option<String
         extract_maven_version(&pom_file)
     } else if let Ok(meson_build) = utils::read_file(base_dir.join("meson.build")) {
         extract_meson_version(&meson_build)
+    } else if let Ok(vlang_mod) = utils::read_file(base_dir.join("v.mod")) {
+        extract_vlang_version(&vlang_mod)
     } else {
         None
     }
@@ -818,6 +827,21 @@ end";
         project_dir.close()
     }
 
+    #[test]
+    fn test_extract_vlang_version() -> io::Result<()> {
+        let config_name = "v.mod";
+        let config_content = "
+        Module {
+            name: 'starship',
+            author: 'matchai',
+            version: '1.2.3'
+        }";
+        let project_dir = create_project_dir()?;
+        fill_config(&project_dir, config_name, Some(&config_content))?;
+        expect_output(&project_dir, Some("v1.2.3"), None);
+        project_dir.close()
+    }
+
     fn create_project_dir() -> io::Result<TempDir> {
         tempfile::tempdir()
     }
diff --git a/src/modules/vlang.rs b/src/modules/vlang.rs
new file mode 100644
index 000000000..0d7d0e7b0
--- /dev/null
+++ b/src/modules/vlang.rs
@@ -0,0 +1,92 @@
+use super::{Context, Module, RootModuleConfig};
+
+use crate::configs::v::VLangConfig;
+use crate::formatter::StringFormatter;
+
+/// Creates a module with the current V version
+pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
+    let mut module = context.new_module("vlang");
+    let config = VLangConfig::try_load(module.config);
+    let is_v_project = context
+        .try_begin_scan()?
+        .set_extensions(&config.detect_extensions)
+        .is_match();
+
+    if !is_v_project {
+        return None;
+    }
+
+    let parsed = StringFormatter::new(config.format).and_then(|formatter| {
+        formatter
+            .map_meta(|var, _| match var {
+                "symbol" => Some(config.symbol),
+                _ => None,
+            })
+            .map_style(|variable| match variable {
+                "style" => Some(Ok(config.style)),
+                _ => None,
+            })
+            .map(|variable| match variable {
+                "version" => context
+                    .exec_cmd("v", &["version"])
+                    .and_then(|output| parse_v_version(output.stdout.trim()))
+                    .map(Ok),
+                _ => None,
+            })
+            .parse(None)
+    });
+
+    module.set_segments(match parsed {
+        Ok(segments) => segments,
+        Err(error) => {
+            log::warn!("Error in module `vlang`:\n{}", error);
+            return None;
+        }
+    });
+
+    Some(module)
+}
+
+fn parse_v_version(v_version: &str) -> Option<String> {
+    let version = v_version
+        // split into ["V", "0.2", "30c0659"]
+        .split_whitespace()
+        // return "0.2"
+        .nth(1)?;
+
+    Some(format!("v{}", version))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::parse_v_version;
+    use crate::test::ModuleRenderer;
+    use ansi_term::Color;
+    use std::fs::File;
+    use std::io;
+
+    #[test]
+    fn test_parse_v_version() {
+        const OUTPUT: &str = "V 0.2 30c0659\n";
+        assert_eq!(parse_v_version(OUTPUT.trim()), Some("v0.2".to_string()))
+    }
+
+    #[test]
+    fn folder_without_v_files() -> io::Result<()> {
+        let dir = tempfile::tempdir()?;
+        let actual = ModuleRenderer::new("vlang").path(dir.path()).collect();
+        let expected = None;
+        assert_eq!(expected, actual);
+        dir.close()
+    }
+
+    #[test]
+    fn folder_with_v_files() -> io::Result<()> {
+        let dir = tempfile::tempdir()?;
+        File::create(dir.path().join("hello.v"))?.sync_all()?;
+        let actual = ModuleRenderer::new("vlang").path(dir.path()).collect();
+        let expected = Some(format!("via {}", Color::Blue.bold().paint("V v0.2 ")));
+        assert_eq!(expected, actual);
+        dir.close()
+    }
+}