robotframework 6.1.1__zip → 7.0__zip

{robotframework-6.1.1 → robotframework-7.0}/src/robot/running/namespace.py

@@ -21,32 +21,32 @@ from itertools import chain
 from robot.errors import DataError, KeywordError
 from robot.libraries import STDLIBS
 from robot.output import LOGGER, Message
-from robot.utils import (RecommendationFinder, eq, find_file, is_string, normalize,
-                         printable_name, seq2str2)
+from robot.utils import (eq, find_file, is_string, normalize, RecommendationFinder,
+                         seq2str2)
 
 from .context import EXECUTION_CONTEXTS
 from .importer import ImportCache, Importer
-from .model import Import
+from .invalidkeyword import InvalidKeyword
+from .resourcemodel import Import
 from .runkwregister import RUN_KW_REGISTER
-from .usererrorhandler import UserErrorHandler
-from .userkeyword import UserLibrary
+
 
 IMPORTER = Importer()
 
 
 class Namespace:
-    _default_libraries = ('BuiltIn', 'Reserved', 'Easter')
+    _default_libraries = ('BuiltIn', 'Easter')
     _library_import_by_path_ends = ('.py', '/', os.sep)
     _variables_import_by_path_ends = _library_import_by_path_ends + ('.yaml', '.yml') + ('.json',)
 
     def __init__(self, variables, suite, resource, languages):
-        LOGGER.info(f"Initializing namespace for suite '{suite.longname}'.")
+        LOGGER.info(f"Initializing namespace for suite '{suite.full_name}'.")
         self.variables = variables
         self.languages = languages
         self._imports = resource.imports
         self._kw_store = KeywordStore(resource, languages)
         self._imported_variable_files = ImportCache()
-        self._suite_name = suite.longname
+        self._suite_name = suite.full_name
         self._running_test = False
 
     @property
@@ -68,7 +68,7 @@ class Namespace:
                     raise DataError(f'{item.setting_name} setting requires value.')
                 self._import(item)
             except DataError as err:
