feat: Profiles can now be enabled or disabled, also with a condition. Profiles can now also be selected with a wildcard pattern.

Author: d-biehl

Diff for: etc/robot.toml.json

@@ -6,6 +6,22 @@
     }
   ],
   "definitions": {
+    "Condition": {
+      "additionalProperties": false,
+      "description": "Condition(if_: 'str')",
+      "properties": {
+        "if": {
+          "description": "Condition to evaluate. This must be a Python \"eval\" expression.\nFor security reasons, only certain expressions and functions are allowed.\n\nExamples:\n```toml\nif = \"re.match(r'^\\d+$', environ.get('TEST_VAR', ''))\"\nif = \"platform.system() == 'Linux'\"\n```\n",
+          "title": "If ",
+          "type": "string"
+        }
+      },
+      "required": [
+        "if"
+      ],
+      "title": "Condition",
+      "type": "object"
+    },
     "LibDocProfile": {
       "additionalProperties": false,
       "description": "LibDocProfile(extra_python_path: 'Optional[List[str]]' = None, doc_format: \"Optional[Literal['ROBOT', 'HTML', 'TEXT', 'REST']]\" = None, format: \"Optional[Literal['HTML', 'XML', 'JSON', 'LIBSPEC']]\" = None, name: 'Optional[str]' = None, python_path: 'Optional[List[str]]' = None, quiet: 'Union[bool, Flag, None]' = None, spec_doc_format: \"Optional[Literal['RAW', 'HTML']]\" = None, theme: \"Optional[Literal['DARK', 'LIGHT', 'NONE']]\" = None)",
@@ -2267,7 +2283,7 @@
         },
         "detached": {
           "default": null,
-          "description": "If the profile should be detached.\"\nDetached means it is not inherited from the main profile.\n",
+          "description": "The profile should be detached.\"\nDetached means it is not inherited from the main profile.\n",
           "title": "Detached",
           "type": [
             "boolean",
@@ -2325,6 +2341,22 @@
           "description": "Verifies test data and runs tests so that library\nkeywords are not executed.\n\n---\ncorresponds to the `--dryrun` option of _robot_\n",
           "title": "Dry run"
         },
+        "enabled": {
+          "anyOf": [
+            {
+              "type": "boolean"
+            },
+            {
+              "$ref": "#/definitions/Condition"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "description": "If enabled the profile is used. You can also use and `if` condition\nto calculate the enabled state.\n\nExamples:\n```toml\n# alway disabled\nenabled = false\n```\n\n```toml\n# enabled if TEST_VAR is set\nenabled = { if = 'env.get(\"CI\") == \"true\"' }\n```\n",
+          "title": "Enabled"
+        },
         "env": {
           "additionalProperties": {
             "type": "string"

Diff for: packages/core/robotcode/core/utils/glob_path.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import functools
 import os
 import re
 from pathlib import Path
@@ -61,10 +62,15 @@ def _glob_pattern_to_re(pattern: str) -> str:
     return result
 
 
+@functools.lru_cache(maxsize=256)
+def _compile_glob_pattern(pattern: str) -> re.Pattern[str]:
+    return re.compile(_glob_pattern_to_re(pattern))
+
+
 class Pattern:
     def __init__(self, pattern: str) -> None:
         self.pattern = pattern
-        self._re_pattern = re.compile(_glob_pattern_to_re(pattern))
+        self._re_pattern = _compile_glob_pattern(pattern)
 
     def matches(self, path: Union[Path, str, os.PathLike[Any]]) -> bool:
         if not isinstance(path, Path):

Diff for: packages/core/robotcode/core/utils/safe_eval.py

@@ -0,0 +1,62 @@
+import ast
+from typing import Any, Dict, Optional, Sequence
+
+
+class Transformer(ast.NodeTransformer):
+    STD_ALLOWED_NAMES = (
+        "None",
+        "False",
+        "True",
+        "str",
+        "bool",
+        "int",
+        "float",
+        "list",
+        "dict",
+        "tuple",
+        "bytes",
+        "complex",
+        "set",
+        "bin",
+        "pow",
+        "min",
+        "max",
+        "sum",
+        "ord",
+        "hex",
+        "oct",
+        "round",
+        "sorted",
+        "reversed",
+        "zip",
+        "divmod",
+        "range",
+        "reprs",
+        "enumerate",
+        "all",
+        "any",
+        "filter",
+        "abs",
+        "map",
+        "chr",
+        "format",
+        "len",
+        "ascii",
+    )
+
+    def __init__(self, allowed_names: Optional[Sequence[str]]) -> None:
+        self.allowed_names = (*self.STD_ALLOWED_NAMES, *(allowed_names or []))
+
+    def visit_Name(self, node: ast.Name) -> ast.AST:  # noqa: N802
+        if node.id not in self.allowed_names:
+            raise NameError(f"Name access to '{node.id}' is not allowed")
+
+        return self.generic_visit(node)
+
+
+def safe_eval(source: str, globals: Dict[str, Any] = {}, filename: str = "<expression>") -> Any:
+    transformer = Transformer(list(globals.keys()))
+    tree = ast.parse(source, mode="eval")
+    tree = transformer.visit(tree)
+    clause = compile(tree, filename, "eval", dont_inherit=True)
+    return eval(clause, globals, {})

Diff for: packages/robot/robotcode/robot/config/model.py

@@ -1,11 +1,16 @@
 from __future__ import annotations
 
 import dataclasses
+import fnmatch
+import os
+import platform
+import re
 from dataclasses import dataclass
 from enum import Enum
 from typing import Any, Callable, Dict, List, Literal, Optional, Tuple, Union, get_type_hints
 
 from robotcode.core.dataclasses import TypeValidationError, ValidateMixin, validate_types
+from robotcode.core.utils.safe_eval import safe_eval
 
 
 class Flag(str, Enum):
@@ -31,7 +36,9 @@ def field(
     robot_is_flag: Optional[bool] = None,
     robot_flag_default: Optional[bool] = None,
     robot_priority: Optional[int] = None,
+    alias: Optional[str] = None,
     convert: Optional[Callable[[Any, Any], Any]] = None,
+    no_default: bool = False,
     **kwargs: Any,
 ) -> Any:
     metadata = kwargs.get("metadata", {})
@@ -56,17 +63,29 @@ def field(
     if robot_priority is not None:
         metadata["robot_priority"] = robot_priority
 
+    if alias is not None:
+        metadata["alias"] = alias
+        metadata["_apischema_alias"] = alias
+
     if metadata:
         kwargs["metadata"] = metadata
 
-    if "default_factory" not in kwargs:
+    if "default_factory" not in kwargs and not no_default:
         kwargs["default"] = None
 
     return dataclasses.field(*args, **kwargs)
 
 
 @dataclass
 class BaseOptions(ValidateMixin):
+    @classmethod
+    def _encode_case(cls, s: str) -> str:
+        return s.replace("_", "-")
+
+    @classmethod
+    def _decode_case(cls, s: str) -> str:
+        return s.replace("-", "_")
+
     """Base class for all options."""
 
     def build_command_line(self) -> List[str]:
@@ -1907,14 +1926,6 @@ class LibDocProfile(LibDocOptions, LibDocExtraOptions):
 class RobotBaseProfile(CommonOptions, CommonExtraOptions, RobotOptions, RobotExtraOptions):
     """Base profile for Robot Framework."""
 
-    @classmethod
-    def _encode_case(cls, s: str) -> str:
-        return s.replace("_", "-")
-
-    @classmethod
-    def _decode_case(cls, s: str) -> str:
-        return s.replace("-", "_")
-
     args: Optional[List[str]] = field(
         description="""\
             Arguments to be passed to _robot_.
@@ -1994,18 +2005,69 @@ class RobotExtraBaseProfile(RobotBaseProfile):
     )
 
 
+class EvaluationError(Exception):
+    """Evaluation error."""
+
+    def __init__(self, expression: str, message: str):
+        super().__init__(f"Evaluation of '{expression}' failed: {message}")
+        self.expr = expression
+
+
+@dataclass
+class Condition:
+    if_: str = field(
+        description="""\
+            Condition to evaluate. This must be a Python "eval" expression.
+            For security reasons, only certain expressions and functions are allowed.
+
+            Examples:
+            ```toml
+            if = "re.match(r'^\\d+$', environ.get('TEST_VAR', ''))"
+            if = "platform.system() == 'Linux'"
+            ```
+            """,
+        alias="if",
+        no_default=True,
+    )
+
+    def evaluate(self) -> bool:
+        try:
+            return bool(safe_eval(self.if_, {"env": os.environ, "re": re, "platform": platform}))
+        except Exception as e:
+            raise EvaluationError(self.if_, str(e)) from e
+
+
 @dataclass
 class RobotProfile(RobotExtraBaseProfile):
     """Robot Framework configuration profile."""
 
     description: Optional[str] = field(description="Description of the profile.")
+
     detached: Optional[bool] = field(
         description="""\
-            If the profile should be detached."
+            The profile should be detached."
             Detached means it is not inherited from the main profile.
             """,
     )
 
+    enabled: Union[bool, Condition, None] = field(
+        description="""\
+            If enabled the profile is used. You can also use and `if` condition
+            to calculate the enabled state.
+
+            Examples:
+            ```toml
+            # alway disabled
+            enabled = false
+            ```
+
+            ```toml
+            # enabled if TEST_VAR is set
+            enabled = { if = 'env.get("CI") == "true"' }
+            ```
+            """
+    )
+
 
 @dataclass
 class RobotConfig(RobotExtraBaseProfile):
@@ -2036,7 +2098,7 @@ class RobotConfig(RobotExtraBaseProfile):
         metadata={"description": "Tool configuration."},
     )
 
-    def get_profile(self, *names: str, verbose_callback: Callable[..., None] = None) -> RobotBaseProfile:
+    def combine_profiles(self, *names: str, verbose_callback: Callable[..., None] = None) -> RobotBaseProfile:
         type_hints = get_type_hints(RobotBaseProfile)
         base_field_names = [f.name for f in dataclasses.fields(RobotBaseProfile)]
 
@@ -2061,12 +2123,37 @@ def get_profile(self, *names: str, verbose_callback: Callable[..., None] = None)
 
             names = (*(default_profile or ()),)
 
-        for profile_name in names:
-            if profile_name not in profiles:
-                raise ValueError(f'Profile "{profile_name}" is not defined.')
+        selected_profiles: List[str] = []
+
+        for name in names:
+            profile_names = [p for p in profiles.keys() if fnmatch.fnmatchcase(p, name)]
+
+            if not profile_names:
+                raise ValueError(f"Can't find any profiles matching the pattern '{name}''.")
 
+            for v in profile_names:
+                if v in selected_profiles:
+                    continue
+                selected_profiles.append(v)
+
+        if verbose_callback:
+            verbose_callback(f"Select profiles {', '.join(selected_profiles)}")
+
+        for profile_name in selected_profiles:
             profile = profiles[profile_name]
 
+            try:
+                if profile.enabled is not None and (
+                    isinstance(profile.enabled, Condition) and not profile.enabled.evaluate() or not profile.enabled
+                ):
+                    if verbose_callback:
+                        verbose_callback(f'Skipping profile "{profile_name}" because it\'s  disabled.')
+                    continue
+            except EvaluationError as e:
+                if verbose_callback:
+                    verbose_callback(f'Skipping profile "{profile_name}" because: {e}')
+                continue
+
             if verbose_callback:
                 verbose_callback(f'Using profile "{profile_name}".')
 

Diff for: packages/runner/robotcode/runner/cli/libdoc.py

@@ -82,7 +82,7 @@ def libdoc(
         if config_files:
             app.verbose(lambda: f"Found configuration files:\n    {', '.join(str(f[0]) for f in config_files)}")
             try:
-                profile = load_config_from_path(*config_files).get_profile(
+                profile = load_config_from_path(*config_files).combine_profiles(
                     *app.config.profiles if app.config.profiles else [],
                     verbose_callback=app.verbose if app.config.verbose else None,
                 )

Diff for: packages/runner/robotcode/runner/cli/rebot.py

@@ -83,7 +83,7 @@ def rebot(
         if config_files:
             app.verbose(lambda: f"Found configuration files:\n    {', '.join(str(f[0]) for f in config_files)}")
             try:
-                profile = load_config_from_path(*config_files).get_profile(
+                profile = load_config_from_path(*config_files).combine_profiles(
                     *app.config.profiles if app.config.profiles else [],
                     verbose_callback=app.verbose if app.config.verbose else None,
                 )

Diff for: packages/runner/robotcode/runner/cli/robot.py

@@ -96,7 +96,7 @@ def robot(
         if config_files:
             app.verbose(lambda: f"Found configuration files:\n    {', '.join(str(f[0]) for f in config_files)}")
             try:
-                profile = load_config_from_path(*config_files).get_profile(
+                profile = load_config_from_path(*config_files).combine_profiles(
                     *app.config.profiles if app.config.profiles else [],
                     verbose_callback=app.verbose if app.config.verbose else None,
                 )

Diff for: robotcode/cli/commands/profiles.py

@@ -39,7 +39,9 @@ def show(
         raise click.ClickException("Cannot find any configuration file. 😥")
 
     try:
-        profile = load_config_from_path(*config_files).get_profile(*(app.config.profiles or []))
+        profile = load_config_from_path(*config_files).combine_profiles(
+            *(app.config.profiles or []), verbose_callback=app.verbose
+        )
 
         app.print_dict(as_dict(profile, remove_defaults=True), format)
 

Diff for: scripts/create_robot_toml_json_schema.py

@@ -19,7 +19,7 @@ def type_base_schema(tp: Any) -> Optional[apischema.schemas.Schema]:
         )
 
     def field_base_schema(tp: Any, name: str, alias: str) -> Optional[apischema.schemas.Schema]:
-        title = alias.replace("_", " ").capitalize()
+        title = name.replace("_", " ").capitalize()
         tp = typing.get_origin(tp) or tp  # tp can be generic
         if is_dataclass(tp):
             field = next((x for x in fields(tp) if x.name == name), None)