[IMP] server: add config file arg

Author: mmahrouss

server/src/args.rs

@@ -54,6 +54,11 @@ pub struct Cli {
     //provide a path to the directory that will be used for logs
     #[arg(long)]
     pub logs_directory: Option<String>,
+
+    /// Default config file path
+    #[arg(long)]
+    pub config_path: Option<String>,
+
 }
 
 #[derive(ValueEnum, Clone, Debug)]

server/src/core/config.rs

@@ -429,7 +429,7 @@ fn parse_manifest_version(contents: String) -> Option<String> {
     None
 }
 
-fn process_version(var: Sourced<String>, ws_folders: &HashMap<String, String>, workspace_name: &String) -> Sourced<String> {
+fn process_version(var: Sourced<String>, ws_folders: &HashMap<String, String>, workspace_name: Option<&String>) -> Sourced<String> {
     let Some(config_path) = var.sources.iter().next().map(PathBuf::from) else {
         unreachable!("Expected at least one source for sourced_path: {:?}", var);
     };
@@ -624,7 +624,7 @@ pub fn default_profile_name() -> String {
     "default".to_string()
 }
 
-fn fill_or_canonicalize<F>(sourced_path: &Sourced<String>, ws_folders: &HashMap<String, String>, workspace_name: &String, predicate: &F, var_map: HashMap<String, String>) -> Option<Sourced<String>>
+fn fill_or_canonicalize<F>(sourced_path: &Sourced<String>, ws_folders: &HashMap<String, String>, workspace_name: Option<&String>, predicate: &F, var_map: HashMap<String, String>) -> Option<Sourced<String>>
 where
 F: Fn(&String) -> bool,
 {
@@ -651,7 +651,7 @@ F: Fn(&String) -> bool,
 fn process_paths(
     entry: &mut ConfigEntryRaw,
     ws_folders: &HashMap<String, String>,
-    workspace_name: &String,
+    workspace_name: Option<&String>,
 ){
     let var_map: HashMap<String, String> = match entry.version.clone() {
         Some(v) => HashMap::from([(S!("version"), v.value().clone())]),
@@ -901,8 +901,23 @@ fn merge_configs(
     merged
 }
 
+fn load_config_from_file(path: String, ws_folders: &HashMap<String, String>,) -> Result<HashMap<String, ConfigEntryRaw>, String> {
+    let path = PathBuf::from(path);
+    if !path.exists() || !path.is_file() {
+        return Err(S!(format!("Config file not found: {}", path.display())));
+    }
+    process_config(
+        read_config_from_file(path)?,
+        ws_folders,
+        None,
+    )
+}
 
-fn load_merged_config_upward(ws_folders: &HashMap<String, String>, workspace_name: &String, workspace_path: &String) -> Result<HashMap<String, ConfigEntryRaw>, String> {
+fn load_config_from_workspace(
+    ws_folders: &HashMap<String, String>,
+    workspace_name: &String,
+    workspace_path: &String,
+) -> Result<HashMap<String, ConfigEntryRaw>, String> {
     let mut current_dir = PathBuf::from(workspace_path);
     let mut visited_dirs = HashSet::new();
     let mut merged_config: HashMap<String, ConfigEntryRaw> = HashMap::new();
@@ -924,10 +939,29 @@ fn load_merged_config_upward(ws_folders: &HashMap<String, String>, workspace_nam
             break;
         }
     }
-    apply_extends(&mut merged_config)?;
+    let mut merged_config = process_config(merged_config, ws_folders, Some(workspace_name))?;
+
+    for entry in merged_config.values_mut() {
+        if entry.abstract_ { continue; }
+        if (matches!(entry.add_workspace_addon_path.as_ref().map(|a| a.value), Some(true)) || entry.addons_paths.is_none()) && is_addon_path(workspace_path) {
+            let addon_path = Sourced { value: workspace_path.clone(), sources: HashSet::from([S!(format!("$workspaceFolder:{workspace_name}"))]), ..Default::default()};
+            match entry.addons_paths {
+                Some(ref mut paths) => paths.push(addon_path),
+                None => entry.addons_paths = Some(vec![addon_path]),
+            }
+        }
+    }
+    Ok(merged_config)
+}
+
+fn process_config(
+    mut config_map: HashMap<String, ConfigEntryRaw>,
+    ws_folders: &HashMap<String, String>,
+    workspace_name: Option<&String>,
+) -> Result<HashMap<String, ConfigEntryRaw>, String> {
+    apply_extends(&mut config_map)?;
     let mut new_configs = vec![];
-    for config in merged_config.values_mut() {
-        // If the config has no odoo_path, try to infer it from workspace folders
+    for config in config_map.values_mut() {
         let Some(version_var) = config.version.clone() else {
             continue;
         };
@@ -965,42 +999,31 @@ fn load_merged_config_upward(ws_folders: &HashMap<String, String>, workspace_nam
         }
     }
     for new_entry in new_configs {
-        merged_config.insert(new_entry.name.clone(), new_entry);
+        config_map.insert(new_entry.name.clone(), new_entry);
     }
 
     // Process vars
-    merged_config.values_mut()
+    config_map.values_mut()
         .for_each(|entry| {
             // apply process_var to all vars
             if entry.abstract_ { return; }
             entry.version = entry.version.clone().map(|v| process_version(v, ws_folders, workspace_name));
         });
     // Process paths in the merged config
-    merged_config.values_mut()
+    config_map.values_mut()
         .for_each(|entry| {
             if entry.abstract_ { return; }
             process_paths(entry, ws_folders, workspace_name);
         });
     // Merge sourced paths
-    merged_config.values_mut()
+    config_map.values_mut()
         .for_each(|entry| {
             if entry.abstract_ { return; }
             entry.addons_paths = entry.addons_paths.clone().map(|paths| group_sourced_iters(paths).collect());
             entry.additional_stubs = entry.additional_stubs.clone().map(|stubs| group_sourced_iters(stubs).collect());
         });
 
-    for entry in merged_config.values_mut() {
-        if entry.abstract_ { continue; }
-        if (matches!(entry.add_workspace_addon_path.as_ref().map(|a| a.value), Some(true)) || entry.addons_paths.is_none()) && is_addon_path(workspace_path) {
-            let addon_path = Sourced { value: workspace_path.clone(), sources: HashSet::from([S!(format!("$workspaceFolder:{workspace_name}"))]), ..Default::default()};
-            match entry.addons_paths {
-                Some(ref mut paths) => paths.push(addon_path),
-                None => entry.addons_paths = Some(vec![addon_path]),
-            }
-        }
-    }
-
-    Ok(merged_config)
+    Ok(config_map)
 }
 
 fn merge_all_workspaces(
@@ -1130,9 +1153,22 @@ fn merge_all_workspaces(
     Ok((final_config, config_file))
 }
 
-pub fn get_configuration(ws_folders: &HashMap<String, String>)  -> Result<(ConfigNew, ConfigFile), String> {
-    let ws_confs: Result<Vec<_>, _> = ws_folders.iter().map(|ws_f| load_merged_config_upward(ws_folders, ws_f.0, ws_f.1)).collect();
-    merge_all_workspaces(ws_confs?, ws_folders)
+pub fn get_configuration(ws_folders: &HashMap<String, String>, cli_config_file: &Option<String>)  -> Result<(ConfigNew, ConfigFile), String> {
+    let mut ws_confs: Vec<HashMap<String, ConfigEntryRaw>> = Vec::new();
+
+    if let Some(ref path) = cli_config_file {
+        let config_from_file = load_config_from_file(path.clone(), ws_folders)?;
+        ws_confs.push(config_from_file);
+    }
+
+    let ws_confs_result: Result<Vec<_>, _> = ws_folders
+        .iter()
+        .map(|ws_f| load_config_from_workspace(ws_folders, ws_f.0, ws_f.1))
+        .collect();
+
+    ws_confs.extend(ws_confs_result?);
+
+    merge_all_workspaces(ws_confs, ws_folders)
 }
 
 /// Check if the old and new configuration entries are different enough to require a restart.

server/src/core/odoo.rs

@@ -59,6 +59,7 @@ pub struct SyncOdoo {
     pub full_version: String,
     pub config: ConfigEntry,
     pub config_file: Option<ConfigFile>,
+    pub config_path: Option<String>,
     pub entry_point_mgr: Rc<RefCell<EntryPointMgr>>, //An Rc to be able to clone it and free session easily
     pub has_main_entry:bool,
     pub has_odoo_main_entry: bool,
@@ -96,6 +97,7 @@ impl SyncOdoo {
             full_version: "0.0.0".to_string(),
             config: ConfigEntry::new(),
             config_file: None,
+            config_path: None,
             entry_point_mgr: Rc::new(RefCell::new(EntryPointMgr::new())),
             has_main_entry: false,
             has_odoo_main_entry: false,
@@ -969,7 +971,7 @@ impl Odoo {
             session.show_message(MessageType::ERROR, String::from("There are repeated workspace folders names, which is not supported by OdooLS. Please remove the repeated folders and restart the server."));
             return;
         }
-        let config = get_configuration(session.sync_odoo.get_file_mgr().borrow().get_workspace_folders());
+        let config = get_configuration(session.sync_odoo.get_file_mgr().borrow().get_workspace_folders(), &session.sync_odoo.config_path);
         if let Ok((_, config_file)) = &config {
             session.sync_odoo.config_file = Some(config_file.clone());
             Odoo::send_all_configurations(session);
@@ -1466,7 +1468,7 @@ impl Odoo {
     fn check_handle_config_file_update(session: &mut SessionInfo, path: &PathBuf) -> bool {
         // Check if the change is affecting a config file
         if Odoo::is_config_workspace_file(session, path) {
-            let config_result =  config::get_configuration(session.sync_odoo.get_file_mgr().borrow().get_workspace_folders())
+            let config_result =  config::get_configuration(session.sync_odoo.get_file_mgr().borrow().get_workspace_folders(), &session.sync_odoo.config_path)
                 .and_then(|(cfg_map, cfg_file)| {
                     let config_name = Odoo::read_selected_configuration(session)?.unwrap_or(default_profile_name());
                     cfg_map.get(&config_name)

server/src/main.rs

@@ -82,34 +82,22 @@ fn main() {
         info!("starting server (single parse mode)");
         let backend = CliBackend::new(cli);
         backend.run();
-    } else if use_debug {
-        info!(tag = "test", "starting server (debug mode)");
-        let mut serv = Server::new_tcp().expect("Unable to start tcp connection");
-        serv.initialize().expect("Error while initializing server");
-        let sender_panic = serv.connection.as_ref().unwrap().sender.clone();
-        std::panic::set_hook(Box::new(move |panic_info| {
-            let backtrace = std::backtrace::Backtrace::capture();
-            panic_hook(panic_info);
-            let _ = sender_panic.send(lsp_server::Message::Notification(Notification{
-                method: "Odoo/displayCrashNotification".to_string(),
-                params: json!({
-                    "crashInfo": format!("{panic_info}\n\nTraceback:\n{backtrace}"),
-                    "pid": std::process::id()
-                })
-            }));
-        }));
-        if !serv.run(cli.clientProcessId) {
-            info!(">>>>>>>>>>>>>>>>>> End Session <<<<<<<<<<<<<<<<<<");
-            process::exit(1);
-        }
     } else {
-        info!("starting server");
-        let mut serv = Server::new_stdio();
+        let mut serv = if use_debug {
+            info!(tag = "test", "starting server (debug mode)");
+            Server::new_tcp().expect("Unable to start tcp connection")
+        } else {
+            info!("starting server");
+            Server::new_stdio()
+        };
         serv.initialize().expect("Error while initializing server");
+        cli.config_path.map(|config_path| {
+            serv.set_config_path(config_path.clone());
+        });
         let sender_panic = serv.connection.as_ref().unwrap().sender.clone();
         std::panic::set_hook(Box::new(move |panic_info| {
-            panic_hook(panic_info);
             let backtrace = std::backtrace::Backtrace::capture();
+            panic_hook(panic_info);
             let _ = sender_panic.send(lsp_server::Message::Notification(Notification{
                 method: "Odoo/displayCrashNotification".to_string(),
                 params: json!({

server/src/server.rs

@@ -155,7 +155,6 @@ impl Server {
         }
     }
 
-
     pub fn initialize(&mut self) -> Result<(), ServerError> {
         info!("Waiting for a connection...");
         let (id, params) = self.connection.as_ref().unwrap().initialize_start()?;
@@ -562,4 +561,9 @@ impl Server {
             }
         })
     }
+
+    pub fn set_config_path(&mut self, config_path: String) {
+        let mut sync_odoo = self.sync_odoo.lock().unwrap();
+        sync_odoo.config_path = Some(config_path);
+    }
 }

server/src/utils.rs

@@ -273,24 +273,24 @@ pub fn build_pattern_map(ws_folders: &HashMap<String, String>) -> HashMap<String
 /// While also checking it with the predicate function.
 /// pass `|_| true` to skip the predicate check.
 /// Currently, only the workspaceFolder[:workspace_name] and userHome variables are supported.
-pub fn fill_validate_path<F, P>(ws_folders: &HashMap<String, String>, workspace_name: &String, template: &str, predicate: F, var_map: HashMap<String, String>, parent_path: P) -> Option<String>
+pub fn fill_validate_path<F, P>(ws_folders: &HashMap<String, String>, workspace_name: Option<&String>, template: &str, predicate: F, var_map: HashMap<String, String>, parent_path: P) -> Option<String>
 where
     F: Fn(&String) -> bool,
     P: AsRef<Path>
 {
         let mut pattern_map: HashMap<String, String> = build_pattern_map(ws_folders).into_iter().chain(var_map.into_iter()).collect();
-        if let Some(path) = ws_folders.get(workspace_name) {
+        if let Some(path) = workspace_name.and_then(|name| ws_folders.get(name)) {
             pattern_map.insert(S!("workspaceFolder"), path.clone());
-            if let Some(path) = fill_template(template, &pattern_map) {
-                if predicate(&path) {
-                    return Some(path);
-                }
-                // Attempt to convert the path to an absolute path
-                if let Ok(abs_path) = std::fs::canonicalize(parent_path.as_ref().join(&path)) {
-                    let abs_path    = abs_path.sanitize();
-                    if predicate(&abs_path) {
-                        return Some(abs_path);
-                    }
+        }
+        if let Some(path) = fill_template(template, &pattern_map) {
+            if predicate(&path) {
+                return Some(path);
+            }
+            // Attempt to convert the path to an absolute path
+            if let Ok(abs_path) = std::fs::canonicalize(parent_path.as_ref().join(&path)) {
+                let abs_path    = abs_path.sanitize();
+                if predicate(&abs_path) {
+                    return Some(abs_path);
                 }
             }
         }