Add mechanism to ignore everything by default

Author: virtuald

robotpy_build/autowrap/generator_data.py

@@ -40,10 +40,6 @@ class ClsReportData:
     functions: FnMissingData = dataclasses.field(default_factory=dict)
 
 
-_default_enum_data = EnumData()
-_default_fn_data = FunctionData()
-
-
 class GeneratorData:
     """
     Used by the hooks to retrieve user-specified generation data, and
@@ -55,6 +51,13 @@ class GeneratorData:
     def __init__(self, data: AutowrapConfigYaml):
         self.data = data
 
+        default_ignore = self.data.defaults.ignore
+        self._default_enum_data = EnumData(ignore=default_ignore)
+        self._default_fn_data = FunctionData(ignore=default_ignore)
+        self._default_method_data = FunctionData()
+        self._default_class_data = ClassData(ignore=default_ignore)
+        self._default_class_enum_data = EnumData()
+
         # report data
         self.functions: FnMissingData = {}
         self.classes: Dict[str, ClsReportData] = {}
@@ -68,7 +71,7 @@ def get_class_data(self, name: str) -> ClassData:
         data = self.data.classes.get(name)
         missing = data is None
         if missing:
-            data = ClassData()
+            data = self._default_class_data
 
         self.classes[name] = ClsReportData(missing=missing)
         return data
@@ -78,19 +81,19 @@ def get_cls_enum_data(
     ) -> EnumData:
         if name is None:
             # TODO
-            return _default_enum_data
+            return self._default_class_enum_data
         data = cls_data.enums.get(name)
         if data is None:
             self.classes[cls_key].enums[name] = False
-            data = _default_enum_data
+            data = self._default_class_enum_data
 
         return data
 
     def get_enum_data(self, name: str) -> EnumData:
         data = self.data.enums.get(name)
         if data is None:
             self.enums[name] = False
-            data = _default_enum_data
+            data = self._default_enum_data
         return data
 
     def get_function_data(
@@ -124,7 +127,10 @@ def get_function_data(
         # signature each time we defer it until we actually need to use it
 
         if missing:
-            data = _default_fn_data
+            if cls_key:
+                data = self._default_method_data
+            else:
+                data = self._default_fn_data
             report_data.deferred_signatures.append((fn, is_private))
         elif not data.overloads:
             report_data.deferred_signatures.append((fn, True))
@@ -187,22 +193,39 @@ def report_missing(self, name: str, reporter: "MissingReporter"):
         data yaml and print it out if there's missing data
         """
 
+        ignore_default = self.data.defaults.ignore
+        report_missing = True
+        if ignore_default and not self.data.defaults.report_ignored_missing:
+            report_missing = False
+
         # note: sometimes we have strings from CppHeaderParser that aren't
         # strings, so we need to cast them to str so yaml doesn't complain
 
         data = self._process_missing(
-            self.attributes, self.functions, self.enums, "functions"
+            self.attributes,
+            self.functions,
+            self.enums,
+            "functions",
+            ignore_default,
+            report_missing,
         )
 
         all_cls_data = {}
         for cls_key, cls_data in self.classes.items():
+            if cls_data.missing and not report_missing:
+                continue
+
             result = self._process_missing(
                 cls_data.attributes,
                 cls_data.functions,
                 cls_data.enums,
                 "methods",
+                False,
+                True,
             )
             if result or cls_data.missing:
+                if ignore_default and cls_data.missing:
+                    result["ignore"] = True
                 all_cls_data[str(cls_key)] = result
         if all_cls_data:
             data["classes"] = all_cls_data
@@ -218,6 +241,8 @@ def _process_missing(
         fns: FnMissingData,
         enums: EnumMissingData,
         fn_key: str,
+        ignore_default: bool,
+        report_missing: bool,
     ):
         data: Dict[str, Dict[str, Dict]] = {}
 
