robotcode-robot 0.77.1__py3-none-any.whl → 0.78.1__py3-none-any.whl

robotcode/robot/__version__.py

@@ -1 +1 @@
-__version__ = "0.77.1"
+__version__ = "0.78.1"

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/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/diagnostics/namespace.py

@@ -99,6 +99,7 @@ from .library_doc import (
     KeywordError,
     KeywordMatcher,
     LibraryDoc,
+    resolve_robot_variables,
 )
 
 EXTRACT_COMMENT_PATTERN = re.compile(r".*(?:^ *|\t+| {2,})#(?P<comment>.*)$")
@@ -184,22 +185,19 @@ class VariablesVisitor(Visitor):
 class BlockVariableVisitor(Visitor):
     def __init__(
         self,
-        library_doc: LibraryDoc,
-        global_variables: List[VariableDefinition],
-        source: str,
+        namespace: "Namespace",
+        nodes: Optional[List[ast.AST]] = None,
         position: Optional[Position] = None,
         in_args: bool = True,
     ) -> None:
         super().__init__()
-        self.library_doc = library_doc
-        self.global_variables = global_variables
-        self.source = source
+        self.namespace = namespace
+        self.nodes = nodes
         self.position = position
         self.in_args = in_args
 
         self._results: Dict[str, VariableDefinition] = {}
         self.current_kw_doc: Optional[KeywordDoc] = None
-        self._var_statements_vars: List[VariableDefinition] = []
 
     def get(self, model: ast.AST) -> List[VariableDefinition]:
         self._results = {}
@@ -224,7 +222,7 @@ class BlockVariableVisitor(Visitor):
         name_token = node.get_token(Token.KEYWORD_NAME)
 
         if name_token is not None and name_token.value:
-            keyword = ModelHelper.get_keyword_definition_at_token(self.library_doc, name_token)
+            keyword = ModelHelper.get_keyword_definition_at_token(self.namespace.get_library_doc(), name_token)
             self.current_kw_doc = keyword
 
             for variable_token in filter(
@@ -246,7 +244,7 @@ class BlockVariableVisitor(Visitor):
                         col_offset=variable_token.col_offset,
                         end_line_no=variable_token.lineno,
                         end_col_offset=variable_token.end_col_offset,
-                        source=self.source,
+                        source=self.namespace.source,
                         keyword_doc=self.current_kw_doc,
                     )
 
@@ -290,7 +288,7 @@ class BlockVariableVisitor(Visitor):
                             col_offset=argument.col_offset,
                             end_line_no=argument.lineno,
                             end_col_offset=argument.end_col_offset,
-                            source=self.source,
+                            source=self.namespace.source,
                             keyword_doc=self.current_kw_doc,
                         )
                         self._results[argument.value] = arg_def
@@ -312,12 +310,48 @@ class BlockVariableVisitor(Visitor):
                         col_offset=variable.col_offset,
                         end_line_no=variable.lineno,
                         end_col_offset=variable.end_col_offset,
-                        source=self.source,
+                        source=self.namespace.source,
                     )
 
             except VariableError:
                 pass
 
+    def _get_var_name(self, original: str, position: Position, require_assign: bool = True) -> Optional[str]:
+        robot_variables = resolve_robot_variables(
+            str(self.namespace.imports_manager.root_folder),
+            str(Path(self.namespace.source).parent) if self.namespace.source else ".",
+            self.namespace.imports_manager.get_resolvable_command_line_variables(),
+            variables=self.namespace.get_resolvable_variables(),
+        )
+
+        try:
+            replaced = robot_variables.replace_string(original)
+        except VariableError:
+            replaced = original
+        try:
+            name = self._resolve_var_name(replaced, robot_variables)
+        except ValueError:
+            name = original
+        match = search_variable(name, identifiers="$@&")
+        match.resolve_base(robot_variables)
+        valid = match.is_assign() if require_assign else match.is_variable()
+        if not valid:
+            return None
+        return str(match)
+
+    def _resolve_var_name(self, name: str, variables: Any) -> str:
+        if name.startswith("\\"):
+            name = name[1:]
+        if len(name) < 2 or name[0] not in "$@&":
+            raise ValueError
+        if name[1] != "{":
+            name = f"{name[0]}{{{name[1:]}}}"
+        match = search_variable(name, identifiers="$@&", ignore_errors=True)
+        match.resolve_base(variables)
+        if not match.is_assign():
+            raise ValueError
+        return str(match)
+
     def visit_KeywordCall(self, node: Statement) -> None:  # noqa: N802
         # TODO  analyze "Set Local/Global/Suite Variable"
 
@@ -341,12 +375,65 @@ class BlockVariableVisitor(Visitor):
                             col_offset=variable_token.col_offset,
                             end_line_no=variable_token.lineno,
                             end_col_offset=variable_token.end_col_offset,
