[sourcegen] Use Jinja templates

Author: ischoegl

interfaces/sourcegen/sourcegen/_helpers.py

@@ -2,9 +2,7 @@
 # at https://cantera.org/license.txt for license and copyright information.
 
 from dataclasses import fields
-import inspect
 from pathlib import Path
-import textwrap
 try:
     from ruamel import yaml
 except ImportError:
@@ -25,30 +23,3 @@ def with_unpack_iter(cls: type) -> type:
     cls.__iter__ = lambda self: (getattr(self, f.name) for f in fields(self))
 
     return cls
-
-
-def hanging_text(text: str, spaces: int) -> str:
-    ret = ("\n" + " "*spaces).join(text.split("\n"))
-    return "\n".join([line.rstrip() for line in ret.split("\n")])
-
-
-def normalize_indent(code: str) -> str:
-    code = textwrap.dedent(code).strip()
-
-    call_line = inspect.stack()[1].code_context[0]
-
-    indent = len(call_line) - len(call_line.lstrip())
-
-    # If called inside a string interpolation, indent to the rest of the block.
-    # Look for the opening brace for the interpolation, which isn"t perfect, but works.
-    # This will fire for lines such as “        {normalize(my_str)}”
-    if call_line[indent] == "{":
-        code = textwrap.indent(code, " " * indent)
-
-        code = code[indent:]
-
-    return code
-
-
-def get_preamble() -> str:
-    return Path(__file__).parent.joinpath("preamble.txt").read_text("utf-8").strip()

interfaces/sourcegen/sourcegen/_orchestrate.py

@@ -34,7 +34,8 @@ def generate_source(lang: str, out_dir: str=""):
 
     module = importlib.import_module(__package__ + "." + lang)
     root = Path(module.__file__).parent
-    config = read_config(root.joinpath("config.yaml"))
+    config = read_config(root / "config.yaml")
+    templates = read_config(root / "templates.yaml")
     ignore_files: List[str] = config.pop("ignore_files", [])
     ignore_funcs: Dict[str, List[str]] = config.pop("ignore_funcs", {})
 
@@ -43,7 +44,7 @@ def generate_source(lang: str, out_dir: str=""):
     # find and instantiate the language-specific SourceGenerator
     _, scaffolder_type = inspect.getmembers(module,
         lambda m: inspect.isclass(m) and issubclass(m, SourceGenerator))[0]
-    scaffolder: SourceGenerator = scaffolder_type(out_dir, config)
+    scaffolder: SourceGenerator = scaffolder_type(out_dir, config, templates)
 
     scaffolder.generate_source(files)
     _logger.info("Done.")

interfaces/sourcegen/sourcegen/csharp/_CSharpSourceGenerator.py

@@ -1,52 +1,26 @@
 # This file is part of Cantera. See License.txt in the top-level directory or
 # at https://cantera.org/license.txt for license and copyright information.
 
-from itertools import starmap
 from pathlib import Path
 import sys
 import logging
 from typing import List, Dict
 import re
-import textwrap
+
+from jinja2 import Environment, BaseLoader
 
 from ._dataclasses import CsFunc
 from ._Config import Config
-from .._helpers import normalize_indent, hanging_text
 from .._dataclasses import Func, Param, HeaderFile, ArgList
 from .._SourceGenerator import SourceGenerator
 
 
 _logger = logging.getLogger()
+_loader = Environment(loader=BaseLoader)
 
 class CSharpSourceGenerator(SourceGenerator):
     """The SourceGenerator for scaffolding C# files for the .NET interface"""
 
-    def _get_interop_func_text(self, func: CsFunc) -> str:
-        ret = f"{self._config.func_prolog} "
-        if func.unsafe():
-            ret += "unsafe "
-        ret += f"{func.declaration()};"  # function text
-        return ret
-
-    @staticmethod
-    def _get_base_handle_text(class_name: str, release_func_name: str) -> str:
-        handle = normalize_indent(f"""
-            class {class_name} : CanteraHandle
-            {{
-                protected override bool ReleaseHandle() =>
-                    LibCantera.{release_func_name}(Value) == InteropConsts.Success;
-            }}
-        """)
-
-        return handle
-
-    @staticmethod
-    def _get_derived_handle_text(derived_class_name: str, base_class_name: str) -> str:
-        derived_text = f"""class {derived_class_name} : {base_class_name} {{ }}"""
-
-        return derived_text
-
-
     def _get_property_text(self, clib_area: str, c_name: str, cs_name: str,
                            known_funcs: Dict[str, CsFunc]) -> str:
         getter = known_funcs.get(clib_area + "_" + c_name)