@@ -230,11 +255,22 @@ def _process_missing(
 
         # enums
         if enums:
-            data["enums"] = {str(n): {} for n in enums.keys()}
+            enums_report = {}
+            for en, enum_present in enums.items():
+                if not enum_present and not report_missing:
+                    continue
+                enums_report[en] = {}
+                if ignore_default:
+                    enums_report[en]["ignore"] = True
+            if enums_report:
+                data["enums"] = enums_report
 
         # functions
         fn_report = {}
         for fn, fndata in fns.items():
+            if fndata.missing and not report_missing:
+                continue
+
             fn = str(fn)
             overloads = fndata.overloads
             deferred_signatures = fndata.deferred_signatures
@@ -264,8 +300,12 @@ def _process_missing(
                     for k, v in fn_report[fn]["overloads"].items():
                         if "initializer_list" in k:
                             v["ignore"] = True
+                        if ignore_default:
+                            v["ignore"] = True
                 else:
                     fn_report[fn] = d
+                    if ignore_default:
+                        d["ignore"] = True
         if fn_report:
             data[fn_key] = fn_report
 

robotpy_build/config/autowrap_yml.py

@@ -6,7 +6,7 @@
 import enum
 from typing import Dict, List, Tuple, Optional
 
-from pydantic import validator
+from pydantic import validator, Field
 from .util import Model, _generating_documentation
 import yaml
 
@@ -463,12 +463,27 @@ class MyClass {};
     doc_append: Optional[str] = None
 
 
+class Defaults(Model):
+    """
+    Defaults to apply to everything
+    """
+
+    #: Set this to True to ignore functions/enums/classes at namespace scope
+    #: by default if they aren't present in the YAML
+    ignore: bool = False
+
+    #: If False and default ignore is True, don't report missing items
+    report_ignored_missing: bool = True
+
+
 class AutowrapConfigYaml(Model):
     """
     Format of the file in [tool.robotpy-build.wrappers."PACKAGENAME"]
     generation_data
     """
 
+    defaults: Defaults = Field(default_factory=Defaults)
+
     strip_prefixes: List[str] = []
 
     #: Adds ``#include <FILENAME>`` directives to the top of the autogenerated

tests/cpp/gen/ft/ignored_by_default.yml

@@ -0,0 +1,17 @@
+defaults:
+  ignore: true
+  # report_ignored_missing: false
+
+enums:
+  id_EnabledEnum:
+    ignore: false
+functions:
+  id_fnEnable:
+    ignore: false
+classes:
+  id_EnabledClass:
+    ignore: false
+    enums:
+      InnerEnum:
+    methods:
+      fn:

tests/cpp/pyproject.toml.tmpl

@@ -55,6 +55,7 @@ generate = [
     { fields = "fields.h" },
     { keepalive = "keepalive.h" },
     { ignore = "ignore.h" },
+    { ignored_by_default = "ignored_by_default.h" },
     { inline_code = "inline_code.h" },
     { lifetime = "lifetime.h" },
     { nested = "nested.h" },

tests/cpp/rpytest/ft/include/ignored_by_default.h

@@ -0,0 +1,39 @@
+
+#pragma once
+
+//
+// Ignore everything by default, but enable some things
+//
+
+int id_fnIgnore(void) { return 1; }
+int id_fnEnable(void) { return 2; }
+
+enum id_IgnoredEnum {
+    Param1 = 1,
+    Param2 = 2,
+};
+
+enum id_EnabledEnum {
+    Param3 = 3,
+    Param4 = 4,
+};
+
+struct id_IgnoreClass {
+    enum InnerEnum { 
+        Param5 = 5,
+    };
+};
+
+struct id_EnabledClass {
+    enum InnerEnum { 
+        Param6 = 6,
+    };
+    enum InnerEnumMissing { 
+        Param7 = 7,
+    };
+
+    int fn() { return 3; }
+
+    // not in yaml but still works
+    int fn_missing() { return 4; }
+};

tests/test_ft_ignore.py

@@ -29,3 +29,27 @@ def test_ignored_enums():
 
     assert not hasattr(ft.EnumWithIgnored, "Ignored")
     assert ft.EnumWithIgnored.NotIgnored == 1
+
+
+#
+# ignored_by_default
+#
+
+
+def test_ignored_by_default_fn():
+    assert not hasattr(ft._rpytest_ft, "id_fnIgnore")
+    assert ft._rpytest_ft.id_fnEnable() == 2
+
+
+def test_ignored_by_default_enum():
+    assert not hasattr(ft._rpytest_ft, "id_IgnoredEnum")
+    assert ft._rpytest_ft.id_EnabledEnum.Param3 == 3
+
+
+def test_ignored_by_default_class():
+    assert not hasattr(ft._rpytest_ft, "id_IgnoreClass")
+    o = ft._rpytest_ft.id_EnabledClass()
+    assert o.fn() == 3
+    assert o.fn_missing() == 4
+    assert ft._rpytest_ft.id_EnabledClass.InnerEnum.Param6 == 6
+    assert ft._rpytest_ft.id_EnabledClass.InnerEnumMissing.Param7 == 7