1 files changed, 120 insertions, 0 deletions
diff --git a/docs/refman/generatorjson.py b/docs/refman/generatorjson.py
new file mode 100644
index 0000000..f5164d4
--- /dev/null
+++ b/docs/refman/generatorjson.py
@@ -0,0 +1,120 @@
+# SPDX-License-Identifer: Apache-2.0
+# Copyright 2021 The Meson development team
+
+from pathlib import Path
+import json
+import re
+
+from .generatorbase import GeneratorBase
+from . import jsonschema as J
+from .model import (
+    ReferenceManual,
+    Function,
+    Object,
+    Type,
+
+    PosArg,
+    VarArgs,
+    Kwarg,
+)
+
+import typing as T
+
+class GeneratorJSON(GeneratorBase):
+    def __init__(self, manual: ReferenceManual, out: Path, enable_modules: bool) -> None:
+        super().__init__(manual)
+        self.out = out
+        self.enable_modules = enable_modules
+
+    def _generate_type(self, typ: Type) -> T.List[J.Type]:
+        return [
+            {
+                'obj': x.data_type.name,
+                'holds': self._generate_type(x.holds) if x.holds else [],
+            }
+            for x in typ.resolved
+        ]
+
+    def _generate_type_str(self, typ: Type) -> str:
+        # Remove all whitespaces
+        return re.sub(r'[ \n\r\t]', '', typ.raw)
+
+    def _generate_arg(self, arg: T.Union[PosArg, VarArgs, Kwarg], isOptarg: bool = False) -> J.Argument:
+        return {
+            'name': arg.name,
+            'description': arg.description,
+            'since': arg.since if arg.since else None,
+            'deprecated': arg.deprecated if arg.deprecated else None,
+            'type': self._generate_type(arg.type),
+            'type_str': self._generate_type_str(arg.type),
+            'required': arg.required if isinstance(arg, Kwarg) else not isOptarg and not isinstance(arg, VarArgs),
+            'default': arg.default if isinstance(arg, (PosArg, Kwarg)) else None,
+            'min_varargs': arg.min_varargs if isinstance(arg, VarArgs) and arg.min_varargs > 0 else None,
+            'max_varargs': arg.max_varargs if isinstance(arg, VarArgs) and arg.max_varargs > 0 else None,
+
+            # Not yet supported
+            'notes': [],
+            'warnings': [],
+        }
+
+    def _generate_function(self, func: Function) -> J.Function:
+        return {
+            'name': func.name,
+            'description': func.description,
+            'since': func.since if func.since else None,
+            'deprecated': func.deprecated if func.deprecated else None,
+            'notes': func.notes,
+            'warnings': func.warnings,
+            'example': func.example if func.example else None,
+            'returns': self._generate_type(func.returns),
+            'returns_str': self._generate_type_str(func.returns),
+            'posargs': {x.name: self._generate_arg(x) for x in func.posargs},
+            'optargs': {x.name: self._generate_arg(x, True) for x in func.optargs},
+            'kwargs': {x.name: self._generate_arg(x) for x in self.sorted_and_filtered(list(func.kwargs.values()))},
+            'varargs': self._generate_arg(func.varargs) if func.varargs else None,
+        }
+
+    def _generate_objects(self, obj: Object) -> J.Object:
+        return {
+            'name': obj.name,
+            'description': obj.description,
+            'since': obj.since if obj.since else None,
+            'deprecated': obj.deprecated if obj.deprecated else None,
+            'notes': obj.notes,
+            'warnings': obj.warnings,
+            'defined_by_module': obj.defined_by_module.name if obj.defined_by_module else None,
+            'object_type': obj.obj_type.name,
+            'is_container': obj.is_container,
+            'example': obj.example if obj.example else None,
+            'extends': obj.extends if obj.extends else None,
+            'returned_by': [x.name for x in self.sorted_and_filtered(obj.returned_by)],
+            'extended_by': [x.name for x in self.sorted_and_filtered(obj.extended_by)],
+            'methods': {x.name: self._generate_function(x) for x in self.sorted_and_filtered(obj.methods)},
+        }
+
+    def _extract_meson_version(self) -> str:
+        # Hack around python relative imports to get to the Meson version
+        import sys
+        sys.path.append(Path(__file__).resolve().parents[2].as_posix())
+        from mesonbuild.coredata import version
+        return version
+
+    def generate(self) -> None:
+        data: J.Root = {
+            'version_major': J.VERSION_MAJOR,
+            'version_minor': J.VERSION_MINOR,
+            'meson_version': self._extract_meson_version(),
+            'functions': {x.name: self._generate_function(x) for x in self.sorted_and_filtered(self.functions)},
+            'objects': {x.name: self._generate_objects(x) for x in self.sorted_and_filtered(self.objects)},
+            'objects_by_type': {
+                'elementary': [x.name for x in self.elementary],
+                'builtins': [x.name for x in self.builtins],
+                'returned': [x.name for x in self.returned],
+                'modules': {
+                    x.name: [y.name for y in self.sorted_and_filtered(self.extract_returned_by_module(x))]
+                    for x in self.modules
+                },
+            },
+        }
+
+        self.out.write_text(json.dumps(data), encoding='utf-8')