style: Improve modules consistency (#3006)

* cmake - consistent parse version method names

* crystal - consistent parse version method names

* dart - consistent parse version method names

* deno - consistent parse version method names

* golang - consistent parse version method names

* helm - consistent parse version method names

* implement get_command_string_output, java - consistent parse version method names & small refactor

* julia - consistent parse version method names

* kotlin - consistent parse version method names and refactor

* lua - consistent parse version method names and refactor

* implement get_command_string_output for scala

* format crystal module

* remove outdated comment

* node use format_module_version

* terraform - consistent parse version method names

* vagrant - consistent parse version method names

* format

* refactor python module

* improve rlang module consistency

* fix clippy warning
This commit is contained in:
filip 2021-08-25 17:41:10 +02:00 committed by GitHub
parent 779def1362
commit 1c9758f08b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
18 changed files with 160 additions and 213 deletions

8
Cargo.lock generated
View File

@ -781,9 +781,9 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
[[package]] [[package]]
name = "libc" name = "libc"
version = "0.2.99" version = "0.2.100"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a7f823d141fe0a24df1e23b4af4e3c7ba9e5966ec514ea068c93024aa7deb765" checksum = "a1fa8cddc8fbbee11227ef194b5317ed014b8acbf15139bd716a18ad3fe99ec5"
[[package]] [[package]]
name = "libgit2-sys" name = "libgit2-sys"
@ -1280,9 +1280,9 @@ checksum = "57e35a3326b75e49aa85f5dc6ec15b41108cf5aee58eabb1f274dd18b73c2451"
[[package]] [[package]]
name = "predicates-tree" name = "predicates-tree"
version = "1.0.2" version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "15f553275e5721409451eb85e15fd9a860a6e5ab4496eb215987502b5f5391f2" checksum = "d7dd0fd014130206c9352efbdc92be592751b2b9274dff685348341082c6ea3d"
dependencies = [ dependencies = [
"predicates-core", "predicates-core",
"treeline", "treeline",

View File

@ -33,7 +33,7 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
.map(|variable| match variable { .map(|variable| match variable {
"version" => { "version" => {
let cmake_version = let cmake_version =
get_cmake_version(&context.exec_cmd("cmake", &["--version"])?.stdout)?; parse_cmake_version(&context.exec_cmd("cmake", &["--version"])?.stdout)?;
VersionFormatter::format_module_version( VersionFormatter::format_module_version(
module.get_name(), module.get_name(),
&cmake_version, &cmake_version,
@ -57,7 +57,7 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
Some(module) Some(module)
} }
fn get_cmake_version(cmake_version: &str) -> Option<String> { fn parse_cmake_version(cmake_version: &str) -> Option<String> {
Some( Some(
cmake_version cmake_version
//split into ["cmake" "version" "3.10.2", ...] //split into ["cmake" "version" "3.10.2", ...]

View File

@ -32,8 +32,9 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
}) })
.map(|variable| match variable { .map(|variable| match variable {
"version" => { "version" => {
let crystal_version = let crystal_version = parse_crystal_version(
get_crystal_version(&context.exec_cmd("crystal", &["--version"])?.stdout)?; &context.exec_cmd("crystal", &["--version"])?.stdout,
)?;
VersionFormatter::format_module_version( VersionFormatter::format_module_version(
module.get_name(), module.get_name(),
&crystal_version, &crystal_version,
@ -57,7 +58,7 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
Some(module) Some(module)
} }
fn get_crystal_version(crystal_version: &str) -> Option<String> { fn parse_crystal_version(crystal_version: &str) -> Option<String> {
Some( Some(
crystal_version crystal_version
// split into ["Crystal", "0.35.1", ...] // split into ["Crystal", "0.35.1", ...]

View File

@ -33,7 +33,7 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
.map(|variable| match variable { .map(|variable| match variable {
"version" => { "version" => {
let dart_version = let dart_version =
get_dart_version(&context.exec_cmd("dart", &["--version"])?.stderr)?; parse_dart_version(&context.exec_cmd("dart", &["--version"])?.stderr)?;
VersionFormatter::format_module_version( VersionFormatter::format_module_version(
module.get_name(), module.get_name(),
&dart_version, &dart_version,
@ -57,7 +57,7 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
Some(module) Some(module)
} }
fn get_dart_version(dart_version: &str) -> Option<String> { fn parse_dart_version(dart_version: &str) -> Option<String> {
Some( Some(
dart_version dart_version
// split into ["Dart", "VM", "version:", "2.8.4", "(stable)", ...] // split into ["Dart", "VM", "version:", "2.8.4", "(stable)", ...]

View File

@ -32,7 +32,7 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
.map(|variable| match variable { .map(|variable| match variable {
"version" => { "version" => {
let deno_version = let deno_version =
get_deno_version(&context.exec_cmd("deno", &["-V"])?.stdout)?; parse_deno_version(&context.exec_cmd("deno", &["-V"])?.stdout)?;
VersionFormatter::format_module_version( VersionFormatter::format_module_version(
module.get_name(), module.get_name(),
&deno_version, &deno_version,
@ -56,7 +56,7 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
Some(module) Some(module)
} }
fn get_deno_version(deno_version: &str) -> Option<String> { fn parse_deno_version(deno_version: &str) -> Option<String> {
Some( Some(
deno_version deno_version
// split into ["deno", "1.8.3"] // split into ["deno", "1.8.3"]

View File

@ -32,7 +32,7 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
.map(|variable| match variable { .map(|variable| match variable {
"version" => { "version" => {
let golang_version = let golang_version =
get_go_version(&context.exec_cmd("go", &["version"])?.stdout)?; parse_go_version(&context.exec_cmd("go", &["version"])?.stdout)?;
VersionFormatter::format_module_version( VersionFormatter::format_module_version(
module.get_name(), module.get_name(),
@ -57,7 +57,7 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
Some(module) Some(module)
} }
fn get_go_version(go_stdout: &str) -> Option<String> { fn parse_go_version(go_stdout: &str) -> Option<String> {
// go version output looks like this: // go version output looks like this:
// go version go1.13.3 linux/amd64 // go version go1.13.3 linux/amd64
@ -189,6 +189,6 @@ mod tests {
#[test] #[test]
fn test_format_go_version() { fn test_format_go_version() {
let input = "go version go1.12 darwin/amd64"; let input = "go version go1.12 darwin/amd64";
assert_eq!(get_go_version(input), Some("1.12".to_string())); assert_eq!(parse_go_version(input), Some("1.12".to_string()));
} }
} }

View File

@ -32,7 +32,7 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
}) })
.map(|variable| match variable { .map(|variable| match variable {
"version" => { "version" => {
let helm_version = get_helm_version( let helm_version = parse_helm_version(
&context &context
.exec_cmd("helm", &["version", "--short", "--client"])? .exec_cmd("helm", &["version", "--short", "--client"])?
.stdout, .stdout,
@ -60,7 +60,7 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
Some(module) Some(module)
} }
fn get_helm_version(helm_stdout: &str) -> Option<String> { fn parse_helm_version(helm_stdout: &str) -> Option<String> {
// `helm version --short --client` output looks like this: // `helm version --short --client` output looks like this:
// v3.1.1+gafe7058 // v3.1.1+gafe7058
// `helm version --short --client` output looks like this for Helm 2: // `helm version --short --client` output looks like this for Helm 2:
@ -123,10 +123,10 @@ mod tests {
} }
#[test] #[test]
fn test_get_helm_version() { fn test_parse_helm_version() {
let helm_2 = "Client: v2.16.9+g8ad7037"; let helm_2 = "Client: v2.16.9+g8ad7037";
let helm_3 = "v3.1.1+ggit afe7058"; let helm_3 = "v3.1.1+ggit afe7058";
assert_eq!(get_helm_version(helm_2), Some("2.16.9".to_string())); assert_eq!(parse_helm_version(helm_2), Some("2.16.9".to_string()));
assert_eq!(get_helm_version(helm_3), Some("3.1.1".to_string())); assert_eq!(parse_helm_version(helm_3), Some("3.1.1".to_string()));
} }
} }

View File

@ -1,10 +1,9 @@
use super::{Context, Module, RootModuleConfig};
use crate::configs::java::JavaConfig; use crate::configs::java::JavaConfig;
use crate::formatter::{StringFormatter, VersionFormatter}; use crate::formatter::{StringFormatter, VersionFormatter};
use crate::utils::get_command_string_output; use crate::utils::get_command_string_output;
use std::path::PathBuf; use std::path::PathBuf;
use super::{Context, Module, RootModuleConfig};
use regex::Regex; use regex::Regex;
const JAVA_VERSION_PATTERN: &str = "(?P<version>[\\d\\.]+)[^\\s]*\\s(?:built|from)"; const JAVA_VERSION_PATTERN: &str = "(?P<version>[\\d\\.]+)[^\\s]*\\s(?:built|from)";
@ -35,7 +34,15 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
_ => None, _ => None,
}) })
.map(|variable| match variable { .map(|variable| match variable {
"version" => get_java_version(context, &config).map(Ok), "version" => {
let java_version = get_java_version(context)?;
VersionFormatter::format_module_version(
module.get_name(),
&java_version,
config.version_format,
)
.map(Ok)
}
_ => None, _ => None,
}) })
.parse(None) .parse(None)
@ -52,7 +59,7 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
Some(module) Some(module)
} }
fn get_java_version(context: &Context, config: &JavaConfig) -> Option<String> { fn get_java_version(context: &Context) -> Option<String> {
let java_command = context let java_command = context
.get_env("JAVA_HOME") .get_env("JAVA_HOME")
.map(PathBuf::from) .map(PathBuf::from)
@ -65,24 +72,18 @@ fn get_java_version(context: &Context, config: &JavaConfig) -> Option<String> {
}) })
.unwrap_or_else(|| String::from("java")); .unwrap_or_else(|| String::from("java"));
let command = context.exec_cmd(&java_command, &["-Xinternalversion"])?; let output = context.exec_cmd(&java_command, &["-Xinternalversion"])?;
let java_version = get_command_string_output(command); let java_version_string = get_command_string_output(output);
format_java_version(&java_version, config.version_format) parse_java_version(&java_version_string)
} }
fn format_java_version(java_version: &str, version_format: &str) -> Option<String> { fn parse_java_version(java_version_string: &str) -> Option<String> {
let re = Regex::new(JAVA_VERSION_PATTERN).ok()?; let re = Regex::new(JAVA_VERSION_PATTERN).ok()?;
let captures = re.captures(java_version)?; let captures = re.captures(java_version_string)?;
let version = &captures["version"]; let version = &captures["version"];
match VersionFormatter::format_version(version, version_format) { Some(version.to_string())
Ok(formatted) => Some(formatted),
Err(error) => {
log::warn!("Error formatting `java` version:\n{}", error);
Some(format!("v{}", version))
}
}
} }
#[cfg(test)] #[cfg(test)]
@ -94,106 +95,67 @@ mod tests {
use std::io; use std::io;
#[test] #[test]
fn test_format_java_version_openjdk() { fn test_parse_java_version_openjdk() {
let java_8 = "OpenJDK 64-Bit Server VM (25.222-b10) for linux-amd64 JRE (1.8.0_222-b10), built on Jul 11 2019 10:18:43 by \"openjdk\" with gcc 4.4.7 20120313 (Red Hat 4.4.7-23)"; let java_8 = "OpenJDK 64-Bit Server VM (25.222-b10) for linux-amd64 JRE (1.8.0_222-b10), built on Jul 11 2019 10:18:43 by \"openjdk\" with gcc 4.4.7 20120313 (Red Hat 4.4.7-23)";
let java_11 = "OpenJDK 64-Bit Server VM (11.0.4+11-post-Ubuntu-1ubuntu219.04) for linux-amd64 JRE (11.0.4+11-post-Ubuntu-1ubuntu219.04), built on Jul 18 2019 18:21:46 by \"build\" with gcc 8.3.0"; let java_11 = "OpenJDK 64-Bit Server VM (11.0.4+11-post-Ubuntu-1ubuntu219.04) for linux-amd64 JRE (11.0.4+11-post-Ubuntu-1ubuntu219.04), built on Jul 18 2019 18:21:46 by \"build\" with gcc 8.3.0";
assert_eq!( assert_eq!(parse_java_version(java_8), Some("1.8.0".to_string()));
format_java_version(java_11, "v${raw}"), assert_eq!(parse_java_version(java_11), Some("11.0.4".to_string()));
Some("v11.0.4".to_string())
);
assert_eq!(
format_java_version(java_8, "v${raw}"),
Some("v1.8.0".to_string())
);
} }
#[test] #[test]
fn test_format_java_version_oracle() { fn test_parse_java_version_oracle() {
let java_8 = "Java HotSpot(TM) Client VM (25.65-b01) for linux-arm-vfp-hflt JRE (1.8.0_65-b17), built on Oct 6 2015 16:19:04 by \"java_re\" with gcc 4.7.2 20120910 (prerelease)"; let java_8 = "Java HotSpot(TM) Client VM (25.65-b01) for linux-arm-vfp-hflt JRE (1.8.0_65-b17), built on Oct 6 2015 16:19:04 by \"java_re\" with gcc 4.7.2 20120910 (prerelease)";
assert_eq!( assert_eq!(parse_java_version(java_8), Some("1.8.0".to_string()));
format_java_version(java_8, "v${raw}"),
Some("v1.8.0".to_string())
);
} }
#[test] #[test]
fn test_format_java_version_redhat() { fn test_parse_java_version_redhat() {
let java_8 = "OpenJDK 64-Bit Server VM (25.222-b10) for linux-amd64 JRE (1.8.0_222-b10), built on Jul 11 2019 20:48:53 by \"root\" with gcc 7.3.1 20180303 (Red Hat 7.3.1-5)"; let java_8 = "OpenJDK 64-Bit Server VM (25.222-b10) for linux-amd64 JRE (1.8.0_222-b10), built on Jul 11 2019 20:48:53 by \"root\" with gcc 7.3.1 20180303 (Red Hat 7.3.1-5)";
let java_12 = "OpenJDK 64-Bit Server VM (12.0.2+10) for linux-amd64 JRE (12.0.2+10), built on Jul 18 2019 14:41:47 by \"jenkins\" with gcc 7.3.1 20180303 (Red Hat 7.3.1-5)"; let java_12 = "OpenJDK 64-Bit Server VM (12.0.2+10) for linux-amd64 JRE (12.0.2+10), built on Jul 18 2019 14:41:47 by \"jenkins\" with gcc 7.3.1 20180303 (Red Hat 7.3.1-5)";
assert_eq!( assert_eq!(parse_java_version(java_8), Some("1.8.0".to_string()));
format_java_version(java_8, "v${raw}"), assert_eq!(parse_java_version(java_12), Some("12.0.2".to_string()));
Some("v1.8.0".to_string())
);
assert_eq!(
format_java_version(java_12, "v${raw}"),
Some("v12.0.2".to_string())
);
} }
#[test] #[test]
fn test_format_java_version_zulu() { fn test_parse_java_version_zulu() {
let java_8 = "OpenJDK 64-Bit Server VM (25.222-b10) for linux-amd64 JRE (Zulu 8.40.0.25-CA-linux64) (1.8.0_222-b10), built on Jul 11 2019 11:36:39 by \"zulu_re\" with gcc 4.4.7 20120313 (Red Hat 4.4.7-3)"; let java_8 = "OpenJDK 64-Bit Server VM (25.222-b10) for linux-amd64 JRE (Zulu 8.40.0.25-CA-linux64) (1.8.0_222-b10), built on Jul 11 2019 11:36:39 by \"zulu_re\" with gcc 4.4.7 20120313 (Red Hat 4.4.7-3)";
let java_11 = "OpenJDK 64-Bit Server VM (11.0.4+11-LTS) for linux-amd64 JRE (Zulu11.33+15-CA) (11.0.4+11-LTS), built on Jul 11 2019 21:37:17 by \"zulu_re\" with gcc 4.9.2 20150212 (Red Hat 4.9.2-6)"; let java_11 = "OpenJDK 64-Bit Server VM (11.0.4+11-LTS) for linux-amd64 JRE (Zulu11.33+15-CA) (11.0.4+11-LTS), built on Jul 11 2019 21:37:17 by \"zulu_re\" with gcc 4.9.2 20150212 (Red Hat 4.9.2-6)";
assert_eq!( assert_eq!(parse_java_version(java_8), Some("1.8.0".to_string()));
format_java_version(java_8, "v${raw}"), assert_eq!(parse_java_version(java_11), Some("11.0.4".to_string()));
Some("v1.8.0".to_string())
);
assert_eq!(
format_java_version(java_11, "v${raw}"),
Some("v11.0.4".to_string())
);
} }
#[test] #[test]
fn test_format_java_version_eclipse_openj9() { fn test_parse_java_version_eclipse_openj9() {
let java_8 = "Eclipse OpenJ9 OpenJDK 64-bit Server VM (1.8.0_222-b10) from linux-amd64 JRE with Extensions for OpenJDK for Eclipse OpenJ9 8.0.222.0, built on Jul 17 2019 21:29:18 by jenkins with g++ (GCC) 7.3.1 20180303 (Red Hat 7.3.1-5)"; let java_8 = "Eclipse OpenJ9 OpenJDK 64-bit Server VM (1.8.0_222-b10) from linux-amd64 JRE with Extensions for OpenJDK for Eclipse OpenJ9 8.0.222.0, built on Jul 17 2019 21:29:18 by jenkins with g++ (GCC) 7.3.1 20180303 (Red Hat 7.3.1-5)";
let java_11 = "Eclipse OpenJ9 OpenJDK 64-bit Server VM (11.0.4+11) from linux-amd64 JRE with Extensions for OpenJDK for Eclipse OpenJ9 11.0.4.0, built on Jul 17 2019 21:51:37 by jenkins with g++ (GCC) 7.3.1 20180303 (Red Hat 7.3.1-5)"; let java_11 = "Eclipse OpenJ9 OpenJDK 64-bit Server VM (11.0.4+11) from linux-amd64 JRE with Extensions for OpenJDK for Eclipse OpenJ9 11.0.4.0, built on Jul 17 2019 21:51:37 by jenkins with g++ (GCC) 7.3.1 20180303 (Red Hat 7.3.1-5)";
assert_eq!( assert_eq!(parse_java_version(java_8), Some("1.8.0".to_string()));
format_java_version(java_8, "v${raw}"), assert_eq!(parse_java_version(java_11), Some("11.0.4".to_string()));
Some("v1.8.0".to_string())
);
assert_eq!(
format_java_version(java_11, "v${raw}"),
Some("v11.0.4".to_string())
);
} }
#[test] #[test]
fn test_format_java_version_graalvm() { fn test_parse_java_version_graalvm() {
let java_8 = "OpenJDK 64-Bit GraalVM CE 19.2.0.1 (25.222-b08-jvmci-19.2-b02) for linux-amd64 JRE (8u222), built on Jul 19 2019 17:37:13 by \"buildslave\" with gcc 7.3.0"; let java_8 = "OpenJDK 64-Bit GraalVM CE 19.2.0.1 (25.222-b08-jvmci-19.2-b02) for linux-amd64 JRE (8u222), built on Jul 19 2019 17:37:13 by \"buildslave\" with gcc 7.3.0";
assert_eq!( assert_eq!(parse_java_version(java_8), Some("8".to_string()));
format_java_version(java_8, "v${raw}"),
Some("v8".to_string())
);
} }
#[test] #[test]
fn test_format_java_version_amazon_corretto() { fn test_parse_java_version_amazon_corretto() {
let java_8 = "OpenJDK 64-Bit Server VM (25.222-b10) for linux-amd64 JRE (1.8.0_222-b10), built on Jul 11 2019 20:48:53 by \"root\" with gcc 7.3.1 20180303 (Red Hat 7.3.1-5)"; let java_8 = "OpenJDK 64-Bit Server VM (25.222-b10) for linux-amd64 JRE (1.8.0_222-b10), built on Jul 11 2019 20:48:53 by \"root\" with gcc 7.3.1 20180303 (Red Hat 7.3.1-5)";
let java_11 = "OpenJDK 64-Bit Server VM (11.0.4+11-LTS) for linux-amd64 JRE (11.0.4+11-LTS), built on Jul 11 2019 20:06:11 by \"\" with gcc 7.3.1 20180303 (Red Hat 7.3.1-5)"; let java_11 = "OpenJDK 64-Bit Server VM (11.0.4+11-LTS) for linux-amd64 JRE (11.0.4+11-LTS), built on Jul 11 2019 20:06:11 by \"\" with gcc 7.3.1 20180303 (Red Hat 7.3.1-5)";
assert_eq!( assert_eq!(parse_java_version(java_8), Some("1.8.0".to_string()));
format_java_version(java_8, "v${raw}"), assert_eq!(parse_java_version(java_11), Some("11.0.4".to_string()));
Some("v1.8.0".to_string())
);
assert_eq!(
format_java_version(java_11, "v${raw}"),
Some("v11.0.4".to_string())
);
} }
#[test] #[test]
fn test_format_java_version_sapmachine() { fn test_parse_java_version_sapmachine() {
let java_11 = "OpenJDK 64-Bit Server VM (11.0.4+11-LTS-sapmachine) for linux-amd64 JRE (11.0.4+11-LTS-sapmachine), built on Jul 17 2019 08:58:43 by \"\" with gcc 7.3.0"; let java_11 = "OpenJDK 64-Bit Server VM (11.0.4+11-LTS-sapmachine) for linux-amd64 JRE (11.0.4+11-LTS-sapmachine), built on Jul 17 2019 08:58:43 by \"\" with gcc 7.3.0";
assert_eq!( assert_eq!(parse_java_version(java_11), Some("11.0.4".to_string()));
format_java_version(java_11, "v${raw}"),
Some("v11.0.4".to_string())
);
} }
#[test] #[test]
fn test_format_java_version_unknown() { fn test_parse_java_version_unknown() {
let unknown_jre = "Unknown JRE"; let unknown_jre = "Unknown JRE";
assert_eq!(format_java_version(unknown_jre, "v${raw}"), None); assert_eq!(parse_java_version(unknown_jre), None);
} }
#[test] #[test]

View File

@ -33,7 +33,7 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
.map(|variable| match variable { .map(|variable| match variable {
"version" => { "version" => {
let julia_version = let julia_version =
get_julia_version(&context.exec_cmd("julia", &["--version"])?.stdout)?; parse_julia_version(&context.exec_cmd("julia", &["--version"])?.stdout)?;
VersionFormatter::format_module_version( VersionFormatter::format_module_version(
module.get_name(), module.get_name(),
&julia_version, &julia_version,
@ -57,7 +57,7 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
Some(module) Some(module)
} }
fn get_julia_version(julia_stdout: &str) -> Option<String> { fn parse_julia_version(julia_stdout: &str) -> Option<String> {
// julia version output looks like this: // julia version output looks like this:
// julia version 1.4.0 // julia version 1.4.0
@ -128,8 +128,8 @@ mod tests {
} }
#[test] #[test]
fn test_get_julia_version() { fn test_parse_julia_version() {
let input = "julia version 1.4.0"; let input = "julia version 1.4.0";
assert_eq!(get_julia_version(input), Some("1.4.0".to_string())); assert_eq!(parse_julia_version(input), Some("1.4.0".to_string()));
} }
} }

View File

@ -62,9 +62,9 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
fn get_kotlin_version(context: &Context, kotlin_binary: &str) -> Option<String> { fn get_kotlin_version(context: &Context, kotlin_binary: &str) -> Option<String> {
let command = context.exec_cmd(kotlin_binary, &["-version"])?; let command = context.exec_cmd(kotlin_binary, &["-version"])?;
let kotlin_version = get_command_string_output(command); let kotlin_version_string = get_command_string_output(command);
parse_kotlin_version(&kotlin_version) parse_kotlin_version(&kotlin_version_string)
} }
fn parse_kotlin_version(kotlin_stdout: &str) -> Option<String> { fn parse_kotlin_version(kotlin_stdout: &str) -> Option<String> {

View File

@ -33,7 +33,9 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
}) })
.map(|variable| match variable { .map(|variable| match variable {
"version" => { "version" => {
let lua_version = get_lua_version(context, config.lua_binary)?; let lua_version_string =
get_command_string_output(context.exec_cmd(config.lua_binary, &["-v"])?);
let lua_version = parse_lua_version(&lua_version_string)?;
VersionFormatter::format_module_version( VersionFormatter::format_module_version(
module.get_name(), module.get_name(),
&lua_version, &lua_version,
@ -57,13 +59,6 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
Some(module) Some(module)
} }
fn get_lua_version(context: &Context, lua_binary: &str) -> Option<String> {
let command = context.exec_cmd(lua_binary, &["-v"])?;
let lua_version = get_command_string_output(command);
parse_lua_version(&lua_version)
}
fn parse_lua_version(lua_version: &str) -> Option<String> { fn parse_lua_version(lua_version: &str) -> Option<String> {
// lua -v output looks like this: // lua -v output looks like this:
// Lua 5.4.0 Copyright (C) 1994-2020 Lua.org, PUC-Rio // Lua 5.4.0 Copyright (C) 1994-2020 Lua.org, PUC-Rio

View File

@ -57,10 +57,20 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
_ => None, _ => None,
}) })
.map(|variable| match variable { .map(|variable| match variable {
"version" => Some(Ok(format_node_version( "version" => {
nodejs_version.deref().as_ref()?, let version = nodejs_version
.deref()
.as_ref()?
.trim_start_matches('v')
.trim();
VersionFormatter::format_module_version(
module.get_name(),
version,
config.version_format, config.version_format,
))), )
.map(Ok)
}
_ => None, _ => None,
}) })
.parse(None) .parse(None)
@ -106,18 +116,6 @@ fn check_engines_version(nodejs_version: &str, engines_version: Option<String>)
r.matches(&v) r.matches(&v)
} }
fn format_node_version(node_version: &str, version_format: &str) -> String {
let version = node_version.trim_start_matches('v').trim();
match VersionFormatter::format_version(version, version_format) {
Ok(formatted) => formatted,
Err(error) => {
log::warn!("Error formatting `node` version:\n{}", error);
format!("v{}", version)
}
}
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use crate::test::ModuleRenderer; use crate::test::ModuleRenderer;

View File

@ -10,8 +10,6 @@ use regex::Regex;
use serde_json as json; use serde_json as json;
/// Creates a module with the current package version /// Creates a module with the current package version
///
/// Will display if a version is defined for your Node.js or Rust project (if one exists)
pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> { pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
let mut module = context.new_module("package"); let mut module = context.new_module("package");
let config: PackageConfig = PackageConfig::try_load(module.config); let config: PackageConfig = PackageConfig::try_load(module.config);

View File

@ -42,7 +42,18 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
_ => None, _ => None,
}) })
.map(|variable| match variable { .map(|variable| match variable {
"version" => get_python_version(context, &config).map(Ok), "version" => {
if config.pyenv_version_name {
return get_pyenv_version(context).map(Ok);
}
let python_version = get_python_version(context, &config)?;
VersionFormatter::format_module_version(
module.get_name(),
&python_version,
config.version_format,
)
.map(Ok)
}
"virtualenv" => { "virtualenv" => {
let virtual_env = get_python_virtual_env(context); let virtual_env = get_python_virtual_env(context);
virtual_env.as_ref().map(|e| Ok(e.trim().to_string())) virtual_env.as_ref().map(|e| Ok(e.trim().to_string()))
@ -64,11 +75,16 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
Some(module) Some(module)
} }
fn get_pyenv_version(context: &Context) -> Option<String> {
let version_name = context
.exec_cmd("pyenv", &["version-name"])?
.stdout
.trim()
.to_string();
Some(version_name)
}
fn get_python_version(context: &Context, config: &PythonConfig) -> Option<String> { fn get_python_version(context: &Context, config: &PythonConfig) -> Option<String> {
if config.pyenv_version_name {
let version_name = context.exec_cmd("pyenv", &["version-name"])?.stdout;
return Some(version_name.trim().to_string());
};
let version = config let version = config
.python_binary .python_binary
.0 .0
@ -76,23 +92,17 @@ fn get_python_version(context: &Context, config: &PythonConfig) -> Option<String
.find_map(|binary| context.exec_cmd(binary, &["--version"])) .find_map(|binary| context.exec_cmd(binary, &["--version"]))
.map(get_command_string_output)?; .map(get_command_string_output)?;
format_python_version(&version, config.version_format) parse_python_version(&version)
} }
fn format_python_version(python_version: &str, version_format: &str) -> Option<String> { fn parse_python_version(python_version_string: &str) -> Option<String> {
let version = python_version let version = python_version_string
// split into ["Python", "3.8.6", ...] // split into ["Python", "3.8.6", ...]
.split_whitespace() .split_whitespace()
// get down to "3.8.6" // get down to "3.8.6"
.nth(1)?; .nth(1)?;
match VersionFormatter::format_version(version, version_format) { Some(version.to_string())
Ok(formatted) => Some(formatted),
Err(error) => {
log::warn!("Error formatting `python` version:\n{}", error);
Some(format!("v{}", version))
}
}
} }
fn get_python_virtual_env(context: &Context) -> Option<String> { fn get_python_virtual_env(context: &Context) -> Option<String> {
@ -122,50 +132,35 @@ mod tests {
use std::io::Write; use std::io::Write;
#[test] #[test]
fn test_format_python_version() { fn test_parse_python_version() {
assert_eq!( assert_eq!(
format_python_version("Python 3.7.2", "v${major}.${minor}.${patch}"), parse_python_version("Python 3.7.2"),
Some("v3.7.2".to_string()) Some("3.7.2".to_string())
); );
} }
#[test] #[test]
fn test_format_python_version_truncated() { fn test_parse_python_version_is_malformed() {
assert_eq!(parse_python_version("Python 3.7"), Some("3.7".to_string()));
}
#[test]
fn test_parse_python_version_anaconda() {
assert_eq!( assert_eq!(
format_python_version("Python 3.7.2", "v${major}.${minor}"), parse_python_version("Python 3.6.10 :: Anaconda, Inc.",),
Some("v3.7".to_string()) Some("3.6.10".to_string())
); );
} }
#[test] #[test]
fn test_format_python_version_is_malformed() { fn test_parse_python_version_pypy() {
assert_eq!( assert_eq!(
format_python_version("Python 3.7", "v${major}.${minor}.${patch}"), parse_python_version(
Some("v3.7.".to_string())
);
}
#[test]
fn test_format_python_version_anaconda() {
assert_eq!(
format_python_version(
"Python 3.6.10 :: Anaconda, Inc.",
"v${major}.${minor}.${patch}"
),
Some("v3.6.10".to_string())
);
}
#[test]
fn test_format_python_version_pypy() {
assert_eq!(
format_python_version(
"\ "\
Python 3.7.9 (7e6e2bb30ac5fbdbd443619cae28c51d5c162a02, Nov 24 2020, 10:03:59) Python 3.7.9 (7e6e2bb30ac5fbdbd443619cae28c51d5c162a02, Nov 24 2020, 10:03:59)
[PyPy 7.3.3-beta0 with GCC 10.2.0]", [PyPy 7.3.3-beta0 with GCC 10.2.0]",
"v${major}.${minor}.${patch}"
), ),
Some("v3.7.9".to_string()) Some("3.7.9".to_string())
); );
} }

View File

@ -31,7 +31,9 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
}) })
.map(|variable| match variable { .map(|variable| match variable {
"version" => { "version" => {
let r_version = get_r_version(context)?; let r_version_string =
get_command_string_output(context.exec_cmd("R", &["--version"])?);
let r_version = parse_r_version(&r_version_string)?;
VersionFormatter::format_module_version( VersionFormatter::format_module_version(
module.get_name(), module.get_name(),
&r_version, &r_version,
@ -55,12 +57,7 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
Some(module) Some(module)
} }
fn get_r_version(context: &Context) -> Option<String> { fn parse_r_version(r_version: &str) -> Option<String> {
let r_version = get_command_string_output(context.exec_cmd("R", &["--version"])?);
parse_version(&r_version)
}
fn parse_version(r_version: &str) -> Option<String> {
r_version r_version
.lines() .lines()
// take first line // take first line
@ -74,7 +71,7 @@ fn parse_version(r_version: &str) -> Option<String> {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::parse_version; use super::parse_r_version;
use crate::test::ModuleRenderer; use crate::test::ModuleRenderer;
use ansi_term::Color; use ansi_term::Color;
use std::fs; use std::fs;
@ -92,7 +89,7 @@ You are welcome to redistribute it under the terms of the
GNU General Public License versions 2 or 3. GNU General Public License versions 2 or 3.
For more information about these matters see For more information about these matters see
https://www.gnu.org/licenses/."#; https://www.gnu.org/licenses/."#;
assert_eq!(parse_version(r_v3), Some(String::from("4.1.0"))); assert_eq!(parse_r_version(r_v3), Some(String::from("4.1.0")));
} }
#[test] #[test]

View File

@ -58,12 +58,13 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
fn get_scala_version(context: &Context) -> Option<String> { fn get_scala_version(context: &Context) -> Option<String> {
let command = context.exec_cmd("scalac", &["-version"])?; let command = context.exec_cmd("scalac", &["-version"])?;
let scala_version = get_command_string_output(command); let scala_version_string = get_command_string_output(command);
parse_scala_version(&scala_version)
parse_scala_version(&scala_version_string)
} }
fn parse_scala_version(scala_version: &str) -> Option<String> { fn parse_scala_version(scala_version_string: &str) -> Option<String> {
let version = scala_version let version = scala_version_string
// split into ["Scala", "compiler", "version", "2.13.5", "--", ...] // split into ["Scala", "compiler", "version", "2.13.5", "--", ...]
.split_whitespace() .split_whitespace()
// take "2.13.5" // take "2.13.5"

View File

@ -36,7 +36,7 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
}) })
.map(|variable| match variable { .map(|variable| match variable {
"version" => { "version" => {
let terraform_version = get_terraform_version( let terraform_version = parse_terraform_version(
context.exec_cmd("terraform", &["version"])?.stdout.as_str(), context.exec_cmd("terraform", &["version"])?.stdout.as_str(),
)?; )?;
VersionFormatter::format_module_version( VersionFormatter::format_module_version(
@ -83,19 +83,18 @@ fn get_terraform_workspace(context: &Context) -> Option<String> {
} }
} }
fn get_terraform_version(version: &str) -> Option<String> { fn parse_terraform_version(version: &str) -> Option<String> {
// `terraform version` output looks like this // `terraform version` output looks like this
// Terraform v0.12.14 // Terraform v0.12.14
// With potential extra output if it detects you are not running the latest version // With potential extra output if it detects you are not running the latest version
Some( let version = version
version
.lines() .lines()
.next()? .next()?
.trim_start_matches("Terraform ") .trim_start_matches("Terraform ")
.trim() .trim()
.trim_start_matches('v') .trim_start_matches('v');
.to_owned(),
) Some(version.to_string())
} }
#[cfg(test)] #[cfg(test)]
@ -107,38 +106,38 @@ mod tests {
use std::io::{self, Write}; use std::io::{self, Write};
#[test] #[test]
fn test_get_terraform_version_release() { fn test_parse_terraform_version_release() {
let input = "Terraform v0.12.14"; let input = "Terraform v0.12.14";
assert_eq!(get_terraform_version(input), Some("0.12.14".to_string())); assert_eq!(parse_terraform_version(input), Some("0.12.14".to_string()));
} }
#[test] #[test]
fn test_get_terraform_version_prerelease() { fn test_parse_terraform_version_prerelease() {
let input = "Terraform v0.12.14-rc1"; let input = "Terraform v0.12.14-rc1";
assert_eq!( assert_eq!(
get_terraform_version(input), parse_terraform_version(input),
Some("0.12.14-rc1".to_string()) Some("0.12.14-rc1".to_string())
); );
} }
#[test] #[test]
fn test_get_terraform_version_development() { fn test_parse_terraform_version_development() {
let input = "Terraform v0.12.14-dev (cca89f74)"; let input = "Terraform v0.12.14-dev (cca89f74)";
assert_eq!( assert_eq!(
get_terraform_version(input), parse_terraform_version(input),
Some("0.12.14-dev (cca89f74)".to_string()) Some("0.12.14-dev (cca89f74)".to_string())
); );
} }
#[test] #[test]
fn test_get_terraform_version_multiline() { fn test_parse_terraform_version_multiline() {
let input = "Terraform v0.12.13 let input = "Terraform v0.12.13
Your version of Terraform is out of date! The latest version Your version of Terraform is out of date! The latest version
is 0.12.14. You can update by downloading from www.terraform.io/downloads.html is 0.12.14. You can update by downloading from www.terraform.io/downloads.html
"; ";
assert_eq!(get_terraform_version(input), Some("0.12.13".to_string())); assert_eq!(parse_terraform_version(input), Some("0.12.13".to_string()));
} }
#[test] #[test]

View File

@ -32,8 +32,9 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
}) })
.map(|variable| match variable { .map(|variable| match variable {
"version" => { "version" => {
let vagrant_version = let vagrant_version = parse_vagrant_version(
get_vagrant_version(&context.exec_cmd("vagrant", &["--version"])?.stdout)?; &context.exec_cmd("vagrant", &["--version"])?.stdout,
)?;
VersionFormatter::format_module_version( VersionFormatter::format_module_version(
module.get_name(), module.get_name(),
&vagrant_version, &vagrant_version,
@ -57,7 +58,7 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
Some(module) Some(module)
} }
fn get_vagrant_version(vagrant_stdout: &str) -> Option<String> { fn parse_vagrant_version(vagrant_stdout: &str) -> Option<String> {
// `vagrant --version` output looks like this: // `vagrant --version` output looks like this:
// Vagrant 2.2.10 // Vagrant 2.2.10
let version = vagrant_stdout let version = vagrant_stdout
@ -101,8 +102,8 @@ mod tests {
} }
#[test] #[test]
fn test_get_vagrant_version() { fn test_parse_vagrant_version() {
let vagrant = "Vagrant 2.2.10\n"; let vagrant = "Vagrant 2.2.10\n";
assert_eq!(get_vagrant_version(vagrant), Some("2.2.10".to_string())); assert_eq!(parse_vagrant_version(vagrant), Some("2.2.10".to_string()));
} }
} }