robotcode-robot 0.78.0__tar.gz → 0.78.1__tar.gz

{robotcode_robot-0.78.0 → robotcode_robot-0.78.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: robotcode-robot
-Version: 0.78.0
+Version: 0.78.1
 Summary: Support classes for RobotCode for handling Robot Framework projects.
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://github.com/sponsors/d-biehl
@@ -26,7 +26,7 @@ Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.8
 Requires-Dist: platformdirs<4.2.0,>=3.2.0
-Requires-Dist: robotcode-core==0.78.0
+Requires-Dist: robotcode-core==0.78.1
 Requires-Dist: robotframework>=4.1.0
 Requires-Dist: tomli>=1.1.0; python_version < '3.11'
 Description-Content-Type: text/markdown

{robotcode_robot-0.78.0 → robotcode_robot-0.78.1}/pyproject.toml

@@ -29,7 +29,7 @@ dependencies = [
   "robotframework>=4.1.0",
   "tomli>=1.1.0; python_version < '3.11'",
   "platformdirs>=3.2.0,<4.2.0",
-  "robotcode-core==0.78.0",
+  "robotcode-core==0.78.1",
 ]
 dynamic = ["version"]
 

robotcode_robot-0.78.1/src/robotcode/robot/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.78.1"

{robotcode_robot-0.78.0 → robotcode_robot-0.78.1}/src/robotcode/robot/config/model.py

@@ -16,6 +16,7 @@ from typing import (
     List,
     Literal,
     Optional,
+    Set,
     Tuple,
     Union,
     get_type_hints,
@@ -2264,6 +2265,9 @@ class RobotExtendBaseProfile(RobotBaseProfile):
 class RobotProfile(RobotExtendBaseProfile):
     """Robot Framework configuration profile."""
 
+    def __hash__(self) -> int:
+        return id(self)
+
     description: Optional[str] = field(description="Description of the profile.")
 
     detached: Optional[bool] = field(
@@ -2291,6 +2295,9 @@ class RobotProfile(RobotExtendBaseProfile):
             """
     )
 
+    def is_enabled(self) -> bool:
+        return self.enabled is None or bool(self.enabled)
+
     hidden: Union[bool, Condition, None] = field(
         description="""\
             The profile should be hidden.
@@ -2349,13 +2356,13 @@ class RobotConfig(RobotExtendBaseProfile):
 
     tool: Any = field(description="Tool configurations.")
 
-    def select_profiles(
+    def _select_profiles(
         self,
         *names: str,
         verbose_callback: Optional[Callable[[Union[str, Callable[[], Any]]], None]] = None,
         error_callback: Optional[Callable[[Union[str, Callable[[], Any]]], None]] = None,
-    ) -> Dict[str, RobotProfile]:
-        result: Dict[str, RobotProfile] = {}
+    ) -> Dict[str, Tuple[RobotProfile, Optional[Set[Tuple[str, RobotProfile]]]]]:
+        result: Dict[str, Tuple[RobotProfile, Optional[Set[Tuple[str, RobotProfile]]]]] = {}
 
         profiles = self.profiles or {}
 
@@ -2372,14 +2379,20 @@ class RobotConfig(RobotExtendBaseProfile):
 
             names = (*(default_profile or ()),)
 
-        def select(name: str) -> None:
+        def select(name: str, parent_profiles: Optional[Set[Tuple[str, RobotProfile]]] = None) -> None:
             if not name:
                 return
 
             nonlocal result
 
             if verbose_callback:
-                verbose_callback(f"Selecting profiles matching '{name}'.")
+                if parent_profiles is not None:
+                    verbose_callback(
+                        f"Selecting profiles matching '{name}'"
+                        f" for parent profile '{next(f for f in parent_profiles)[0]}'."
+                    )
+                else:
+                    verbose_callback(f"Selecting profiles matching '{name}'.")
 
             profile_names = [p for p in profiles.keys() if fnmatch.fnmatchcase(p, name)]
 
@@ -2393,13 +2406,24 @@ class RobotConfig(RobotExtendBaseProfile):
 
             for v in profile_names:
                 p = profiles[v]
-                result.update({v: p})
+
                 if p.inherits:
                     if isinstance(p.inherits, list):
                         for i in p.inherits:
-                            select(str(i))
+                            select(str(i), {(v, p)})
+                    else:
+                        select(str(p.inherits), {(v, p)})
+
+                if v in result:
+                    if parent_profiles is None:
+                        result[v] = (p, None)
                     else:
-                        select(str(p.inherits))
+                        parents = result[v][1]
+                        if parents is not None:
+                            parents.update(parent_profiles)
+
+                else:
+                    result.update({v: (p, parent_profiles)})
 
         for name in names:
             select(name)
@@ -2438,7 +2462,7 @@ class RobotConfig(RobotExtendBaseProfile):
             }
         )
 
-        selected_profiles = self.select_profiles(
+        selected_profiles = self._select_profiles(
             *names, verbose_callback=verbose_callback, error_callback=error_callback
         )
         if verbose_callback:
@@ -2447,14 +2471,16 @@ class RobotConfig(RobotExtendBaseProfile):
             else:
                 verbose_callback("No profiles selected.")
 
-        for profile_name, profile in sorted(selected_profiles.items(), key=lambda x: x[1].precedence or 0):
+        for profile_name, (profile, parent_profiles) in sorted(
+            selected_profiles.items(), key=lambda x: x[1][0].precedence or 0
+        ):
             try:
-                if profile.enabled is not None and not bool(profile.enabled):
+                if not profile.is_enabled():
                     if verbose_callback:
                         verbose_callback(f'Skipping profile "{profile_name}" because it\'s disabled.')
                     continue
             except EvaluationError as e:
-                message = f'Error evaluating "enabled" condition for profile "{profile_name}": {e}'
+                message = f"Error evaluating 'enabled' condition for profile '{profile_name}': {e}"
 
                 if error_callback is None:
                     raise ValueError(message) from e
@@ -2462,6 +2488,31 @@ class RobotConfig(RobotExtendBaseProfile):
                 error_callback(message)
                 continue
 
+            if parent_profiles is not None:
+                disabled_profiles = []
+                skip = False
+                for parent_profile in parent_profiles:
+                    try:
+                        if not parent_profile[1].is_enabled():
+                            disabled_profiles.append(parent_profile[0])
+                    except EvaluationError as e:
+                        message = f"Error evaluating 'enabled' condition for profile '{parent_profile[0]}': {e}"
+
+                        if error_callback is None:
+                            raise ValueError(message) from e
+
+                        error_callback(message)
+                        skip = True
+                        break
+
+                if skip or len(disabled_profiles) == len(parent_profiles):
+                    if verbose_callback:
+                        verbose_callback(
+                            f"Skipping profile inherited '{profile_name}' because no parent is enabled."
+                            f" Disabled profiles: {', '.join(disabled_profiles)}."
+                        )
+                    continue
+
             if verbose_callback:
                 verbose_callback(f'Using profile "{profile_name}".')
 
@@ -2471,7 +2522,7 @@ class RobotConfig(RobotExtendBaseProfile):
                 for k, v in profile.env.items():
                     os.environ[k] = str(v)
                     if verbose_callback:
-                        verbose_callback(lambda: f"Set environment variable `{k}` to `{v}`")
+                        verbose_callback(lambda: f"Set environment variable '{k}' to '{v}'")
 
             if profile.detached:
                 result = RobotBaseProfile()
@@ -2520,4 +2571,4 @@ class RobotConfig(RobotExtendBaseProfile):
                 if new is not None:
                     setattr(result, f.name, new)
 
-        return result, selected_profiles, enabled_profiles
+        return result, {k: v[0] for k, v in selected_profiles.items()}, enabled_profiles

{robotcode_robot-0.78.0 → robotcode_robot-0.78.1}/src/robotcode/robot/diagnostics/entities.py

@@ -155,6 +155,9 @@ class VariableMatcher:
         if isinstance(o, str):
             match = search_variable(o, "$@&%", ignore_errors=True)
             base = match.base
+            if base is None:
+                return False
+
             normalized = str(normalize(base))
             return self.normalized_name == normalized
 

{robotcode_robot-0.78.0 → robotcode_robot-0.78.1}/src/robotcode/robot/diagnostics/namespace.py

@@ -1123,6 +1123,7 @@ class Namespace:
         top_level: bool = False,
         source: Optional[str] = None,
         parent_import: Optional[Import] = None,
+        parent_source: Optional[str] = None,
     ) -> Optional[LibraryEntry]:
         result: Optional[LibraryEntry] = None
         try:
@@ -1304,6 +1305,26 @@ class Namespace:
                     source=DIAGNOSTICS_SOURCE_NAME,
                     code=type(e).__qualname__,
                 )
