robotcode-robot 2.8.0.dev677__py3-none-any.whl → 2.9.0.dev51__py3-none-any.whl

robotcode/robot/__version__.py

@@ -1 +1 @@
-__version__ = "2.8.0-dev.677"
+__version__ = "2.9.0-dev.51"

robotcode/robot/config/model.py

@@ -3222,6 +3222,42 @@ class RobotProfile(RobotExtendBaseProfile):
     )
 
 
+@dataclass(frozen=True)
+class UnknownProfile:
+    """A profile name or pattern that selects no profile, and where it comes from."""
+
+    name: str
+    # the profile whose `inherits` names it; None for a name of the selection or of `default-profiles`
+    inherited_by: Optional[str] = None
+    # whether it comes from `default-profiles`
+    default: bool = False
+
+    @property
+    def selected(self) -> bool:
+        """Whether the name comes from the selection: `-p`, `ROBOTCODE_PROFILES` or an editor."""
+        return self.inherited_by is None and not self.default
+
+    @property
+    def message(self) -> str:
+        return f"No profile matches '{self.name}'."
+
+
+class ProfileNotFoundError(ValueError):
+    """A profile name or pattern that selects no profile."""
+
+    def __init__(self, unknown: UnknownProfile) -> None:
+        super().__init__(unknown.message)
+        self.unknown = unknown
+
+
+class ProfileInheritanceError(ValueError):
+    """A profile that inherits itself, directly or through other profiles."""
+
+    def __init__(self, path: Tuple[str, ...]) -> None:
+        super().__init__(f"The profile '{path[0]}' inherits itself: {' -> '.join(path)}.")
+        self.path = path
+
+
 @dataclass
 class RobotConfig(RobotExtendBaseProfile):
     """Robot Framework configuration."""
@@ -3288,11 +3324,13 @@ class RobotConfig(RobotExtendBaseProfile):
         *names: str,
         verbose_callback: Optional[Callable[[Union[str, Callable[[], Any]]], None]] = None,
         error_callback: Optional[Callable[[Union[str, Callable[[], Any]]], None]] = None,
+        unknown_profile_callback: Optional[Callable[[UnknownProfile], None]] = None,
     ) -> Dict[str, Tuple[RobotProfile, Optional[Set[Tuple[str, RobotProfile]]]]]:
         result: Dict[str, Tuple[RobotProfile, Optional[Set[Tuple[str, RobotProfile]]]]] = {}
 
         profiles = self.profiles or {}
 
+        from_default_profiles = not names
         if not names:
             if verbose_callback:
                 verbose_callback("No profiles given, try to check if there are default profiles specified.")
@@ -3306,40 +3344,65 @@ class RobotConfig(RobotExtendBaseProfile):
 
             names = (*(default_profile or ()),)
 
-        def select(name: str, parent_profiles: Optional[Set[Tuple[str, RobotProfile]]] = None) -> None:
+        # each name that selects no profile is reported once for each place it comes from
+        reported: Set[UnknownProfile] = set()
+
+        def report(unknown: UnknownProfile) -> None:
+            if unknown in reported:
+                return
+            reported.add(unknown)
+
+            # a name that selects no profile is an error of the configuration; only callers that must go on, such as
+            # the language server, take it and go on without it
+            if unknown_profile_callback is not None:
+                unknown_profile_callback(unknown)
+            # a name of `default-profiles` is only reported: the `default-profiles` of the user configuration can name
+            # a profile of that file, which the `[profiles]` of a project replace
+            elif unknown.default and error_callback is not None:
+                error_callback(unknown.message)
+            else:
+                raise ProfileNotFoundError(unknown)
+
+        # `path` holds the profiles whose `inherits` lead to the name; the last one names it
+        def select(name: str, path: Tuple[str, ...] = ()) -> None:
             if not name:
                 return
 
             nonlocal result
 
+            parent = path[-1] if path else None
+
             if verbose_callback:
