[IMP] list namespace dirs on hover

Instead of displaying the "See also" link, we now list the namespace
directories when hovering over a namespace symbol.

We also make sure that the documentation section appears before the
useful links/directories list section.

Author: cammarosano

server/src/features/features_utils.rs

@@ -4,10 +4,9 @@ use ruff_text_size::{Ranged, TextRange, TextSize};
 use crate::core::file_mgr::FileMgr;
 use crate::core::odoo::SyncOdoo;
 use crate::core::symbols::function_symbol::Argument;
-use crate::utils::{compare_semver, PathSanitizer};
+use crate::utils::compare_semver;
 use std::cmp::Ordering;
 use std::collections::HashMap;
-use std::path::PathBuf;
 use std::rc::Weak;
 use std::{cell::RefCell, rc::Rc};
 
@@ -507,12 +506,12 @@ impl FeaturesUtils {
             let from_modules = info_pieces.iter().filter_map(|info| info.from_module.clone().map(|module_rc| module_rc.borrow().name().clone())).unique().collect::<Vec<_>>();
             // BLOCK 1: (type) **name** -> inferred_type
             block += FeaturesUtils::build_block_1(session, id.type_, &id.name, sym_type_tag, &inferred_types).as_str();
-            // BLOCK 2: useful links
-            block += inferred_types.iter().map(|typ| FeaturesUtils::get_useful_link(session, &typ.eval_ptr)).collect::<String>().as_str();
-            // BLOCK 3: documentation
+            // BLOCK 2: documentation
             if let Some(documentation_block) = FeaturesUtils::get_documentation_block(session, &from_modules, &inferred_types){
                 block = block + "  \n***  \n" + &documentation_block;
             }
+            // BLOCK 3: useful links or directory paths
+            block += inferred_types.iter().map(|typ| FeaturesUtils::get_location_info(session, &typ.eval_ptr)).collect::<String>().as_str();
             blocks.push(block);
         }
         blocks.iter().join("  \n***  \n")
@@ -674,24 +673,41 @@ impl FeaturesUtils {
 
     }
 