@@ -61,58 +35,37 @@ def _get_property_text(self, clib_area: str, c_name: str, cs_name: str,
             # from which we determine the appropriate C# type
             prop_type = self._config.prop_type_crosswalk[getter.arglist[-1].p_type]
 
-        setter = known_funcs.get(clib_area + "_set" + c_name.capitalize())
+        setter = known_funcs.get(
+            clib_area + "_set" + c_name.capitalize(),
+            CsFunc("", "", "", "", ""))
 
         if prop_type in ["int", "double"]:
-            text = f"""
-                public {prop_type} {cs_name}
-                {{
-                    get => InteropUtil.CheckReturn(
-                        LibCantera.{getter.name}(_handle));"""
-
-            if setter:
-                text += f"""
-                    set => InteropUtil.CheckReturn(
-                        LibCantera.{setter.name}(_handle, value));"""
-
-            text += """
-                }
-            """
-        elif prop_type == "string":
-            p_type = getter.arglist[1].p_type
+            template = _loader.from_string(self._templates["csharp-property-int-double"])
+            return template.render(
+                prop_type=prop_type, cs_name=cs_name,
+                getter=getter.name, setter=setter.name)
 
+        if prop_type == "string":
             # for get-string type functions we need to look up the type of the second
             # (index 1) param for a cast because sometimes it"s an int and other times
             # its a nuint (size_t)
-            text = f"""
-                public unsafe string {cs_name}
-                {{
-                    get => InteropUtil.GetString(40, (length, buffer) =>
-                        LibCantera.{getter.name}(_handle, ({p_type}) length, buffer));
-            """
-
-            if setter:
-                text += f"""
-                    set => InteropUtil.CheckReturn(
-                        LibCantera.{setter.name}(_handle, value));"""
-
-            text += """
-                }
-            """
-        else:
-            _logger.critical(f"Unable to scaffold properties of type {prop_type!r}!")
-            sys.exit(1)
+            template = _loader.from_string(self._templates["csharp-property-string"])
+            return template.render(
+                cs_name=cs_name, p_type=getter.arglist[1].p_type,
+                getter=getter.name, setter=setter.name)
 
-        return normalize_indent(text)
+        _logger.critical(f"Unable to scaffold properties of type {prop_type!r}!")
+        sys.exit(1)
 
-    def __init__(self, out_dir: str, config: dict):
+    def __init__(self, out_dir: str, config: dict, templates: dict):
         if not out_dir:
             _logger.critical("Non-empty string identifying output path required.")
             sys.exit(1)
         self._out_dir = Path(out_dir)
 
         # use the typed config
         self._config = Config.from_parsed(**config)
+        self._templates = templates
 
     def _get_wrapper_class_name(self, clib_area: str) -> str:
         return self._config.class_crosswalk[clib_area]
@@ -197,94 +150,59 @@ def _convert_func(self, parsed: Func) -> CsFunc:
 
         return func
 
-    def _write_file(self, filename: str, contents: str):
-        _logger.info(f"  writing {filename!r}")
+    def _write_file(self, file_name: str, template_name: str, **kwargs) -> None:
+        _logger.info(f"  writing {file_name!r}")
+        template = _loader.from_string(self._templates["csharp-preamble"])
+        preamble = template.render(file_name=file_name)
 
-        self._out_dir.joinpath(filename).write_text(contents, encoding="utf-8")
+        template = _loader.from_string(self._templates[template_name])
+        contents = template.render(preamble=preamble, **kwargs)
 
-    def _scaffold_interop(self, header_file_path: Path, cs_funcs: List[CsFunc]):
-        functions_text = "\n\n".join(map(self._get_interop_func_text, cs_funcs))
-
-        interop_text = textwrap.dedent(f"""
-            {hanging_text(self._config.preamble, 12)}
-
-            using System.Runtime.InteropServices;
-
-            namespace Cantera.Interop;
+        self._out_dir.joinpath(file_name).write_text(contents, encoding="utf-8")
 
-            static partial class LibCantera
-            {{
-                {hanging_text(functions_text, 16)}
-            }}
-        """).lstrip()
+    def _scaffold_interop(self, header_file_path: Path, cs_funcs: List[CsFunc]):
+        template = _loader.from_string(self._templates["csharp-interop-func"])
+        function_list = [
+            template.render(unsafe=func.unsafe(), declaration=func.declaration())
+            for func in cs_funcs]
 
-        self._write_file("Interop.LibCantera." + header_file_path.name + ".g.cs",
-            interop_text)
+        file_name = "Interop.LibCantera." + header_file_path.name + ".g.cs"
+        self._write_file(
+            file_name, "csharp-scaffold-interop", cs_functions=function_list)
 
     def _scaffold_handles(self, header_file_path: Path, handles: Dict[str, str]):
-        handles_text = "\n\n".join(starmap(self._get_base_handle_text, handles.items()))
-
-        handles_text = textwrap.dedent(f"""
-            {hanging_text(self._config.preamble, 12)}
-
-            namespace Cantera.Interop;
-
-            {hanging_text(handles_text, 12)}
-        """).lstrip()
+        template = _loader.from_string(self._templates["csharp-base-handle"])
+        handle_list = [
+            template.render(class_name=key, release_func_name=val)
+            for key, val in handles.items()]
 
-        self._write_file("Interop.Handles." + header_file_path.name + ".g.cs",
-            handles_text)
+        file_name = "Interop.Handles." + header_file_path.name + ".g.cs"
+        self._write_file(
+            file_name, "csharp-scaffold-handles", cs_handles=handle_list)
 
     def _scaffold_derived_handles(self):
-        derived_handles = "\n\n".join(starmap(self._get_derived_handle_text,
-            self._config.derived_handles.items()))
+        template = _loader.from_string(self._templates["csharp-derived-handle"])
+        handle_list = [
+            template.render(derived_class_name=key, base_class_name=val)
+            for key, val in self._config.derived_handles.items()]
 
-        derived_handles_text = textwrap.dedent(f"""
-            {hanging_text(self._config.preamble, 12)}
-
-            namespace Cantera.Interop;
-
-            {hanging_text(derived_handles, 12)}
-        """).lstrip()
-
-        self._write_file("Interop.Handles.g.cs", derived_handles_text)
+        file_name = "Interop.Handles.g.cs"
+        self._write_file(
+            file_name, "csharp-scaffold-handles", cs_handles=handle_list)
 
     def _scaffold_wrapper_class(self, clib_area: str, props: Dict[str, str],
                                 known_funcs: Dict[str, CsFunc]):
-        wrapper_class_name = self._get_wrapper_class_name(clib_area)
-        handle_class_name = self._get_handle_class_name(clib_area)
-
-        properties_text = "\n\n".join(
+        property_list = [
             self._get_property_text(clib_area, c_name, cs_name, known_funcs)
-                for (c_name, cs_name) in props.items())
-
-        wrapper_class_text = textwrap.dedent(f"""
-            {hanging_text(self._config.preamble, 12)}
-
-            using Cantera.Interop;
+            for c_name, cs_name in props.items()]
 
-            namespace Cantera;
-
-            public partial class {wrapper_class_name} : IDisposable
-            {{
-                readonly {handle_class_name} _handle;
-
-                #pragma warning disable CS1591
-
-                {hanging_text(properties_text, 16)}
-
-                #pragma warning restore CS1591
-
-                /// <summary>
-                /// Frees the underlying resources used by the
-                /// native Cantera library for this instance.
-                /// </summary>
-                public void Dispose() =>
-                    _handle.Dispose();
-            }}
-        """).lstrip()
-
-        self._write_file(wrapper_class_name + ".g.cs", wrapper_class_text)
+        wrapper_class_name = self._get_wrapper_class_name(clib_area)
+        handle_class_name = self._get_handle_class_name(clib_area)
+        file_name = wrapper_class_name + ".g.cs"
+        self._write_file(
+            file_name, "csharp-scaffold-wrapper-class",
+            wrapper_class_name=wrapper_class_name, handle_class_name=handle_class_name,
+            cs_properties=property_list)
 
     def generate_source(self, headers_files: List[HeaderFile]):
         self._out_dir.mkdir(parents=True, exist_ok=True)

interfaces/sourcegen/sourcegen/csharp/_Config.py

@@ -4,19 +4,12 @@
 from dataclasses import dataclass
 from typing import Dict
 
-from .._helpers import get_preamble, normalize_indent
-
 
 @dataclass(frozen=True)
 class Config:
     """Provides configuration info for the CSharpSourceGenerator class"""
 
 
-    func_prolog = normalize_indent("""
-        [DllImport(LibFile)]
-        public static extern
-    """)
-
     ret_type_crosswalk = {
         "const char*": "string",
         "const double*": "double[]",
@@ -30,9 +23,6 @@ class Config:
         "double*": "double[]"
     }
 
-    # Reformat preamble to standard comment block
-    preamble = "\n * ".join(["/*"] + get_preamble().split("\n")) + "\n */"
-
     # These we load from the parsed YAML config file
     class_crosswalk: Dict[str, str]