-                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]}'."
-                    )
+                if parent is not None:
+                    verbose_callback(f"Selecting profiles matching '{name}' for parent profile '{parent}'.")
                 else:
                     verbose_callback(f"Selecting profiles matching '{name}'.")
 
-            profile_names = [p for p in profiles.keys() if fnmatch.fnmatchcase(p, name)]
+            if name in profiles:
+                # an exact name selects its profile, also when it contains `*`, `?` or `[`
+                profile_names = [name]
+            else:
+                # a pattern in `inherits` does not match the profile that has it
+                profile_names = [p for p in profiles.keys() if p != parent and fnmatch.fnmatchcase(p, name)]
 
             if not profile_names:
-                message = f"Can't find any configuration profiles matching the pattern '{name}'."
-                if error_callback is None:
-                    raise ValueError(message)
-
-                error_callback(message)
+                report(UnknownProfile(name, inherited_by=parent, default=from_default_profiles and parent is None))
                 return
 
+            parent_profiles = {(parent, profiles[parent])} if parent is not None else None
+
             for v in profile_names:
+                if v in path:
+                    raise ProfileInheritanceError((*path[path.index(v) :], v))
+
                 p = profiles[v]
 
                 if p.inherits:
                     if isinstance(p.inherits, list):
                         for i in p.inherits:
-                            select(str(i), {(v, p)})
+                            select(str(i), (*path, v))
                     else:
-                        select(str(p.inherits), {(v, p)})
+                        select(str(p.inherits), (*path, v))
 
                 if v in result:
                     if parent_profiles is None:
@@ -3362,14 +3425,21 @@ class RobotConfig(RobotExtendBaseProfile):
         *names: str,
         verbose_callback: Optional[Callable[[Union[str, Callable[[], Any]]], None]] = None,
         error_callback: Optional[Callable[[Union[str, Callable[[], Any]]], None]] = None,
+        unknown_profile_callback: Optional[Callable[[UnknownProfile], None]] = None,
     ) -> RobotBaseProfile:
-        return self.combine_profiles_ex(*names, verbose_callback=verbose_callback, error_callback=error_callback)[0]
+        return self.combine_profiles_ex(
+            *names,
+            verbose_callback=verbose_callback,
+            error_callback=error_callback,
+            unknown_profile_callback=unknown_profile_callback,
+        )[0]
 
     def combine_profiles_ex(
         self,
         *names: str,
         verbose_callback: Optional[Callable[[Union[str, Callable[[], Any]]], None]] = None,
         error_callback: Optional[Callable[[Union[str, Callable[[], Any]]], None]] = None,
+        unknown_profile_callback: Optional[Callable[[UnknownProfile], None]] = None,
     ) -> Tuple[RobotBaseProfile, Dict[str, RobotProfile], List[str]]:
         enabled_profiles = []
         type_hints = get_type_hints(RobotBaseProfile)
@@ -3390,7 +3460,10 @@ class RobotConfig(RobotExtendBaseProfile):
         )
 
         selected_profiles = self._select_profiles(
-            *names, verbose_callback=verbose_callback, error_callback=error_callback
+            *names,
+            verbose_callback=verbose_callback,
+            error_callback=error_callback,
+            unknown_profile_callback=unknown_profile_callback,
         )
         if verbose_callback:
             if selected_profiles:

robotcode/robot/diagnostics/library_doc.py

@@ -2728,7 +2728,7 @@ class _Logger(AbstractLogger):
 
 def _import_test_library(name: str) -> Union[Any, Tuple[Any, str]]:
     with OutputCapturer(library_import=True):
-        importer = Importer("test library", LOGGER)
+        importer = Importer("library", LOGGER)
         return importer.import_class_or_module(name, return_source=True)
 
 

robotcode/robot/utils/markdownformatter.py