-                item.report_invalid_syntax(err.message)
+                item.report_error(err.message)
 
     def _import(self, import_setting):
         action = import_setting.select(self._import_library,
@@ -84,11 +84,10 @@ class Namespace:
         self._validate_not_importing_init_file(path)
         if overwrite or path not in self._kw_store.resources:
             resource = IMPORTER.import_resource(path, self.languages)
-            self.variables.set_from_variable_table(resource.variables, overwrite)
-            user_library = UserLibrary(resource)
-            self._kw_store.resources[path] = user_library
+            self.variables.set_from_variable_section(resource.variables, overwrite)
+            self._kw_store.resources[path] = resource
             self._handle_imports(resource.imports)
-            LOGGER.imported("Resource", user_library.name,
+            LOGGER.imported("Resource", resource.name,
                             importer=str(import_setting.source),
                             source=path)
         else:
@@ -134,13 +133,13 @@ class Namespace:
         if notify:
             LOGGER.imported("Library", lib.name,
                             args=list(import_setting.args),
-                            originalname=lib.orig_name,
+                            originalname=lib.real_name,
                             importer=str(import_setting.source),
-                            source=lib.source)
+                            source=str(lib.source or ''))
         self._kw_store.libraries[lib.name] = lib
-        lib.start_suite()
+        lib.scope_manager.start_suite()
         if self._running_test:
-            lib.start_test()
+            lib.scope_manager.start_test()
 
     def _resolve_name(self, setting):
         name = setting.name
@@ -179,12 +178,12 @@ class Namespace:
         self._running_test = True
         self.variables.start_test()
         for lib in self.libraries:
-            lib.start_test()
+            lib.scope_manager.start_test()
 
     def end_test(self):
         self.variables.end_test()
         for lib in self.libraries:
-            lib.end_test()
+            lib.scope_manager.end_test()
         self._running_test = True
 
     def start_suite(self):
@@ -192,7 +191,7 @@ class Namespace:
 
     def end_suite(self, suite):
         for lib in self.libraries:
-            lib.end_suite()
+            lib.scope_manager.end_suite()
         if not suite.parent:
             IMPORTER.close_global_library_listeners()
         self.variables.end_suite()
@@ -203,29 +202,29 @@ class Namespace:
     def end_user_keyword(self):
         self.variables.end_keyword()
 
-    def get_library_instance(self, libname):
-        return self._kw_store.get_library(libname).get_instance()
+    def get_library_instance(self, name):
+        return self._kw_store.get_library(name).instance
 
     def get_library_instances(self):
-        return dict((name, lib.get_instance())
+        return dict((name, lib.instance)
                     for name, lib in self._kw_store.libraries.items())
 
-    def reload_library(self, libname_or_instance):
-        library = self._kw_store.get_library(libname_or_instance)
-        library.reload()
+    def reload_library(self, name_or_instance):
+        library = self._kw_store.get_library(name_or_instance)
+        library.create_keywords()
         return library
 
     def get_runner(self, name, recommend_on_failure=True):
         try:
             return self._kw_store.get_runner(name, recommend_on_failure)
-        except DataError as error:
-            return UserErrorHandler(error, name)
+        except DataError as err:
+            return InvalidKeyword(str(name), error=str(err)).create_runner(name)
 
 
 class KeywordStore:
 
-    def __init__(self, resource, languages):
-        self.user_keywords = UserLibrary(resource, resource_file=False)
+    def __init__(self, suite_file, languages):
+        self.suite_file = suite_file
         self.libraries = OrderedDict()
         self.resources = ImportCache()
         self.search_order = ()
@@ -253,7 +252,7 @@ class KeywordStore:
 
     def _get_lib_by_instance(self, instance):
         for lib in self.libraries.values():
-            if lib.get_instance(create=False) is instance:
+            if lib._instance is instance:
                 return lib
         self._no_library_found(instance)
 
@@ -277,18 +276,18 @@ class KeywordStore:
             )
         message = f"No keyword with name '{name}' found."
         if recommend:
-            finder = KeywordRecommendationFinder(self.user_keywords,
-                                                 self.libraries,
-                                                 self.resources)
+            finder = KeywordRecommendationFinder(self.suite_file,
+                                                 *self.libraries.values(),
+                                                 *self.resources.values())
             raise KeywordError(finder.recommend_similar_keywords(name, message))
         else:
             raise KeywordError(message)
 
     def _get_runner(self, name):
         if not name:
-            raise DataError('Keyword name cannot be empty.', syntax=True)
+            raise DataError('Keyword name cannot be empty.')
         if not is_string(name):
-            raise DataError('Keyword name must be a string.', syntax=True)
+            raise DataError('Keyword name must be a string.')
         runner = self._get_runner_from_suite_file(name)
         if not runner and '.' in name:
             runner = self._get_explicit_runner(name)
@@ -315,35 +314,35 @@ class KeywordStore:
                 self._get_runner_from_libraries(name))
 
     def _get_runner_from_suite_file(self, name):
-        if name not in self.user_keywords.handlers:
+        keywords = self.suite_file.find_keywords(name)
+        if not keywords:
             return None
-        handlers = self.user_keywords.handlers.get_handlers(name)
-        if len(handlers) > 1:
-            handlers = self._select_best_matches(handlers)
-            if len(handlers) > 1:
-                self._raise_multiple_keywords_found(handlers, name)
-        runner = handlers[0].create_runner(name, self.languages)
+        if len(keywords) > 1:
+            keywords = self._select_best_matches(keywords)
+            if len(keywords) > 1:
+                self._raise_multiple_keywords_found(keywords, name)
+        runner = keywords[0].create_runner(name, self.languages)
         ctx = EXECUTION_CONTEXTS.current
         caller = ctx.user_keywords[-1] if ctx.user_keywords else ctx.test
-        if caller and runner.source != caller.source:
+        if caller and runner.keyword.source != caller.source:
             if self._exists_in_resource_file(name, caller.source):
                 message = (
-                    f"Keyword '{caller.longname}' called keyword '{name}' that exists "
+                    f"Keyword '{caller.full_name}' called keyword '{name}' that exists "
                     f"both in the same resource file as the caller and in the suite "
                     f"file using that resource. The keyword in the suite file is used "
-                    f"now, but this will change in Robot Framework 7.0."
+                    f"now, but this will change in Robot Framework 8.0."
                 )
                 runner.pre_run_messages += Message(message, level='WARN'),
         return runner
 