-    /// Finds and returns useful links for an evaluation
-    fn get_useful_link(_session: &mut SessionInfo, typ: &EvaluationSymbolPtr) -> String {
+    /// Finds and returns useful links or directory locations for an evaluation
+    fn get_location_info(_session: &mut SessionInfo, typ: &EvaluationSymbolPtr) -> String {
         // Possibly add more links in the future
         let Some(typ) = typ.upgrade_weak() else {
-            return S!("")
+            return S!("");
         };
-        let paths = &typ.borrow().paths();
-        if paths.len() == 1 { //we won't put a link to a namespace
-            let type_ref = typ.borrow();
-            let base_path = match type_ref.typ() {
-                SymType::PACKAGE(_) => PathBuf::from(paths.first().unwrap().clone()).join(format!("__init__.py{}", type_ref.as_package().i_ext())).sanitize(),
-                _ => paths.first().unwrap().clone()
-            };
-            let path = FileMgr::pathname2uri(&base_path);
-            let range = if type_ref.is_file_content() { type_ref.range().start().to_u32() } else { 0 };
-            format!("  \n***  \nSee also: [{}]({}#{}){}", type_ref.name().as_str(), path.as_str(), range, "  \n")
-        } else {
-            S!("")
+        let symbol = &*typ.borrow();
+        let lb = FeaturesUtils::get_line_break(_session);
+        match symbol {
+            Symbol::Namespace(ns) => {
+                // List namespace directories
+                let paths = ns.paths();
+                let name = &ns.name;
+                match paths.len() {
+                    0 => S!(""),
+                    1 => format!("  \n***  \n`{name}` namespace directory: `{}`{lb}", paths[0]),
+                    _ => {
+                        let path_list = paths.iter().map(|p| format!("- `{p}`")).join(lb);
+                        format!("  \n***  \n`{name}` namespace directories:{lb}{path_list}{lb}")
+                    }
+                }
+            }
+            Symbol::Package(_)
+            | Symbol::File(_)
+            | Symbol::XmlFileSymbol(_)
+            | Symbol::CsvFileSymbol(_) => {
+                // Get useful link
+                let uri = FileMgr::pathname2uri(&symbol.get_symbol_first_path());
+                let range = if symbol.is_file_content() { symbol.range().start().to_u32() } else { 0 };
+                format!( "  \n***  \nSee also: [{}]({}#{}){lb}", symbol.name(), uri.as_str(), range)
+            }
+            Symbol::Compiled(c) => {
+                format!("  \n***  \n`{}` is a binary at `{}`{lb}", c.name, c.path)
+            }
+            _ => S!(""),
         }
     }
 

server/tests/test_get_symbol.rs

@@ -150,6 +150,72 @@ fn test_hover_on_model_field_and_method() {
     );
 }
 
+#[test]
+fn test_hover_on_namespace_and_module() {
+    // Setup server and session with test addons
+    let mut odoo = setup::setup::setup_server(true);
+    let test_addons_path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests").join("data").join("addons");
+    let test_file = test_addons_path.join("module_1").join("models").join("base_test_models.py").sanitize();
+    
+    // Ensure the test file exists
+    assert!(PathBuf::from(&test_file).exists(), "Test file does not exist: {}", test_file);
+    let mut session = setup::setup::create_session(&mut odoo);
+
+    // Get file symbol and file info
+    let file_mgr = session.sync_odoo.get_file_mgr();
+    let file_info = file_mgr.borrow().get_file_info(&test_file).unwrap();
+    let Some(file_symbol) = SyncOdoo::get_symbol_of_opened_file(
+        &mut session,
+        &PathBuf::from(&test_file)
+    ) else {
+        panic!("Failed to get file symbol");
+    };
+
+    // Test hover on namespace: "odoo.addons" in line 2: from odoo.addons.module_1.constants import ...
+    // Position: line 1 (0-indexed), character at "addons" (~10-16)
+    let hover_namespace = test_utils::get_hover_markdown(&mut session, &file_symbol, &file_info, 1, 12).unwrap_or_default();
+    
+    // Should show namespace symbol type
+    assert!(
+        hover_namespace.contains("(namespace)"),
+        "Hover on namespace should show '(namespace)' type. Got: {}", hover_namespace
+    );
+    
+    // Should show "addons" as the name
+    assert!(
+        hover_namespace.contains("addons"),
+        "Hover on namespace should show namespace name. Got: {}", hover_namespace
+    );
+    
+    // Should list directories instead of "See also" link
+    assert!(
+        hover_namespace.contains("directories:"),
+        "Hover on namespace should list directories. Got: {}", hover_namespace
+    );
+    
+    // Should NOT contain "See also:" link 
+    assert!(
+        !hover_namespace.contains("See also:"),
+        "Hover on namespace should NOT show 'See also' link. Got: {}", hover_namespace
+    );
+
+    // Test hover on Odoo module: "module_1" in line 2: from odoo.addons.module_1.constants import ...
+    // Position: line 1 (0-indexed), character at "module_1" (~17-24)
+    let hover_module = test_utils::get_hover_markdown(&mut session, &file_symbol, &file_info, 1, 20).unwrap_or_default();
+    
+    // Should show package type, module name and "Module" inferred type
+    assert!(
+        hover_module.contains("(package) module_1: Module"),
+        "Hover on Odoo module should show package type, module_1 as name and 'Module' inferred type. Got: {}", hover_module
+    );
+    
+    // Module should show "See also" link
+    assert!(
+        hover_module.contains("See also:"),
+        "Hover on Odoo module should show 'See also' link. Got: {}", hover_module
+    );
+}
+
 #[test]
 fn test_definition() {
     // Setup server and session with test addons