@@ -144,14 +144,18 @@ class LinkFormatter:
         return pre + self._get_link(url)
 
     def _get_image(self, src: str, title: Optional[str] = None) -> str:
-        return f"![{title or src}]({self._unquote_hash(src)})"
+        return f"![{title or src}]({self._target(src)})"
 
     def _get_link(self, href: str, content: Optional[str] = None) -> str:
-        return f"[{content or href}]({self._unquote_hash(href)})"
+        return f"[{content or href}]({self._target(href)})"
 
-    def _unquote_hash(self, target: str) -> str:
+    def _target(self, target: str) -> str:
         # `#` is escaped in the whole line before links are formatted, a link target needs it as it is
-        return target.replace("\\#", "#")
+        target = target.replace("\\#", "#")
+        # Markdown takes a target with spaces only in angle brackets; `<` is already escaped in the whole line
+        if " " in target:
+            return "<" + target.replace(">", "\\>") + ">"
+        return target
 
     def _quot(self, attr: str) -> str:
         return attr if '"' not in attr else attr.replace('"', "&quot;")

{robotcode_robot-2.8.0.dev677.dist-info → robotcode_robot-2.9.0.dev51.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: robotcode-robot
-Version: 2.8.0-dev.677
+Version: 2.9.0-dev.51
 Summary: Support classes for RobotCode for handling Robot Framework projects.
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode
@@ -27,7 +27,7 @@ Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: platformdirs>=4.3
-Requires-Dist: robotcode-core==2.8.0-dev.677
+Requires-Dist: robotcode-core==2.9.0-dev.51
 Requires-Dist: robotframework>=5.0.0
 Requires-Dist: tomli>=1.1.0; python_version < '3.11'
 Description-Content-Type: text/markdown

{robotcode_robot-2.8.0.dev677.dist-info → robotcode_robot-2.9.0.dev51.dist-info}/RECORD

@@ -1,9 +1,9 @@
 robotcode/robot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robotcode/robot/__version__.py,sha256=0xyLlet74gxp40f05fA-fjXhAr2XdtEik3UuIJs6yAM,30
+robotcode/robot/__version__.py,sha256=68lI1Ud2IVxiSKwJTXlHsfwV7s6ASsCia4CPMEdJ8Ls,29
 robotcode/robot/py.typed,sha256=bWew9mHgMy8LqMu7RuqQXFXLBxh2CRx0dUbSx-3wE48,27
 robotcode/robot/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robotcode/robot/config/loader.py,sha256=HLbkZem8JiBuy9Q5naghZddAuMPOn8Tk6UBgN2T3Uyc,9073
-robotcode/robot/config/model.py,sha256=i8EH_n_20U7eCNY81nWa7oTFAxKj9iSH5Sxm1vr8bOQ,112151
+robotcode/robot/config/model.py,sha256=2dRKRDQV50_k1PmX-7uhqrPTX7Z6oJq4PcAG4pBDRi8,115165
 robotcode/robot/config/utils.py,sha256=A8gD5IItxuC7AY5Olcc8tmsSbqCCi_vZPVoK3BqWt_8,4070
 robotcode/robot/diagnostics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robotcode/robot/diagnostics/analyzer_result.py,sha256=5pHW5Yf3C3rmaDvmM7tP0y_qwqLW3YHhkeVV-qDhxtg,1459
@@ -16,7 +16,7 @@ robotcode/robot/diagnostics/errors.py,sha256=lqHDWrMNy3ZhuEIVxeEhaU0ns8PB6pVTQBf
 robotcode/robot/diagnostics/import_resolver.py,sha256=DZjUOD3uNxFAwsVUqrCTRhColjz9DRPetAvIb_Ccufs,32588
 robotcode/robot/diagnostics/imports_manager.py,sha256=opemApuCLgPNsnqVuYc9MefqHt42g_7Ozqhrmu_osH0,90401
 robotcode/robot/diagnostics/keyword_finder.py,sha256=nwTmjvhyu5H7HHzyk8gt-pny2K2xdH2qCNyKXwwXRnk,18998
-robotcode/robot/diagnostics/library_doc.py,sha256=MYztjgnOmXAPjXn7td651oWats2qDlPrLgCkmwpdSmU,153576
+robotcode/robot/diagnostics/library_doc.py,sha256=xJCFm1uMM2OFZqn6sJNfdjGZJ2WsQjGlRmlqDHv64uA,153571
 robotcode/robot/diagnostics/model_helper.py,sha256=_ySXwerkK5xvjWa82T0DFy8jpxRzcaavTJiAHnk2lXQ,29740
 robotcode/robot/diagnostics/namespace.py,sha256=Rcmjk3V0vcY-DUkgjkRyuOdYXurKaTEqXJLc6efYrwY,35489
 robotcode/robot/diagnostics/namespace_analyzer.py,sha256=dGAEbbznPJlFBKN4dLkMDU7w9xc0mYdmRARvRS3Zlwg,104331
@@ -36,13 +36,13 @@ robotcode/robot/diagnostics/semantic_analyzer/variable_tokenizer.py,sha256=vBor3
 robotcode/robot/utils/__init__.py,sha256=-A0YeHv7e7WK1SId7Er7Vu6frrDYWopUrcyFlyxLmPY,396
 robotcode/robot/utils/ast.py,sha256=S9xyiJZee4Y5VcroNrGIIWp8f9sutb_1o4blAlCqzdg,11218
 robotcode/robot/utils/markdown_docs.py,sha256=jY3jT919TicVRMhcYo03dR0NzhGq0kEnDolBSPc-lNI,29548
-robotcode/robot/utils/markdownformatter.py,sha256=hThVK-L7_0-xcAtNNXvFeAaSzbNix0hP73t_BO_JCsc,14122
+robotcode/robot/utils/markdownformatter.py,sha256=hHilBaj1DzBV1tlNHyNfMvM3h92Six-15guhQy6edgU,14323
 robotcode/robot/utils/match.py,sha256=KgA6o6TbnQpOT1eAzEjhl_-FZ2XO07xiV0L7IYRzyzE,1125
 robotcode/robot/utils/robot_patching.py,sha256=jXHhnPvZx8hCQq4B_2uwX9j51Be_toWpUoTYYe8HjPo,1463
 robotcode/robot/utils/robot_path.py,sha256=ObLP8PqamTZAz5oi0eDXE_dnyZwAPXp4TJYm6ugeENs,2185
 robotcode/robot/utils/stubs.py,sha256=umugZYAyneFNgqRJBRMJPzm0u0B_TH8Sx_y-ykXnxpw,351
 robotcode/robot/utils/variables.py,sha256=9WnP3QqcHdq-zioJ_gJXJobw_2Gcto_rGPCUGmOH9YQ,9829
 robotcode/robot/utils/visitor.py,sha256=nP3O0qh3YYuxR6S8wYJRBFfNwIVgsgohURBlrnFkRYQ,2299
-robotcode_robot-2.8.0.dev677.dist-info/METADATA,sha256=-WMG4AXbck6ZGANXnHl578n_RxVj5Y5o7iron1Hu8OU,2960
-robotcode_robot-2.8.0.dev677.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-robotcode_robot-2.8.0.dev677.dist-info/RECORD,,
+robotcode_robot-2.9.0.dev51.dist-info/METADATA,sha256=RziLuNl8hmcFuiRfMnuUYgOZm7OFM-E06dYl1ZNS6yE,2958
+robotcode_robot-2.9.0.dev51.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+robotcode_robot-2.9.0.dev51.dist-info/RECORD,,

{robotcode_robot-2.8.0.dev677.dist-info → robotcode_robot-2.9.0.dev51.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.32.4
+Generator: hatchling 1.33.0
 Root-Is-Purelib: true
 Tag: py3-none-any