-    def _select_best_matches(self, handlers):
+    def _select_best_matches(self, keywords):
         # "Normal" matches are considered exact and win over embedded matches.
-        normal = [hand for hand in handlers if not hand.supports_embedded_args]
+        normal = [kw for kw in keywords if not kw.embedded]
         if normal:
             return normal
-        matches = [hand for hand in handlers
-                   if not self._is_worse_match_than_others(hand, handlers)]
-        return matches or handlers
+        matches = [kw for kw in keywords
+                   if not self._is_worse_match_than_others(kw, keywords)]
+        return matches or keywords
 
     def _is_worse_match_than_others(self, candidate, alternatives):
         for other in alternatives:
@@ -360,135 +359,133 @@ class KeywordStore:
 
     def _exists_in_resource_file(self, name, source):
         for resource in self.resources.values():
-            if resource.source == source and name in resource.handlers:
+            if resource.source == source and resource.find_keywords(name):
                 return True
         return False
 
     def _get_runner_from_resource_files(self, name):
-        handlers = [handler for res in self.resources.values()
-                    for handler in res.handlers_for(name)]
-        if not handlers:
+        keywords = [kw for resource in self.resources.values()
+                    for kw in resource.find_keywords(name)]
+        if not keywords:
             return None
-        if len(handlers) > 1:
-            handlers = self._filter_based_on_search_order(handlers)
-            if len(handlers) > 1:
-                handlers = self._prioritize_same_file_or_public(handlers)
-                if len(handlers) > 1:
-                    handlers = self._select_best_matches(handlers)
-                    if len(handlers) > 1:
-                        self._raise_multiple_keywords_found(handlers, name)
-        return handlers[0].create_runner(name, self.languages)
+        if len(keywords) > 1:
+            keywords = self._filter_based_on_search_order(keywords)
+            if len(keywords) > 1:
+                keywords = self._prioritize_same_file_or_public(keywords)
+                if len(keywords) > 1:
+                    keywords = self._select_best_matches(keywords)
+                    if len(keywords) > 1:
+                        self._raise_multiple_keywords_found(keywords, name)
+        return keywords[0].create_runner(name, self.languages)
 
     def _get_runner_from_libraries(self, name):
-        handlers = [handler for lib in self.libraries.values()
-                    for handler in lib.handlers_for(name)]
-        if not handlers:
+        keywords = [kw for lib in self.libraries.values()
+                    for kw in lib.find_keywords(name)]
+        if not keywords:
             return None
         pre_run_message = None
-        if len(handlers) > 1:
-            handlers = self._filter_based_on_search_order(handlers)
-            if len(handlers) > 1:
-                handlers = self._select_best_matches(handlers)
-                if len(handlers) > 1:
-                    handlers, pre_run_message = self._filter_stdlib_handler(handlers)
-                    if len(handlers) > 1:
-                        self._raise_multiple_keywords_found(handlers, name)
-        runner = handlers[0].create_runner(name, self.languages)
+        if len(keywords) > 1:
+            keywords = self._filter_based_on_search_order(keywords)
+            if len(keywords) > 1:
+                keywords = self._select_best_matches(keywords)
+                if len(keywords) > 1:
+                    keywords, pre_run_message = self._filter_stdlib_handler(keywords)
+                    if len(keywords) > 1:
+                        self._raise_multiple_keywords_found(keywords, name)
+        runner = keywords[0].create_runner(name, self.languages)
         if pre_run_message:
             runner.pre_run_messages += (pre_run_message,)
         return runner
 
-    def _prioritize_same_file_or_public(self, handlers):
+    def _prioritize_same_file_or_public(self, keywords):
         user_keywords = EXECUTION_CONTEXTS.current.user_keywords
         if user_keywords:
             parent_source = user_keywords[-1].source
-            matches = [h for h in handlers if h.source == parent_source]
+            matches = [kw for kw in keywords if kw.source == parent_source]
             if matches:
                 return matches
-        matches = [handler for handler in handlers if not handler.private]
-        return matches or handlers
+        matches = [kw for kw in keywords if not kw.private]
+        return matches or keywords
 
-    def _filter_based_on_search_order(self, handlers):
-        for libname in self.search_order:
-            matches = [hand for hand in handlers if eq(libname, hand.libname)]
+    def _filter_based_on_search_order(self, keywords):
+        for name in self.search_order:
+            matches = [kw for kw in keywords if eq(name, kw.owner.name)]
             if matches:
                 return matches
