Added script for generating modules.

tools/new_module.py

@@ -0,0 +1,221 @@
+import json
+import logging
+import os
+import shutil
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, Literal, Any, Callable
+
+sys.path.append(os.path.dirname(__file__))
+
+from common import exec_checked, prompt, prompt_and_validate, prompt_choices, run_script, escape_filename, prompt_yesno
+from common.jinja import is_jinja_installed, generate_file, render_string
+from new_source import run_new_source
+
+class _TemplateCustomizable: ...
+@dataclass
+class _TemplateOption:
+    name: str
+    message: str
+
+    @staticmethod
+    def from_json(type: str, **kwargs) -> '_TemplateOption':
+        tp = {
+            'choices': _TemplateOptionChoices
+        }[type]
+        return tp.from_json(**kwargs)
+
+@dataclass
+class _TemplateOptionChoices(_TemplateOption):
+    choices: list[str]
+
+    @staticmethod
+    def from_json(**kwargs) -> '_TemplateOptionChoices':
+        return _TemplateOptionChoices(**kwargs)
+
+
+@dataclass
+class _TemplateNewSource(_TemplateCustomizable):
+    header: Literal['public', 'private', 'no']
+    source: bool
+    path: str
+
+    @staticmethod
+    def from_json(**kwargs) -> '_TemplateNewSource':
+        return _TemplateNewSource(**kwargs)
+
+@dataclass
+class _TemplateConfig(_TemplateCustomizable):
+    options: list[_TemplateOption]
+    new_sources: list[_TemplateNewSource]
+
+    @staticmethod
+    def from_json(data: dict) -> '_TemplateConfig':
+        return _TemplateConfig(
+            options=[_TemplateOption.from_json(**ele) for ele in data.get('options', [])],
+            new_sources=[_TemplateNewSource.from_json(**ele) for ele in data.get('new_sources', [])]
+        )
+
+
+_PRIVATE_PATH = Path('private')
+_PUBLIC_PATH = Path('public')
+_TEMPLATE_BASE_PATH = Path(__file__).parent / 'templates/module'
+
+_logger = logging.getLogger(__name__)
+_module_folder_name: str
+_module_name: str
+_template_folder: Path
+_template_config: _TemplateConfig
+_template_options: dict[str, Any] = {}
+
+def verify_tools() -> None:
+    success = True
+    if not is_jinja_installed():
+        _logger.error('Python module Jinja2 is not installed.')
+        success = False
+    if not success:
+        raise RuntimeError('one or more required tools could not be found')
+
+def query_common_params() -> None:
+    global _module_folder_name, _module_name, _template_folder
+
+    def _validate_name(name: str) -> bool:
+        return name.strip() != ''
+
+    _module_name = prompt_and_validate('Enter module name.', _validate_name).strip()
+
+    _module_folder_name = escape_filename(_module_name.lower())
+    while True:
+        print(f'Please enter a folder name for the module. Leave empty for "{_module_folder_name}". Anything but [A-Za-z0-9_] will be replaced with underscores.')
+        new_name = prompt().strip()
+        if new_name != '':
+            _module_folder_name = escape_filename(new_name) # just enforce nice names
+        module_path = _PRIVATE_PATH / _module_folder_name
+        if not module_path.exists():
+            break
+        print(f'Module folder at {module_path} already exists.')
+
+
+    template_choices = {}
+    for subpath in sorted(_TEMPLATE_BASE_PATH.iterdir()):
+        if not subpath.is_dir():
+            continue
+        template_choices[subpath.name] = subpath
+    _template_folder = prompt_choices('Please select a module template.', template_choices)
+
+    # sanity check
+    if not (_template_folder / 'private/SModule.jinja').exists():
+        raise RuntimeError('module template appears to be invalid')
+
+def load_template_config() -> None:
+    global _template_config
+    config_file = _template_folder / 'config.json'
+    if not config_file.exists():
+        _template_config = {}
+        return
+    with config_file.open('r') as f:
+        try:
+            _template_config = _TemplateConfig.from_json(json.load(f))
+        except Exception as e:
+            raise RuntimeError(f'Error while parsing template config: {e}')
+
+def query_template_params() -> None:
+    def _query_choices(option: _TemplateOptionChoices) -> str:
+        return prompt_choices(option.message, {ele: ele for ele in option.choices})
+
+    _QUERY_FUNCS : dict[type[_TemplateOption], Callable] = {
+        _TemplateOptionChoices: _query_choices
+    }
+    for option in _template_config.options:
+        _template_options[option.name] = _QUERY_FUNCS[option.__class__](option)
+
+def generate_module() -> None:
+    # firest prepare the template context
+    context = {
+        'name': _module_name,
+        'target_name': _module_folder_name,
+        'folder_name': _module_folder_name,
+        **_template_options
+    }
+
+    # next parse templates in the config
+    def _replace_options(obj: _TemplateCustomizable) -> None:
+        def _process_value(value: Any, setter: Optional[Callable[[str], None]]) -> None:
+            if isinstance(value, str):
+                setter(render_string(value, context))
+            elif isinstance(value, list):
+                for idx in range(len(value)):
+                    def __set(v: str) -> None:
+                        value[idx] = v
+                    _process_value(value[idx], __set)
+            elif isinstance(value, dict):
+                for key in list(value.keys()):
+                    def __set(v: str) -> None:
+                        value[key] = v
+                    _process_value(value[key], __set)
+            elif isinstance(value, _TemplateCustomizable):
+                _process_value(value.__dict__, setter)
+        _process_value(obj.__dict__, None)
+    _replace_options(_template_config)
+
+    # then copy the files over
+    def _copy_template(src: Path, dst: Path) -> None:
+        dst.mkdir(parents=True, exist_ok=True)
+        for ele in src.iterdir():
+            dstele = dst / ele.name
+            if ele.is_dir():
+                _copy_template(ele, dstele)
+                continue
+            if ele.suffix == '.jinja':
+                generate_file(str(ele.relative_to(_template_folder)), dstele.with_suffix(''), context, templates_path=_template_folder)
+            else:
+                shutil.copyfile(ele, dstele)
+
+    template_private = _template_folder / 'private'
+    template_public = _template_folder / 'public'
+
+    _copy_template(template_private, _PRIVATE_PATH / _module_folder_name)
+
+    if template_public.exists():
+        _copy_template(template_public, _PUBLIC_PATH / _module_folder_name)
+
+    # and then generate sources
+    for new_source in _template_config.new_sources:
+        run_new_source(new_source.header, new_source.source, Path(new_source.path))
+
+def append_module() -> None:
+    print('Appending module to SConstruct file. You might want to adjust it.')
+
+    sconstruct_file = Path('SConstruct')
+    bak_file = sconstruct_file.with_suffix('.bak')
+
+    shutil.copyfile(sconstruct_file, bak_file)
+
+    with bak_file.open('r') as fin, sconstruct_file.open('w') as fout:
+        for line in fin:
+            if line.strip() == 'env.Finalize()':
+                fout.write(f'# {_module_name}\n')
+                fout.write(f"env = env.Module('{_PRIVATE_PATH / _module_folder_name}/SModule')\n")
+                fout.write('\n\n')
+            fout.write(line)
+
+def refresh_projects() -> None:
+    if Path('.idea').exists():
+        if prompt_yesno('CLion project found. Regenerate it?'):
+            exec_checked(('scons', '--generate_project=clion'))
+    if Path('.vscode').exists():
+        if prompt_yesno('VS Code project found. Regenerate it?'):
+            exec_checked(('scons', '--generate_project=vscode'))
+
+def script_main() -> None:
+    verify_tools()
+    query_common_params()
+    load_template_config()
+    query_template_params()
+    generate_module()
+    append_module()
+    refresh_projects()
+
+if __name__ == '__main__':
+    run_script(script_main)