EIM-827 fix openocd script path (#835)

* EIM-827 fix openocd script path

* get_tools_export_vars_from_list uses name and version sufixed paths

Author: Hahihula

src-tauri/src/cli/wizard.rs

@@ -828,8 +828,8 @@ pub async fn run_wizzard_run(mut config: Settings) -> Result<(), String> {
             .map_err(|err| t!("wizard.error.create_python_env", error = err.to_string()))?;
 
         let export_paths = idf_im_lib::idf_tools::get_tools_export_paths_from_list(
-            tools,
-            installed_tools_list,
+            tools.clone(),
+            installed_tools_list.clone(),
             tool_install_directory.to_str().unwrap(),
         )
         .into_iter()
@@ -841,14 +841,19 @@ pub async fn run_wizzard_run(mut config: Settings) -> Result<(), String> {
             }
         })
         .collect();
+        let export_vars = idf_im_lib::idf_tools::get_tools_export_vars_from_list(
+            tools,
+            installed_tools_list,
+            tool_install_directory.to_str().unwrap(),
+        );
         idf_im_lib::single_version_post_install(
             &paths.activation_script_path.to_str().unwrap(),
             paths.idf_path.to_str().unwrap(),
             &paths.actual_version,
             tool_install_directory.to_str().unwrap(),
             export_paths,
             paths.python_venv_path.to_str(),
-            None, // env_vars
+            Some(export_vars), // env_vars
             &paths.python_path.to_string_lossy(),
             config.create_bat_activation_script.unwrap_or(false),
             offline_mode,

src-tauri/src/gui/commands/idf_tools.rs

@@ -97,7 +97,7 @@ pub async fn setup_tools(
     idf_path: &PathBuf,
     idf_version: &str,
     offline_archive_dir: Option<&Path>,
-) -> Result<Vec<String>> {
+) -> Result<(Vec<String>,Vec<(String,String)>)> {
     info!("Setting up tools...");
 
     let is_simple_installation = crate::gui::app_state::is_simple_installation(&app_handle);
@@ -467,7 +467,7 @@ pub async fn setup_tools(
 
     let paths = match settings.get_version_paths(&idf_version) {
       Ok(paths) => paths,
-      Err(err) => {
+      Err(_err) => {
         return Err(anyhow!("Failed to setup environment paths for idf versions"));
       }
     };
@@ -520,8 +520,8 @@ pub async fn setup_tools(
 
     // Generate export paths
     let export_paths = idf_im_lib::idf_tools::get_tools_export_paths_from_list(
-        tools,
-        installed_tools_list,
+        tools.clone(),
+        installed_tools_list.clone(),
         tools_install_folder.to_str().unwrap(),
     )
     .into_iter()
@@ -534,6 +534,12 @@ pub async fn setup_tools(
     })
     .collect();
 
+    let export_vars = idf_im_lib::idf_tools::get_tools_export_vars_from_list(
+        tools,
+        installed_tools_list,
+        tools_install_folder.to_str().unwrap(),
+    );
+
     // Configuration phase (95%)
     emit_installation_event(app_handle, InstallationProgress {
         stage: InstallationStage::Configure,
@@ -546,7 +552,7 @@ pub async fn setup_tools(
     emit_log_message(app_handle, MessageLevel::Success,
         t!("gui.setup_tools.setup_completed").to_string());
 
-    Ok(export_paths)
+    Ok((export_paths,export_vars))
 }
 
 #[tauri::command]

src-tauri/src/gui/commands/installation.rs

@@ -219,16 +219,16 @@ pub async fn install_single_version(
   }
 
 
-  let export_vars = setup_tools(&app_handle, settings, &paths.idf_path, &paths.actual_version, None).await?;
+  let (export_paths,export_vars) = setup_tools(&app_handle, settings, &paths.idf_path, &paths.actual_version, None).await?;
 
   idf_im_lib::single_version_post_install(
       &paths.activation_script_path.to_string_lossy().to_string(),
       &paths.idf_path.to_string_lossy().to_string(),
       &paths.actual_version,
       &paths.tool_install_directory.to_string_lossy().to_string(),
-      export_vars,
+      export_paths,
       paths.python_venv_path.to_str(),
-      None, // env_vars
+      Some(export_vars), // env_vars
       &paths.python_path.to_string_lossy().to_string(),
       false, // create_cmd_bat
       false, // offline_installation
@@ -1826,11 +1826,11 @@ pub async fn start_offline_installation(app_handle: AppHandle, archives: Vec<Str
                 version: Some(idf_version.clone()),
             });
 
-            let export_vars = match setup_tools(&app_handle, &settings, &paths.idf_path, &paths.actual_version, Some(offline_archive_dir.path())).await {
-                Ok(vars) => {
+            let (export_paths, export_vars ) = match setup_tools(&app_handle, &settings, &paths.idf_path, &paths.actual_version, Some(offline_archive_dir.path())).await {
+                Ok((paths, vars)) => {
                     emit_log_message(&app_handle, MessageLevel::Success,
                         rust_i18n::t!("gui.offline.tools_configured").to_string());
-                    vars
+                    (paths, vars)
                 }
                 Err(err) => {
                     let error_msg = rust_i18n::t!("gui.offline.tools_setup_failed", error = err.to_string()).to_string();
@@ -1861,9 +1861,9 @@ pub async fn start_offline_installation(app_handle: AppHandle, archives: Vec<Str
                 &paths.idf_path.to_string_lossy().to_string(),
                 &paths.actual_version,
                 &paths.tool_install_directory.to_string_lossy().to_string(),
-                export_vars,
+                export_paths,
                 paths.python_venv_path.to_str(),
-                None,
+                Some(export_vars),
                 &paths.python_path.to_string_lossy(),
                 false, // create_cmd_bat
                 true,  // is_offline_install

src-tauri/src/lib/idf_tools.rs

@@ -699,6 +699,48 @@ pub fn get_tools_export_paths_from_list(
     paths
 }
 
+/// Returns a `Vec<(String, String)>` of export variables for the installed tools.
+///
+/// This function iterates through a map of installed tools, finds their export variables
+/// from the `ToolsFile` definition, and replaces any `${TOOL_PATH}` placeholder in the
+/// values with the actual `tools_install_path`. All collected key-value pairs are returned
+/// as a vector of tuples.
+///
+/// # Arguments
+///
+/// * `tools_file` - A `ToolsFile` struct containing the definitions of tools,
+///                  including their `export_vars`.
+/// * `installed_tools` - A `HashMap` where keys are tool names (`String`) and values
+///                       are tuples containing the tool's installed version (`String`)
+///                       and its `Download` information.
+/// * `tools_install_path` - A string slice representing the base directory where tools are installed.
+///
+/// # Returns
+///
+/// A `Vec<(String, String)>` containing the export variable names and their values
+/// for the specified installed tools.
+///
+pub fn get_tools_export_vars_from_list(
+  _tools_file: ToolsFile,
+  installed_tools: HashMap<String, (String, Download)>,
+  tools_install_path: &str,
+) -> Vec<(String, String)> {
+    let mut vars: Vec<(String, String)> = Vec::new();
+
+    for (tool_name, (_version, _download)) in installed_tools {
+        if let Some(tool) = _tools_file.tools.iter().find(|t| t.name == tool_name) {
+            for (var_name, var_value) in &tool.export_vars {
+                let single_tool_install_path = PathBuf::from(tools_install_path).join(tool.name.clone()).join(tool.versions.first().unwrap().name.clone());
+                let processed_value = var_value.replace("${TOOL_PATH}", &single_tool_install_path.to_string_lossy());
+                vars.push((var_name.clone(), processed_value));
+            }
+        }
+    }
+
+    log::debug!("Export vars from list: {:?}", vars);
+    vars
+}
+
 /// Recursively searches for directories named "bin" within the given path.
 ///
 /// # Parameters