Fix programming languages structure

Author: markcda

src/configs.rs

@@ -23,7 +23,7 @@ use crate::pipelines::DescribedPipeline;
 use crate::utils::{ordered_map, ordered_set};
 use crate::{hmap, hset};
 
-const CURRENT_PROJECT_CONF_VERSION: u8 = 3;
+const CURRENT_PROJECT_CONF_VERSION: u8 = 4;
 fn get_default_project_conf_version() -> u8 {
   CURRENT_PROJECT_CONF_VERSION
 }
@@ -98,7 +98,7 @@ impl Default for DeployerProjectOptions {
   }
 }
 
-const CURRENT_GLOBAL_CONF_VERSION: u8 = 3;
+const CURRENT_GLOBAL_CONF_VERSION: u8 = 4;
 fn get_default_global_conf_version() -> u8 {
   CURRENT_GLOBAL_CONF_VERSION
 }
@@ -164,7 +164,7 @@ impl Default for DeployerGlobalConfig {
         info,
         tags: vec!["rust".into(), "cargo".into()],
         action: Action::Build(BuildAction {
-          supported_langs: vec![ProgrammingLanguage::Rust],
+          supported_langs: vec![ProgrammingLanguage("rust".to_string())],
           commands: vec![CustomCommand {
             bash_c: "cargo build --release".into(),
             placeholders: None,

src/configs/migrate.rs

@@ -53,12 +53,12 @@ fn migrate_custom_v3_to_v4(prev_cmd: &CustomCommandV3) -> CustomCommand {
 
 fn migrate_pls_v3_to_v4(prev_lang: &ProgrammingLanguageV3) -> ProgrammingLanguage {
   match prev_lang {
-    ProgrammingLanguageV3::Rust => ProgrammingLanguage::Rust,
-    ProgrammingLanguageV3::Go => ProgrammingLanguage::Go,
-    ProgrammingLanguageV3::C => ProgrammingLanguage::C,
-    ProgrammingLanguageV3::Cpp => ProgrammingLanguage::Cpp,
-    ProgrammingLanguageV3::Python => ProgrammingLanguage::Python,
-    ProgrammingLanguageV3::Other(v) => ProgrammingLanguage::Other(v.to_owned()),
+    ProgrammingLanguageV3::Rust => ProgrammingLanguage("rust".to_string()),
+    ProgrammingLanguageV3::Go => ProgrammingLanguage("go".to_string()),
+    ProgrammingLanguageV3::C => ProgrammingLanguage("c".to_string()),
+    ProgrammingLanguageV3::Cpp => ProgrammingLanguage("cpp".to_string()),
+    ProgrammingLanguageV3::Python => ProgrammingLanguage("python".to_string()),
+    ProgrammingLanguageV3::Other(v) => ProgrammingLanguage(v.to_string()),
   }
 }
 

src/entities/programming_languages.rs

@@ -7,27 +7,11 @@ use serde::{Deserialize, Serialize};
 /// Canonically represents most well-known by `deployer` author languages,
 /// but you always specify yours.
 #[derive(Deserialize, Serialize, Clone, Debug, PartialEq)]
-#[serde(rename_all = "snake_case", untagged)]
-pub enum ProgrammingLanguage {
-  Rust,
-  Go,
-  C,
-  Cpp,
-  Python,
-  Other(String),
-}
+#[serde(rename_all = "snake_case")]
+pub struct ProgrammingLanguage(pub String);
 
 impl std::fmt::Display for ProgrammingLanguage {
   fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-    let lang = match self {
-      Self::Rust => "Rust".to_string(),
-      Self::Go => "Go".to_string(),
-      Self::C => "C".to_string(),
-      Self::Cpp => "C++".to_string(),
-      Self::Python => "Python".to_string(),
-      Self::Other(s) => s.to_owned(),
-    };
-
-    f.write_str(&lang)
+    f.write_str(&self.0)
   }
 }

src/tui/add.rs

@@ -46,17 +46,18 @@ impl DeployerProjectOptions {
     println!("{}", i18n::PROJECT_SPECIFY_PLS);
     self.langs = specify_programming_languages()?;
     for lang in &self.langs {
-      match lang {
-        ProgrammingLanguage::Rust => self
+      let ProgrammingLanguage(lang) = lang;
+      match lang.as_str() {
+        "rust" => self
           .cache_files
           .extend([PathBuf::from("Cargo.lock"), PathBuf::from("target")].into_iter()),
-        ProgrammingLanguage::Go => self
+        "go" => self
           .cache_files
           .extend([PathBuf::from("go.sum"), PathBuf::from("vendor")].into_iter()),
-        ProgrammingLanguage::Python => self
+        "python" => self
           .cache_files
           .extend([PathBuf::from("__pycache__"), PathBuf::from("dist")].into_iter()),
-        ProgrammingLanguage::C | ProgrammingLanguage::Cpp => self
+        "c" | "cpp" => self
           .cache_files
           .extend([PathBuf::from("CMakeFiles"), PathBuf::from("CMakeCache.txt")].into_iter()),
         _ => {}
@@ -990,12 +991,12 @@ impl ProgrammingLanguage {
   pub fn new_from_prompt() -> anyhow::Result<Self> {
     let s = inquire::Text::new(i18n::PL_INPUT_PROMPT).prompt()?;
     let pl = match s.as_str() {
-      "Rust" => Self::Rust,
-      "Go" => Self::Go,
-      "C" => Self::C,
-      "C++" => Self::Cpp,
-      "Python" => Self::Python,
-      s => Self::Other(s.to_owned()),
+      "Rust" => Self("rust".to_string()),
+      "Go" => Self("go".to_string()),
+      "C" => Self("c".to_string()),
+      "C++" => Self("cpp".to_string()),
+      "Python" => Self("python".to_string()),
+      s => Self(s.to_string()),
     };
     Ok(pl)
   }
@@ -1011,11 +1012,11 @@ pub fn specify_programming_languages() -> anyhow::Result<Vec<ProgrammingLanguage
   let mut result = Vec::new();
   for lang in selected {
     let lang = match lang {
-      "Rust" => ProgrammingLanguage::Rust,
-      "Go" => ProgrammingLanguage::Go,
-      "C" => ProgrammingLanguage::C,
-      "C++" => ProgrammingLanguage::Cpp,
-      "Python" => ProgrammingLanguage::Python,
+      "Rust" => ProgrammingLanguage("rust".to_string()),
+      "Go" => ProgrammingLanguage("go".to_string()),
+      "C" => ProgrammingLanguage("c".to_string()),
+      "C++" => ProgrammingLanguage("cpp".to_string()),
+      "Python" => ProgrammingLanguage("python".to_string()),
       "Others" => {
         let langs = collect_multiple_languages()?;
         result.extend_from_slice(&langs);
@@ -1037,7 +1038,7 @@ fn collect_multiple_languages() -> anyhow::Result<Vec<ProgrammingLanguage>> {
   for lang in langs {
     match lang.as_str() {
       "Rust" | "Go" | "C" | "C++" | "Python" => continue,
-      lang => v.push(ProgrammingLanguage::Other(lang.to_owned())),
+      lang => v.push(ProgrammingLanguage(lang.to_string())),
     }
   }
 

src/tui/setup.rs

@@ -26,9 +26,7 @@ impl DescribedAction {
     let mut action = action.clone();
     if !langs.is_empty()
       && !langs.iter().any(|l| action.supported_langs.contains(l))
-      && !action
-        .supported_langs
-        .contains(&ProgrammingLanguage::Other("any".to_string()))
+      && !action.supported_langs.contains(&ProgrammingLanguage("any".to_string()))
       && !inquire::Confirm::new(
         &i18n::ACTION_COMPAT_PLS
           .replace("{1}", &self.info.to_str())