-                            source=self.source,
+                            source=self.namespace.source,
                         )
 
             except VariableError:
                 pass
 
+        keyword_token = node.get_token(Token.KEYWORD)
+        if keyword_token is None or not keyword_token.value:
+            return
+
+        keyword = self.namespace.find_keyword(keyword_token.value, raise_keyword_error=False)
+        if keyword is None:
+            return
+
+        if keyword.libtype == "LIBRARY" and keyword.libname == "BuiltIn":
+            var_type = None
+            if keyword.name == "Set Suite Variable":
+                var_type = VariableDefinition
+            elif keyword.name == "Set Global Variable":
+                var_type = GlobalVariableDefinition
+            elif keyword.name == "Set Test Variable" or keyword.name == "Set Task Variable":
+                var_type = TestVariableDefinition
+            elif keyword.name == "Set Local Variable":
+                var_type = LocalVariableDefinition
+            else:
+                return
+            try:
+                variable = node.get_token(Token.ARGUMENT)
+                if variable is None:
+                    return
+
+                position = range_from_node(node).start
+                position.character = 0
+                var_name = self._get_var_name(variable.value, position)
+
+                if var_name is None or not is_variable(var_name):
+                    return
+
+                var = var_type(
+                    name=var_name,
+                    name_token=strip_variable_token(variable),
+                    line_no=variable.lineno,
+                    col_offset=variable.col_offset,
+                    end_line_no=variable.lineno,
+                    end_col_offset=variable.end_col_offset,
+                    source=self.namespace.source,
+                )
+
+                if var_name not in self._results or type(self._results[var_name]) != type(var):
+                    if isinstance(var, LocalVariableDefinition) or not any(
+                        l for l in self.namespace.get_global_variables() if l.matcher == var.matcher
+                    ):
+                        self._results[var_name] = var
+                    else:
+                        self._results.pop(var_name, None)
+
+            except VariableError:
+                pass
+
     def visit_InlineIfHeader(self, node: Statement) -> None:  # noqa: N802
         for assign_token in node.get_tokens(Token.ASSIGN):
             variable_token = self.get_variable_token(assign_token)
@@ -368,7 +455,7 @@ class BlockVariableVisitor(Visitor):
                             col_offset=variable_token.col_offset,
                             end_line_no=variable_token.lineno,
                             end_col_offset=variable_token.end_col_offset,
-                            source=self.source,
+                            source=self.namespace.source,
                         )
 
             except VariableError:
@@ -386,7 +473,7 @@ class BlockVariableVisitor(Visitor):
                     col_offset=variable_token.col_offset,
                     end_line_no=variable_token.lineno,
                     end_col_offset=variable_token.end_col_offset,
-                    source=self.source,
+                    source=self.namespace.source,
                 )
 
     def visit_Var(self, node: Statement) -> None:  # noqa: N802
@@ -421,14 +508,12 @@ class BlockVariableVisitor(Visitor):
                 col_offset=variable.col_offset,
                 end_line_no=variable.lineno,
                 end_col_offset=variable.end_col_offset,
-                source=self.source,
+                source=self.namespace.source,
             )
 
-            self._var_statements_vars.append(var)
-
             if var_name not in self._results or type(self._results[var_name]) != type(var):
                 if isinstance(var, LocalVariableDefinition) or not any(
-                    l for l in self.global_variables if l.matcher == var.matcher
+                    l for l in self.namespace.get_global_variables() if l.matcher == var.matcher
                 ):
                     self._results[var_name] = var
                 else:
@@ -924,9 +1009,8 @@ class Namespace:
                 (
                     (
                         BlockVariableVisitor(
-                            self.get_library_doc(),
-                            self.get_global_variables(),
-                            self.source,
+                            self,
+                            nodes,
                             position,
                             isinstance(test_or_keyword_nodes[-1], Arguments) if nodes else False,
                         ).get(test_or_keyword)
@@ -1039,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:
@@ -1220,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()
 
@@ -1234,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]]:
 
@@ -1251,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:
@@ -1274,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.77.1.dist-info → robotcode_robot-0.78.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: robotcode-robot
-Version: 0.77.1
+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.77.1
+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.77.1.dist-info → robotcode_robot-0.78.1.dist-info}/RECORD

@@ -1,18 +1,18 @@
 robotcode/robot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robotcode/robot/__version__.py,sha256=KAGTP0ql_FPeQE1WIVlTa-PVmeudJNxVGVpT_IPdAEg,23
