Separate GL features parsing based on canonical name and calculated graph

Signed-off-by: Tobias Wolf <wolf@b1-systems.de>

Author: NotTheEvilOne

src/gardenlinux/features/parser.py

@@ -137,34 +137,8 @@ def filter(
         :since:  0.7.0
         """
 
-        input_features = Parser.get_cname_as_feature_set(cname)
-        filter_set = input_features.copy()
-
-        # @TODO: Remove "special" handling once "bare" is a first-class citizen of the feature graph
-        if "bare" in input_features:
-            if not self.graph.has_node("bare"):
-                self.graph.add_node("bare", content=BARE_FLAVOR_FEATURE_CONTENT)
-            if not self.graph.has_node("libc"):
-                self.graph.add_node("libc", content=BARE_FLAVOR_LIBC_FEATURE_CONTENT)
-
-        for feature in input_features:
-            filter_set.update(
-                networkx.descendants(
-                    Parser._get_graph_view_for_attr(self.graph, "include"), feature
-                )
-            )
-
-        graph = networkx.subgraph_view(
-            self.graph,
-            filter_node=self._get_filter_set_callable(
-                filter_set, additional_filter_func
-            ),
-        )
-
-        if not ignore_excludes:
-            Parser._exclude_from_filter_set(graph, input_features, filter_set)
-
-        return graph
+        feature_set = Parser.get_cname_as_feature_set(cname)
+        return self.filter_based_on_feature_set(feature_set, ignore_excludes, additional_filter_func)
 
     def filter_as_dict(
         self,
@@ -184,19 +158,7 @@ def filter_as_dict(
         """
 
         graph = self.filter(cname, ignore_excludes, additional_filter_func)
-        features = Parser.sort_reversed_graph_nodes(graph)
-
-        features_by_type = {}
-
-        for feature in features:
-            node_type = Parser._get_graph_node_type(graph.nodes[feature])
-
-            if node_type not in features_by_type:
-                features_by_type[node_type] = []
-
-            features_by_type[node_type].append(feature)
-
-        return features_by_type
+        return self.filter_graph_as_dict(graph)
 
     def filter_as_list(
         self,
@@ -216,7 +178,7 @@ def filter_as_list(
         """
 
         graph = self.filter(cname, ignore_excludes, additional_filter_func)
-        return Parser.sort_reversed_graph_nodes(graph)
+        return self.filter_graph_as_list(graph)
 
     def filter_as_string(
         self,
@@ -236,15 +198,116 @@ def filter_as_string(
         """
 
         graph = self.filter(cname, ignore_excludes, additional_filter_func)
+        return self.filter_graph_as_string(graph)
+
+    def filter_graph_as_dict(
+        self,
+        graph: networkx.Graph,
+    ) -> dict:
+        """
+        Filters the features graph and returns it as a dict.
+
+        :param graph: Features graph
+
+        :return: (dict) List of features for a given cname, split into platform, element and flag
+        :since:  0.9.2
+        """
+
         features = Parser.sort_reversed_graph_nodes(graph)
 
+        features_by_type = {}
+
+        for feature in features:
+            node_type = Parser._get_graph_node_type(graph.nodes[feature])
+
+            if node_type not in features_by_type:
+                features_by_type[node_type] = []
+
+            features_by_type[node_type].append(feature)
+
+        return features_by_type
+
+    def filter_graph_as_list(
+        self,
+        graph: networkx.Graph,
+    ) -> list:
+        """
+        Filters the features graph and returns it as a list.
+
+        :param graph: Features graph
+
+        :return: (list) Features list for a given cname
+        :since:  0.9.2
+        """
+
+        return Parser.sort_reversed_graph_nodes(graph)
+
+    def filter_graph_as_string(
+        self,
+        graph: networkx.Graph,
+    ) -> str:
+        """
+        Filters the features graph and returns it as a string.
+
+        :param graph: Features graph
+
+        :return: (str) Comma separated string with the expanded feature set for the cname
+        :since:  0.9.2
+        """
+
+        features = Parser.sort_reversed_graph_nodes(graph)
         return ",".join(features)
 
-    def _exclude_from_filter_set(graph, input_features, filter_set):
+    def filter_based_on_feature_set(
+        self,
+        feature_set: (str,),
+        ignore_excludes: bool = False,
+        additional_filter_func: Optional[Callable[(str,), bool]] = None,
+    ) -> networkx.Graph:
+        """
+        Filters the features graph based on a feature set given.
+
+        :param feature_set:            Feature set to filter
+        :param ignore_excludes:        Ignore `exclude` feature files
+        :param additional_filter_func: Additional filter function
+
+        :return: (networkx.Graph) Filtered features graph
+        :since:  0.9.2
+        """
+
+        filter_set = feature_set.copy()
+
+        # @TODO: Remove "special" handling once "bare" is a first-class citizen of the feature graph
+        if "bare" in feature_set:
+            if not self.graph.has_node("bare"):
+                self.graph.add_node("bare", content=BARE_FLAVOR_FEATURE_CONTENT)
+            if not self.graph.has_node("libc"):
+                self.graph.add_node("libc", content=BARE_FLAVOR_LIBC_FEATURE_CONTENT)
+
+        for feature in feature_set:
+            filter_set.update(
+                networkx.descendants(
+                    Parser._get_graph_view_for_attr(self.graph, "include"), feature
+                )
+            )
+
+        graph = networkx.subgraph_view(
+            self.graph,
+            filter_node=self._get_filter_set_callable(
+                filter_set, additional_filter_func
+            ),
+        )
+
+        if not ignore_excludes:
+            Parser._exclude_from_filter_set(graph, feature_set, filter_set)
+
+        return graph
+
+    def _exclude_from_filter_set(graph, feature_set, filter_set):
         """
-        Removes the given `filter_set` out of `input_features`.
+        Removes the given `filter_set` out of `feature_set`.
 
-        :param input_features: Features
+        :param feature_set: Features
         :param filter_set: Set to filter out
 
         :since: 0.7.0
@@ -259,7 +322,7 @@ def _exclude_from_filter_set(graph, input_features, filter_set):
                     exclude_list.append(exclude)
 
         for exclude in exclude_list:
-            if exclude in input_features:
+            if exclude in feature_set:
                 raise ValueError(
                     f"Excluding explicitly included feature {exclude}, unsatisfiable condition"
                 )