use tclint as parser / formatter

server/libs/tclint/commands/plugins.py

@@ -0,0 +1,86 @@
+from importlib_metadata import entry_points
+import json
+import pathlib
+from typing import Dict, Optional
+from types import ModuleType
+
+import voluptuous
+
+from tclint.commands.schema import schema as command_schema
+
+
+class _PluginManager:
+    def __init__(self):
+        self._loaded = {}
+        self._installed = {}
+        self._loaded_specs = {}
+        for plugin in entry_points(group="tclint.plugins"):
+            if plugin.name in self._installed:
+                print(f"Warning: found duplicate definitions for plugin {plugin.name}")
+            self._installed[plugin.name] = plugin
+
+    def load(self, name: str) -> Optional[Dict]:
+        if name in self._loaded:
+            return self._loaded[name]
+
+        mod = self._load(name)
+        self._loaded[name] = mod
+        return mod
+
+    def load_from_spec(self, path: pathlib.Path) -> Optional[Dict]:
+        if path in self._loaded_specs:
+            return self._loaded_specs[path]
+
+        spec = self._load_from_spec(path)
+        self._loaded_specs[path] = spec
+        return spec
+
+    def _load_from_spec(self, path: pathlib.Path) -> Optional[Dict]:
+        try:
+            with open(path.expanduser(), "r") as f:
+                spec = json.load(f)
+        except (FileNotFoundError, RuntimeError):
+            print(f"Warning: command spec {path} not found, skipping...")
+            return None
+
+        try:
+            # Apply defaults and validate the spec.
+            spec = command_schema(spec)
+        except voluptuous.Invalid as e:
+            print(f"Warning: invalid command spec {path}: {e}")
+            return None
+
+        return spec["commands"]
+
+    def get_mod(self, name: str) -> Optional[ModuleType]:
+        if name not in self._installed:
+            print(f"Warning: plugin {name} is not installed")
+            return None
+
+        plugin = self._installed[name]
+
+        try:
+            module = plugin.load()
+        except Exception as e:
+            print(f"Warning: error loading plugin {name}: {e}")
+            return None
+
+        return module
+
+    def _load(self, name: str):
+        module = self.get_mod(name)
+        if module is None:
+            print(f"Skipping requested plugin {name}")
+            return None
+
+        if not hasattr(module, "commands"):
+            print(f"Warning: skipping plugin {name} since it does not define commands")
+            return None
+
+        return getattr(module, "commands")
+
+
+# TODO: we'll probably want to construct this in the tclint entry point and pass
+# it around rather than using a singleton instance, but this made for an easier
+# refactor.
+PluginManager = _PluginManager()