+            elif parent_import is not None:
+                self.append_diagnostics(
+                    range=parent_import.range,
+                    message="Import definition contains errors.",
+                    severity=DiagnosticSeverity.ERROR,
+                    source=DIAGNOSTICS_SOURCE_NAME,
+                    code=Error.IMPORT_CONTAINS_ERRORS,
+                    related_information=(
+                        (
+                            [
+                                DiagnosticRelatedInformation(
+                                    location=Location(str(Uri.from_path(parent_source)), value.range),
+                                    message=str(e),
+                                ),
+                            ]
+                        )
+                        if parent_source
+                        else None
+                    ),
+                )
         finally:
             self._reset_global_variables()
 
@@ -1318,6 +1339,7 @@ class Namespace:
         variables: Optional[Dict[str, Any]] = None,
         source: Optional[str] = None,
         parent_import: Optional[Import] = None,
+        parent_source: Optional[str] = None,
         depth: int = 0,
     ) -> Optional[Dict[str, Any]]:
 
@@ -1335,6 +1357,7 @@ class Namespace:
                     top_level=top_level,
                     source=source,
                     parent_import=parent_import,
+                    parent_source=parent_source if parent_source else source,
                 )
 
                 if entry is not None:
@@ -1358,6 +1381,7 @@ class Namespace:
                                     variables=variables,
                                     source=entry.library_doc.source,
                                     parent_import=imp if top_level else parent_import,
+                                    parent_source=parent_source if top_level else source,
                                     depth=depth + 1,
                                 )
                             except (SystemExit, KeyboardInterrupt):

robotcode_robot-0.78.0/src/robotcode/robot/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.78.0"