-        return handlers
+        return keywords
 
-    def _filter_stdlib_handler(self, handlers):
+    def _filter_stdlib_handler(self, keywords):
         warning = None
-        if len(handlers) != 2:
-            return handlers, warning
+        if len(keywords) != 2:
+            return keywords, warning
         stdlibs_without_remote = STDLIBS - {'Remote'}
-        if handlers[0].library.orig_name in stdlibs_without_remote:
-            standard, custom = handlers
-        elif handlers[1].library.orig_name in stdlibs_without_remote:
-            custom, standard = handlers
+        if keywords[0].owner.real_name in stdlibs_without_remote:
+            standard, custom = keywords
+        elif keywords[1].owner.real_name in stdlibs_without_remote:
+            custom, standard = keywords
         else:
-            return handlers, warning
-        if not RUN_KW_REGISTER.is_run_keyword(custom.library.orig_name, custom.name):
+            return keywords, warning
+        if not RUN_KW_REGISTER.is_run_keyword(custom.owner.real_name, custom.name):
             warning = self._custom_and_standard_keyword_conflict_warning(custom, standard)
         return [custom], warning
 
     def _custom_and_standard_keyword_conflict_warning(self, custom, standard):
         custom_with_name = standard_with_name = ''
-        if custom.library.name != custom.library.orig_name:
-            custom_with_name = f" imported as '{custom.library.name}'"
-        if standard.library.name != standard.library.orig_name:
-            standard_with_name = f" imported as '{standard.library.name}'"
+        if custom.owner.name != custom.owner.real_name:
+            custom_with_name = f" imported as '{custom.owner.name}'"
+        if standard.owner.name != standard.owner.real_name:
+            standard_with_name = f" imported as '{standard.owner.name}'"
         return Message(
             f"Keyword '{standard.name}' found both from a custom library "
-            f"'{custom.library.orig_name}'{custom_with_name} and a standard library "
-            f"'{standard.library.orig_name}'{standard_with_name}. The custom keyword "
+            f"'{custom.owner.real_name}'{custom_with_name} and a standard library "
+            f"'{standard.owner.real_name}'{standard_with_name}. The custom keyword "
             f"is used. To select explicitly, and to get rid of this warning, use "
-            f"either '{custom.longname}' or '{standard.longname}'.", level='WARN'
+            f"either '{custom.full_name}' or '{standard.full_name}'.", level='WARN'
         )
 
     def _get_explicit_runner(self, name):
-        handlers_and_names = []
+        kws_and_names = []
         for owner_name, kw_name in self._get_owner_and_kw_names(name):
             for owner in chain(self.libraries.values(), self.resources.values()):
-                if eq(owner.name, owner_name) and kw_name in owner.handlers:
-                    for handler in owner.handlers.get_handlers(kw_name):
-                        handlers_and_names.append((handler, kw_name))
-        if not handlers_and_names:
+                if eq(owner.name, owner_name):
+                    for kw in owner.find_keywords(kw_name):
+                        kws_and_names.append((kw, kw_name))
+        if not kws_and_names:
             return None
-        if len(handlers_and_names) == 1:
-            handler, kw_name = handlers_and_names[0]
+        if len(kws_and_names) == 1:
+            kw, kw_name = kws_and_names[0]
         else:
-            handlers = [h for h, n in handlers_and_names]
-            matches = self._select_best_matches(handlers)
+            keywords = [kw for kw, _ in kws_and_names]
+            matches = self._select_best_matches(keywords)
             if len(matches) > 1:
-                self._raise_multiple_keywords_found(handlers, name, implicit=False)
-            handler, kw_name = handlers_and_names[handlers.index(matches[0])]
-        return handler.create_runner(kw_name, self.languages)
+                self._raise_multiple_keywords_found(keywords, name, implicit=False)
+            kw, kw_name = kws_and_names[keywords.index(matches[0])]
+        return kw.create_runner(kw_name, self.languages)
 
     def _get_owner_and_kw_names(self, full_name):
         tokens = full_name.split('.')
         return [('.'.join(tokens[:index]), '.'.join(tokens[index:]))
                 for index in range(1, len(tokens))]
 
