find all esp-idf instances and evaluate which one to process

Author: Hahihula

src-tauri/src/cli/mod.rs

@@ -8,6 +8,7 @@ use config::ConfigError;
 use helpers::generic_input;
 use helpers::generic_select;
 use idf_im_lib::get_log_directory;
+use idf_im_lib::idf_config::IdfConfig;
 use idf_im_lib::settings::Settings;
 use idf_im_lib::version_manager::remove_single_idf_version;
 use idf_im_lib::version_manager::select_idf_version;
@@ -293,12 +294,37 @@ pub async fn run_cli(cli: Cli) {
             }
         }
         Commands::Discover => {
-            // TODO:Implement version discovery
-            unimplemented!("Version discovery not implemented yet");
-            println!("Discovering available versions... (This can take couple of minutes)");
-            let idf_dirs = idf_im_lib::version_manager::find_esp_idf_folders("/");
+            info!("Discovering available versions... (This can take couple of minutes)");
+            let idf_dirs = idf_im_lib::version_manager::find_esp_idf_folders("/tmp");
+            if idf_dirs.is_empty() {
+                info!("No IDF directories found");
+            } else {
+                info!("Found {} IDF directories:", idf_dirs.len());
+            }
+            let config = match idf_im_lib::version_manager::get_esp_ide_config() {
+              Ok(config) => {
+                if config.idf_installed.is_empty() {
+                  debug!(
+                      "No versions found. Every discovered version can be imported."
+                  );
+                }
+                config
+              }
+              Err(err) => {
+                debug!("No ide config found. New will be created.");
+                IdfConfig::default()
+              }
+            };
+            let mut paths_to_add = vec![];
             for dir in idf_dirs {
-                println!("Found IDF directory: {}", dir);
+              info!("- {} ", &dir);
+              if config.clone().is_path_in_config(dir.clone()) {
+                info!("Already present!");
+              } else {
+                info!("Will be added...");
+                paths_to_add.push(dir);
+              }
+
             }
         }
         Commands::Import { path } => match path {

src-tauri/src/lib/idf_config.rs

@@ -32,6 +32,17 @@ pub struct IdfConfig {
     pub eim_path: Option<String>,
 }
 
+impl Default for IdfConfig {
+  fn default() -> Self {
+      IdfConfig {
+        git_path: crate::utils::get_git_path().unwrap(),
+        idf_installed: [].to_vec(),
+        idf_selected_id: "".to_string(),
+        eim_path: None
+      }
+  }
+}
+
 impl IdfConfig {
     /// Saves the configuration to a file.
     ///
@@ -189,6 +200,10 @@ impl IdfConfig {
         }
     }
 
+    pub fn is_path_in_config(self, path:String) -> bool {
+      self.idf_installed.iter().find(|i| i.path == path).is_some()
+    }
+
     /// Removes an IDF installation from the configuration.
     ///
     /// This function searches for an installation matching the given identifier

src-tauri/src/lib/utils.rs

@@ -106,14 +106,18 @@ pub fn is_valid_idf_directory(path: &str) -> bool {
     let path = PathBuf::from(path);
     let tools_path = path.join("tools");
     let tools_json_path = tools_path.join("tools.json");
+    debug!("Checking for tools.json at: {}", tools_json_path.display());
     if !tools_json_path.exists() {
         return false;
     }
+    debug!("Found tools.json at: {}", tools_json_path.display());
     match read_and_parse_tools_file(tools_json_path.to_str().unwrap()) {
         Ok(_) => {
+            debug!("Valid IDF directory: {}", path.display());
             true
         }
         Err(_) => {
+            debug!("Invalid IDF directory: {}", path.display());
             false
         }
     }
@@ -346,54 +350,71 @@ pub fn parse_tool_set_config(config_path: &str) -> Result<()> {
         let new_export_paths = vec![tool_set.env_vars.get("PATH").unwrap().to_string()];
         let tmp = PathBuf::from(tool_set.idf_location.clone());
         let version_path = tmp.parent().unwrap();
-        single_version_post_install(
+        match import_single_version(
             version_path.to_str().unwrap(),
             &tool_set.idf_location,
             &tool_set.idf_version,
             &new_idf_tools_path,
             new_export_paths,
-        );
-
-        let new_activation_script = match std::env::consts::OS {
-            "windows" => format!(
-                "{}\\Microsoft.PowerShell_profile.ps1",
-                version_path.to_str().unwrap()
-            ),
-            _ => format!(
-                "{}/activate_idf_{}.sh",
-                version_path.to_str().unwrap(),
-                tool_set.idf_version
-            ),
-        };
-        let installation = IdfInstallation {
-            id: tool_set.id.to_string(),
-            activation_script: new_activation_script,
-            path: tool_set.idf_location,
-            name: tool_set.idf_version,
-            python: tool_set.system_python_executable_path,
-            idf_tools_path: new_idf_tools_path,
-        };
-        let config_path = get_default_config_path();
-        let mut current_config = match IdfConfig::from_file(&config_path) {
-            Ok(config) => config,
-            Err(e) => {
-                return Err(anyhow!("Config file not found: {}", e));
-            }
-        };
-        current_config.idf_installed.push(installation);
-        match current_config.to_file(config_path, true, false) {
+            Some(tool_set.system_python_executable_path),
+        ) {
             Ok(_) => {
-                debug!("Updated config file with new tool set");
-                return Ok(());
+                debug!("Successfully imported tool set");
             }
             Err(e) => {
-                return Err(anyhow!("Failed to update config file: {}", e));
+                return Err(anyhow!("Failed to import tool set: {}", e));
             }
         }
     }
     Ok(())
 }
 
+pub fn import_single_version(path_to_create_activation_script: &str,idf_location: &str, idf_version: &str, idf_tools_path: &str, export_paths: Vec<String>, python: Option<String>) -> Result<()> {
+  single_version_post_install(
+    path_to_create_activation_script,
+    idf_location,
+    idf_version,
+    &idf_tools_path,
+    export_paths,
+  );
+  let activation_script = match std::env::consts::OS {
+    "windows" => format!(
+        "{}\\Microsoft.PowerShell_profile.ps1",
+        path_to_create_activation_script,
+    ),
+    _ => format!(
+        "{}/activate_idf_{}.sh",
+        path_to_create_activation_script,
+        idf_version
+    ),
+  };
+  let installation = IdfInstallation {
+    id: idf_version.to_string(),
+    activation_script,
+    path: idf_location.to_string(),
+    name: idf_version.to_string(),
+    python: python.unwrap_or_else(|| "python".to_string()),
+    idf_tools_path: idf_tools_path.to_string(),
+  };
+  let config_path = get_default_config_path();
+  let mut current_config = match IdfConfig::from_file(&config_path) {
+      Ok(config) => config,
+      Err(e) => {
+          return Err(anyhow!("Config file not found: {}", e));
+      }
+  };
+  current_config.idf_installed.push(installation);
+  match current_config.to_file(config_path, true, false) {
+      Ok(_) => {
+          debug!("Updated config file with new tool set");
+          return Ok(());
+      }
+      Err(e) => {
+          return Err(anyhow!("Failed to update config file: {}", e));
+      }
+  }
+}
+
 /// Converts a path to a long path compatible with Windows.
 ///
 /// This function takes a string representing a path and returns a new string.

src-tauri/src/lib/version_manager.rs

@@ -224,9 +224,12 @@ pub fn remove_single_idf_version(identifier: &str) -> Result<String> {
 pub fn find_esp_idf_folders(path: &str) -> Vec<String> {
     let path = Path::new(path);
     let mut dirs = crate::utils::find_directories_by_name(path, "esp-idf");
+    debug!("Found {} esp-idf folders", dirs.len());
+    debug!("Found folders: {:?}", dirs);
     dirs.sort();
     dirs.reverse();
     let filtered_dirs = crate::utils::filter_duplicate_paths(dirs.clone());
+    debug!("Filtered folders: {:?}", filtered_dirs);
     filtered_dirs
         .iter()
         .filter(|p| crate::utils::is_valid_idf_directory(p))