+robotcode/robot/__version__.py,sha256=HinYe1V3FgUaLri1gy6R6_VuKh3sB-UYTNM51cV6k4I,23
 robotcode/robot/py.typed,sha256=bWew9mHgMy8LqMu7RuqQXFXLBxh2CRx0dUbSx-3wE48,27
 robotcode/robot/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robotcode/robot/config/loader.py,sha256=LpGqJAdysvVSZpccW-Il52xn9RMBBb9X94emlBY7zCc,6077
-robotcode/robot/config/model.py,sha256=QzniYg-pxQucKJDg7_lSodWg6DKwhTaVf_wN3biUXCk,86499
+robotcode/robot/config/model.py,sha256=LReuQ0Z8zYEYW9XLjnyR2hSUn8upbWzbh8VTTBIRQig,88642
 robotcode/robot/config/utils.py,sha256=c_WZg39DJgM6kXcAH_h-v68qhf1eStJ0TslTawaJoZw,2827
 robotcode/robot/diagnostics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robotcode/robot/diagnostics/document_cache_helper.py,sha256=XLOqPl88Rbo_01pt8Zx2jMH38m5kvoOnASNDoe8BK_0,22292
-robotcode/robot/diagnostics/entities.py,sha256=djUbkVSLmwlg9E-jvW_jw7h6yjpSl6YmTpDDzUNB0-8,11051
+robotcode/robot/diagnostics/entities.py,sha256=CrjhLHHwKCCE3YI_dcjoZADJz1urm0VGbGFdHXOuaoc,11110
 robotcode/robot/diagnostics/errors.py,sha256=VavgWYuHoW5sTT16j2rl9hxMhWxBKNSFsNmHWPzARQQ,1413
 robotcode/robot/diagnostics/imports_manager.py,sha256=eMt3Quac1hV5zq6CO45afhUOiL4usww3YTNSyt1bZrE,56185
 robotcode/robot/diagnostics/library_doc.py,sha256=ZhoJIscHIx0UaLWm56LEoa3oxR0uNZourZsnpvOg-Hs,97035
 robotcode/robot/diagnostics/model_helper.py,sha256=3-6lZluPQaT9KstHLfV0jsRUAjTfrkUOomSXiMPKoQg,29868
-robotcode/robot/diagnostics/namespace.py,sha256=EhbHHX2c-Yy_j1YBzC6PFxNVCY50E2LB3kGOT-qgDZ4,85145
+robotcode/robot/diagnostics/namespace.py,sha256=yerha8VmX_01h8Ga7MaH4wRVk1waVQ4pJfPu55ohcYU,89792
 robotcode/robot/diagnostics/namespace_analyzer.py,sha256=tElI2NzcCRnsvPqv7wYaV2p5E22VyqEwQQ90FOOjadI,50086
 robotcode/robot/diagnostics/workspace_config.py,sha256=lWNq1KmGGJ9cHFNHn0QTCBHHzgz4AewTw0l-W4TKrj0,1803
 robotcode/robot/utils/__init__.py,sha256=OjNPMn_XSnfaMCyKd8Kmq6vlRt6mIGlzW4qiiD3ykUg,447
@@ -23,7 +23,7 @@ robotcode/robot/utils/robot_path.py,sha256=qKBh1cEnReBBLKkWu4gB9EzM-scAwE4xJc1m6
 robotcode/robot/utils/stubs.py,sha256=6-DMI_CQVJHDgG13t-zINKGCRb_Q7MQPm0_AkfhAEvE,748
 robotcode/robot/utils/variables.py,sha256=fEl8S37lb_mD4hn2MZRAlkiuLGBjAOeZVK0r2o2CfPw,742
 robotcode/robot/utils/visitor.py,sha256=uYLqEhGPmzWKWI3SSrmCaYMwtKvNShvbiPZ4b3FavX8,3241
-robotcode_robot-0.77.1.dist-info/METADATA,sha256=qvOHq_EZVfXNrKxxgy2gr2udDF06euy9IidbrVaBmYQ,2209
-robotcode_robot-0.77.1.dist-info/WHEEL,sha256=TJPnKdtrSue7xZ_AVGkp9YXcvDrobsjBds1du3Nx6dc,87
-robotcode_robot-0.77.1.dist-info/licenses/LICENSE.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
-robotcode_robot-0.77.1.dist-info/RECORD,,
+robotcode_robot-0.78.1.dist-info/METADATA,sha256=v5pSI5CijBpAZYaOJTl0jdCgjhavFlZDydZi_LkF3JU,2209
+robotcode_robot-0.78.1.dist-info/WHEEL,sha256=TJPnKdtrSue7xZ_AVGkp9YXcvDrobsjBds1du3Nx6dc,87
+robotcode_robot-0.78.1.dist-info/licenses/LICENSE.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
+robotcode_robot-0.78.1.dist-info/RECORD,,