-    def _raise_multiple_keywords_found(self, handlers, name, implicit=True):
-        if any(hand.supports_embedded_args for hand in handlers):
+    def _raise_multiple_keywords_found(self, keywords, name, implicit=True):
+        if any(kw.embedded for kw in keywords):
             error = f"Multiple keywords matching name '{name}' found"
         else:
             error = f"Multiple keywords with name '{name}' found"
             if implicit:
                 error += ". Give the full name of the keyword you want to use"
-        names = sorted(hand.longname for hand in handlers)
+        names = sorted(kw.full_name for kw in keywords)
         raise KeywordError('\n    '.join([error+':'] + names))
 
 
 class KeywordRecommendationFinder:
 
-    def __init__(self, user_keywords, libraries, resources):
-        self.user_keywords = user_keywords
-        self.libraries = libraries
-        self.resources = resources
+    def __init__(self, *owners):
+        self.owners = owners
 
     def recommend_similar_keywords(self, name, message):
         """Return keyword names similar to `name`."""
-        candidates = self._get_candidates('.' in name)
+        candidates = self._get_candidates(use_full_name='.' in name)
         finder = RecommendationFinder(
             lambda name: normalize(candidates.get(name, name), ignore='_')
         )
@@ -499,21 +496,11 @@ class KeywordRecommendationFinder:
     def format_recommendations(message, recommendations):
         return RecommendationFinder().format(message, recommendations)
 
-    def _get_candidates(self, use_full_name):
-        names = {}
-        for owner, name in self._get_all_handler_names():
+    def _get_candidates(self, use_full_name=False):
+        candidates = {}
+        names = sorted((owner.name or '', kw.name)
+                       for owner in self.owners for kw in owner.keywords)
+        for owner, name in names:
             full_name = f'{owner}.{name}' if owner else name
-            names[full_name] = full_name if use_full_name else name
-        return names
-
-    def _get_all_handler_names(self):
-        """Return a list of `(library_name, handler_name)` tuples."""
-        handlers = [('', printable_name(handler.name, True))
-                    for handler in self.user_keywords.handlers]
-        for library in chain(self.libraries.values(), self.resources.values()):
-            if library.name != 'Reserved':
-                handlers.extend(
-                    ((library.name or '',
-                      printable_name(handler.name, code_style=True))
-                     for handler in library.handlers))
-        return sorted(handlers)
+            candidates[full_name] = full_name if use_full_name else name
+        return candidates

{robotframework-6.1.1 → robotframework-7.0}/src/robot/running/outputcapture.py

@@ -13,8 +13,8 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from io import StringIO
 import sys
+from io import StringIO
 
 from robot.output import LOGGER
 from robot.utils import console_decode, console_encode
@@ -23,19 +23,27 @@ from robot.utils import console_decode, console_encode
 class OutputCapturer:
 
     def __init__(self, library_import=False):
-        self._library_import = library_import
-        self._python_out = PythonCapturer(stdout=True)
-        self._python_err = PythonCapturer(stdout=False)
+        self.library_import = library_import
+        self.stdout = None
+        self.stderr = None
+
+    def start(self):
+        self.stdout = StreamCapturer(stdout=True)
+        self.stderr = StreamCapturer(stdout=False)
+        if self.library_import:
+            LOGGER.enable_library_import_logging()
+
+    def stop(self):
+        self._release_and_log()
+        if self.library_import:
+            LOGGER.disable_library_import_logging()
 
     def __enter__(self):
-        if self._library_import:
-            LOGGER.enable_library_import_logging()
+        self.start()
         return self
 
     def __exit__(self, exc_type, exc_value, exc_trace):
-        self._release_and_log()
-        if self._library_import:
-            LOGGER.disable_library_import_logging()
+        self.stop()
         return False
 
     def _release_and_log(self):
@@ -47,12 +55,12 @@ class OutputCapturer:
             sys.__stderr__.write(console_encode(stderr, stream=sys.__stderr__))
 
     def _release(self):
-        stdout = self._python_out.release()
-        stderr = self._python_err.release()
+        stdout = self.stdout.release()
+        stderr = self.stderr.release()
         return stdout, stderr
 
 
-class PythonCapturer:
+class StreamCapturer:
 
     def __init__(self, stdout=True):
         if stdout: