Add plugin config tabs; remove required_files usage

Author: raidos23

OnlyMod/BcaslOnlyMod/app.py

@@ -407,7 +407,6 @@ def run_plugins(
             "workspace_path": str(ws_root),
             "file_patterns": cfg.get("file_patterns", []),
             "exclude_patterns": cfg.get("exclude_patterns", []),
-            "required_files": cfg.get("required_files", []),
         }
 
         ctx = PreCompileContext(

OnlyMod/BcaslOnlyMod/gui.py

@@ -164,7 +164,6 @@ def run(self):
                 "workspace_path": str(self.workspace_root),
                 "file_patterns": self.config.get("file_patterns", []),
                 "exclude_patterns": self.config.get("exclude_patterns", []),
-                "required_files": self.config.get("required_files", []),
             }
 
             # Exécuter les plugins

Plugins/Cleaner/__init__.py

@@ -60,6 +60,48 @@ def __init__(self):
         self.cleaned_files = 0
         self.cleaned_dirs = 0
 
+    def _get_config(self, ctx: PreCompileContext) -> dict:
+        try:
+            cfg = ctx.get_workspace_config() or {}
+            plugins_cfg = cfg.get("plugins", {}) if isinstance(cfg, dict) else {}
+            entry = plugins_cfg.get(self.meta.id, {}) if isinstance(plugins_cfg, dict) else {}
+            plugin_cfg = entry.get("config", {}) if isinstance(entry, dict) else {}
+            if isinstance(plugin_cfg, dict):
+                return dict(plugin_cfg)
+        except Exception:
+            pass
+        return {}
+
+    def build_config_tab(self, parent, ctx: PreCompileContext, config: dict):
+        try:
+            from PySide6.QtWidgets import QWidget, QVBoxLayout, QLabel, QCheckBox
+        except Exception:
+            return None
+
+        w = QWidget(parent)
+        lay = QVBoxLayout(w)
+        lay.addWidget(QLabel("Cleaner settings"))
+
+        chk_confirm = QCheckBox("Ask confirmation before cleaning", w)
+        chk_pyc = QCheckBox("Remove .pyc files", w)
+        chk_pycache = QCheckBox("Remove __pycache__ folders", w)
+
+        chk_confirm.setChecked(bool(config.get("confirm", True)))
+        chk_pyc.setChecked(bool(config.get("clean_pyc", True)))
+        chk_pycache.setChecked(bool(config.get("clean_pycache", True)))
+
+        lay.addWidget(chk_confirm)
+        lay.addWidget(chk_pyc)
+        lay.addWidget(chk_pycache)
+
+        def on_save(cfg: dict):
+            cfg["confirm"] = bool(chk_confirm.isChecked())
+            cfg["clean_pyc"] = bool(chk_pyc.isChecked())
+            cfg["clean_pycache"] = bool(chk_pycache.isChecked())
+            return cfg
+
+        return ("Cleaner", w, on_save)
+
     def on_pre_compile(self, ctx: PreCompileContext) -> None:
         """Nettoie le workspace avant la compilation.
 
@@ -72,16 +114,25 @@ def on_pre_compile(self, ctx: PreCompileContext) -> None:
                 log.log_warn("Workspace is not valid or bcasl.yml not found")
                 return
 
+            cfg = self._get_config(ctx)
+            ask_confirm = bool(cfg.get("confirm", True))
+            clean_pyc = bool(cfg.get("clean_pyc", True))
+            clean_pycache = bool(cfg.get("clean_pycache", True))
+            if not clean_pyc and not clean_pycache:
+                log.log_info("Cleaner: nothing to do (both options disabled)")
+                return
+
             # Demander confirmation à l'utilisateur
-            response = dialog.msg_question(
-                title="Cleaner",
-                text="Do you want to clean the workspace (.pyc and __pycache__)?",
-                default_yes=True,
-            )
+            if ask_confirm:
+                response = dialog.msg_question(
+                    title="Cleaner",
+                    text="Do you want to clean the workspace (.pyc and __pycache__)?",
+                    default_yes=True,
+                )
 
-            if not response:
-                log.log_info("Cleaner cancelled by user")
-                return
+                if not response:
+                    log.log_info("Cleaner cancelled by user")
+                    return
 
             # Réinitialiser les compteurs
             self.cleaned_files = 0
@@ -107,46 +158,51 @@ def on_pre_compile(self, ctx: PreCompileContext) -> None:
                 try:
                     # Utiliser les patterns d'exclusion depuis bcasl.yml
                     exclude_patterns = ctx.get_exclude_patterns()
-                    for file_path in ctx.iter_files(["**/*.pyc"], exclude_patterns):
-                        pyc_files.append(file_path)
+                    if clean_pyc:
+                        for file_path in ctx.iter_files(["**/*.pyc"], exclude_patterns):
+                            pyc_files.append(file_path)
                 except Exception as e:
                     log.log_warn(f"Error iterating .pyc files: {e}")
 
                 # Étape 2: Supprimer les fichiers .pyc
-                progress.set_message("Removing .pyc files...")
-                progress.set_progress(0, len(pyc_files))
-
-                for idx, file_path in enumerate(pyc_files):
-                    if progress.is_canceled():
-                        break
-                    try:
-                        Path(file_path).unlink()
-                        self.cleaned_files += 1
-                    except Exception as e:
-                        log.log_warn(f"Failed to remove {file_path}: {e}")
-                    progress.set_progress(idx + 1, len(pyc_files))
+                if clean_pyc:
+                    progress.set_message("Removing .pyc files...")
+                    progress.set_progress(0, len(pyc_files))
+
+                    for idx, file_path in enumerate(pyc_files):
+                        if progress.is_canceled():
+                            break
+                        try:
+                            Path(file_path).unlink()
+                            self.cleaned_files += 1
+                        except Exception as e:
+                            log.log_warn(f"Failed to remove {file_path}: {e}")
+                        progress.set_progress(idx + 1, len(pyc_files))
 
                 # Étape 3: Parcourir et supprimer les dossiers __pycache__
-                progress.set_message("Removing __pycache__ directories...")
+                if clean_pycache:
+                    progress.set_message("Removing __pycache__ directories...")
 
                 pycache_dirs = []
                 try:
-                    for pycache_dir in workspace_path.rglob("__pycache__"):
-                        pycache_dirs.append(pycache_dir)
+                    if clean_pycache:
+                        for pycache_dir in workspace_path.rglob("__pycache__"):
+                            pycache_dirs.append(pycache_dir)
                 except Exception as e:
                     log.log_warn(f"Error iterating __pycache__ directories: {e}")
 
-                progress.set_progress(0, len(pycache_dirs))
-
-                for idx, pycache_dir in enumerate(pycache_dirs):
-                    if progress.is_canceled():
-                        break
-                    try:
-                        shutil.rmtree(pycache_dir)
-                        self.cleaned_dirs += 1
-                    except Exception as e:
-                        log.log_warn(f"Failed to remove {pycache_dir}: {e}")
-                    progress.set_progress(idx + 1, len(pycache_dirs))
+                if clean_pycache:
+                    progress.set_progress(0, len(pycache_dirs))
+
+                    for idx, pycache_dir in enumerate(pycache_dirs):
+                        if progress.is_canceled():
+                            break
+                        try:
+                            shutil.rmtree(pycache_dir)
+                            self.cleaned_dirs += 1
+                        except Exception as e:
+                            log.log_warn(f"Failed to remove {pycache_dir}: {e}")
+                        progress.set_progress(idx + 1, len(pycache_dirs))
 
             finally:
                 progress.close()

bcasl/Base.py

@@ -355,6 +355,20 @@ def get_full_compatibility_info(self) -> dict[str, str]:
     def apply_i18n(self, gui, tr: dict[str, str]) -> None:
         raise NotImplementedError
 
+    def build_config_tab(self, parent, ctx: "PreCompileContext", config: dict[str, Any]):
+        """Optionnel: construire un onglet UI de configuration pour la boîte BCASL.
+
+        Doit retourner soit:
+        - None (pas d'UI)
+        - Un widget Qt
+        - Un tuple (title, widget) ou (title, widget, on_save)
+        - Un dict {"title": ..., "widget": ..., "on_save": ...}
+
+        Le callback on_save (si fourni) sera appelé lors de l'enregistrement:
+            on_save(config_dict) -> dict | None
+        """
+        return None
+
 
 @dataclass
 class PreCompileContext:
@@ -398,14 +412,13 @@ def get_workspace_config(self) -> dict[str, Any]:
         return dict(cfg) if cfg else {}
 
     def get_workspace_metadata(self) -> dict[str, Any]:
-        """Retourne les métadonnées du workspace depuis bcasl.yml (fichiers requis, patterns, etc.)."""
+        """Retourne les métadonnées du workspace depuis bcasl.yml (patterns, etc.)."""
         cfg = self._load_bcasl_config()
         return {
             "workspace_name": self.project_root.name,
             "workspace_path": str(self.project_root),
             "file_patterns": cfg.get("file_patterns", []),
             "exclude_patterns": cfg.get("exclude_patterns", []),
-            "required_files": cfg.get("required_files", []),
         }
 
     def get_file_patterns(self) -> tuple[str, ...]:
@@ -420,20 +433,6 @@ def get_exclude_patterns(self) -> tuple[str, ...]:
         patterns = cfg.get("exclude_patterns", []) if isinstance(cfg, dict) else []
         return tuple(patterns) if patterns else ()
 
-    def get_required_files(self) -> tuple[str, ...]:
-        """Retourne la liste des fichiers requis du workspace depuis bcasl.yml."""
-        cfg = self._load_bcasl_config()
-        files = cfg.get("required_files", []) if isinstance(cfg, dict) else []
-        return tuple(files) if files else ()
-
-    def has_required_file(self, filename: str) -> bool:
-        """Vérifie si un fichier requis existe dans le workspace (basé sur bcasl.yml)."""
-        try:
-            required = self.get_required_files()
-            return filename in required and (self.project_root / filename).is_file()
-        except Exception:
-            return False
-
     def get_workspace_files(self, pattern: str = "**/*") -> list[Path]:
         """Retourne tous les fichiers du workspace correspondant au pattern (patterns depuis bcasl.yml)."""
         try: