[IMP] server: hooks for werkzeug monkeypatches

Author: fda-odoo

server/src/core/import_resolver.rs

@@ -1,12 +1,13 @@
 use glob::glob;
 use lsp_types::{Diagnostic, DiagnosticTag, Position, Range};
+use ruff_python_ast::name::Name;
 use tracing::error;
 use std::collections::{HashMap, HashSet};
 use std::rc::Rc;
 use std::cell::RefCell;
 use std::path::{Path, PathBuf};
 
-use ruff_text_size::TextRange;
+use ruff_text_size::{TextRange, TextSize};
 use ruff_python_ast::{Alias, Identifier};
 use crate::{constants::*, oyarn, Sy, S};
 use crate::core::diagnostics::{create_diagnostic, DiagnosticCode};
@@ -51,15 +52,32 @@ fn resolve_import_stmt_hook(alias: &Alias, from_symbol: &Option<Rc<RefCell<Symbo
     }
 }
 
+/**
+ * Helper to manually import a symbol. Do not forget to use level instead of '.' in the from_stmt parameter.
+ */
+pub fn manual_import(session: &mut SessionInfo, source_file_symbol: &Rc<RefCell<Symbol>>, from_stmt:Option<String>, name: &str, asname: Option<String>, level: Option<u32>, diagnostics: &mut Option<&mut Vec<Diagnostic>>) -> Vec<ImportResult> {
+    let name_aliases = vec![Alias {
+        name: Identifier { id: Name::new(name), range: TextRange::new(TextSize::new(0), TextSize::new(0)) },
+        asname: match asname {
+            Some(asname_inner) => Some(Identifier { id: Name::new(asname_inner), range: TextRange::new(TextSize::new(0), TextSize::new(0)) }),
+            None => None,
+        },
+        range: TextRange::new(TextSize::new(0), TextSize::new(0)),
+    }];
+    let from_stmt = match from_stmt {
+        Some(from_stmt_inner) => Some(Identifier { id: Name::new(from_stmt_inner), range: TextRange::new(TextSize::new(0), TextSize::new(0)) }),
+        None => None,
+    };
+    resolve_import_stmt(session, source_file_symbol, from_stmt.as_ref(), &name_aliases, level, diagnostics)
+}
+
 pub fn resolve_import_stmt(session: &mut SessionInfo, source_file_symbol: &Rc<RefCell<Symbol>>, from_stmt: Option<&Identifier>, name_aliases: &[Alias], level: Option<u32>, diagnostics: &mut Option<&mut Vec<Diagnostic>>) -> Vec<ImportResult> {
     //A: search base of different imports
     let source_root = source_file_symbol.borrow().get_root().as_ref().unwrap().upgrade().unwrap();
     let entry = source_root.borrow().get_entry().unwrap();
     let _source_file_symbol_lock = source_file_symbol.borrow_mut();
     let file_tree = _resolve_packages(
-        &_source_file_symbol_lock.paths()[0].clone(),
-        &_source_file_symbol_lock.get_tree(),
-        &_source_file_symbol_lock.typ(),
+        &_source_file_symbol_lock,
         level,
         from_stmt);
     drop(_source_file_symbol_lock);
@@ -206,20 +224,20 @@ pub fn find_module(session: &mut SessionInfo, odoo_addons: Rc<RefCell<Symbol>>,
     None
 }
 
-fn _resolve_packages(file_path: &String, file_tree: &Tree, file_sym_type: &SymType, level: Option<u32>, from_stmt: Option<&Identifier>) -> Vec<OYarn> {
+fn _resolve_packages(from_file: &Symbol, level: Option<u32>, from_stmt: Option<&Identifier>) -> Vec<OYarn> {
     let mut first_part_tree: Vec<OYarn> = vec![];
     if level.is_some() && level.unwrap() > 0 {
         let mut lvl = level.unwrap();
-        if lvl > Path::new(file_path).components().count() as u32 {
+        if lvl > Path::new(&from_file.paths()[0]).components().count() as u32 {
             panic!("Level is too high!")
         }
-        if matches!(*file_sym_type, SymType::PACKAGE(_)) {
+        if matches!(from_file.typ(), SymType::PACKAGE(_)) {
             lvl -= 1;
         }
         if lvl == 0 {
-            first_part_tree = file_tree.0.clone();
+            first_part_tree = from_file.get_tree().0.clone();
         } else {
-            let tree = file_tree;
+            let tree = from_file.get_tree();
             if lvl > tree.0.len() as u32 {
                 error!("Level is too high and going out of scope");
                 first_part_tree = vec![];
@@ -417,9 +435,7 @@ pub fn get_all_valid_names(session: &mut SessionInfo, source_file_symbol: &Rc<Re
     let entry = source_root.borrow().get_entry().unwrap();
     let _source_file_symbol_lock = source_file_symbol.borrow_mut();
     let file_tree = _resolve_packages(
-        &_source_file_symbol_lock.paths()[0].clone(),
-        &_source_file_symbol_lock.get_tree(),
-        &_source_file_symbol_lock.typ(),
+        &_source_file_symbol_lock,
         level,
         from_stmt);
     drop(_source_file_symbol_lock);

server/src/core/odoo.rs

@@ -235,6 +235,7 @@ impl SyncOdoo {
                     .map(|v| v as u32)
                     .take(3)
                     .collect();
+                info!("Detected python version: {}.{}.{}", session.sync_odoo.python_version[0], session.sync_odoo.python_version[1], session.sync_odoo.python_version[2]);
             } else {
                 let stderr = String::from_utf8_lossy(&output.stderr);
                 error!("{}", stderr);

server/src/core/python_arch_builder_hooks.rs

@@ -4,11 +4,12 @@ use std::rc::Rc;
 use std::cell::RefCell;
 use once_cell::sync::Lazy;
 use ruff_text_size::{TextRange, TextSize};
-use tracing::warn;
+use tracing::{info, warn};
 use crate::core::entry_point::EntryPoint;
+use crate::core::import_resolver::manual_import;
 use crate::core::symbols::symbol::Symbol;
 use crate::threads::SessionInfo;
-use crate::utils::compare_semver;
+use crate::utils::{compare_semver, is_file_cs, PathSanitizer};
 use crate::{Sy, S};
 use crate::constants::OYarn;
 
@@ -195,6 +196,45 @@ impl PythonArchBuilderHooks {
                     }
                 }
             }
+        } else if name == "werkzeug" {
+            if symbol.borrow().get_main_entry_tree(session) == (vec![Sy!("odoo"), Sy!("_monkeypatches"), Sy!("werkzeug")], vec![]) {
+                //doing this patch like this imply that an odoo project will make these functions available for all entrypoints, but heh
+                let werkzeug_url = session.sync_odoo.get_symbol(symbol.borrow().paths()[0].as_str(), &(vec![Sy!("werkzeug"), Sy!("urls")], vec![]), u32::MAX);
+                if let Some(werkzeug_url) = werkzeug_url.first() {
+                    //fake variable, as ext_symbols are not seen through get_symbol, etc...
+                    werkzeug_url.borrow_mut().add_new_variable(session, Sy!("url_decode"), &TextRange::new(TextSize::new(0), TextSize::new(0)));
+                    werkzeug_url.borrow_mut().add_new_variable(session, Sy!("url_encode"), &TextRange::new(TextSize::new(0), TextSize::new(0)));
+                    werkzeug_url.borrow_mut().add_new_variable(session, Sy!("url_join"), &TextRange::new(TextSize::new(0), TextSize::new(0)));
+                    werkzeug_url.borrow_mut().add_new_variable(session, Sy!("url_parse"), &TextRange::new(TextSize::new(0), TextSize::new(0)));
+                    werkzeug_url.borrow_mut().add_new_variable(session, Sy!("url_quote"), &TextRange::new(TextSize::new(0), TextSize::new(0)));
+                    werkzeug_url.borrow_mut().add_new_variable(session, Sy!("url_unquote"), &TextRange::new(TextSize::new(0), TextSize::new(0)));
+                    werkzeug_url.borrow_mut().add_new_variable(session, Sy!("url_quote_plus"), &TextRange::new(TextSize::new(0), TextSize::new(0)));
+                    werkzeug_url.borrow_mut().add_new_variable(session, Sy!("url_unquote_plus"), &TextRange::new(TextSize::new(0), TextSize::new(0)));
+                    werkzeug_url.borrow_mut().add_new_variable(session, Sy!("url_unparse"), &TextRange::new(TextSize::new(0), TextSize::new(0)));
+                    werkzeug_url.borrow_mut().add_new_variable(session, Sy!("URL"), &TextRange::new(TextSize::new(0), TextSize::new(0)));
+                } else {
+                    warn!("Unable to find werkzeug.urls to monkeypatch it");
+                }
+            }
+        } else if name == "urls" {
+            if symbol.borrow().get_local_tree() == (vec![Sy!("werkzeug"), Sy!("urls")], vec![]) {
+                //manually load patch, as a manual dependency
+                let full_path_monkeypatches = S!("odoo._monkeypatches");
+                let mut main_odoo_symbol = None;
+                if let Some(main_ep) = session.sync_odoo.entry_point_mgr.borrow().main_entry_point.as_ref() {
+                    //To import from main entry point, we have to import 'from' a symbol coming from main entry point. 
+                    //We then use the main symbol of the main entry point to achieve that, instead of the werkzeug symbol
+                    main_odoo_symbol = Some(main_ep.borrow().get_symbol().unwrap());
+                }
+                if let Some(main_odoo_symbol) = main_odoo_symbol {
+                    let werkzeug_patch = manual_import(session, &main_odoo_symbol, Some(full_path_monkeypatches), "werkzeug", None, None, &mut None);
+                    for werkzeug_patch in werkzeug_patch {
+                        if werkzeug_patch.found {
+                            info!("monkeypatch manually found");
+                        }
+                    }
+                }
+            }
         }
     }
 }