Better results from steps in test but not resource. WIP many debugs

src/robotide/controller/ctrlcommands.py

@@ -347,7 +347,7 @@ def _notify_values_changed(self, occurrences, old_name=None):
                       f"oc= {oc.source} {oc.item} {oc.usage} {oc._value}")
             except AttributeError:
                 print(f"DEBUG: ctlcommands.py RenameKeywordOccurrences _notify_values_changed: "
-                      f" in AttributeError oc= {oc.item} {oc.usage} {oc._value}")
+                      f" in AttributeError oc= {oc}")
             oc.notify_value_changed(old_name)
             self._observer.notify()
 
@@ -367,7 +367,7 @@ def _params(self):
     def _execute(self, context):
         old_name = context.name
         context.test_name.rename(self._new_name)
-        context.test_name._item.notify_name_changed(old_name)
+        context.test_name._item.notify_name_changed(old_name=old_name, new_name=self._new_name)
 
     def _get_undo_command(self):
         return self
@@ -654,21 +654,38 @@ def execute(self, context):
 
 def normalize_kw_name(name):
     name = re.sub('(.)([A-Z][a-z]+)', r'\1 \2', name)
-    return re.sub('([a-z0-9])([A-Z])', r'\1 \2', name).lower().replace('_', ' ')
+    # print(f"DEBUG: ctlcommands.py normalize_kw_name First step keyword_name={name}")
+    name = re.sub('([a-z0-9])([A-Z])', r'\1 \2', name).lower().replace('_', ' ')
+    # print(f"DEBUG: ctlcommands.py normalize_kw_name RETURN keyword_name={name}")
+    return name
 
 
 class FindOccurrences(_Command):
     modifying = False
 
-    def __init__(self, keyword_name, keyword_info=None):
+    def __init__(self, keyword_name, keyword_info=None, prefix=None):
         if keyword_name.strip() == '':
             raise ValueError('Keyword name can not be "%s"' % keyword_name)
         self.normalized_name = normalize_kw_name(keyword_name)
         print(f"DEBUG: ctlcommands.py FindOccurrences INIT keyword_name={keyword_name}")
         self._keyword_name = keyword_name
         self._keyword_info = keyword_info
+        self.normalized_name_res = None
+        if self._keyword_info:
+            self.normalized_name_res = (keyword_name if '.' in keyword_name
+                                        else (self._keyword_info.source.replace('.robot', '').replace('.resource', '')
+                                        +"."+keyword_name))
+            self._keyword_source = self._keyword_info.source
+            # if keyword_name == self.normalized_name_res:
+            #     self.normalized_name_res = None
+        else:
+            self._keyword_source = None
+        self.prefix = prefix
+        if self.prefix and not self.normalized_name_res:
+            self.normalized_name_res = f"{self.prefix}.{self._keyword_name}"
+        print(f"DEBUG: ctlcommands.py FindOccurrences INIT normalized_name_res={self.normalized_name_res}"
+              f"\nSOURCE={self._keyword_source} PREFIX={self.prefix}")
         self._keyword_regexp = self._create_regexp(keyword_name)
-        self._keyword_source = None
 
     @staticmethod
     def _create_regexp(keyword_name):
@@ -684,9 +701,16 @@ def _create_regexp(keyword_name):
             return name
 
     def execute(self, context):
+        print(f"DEBUG: ctrlcommands FindOccurrences EXECUTE context={context}")
         self._keyword_source = \
             self._keyword_info and self._keyword_info.source or \
             self._find_keyword_source(context.datafile_controller)
+        if not self.normalized_name_res:
+            self.normalized_name_res = (self._keyword_name if '.' in self._keyword_name
+                                        else (self._keyword_source.replace('.robot', '').replace('.resource', '')
+                                        +"."+self._keyword_name))
+        if self._keyword_name == self.normalized_name_res and '.' in self._keyword_name:
+            self._keyword_name = self._keyword_name.split('.')[-1]
         return self._find_occurrences_in(self._items_from(context))
 
     def _items_from(self, context):
@@ -710,29 +734,72 @@ def _items_from_datafile(self, df):
                 yield item
         for kw_items in (self._items_from_keyword(kw) for kw in df.keywords):
             for item in kw_items:
+                # print(f"DEBUG: ctrlcommands FindOccurrences _items_from_datafile  kw_items yield {item}"
+                #      f"\nself._keyword_source = {self._keyword_source}")
                 yield item
 
     def _items_from_keyword(self, kw):
         return chain([kw.keyword_name] if kw.source == self._keyword_source
-                     else [], kw.steps, [kw.teardown] if kw.teardown else [])
+                     else [], kw.steps, [kw.setup] if kw.setup else [], [kw.teardown] if kw.teardown else [])
 
     @staticmethod
     def _items_from_test(test):
         return chain(test.settings, test.steps)
 
     def _find_keyword_source(self, datafile_controller):
         item_info = datafile_controller.keyword_info(None, self._keyword_name)
+        print(f"DEBUG: ctrlcommands _find_keyword_source datafile_controller={datafile_controller}"
+              f"item_info={item_info}")
         return item_info.source if item_info else None
 
     def _find_occurrences_in(self, items):
+        # print(f"DEBUG: ctrlcommands _find_occurrences_in ENTER normalized_name={self.normalized_name} WITH resource"
+        #      f" {self.normalized_name_res} PREFIX={self.prefix}\n"
+        #      f"LIST OF ITEMS={items}")
+        if not self._keyword_source.startswith(self.prefix):
+            print(f"DEBUG: ctrlcommands FindOccurrences _find_occurrences_in SKIP SEARCH"
+                  f" self._keyword_source={self._keyword_source}\n"
+                  f"prefix={self.prefix}")
+            yield None
+        else:
+            for item in items:
+                # print(f"DEBUG: ctrlcommands _find_occurrences_in searching item={item}")
+                if (self.normalized_name_res and (self.normalized_name_res.startswith(self.prefix)
+                        and item.contains_keyword(self.normalized_name_res)
+                        or item.contains_keyword(self._keyword_name))):
+                    # This block is active when finding from a cell with resource prefix
+                    print(f"DEBUG: ctrlcommands _find_occurrences_in searching item={item}  ADD TO OCCURRENCES: FOUND "
+                          f"{self.normalized_name_res}")
+                    yield Occurrence(item, self._keyword_name)
+                elif self._contains_exact_item(item):
+                    # print(f"DEBUG: ctrlcommands _find_occurrences_in searching item={item} NAME={self._keyword_name}"
+                    #       f" source={self._keyword_source}\n"
+                    #       f"self.normalized_name_res={self.normalized_name_res} parent={item.parent}\n"
+                    #       f" PREFIX={self.prefix}")
+                    # print(f"DEBUG: ctrlcommands _find_occurrences_in searching item type = {type(item)}"
+                    #       f" kwsource={self._keyword_source}")
+                    # if self._keyword_source.startswith(self.prefix):
+                    print(f"DEBUG: ctrlcommands _find_occurrences_in searching ADD TO OCCURRENCES: {self._keyword_name}")
+                    yield Occurrence(item, self._keyword_name)
+
+    def _contains_exact_item(self, item):
         from .tablecontrollers import VariableTableController
-        print(f"DEBUG: ctrlcommands _find_occurrences_in NORMALIZED NAME {self.normalized_name}")
-        for item in items:
-            # print(f"DEBUG: ctrlcommands _find_occurrences_in searching item={item}")
-            if self._contains_item(item) or (not isinstance(item, VariableTableController)
-                                             and (item.contains_keyword(self.normalized_name) or
-                                             item.contains_keyword(self.normalized_name.replace(' ', '_')))):
-                yield Occurrence(item, self._keyword_name)
+        match_name = self._contains_item(item)
+        if match_name and isinstance(match_name, re.Match) and '.' in match_name.string:
+                # print(f"DEBUG: ctrlcommands _find_occurrences_in _contains_exact_item PREFIXED Name={match_name}"
+                #       f"\n groups={match_name.groups()} string={match_name.string}"
+                #       f" RETURNS {match_name.string.startswith(self.prefix)}")
+                return match_name.string.startswith(self.prefix)  # Avoid false positive for res prefixed
+        elif match_name or (not isinstance(item, VariableTableController) and
+                          (item.contains_keyword(self.normalized_name) or
+                           item.contains_keyword(self.normalized_name.replace(' ', '_')))):
+            if match_name and isinstance(match_name, re.Match):
+                print(f"DEBUG: ctrlcommands _find_occurrences_in _contains_exact_item Matching Name={match_name}")
+            else:
+                 print(f"DEBUG: ctrlcommands _find_occurrences_in _contains_exact_item  item={item}"
+                       f"self.normalized_name={self.normalized_name} OR "
+                       f"underscore={self.normalized_name.replace(' ', '_')}")
+            return True
 
     def _contains_item(self, item):
         self._yield_for_other_threads()

src/robotide/controller/macrocontrollers.py

@@ -61,7 +61,7 @@ def rename(self, new_name):
 
     def notify_value_changed(self, old_name=None):
         print(f"DEBUG: macrocontrollers.py notify_value_changed item={self._item.name} old_name={old_name}")
-        self._item.notify_name_changed(old_name)
+        self._item.notify_name_changed(old_name=old_name, new_name=self._item.name)
 
     @property
     def parent(self):
@@ -287,10 +287,10 @@ def _create_extracted_kw(self, name, argstr, extracted_steps):
     def validate_name(self, name):
         return self._parent.validate_name(name, self)
 
-    def notify_name_changed(self, old_name=None):
+    def notify_name_changed(self, old_name=None, new_name=None):
         self.update_namespace()
         self.mark_dirty()
-        RideItemNameChanged(item=self, old_name=old_name).publish()
+        RideItemNameChanged(item=self, old_name=old_name, new_name=new_name).publish()
 
     def notify_keyword_removed(self):
         self.update_namespace()

src/robotide/controller/settingcontrollers.py

@@ -640,6 +640,8 @@ def contains_filename(self, filename):
         return self.name.endswith(filename)
 
     def change_name(self, old_name, new_name):
+        print(f"DEBUG: settingcontrollers.py ResourceImportController change_name ENTER\n"
+              f"old_name={old_name} new_name={new_name}")
         if self.contains_filename(old_name):
             self.set_value(self.name[:-len(old_name)] + new_name)
         else:

src/robotide/controller/stepcontrollers.py

@@ -282,8 +282,15 @@ def contains_variable_assignment(self, name):
                    for item in self.as_list())
 
     def contains_keyword(self, name):
+        for item in [self.keyword or ''] + self.args:
+            matching = self._kw_name_match(item, name)
+            if matching is not None:
+                return matching
+        return False
+        """    
         return any(self._kw_name_match(item, name)
                    for item in [self.keyword or ''] + self.args)
+        """
 
     def _kw_name_match(self, item, expected):
         if isinstance(expected, str):
@@ -566,7 +573,7 @@ def notify_value_changed(self, old_name=None):
         print(f"DEBUG: stepcontrollers.py StepController notify_value_changed: ENTER old_name={old_name}"
               f" parent={self.parent.name}  calling self.parent.notify_steps_changed()")
         if old_name is not None:
-            RideItemNameChanged(item=self, old_name=old_name).publish()
+            RideItemNameChanged(item=self, old_name=old_name, new_name=None).publish()
         self.parent.notify_steps_changed(old_name)
 
     def increase_indent(self):

src/robotide/namespace/namespace.py

@@ -203,8 +203,6 @@ def new_resource(self, path, directory=''):
 
     def find_user_keyword(self, datafile, kw_name):
         kw = self.find_keyword(datafile, kw_name)
-        # print(f"DEBUG: namespace.py Namespace find_user_keyword datafile={datafile} "
-        #       f" kw_name={kw_name} keyword={kw}")
         return kw if isinstance(kw, UserKeywordInfo) else None
 
     def is_user_keyword(self, datafile, kw_name):
@@ -229,13 +227,14 @@ def find_keyword(self, datafile, kw_name):
         casesensitive = (kw_name.upper() != kw_name and kw_name.upper() in UPPERCASE_KWS)
         kwds = self._retriever.get_keywords_cached(datafile, self._context_factory, caseless=not casesensitive)
         # print(f"DEBUG: namespace.py Namespace find_keyword will GET kw_name=={kw_name} casesensitive={casesensitive}")
-        return kwds.get(kw_name)
+        return kwds.get(kw_name, origin=datafile)
 
     def is_library_keyword(self, datafile, kw_name):
         return bool(self.find_library_keyword(datafile, kw_name))
 
     def keyword_details(self, datafile, name):
-        # print(f"DEBUG: namespace.py Namespace  keyword_details ENTER will look for name=={name}")
+        # print(f"DEBUG: namespace.py Namespace  keyword_details ENTER will look for name=={name} "
+        #       f"in datafile={datafile.source}")
         kw = self.find_keyword(datafile, name)
         return kw.details if kw else None
 
@@ -548,7 +547,9 @@ def get_keywords_cached(self, datafile, context_factory, caseless=False):
             words.extend(self.default_kws)
             values = _Keywords(words, caseless=caseless)
             self.keyword_cache.put(datafile.source, values)
-        # print(f"DEBUG: namespace.py DatafileRetrieve get_keywords_cached returning cached keywords values=={values}")
+        # print(f"DEBUG: namespace.py DatafileRetrieve get_keywords_cached returning cached keywords values=={values}"
+        #       f"\ndatafile={datafile.source}")
+        # print(f"DEBUG: namespace.py DatafileRetrieve get_keywords_cached datafile = {datafile.source}")
         return values
 
     def _get_user_keywords_from(self, datafile):
@@ -642,8 +643,11 @@ def _add_embedded(self, kw):
         except TypeError:
             pass
 
-    def get(self, kw_name):
+    def get(self, kw_name, origin=None):
         if kw_name in self.keywords:
+            filename = os.path.basename(origin.source)
+            # print(f"DEBUG: namespace.py _Keywords get keywords in loop FOUND {kw_name} @ {filename}"
+            #       f" RETURNING {self.keywords[kw_name]} {self.keywords[kw_name].source == filename}")
             return self.keywords[kw_name]
         # print(f"DEBUG: namespace.py _Keywords get keywords {self.keywords}")
         bdd_name = self._get_bdd_name(kw_name)

src/robotide/publish/messages.py

@@ -409,7 +409,7 @@ class RideItemStepsChanged(RideItem):
 
 class RideItemNameChanged(RideItem):
     """"""
-    data = ['item', 'old_name']
+    data = ['item', 'old_name', 'new_name']
 
 
 class RideItemSettingsChanged(RideItem):

src/robotide/spec/iteminfo.py

@@ -38,6 +38,7 @@ def __init__(self, name, source, details):
         """
         self.name = name
         self.source = source
+        # print(f"DEBUG: iteminfo.py ItemInfo {name=} {source=}")
         if details is not None:
             self.details = details
         self._priority = PRIORITIES.get(self.__class__, PRIORITIES[ItemInfo])

src/robotide/ui/treenodehandlers.py

@@ -748,6 +748,8 @@ def _add_copy_to_tree(self, parent_node, copied):
         self._tree.add_keyword(parent_node, copied)
 
     def _create_rename_command(self, new_name):
+        print(f"DEBUG: treenodehandlers.py UserKeywodHandler _create_rename_command controller.name={self.controller.name}"
+              f", new_name={new_name} info={self.controller.info}")
         return ctrlcommands.RenameKeywordOccurrences(
             self.controller.name, new_name,
             RenameProgressObserver(self._tree.GetParent()),

src/robotide/ui/treeplugin.py

@@ -24,6 +24,7 @@
 from wx.lib.mixins import treemixin
 
 from ..context import IS_WINDOWS
+from ..controller import ResourceFileController
 from ..publish.messages import (RideTestRunning, RideTestPaused, RideTestPassed, RideTestFailed, RideTestSkipped,
                                 RideTestExecutionStarted, RideTestStopped, RideImportSetting, RideExcludesChanged,
                                 RideIncludesChanged, RideOpenSuite, RideNewProject)
@@ -686,7 +687,12 @@ def _filename_changed(self, message):
         node = self.controller.find_node_by_controller(df)
         if not node:
             raise AssertionError('No node found with controller "%s"' % df)
+        old_name = node.GetText()
+        print(f"DEBUG: treeplugin.py Tree _filename_changed message={message} df={df}"
+              f" node={node} {old_name=} df.display_name={df.display_name}")
         wx.CallAfter(self.SetItemText, node, df.display_name)
+        if isinstance(df, ResourceFileController):
+            RideItemNameChanged(item=node, old_name=old_name, new_name=df.display_name).publish()
 
     def add_keyword_controller(self, controller):
         parent = self._get_datafile_node(self.get_selected_datafile())
@@ -1086,6 +1092,7 @@ def on_move_down(self, event):
             handler.on_move_down(event)
 
     def _item_changed(self, message):
+        print(f"DEBUG: treeplugin.py Tree _item_changed ENTER message={message}")
         if isinstance(message, RideItemNameChanged):
             return
         controller = message.item
@@ -1099,25 +1106,31 @@ def _item_changed(self, message):
 
     def _item_renamed(self, message):
         from ..lib.robot.parsing.settings import Resource
+        print(f"DEBUG: treeplugin.py Tree _item_renamed ENTER message={message}")
         if not isinstance(message, RideItemNameChanged):
             return
         controller = message.item
-        print(f"DEBUG: treeplugin.py Tree _item_renamed ENTER controller={controller.display_name}")
-        node = self.controller.find_node_by_controller(controller)
-        if hasattr(controller.datafile, 'setting_table'):
+        node = (self.controller.find_node_by_controller(controller) or
+                self.controller.find_node_with_label(controller, message.old_name))
+        print(f"DEBUG: treeplugin.py Tree _item_renamed ENTER controller={controller}"
+              f" NODE={node}")
+        if hasattr(controller, 'datafile') and hasattr(controller.datafile, 'setting_table'):
             imports = controller.datafile.setting_table.imports
             print(f"DEBUG: treeplugin.py Tree _item_renamed HAS IMPORTS imports={imports}")
             for imp in imports:
-                if isinstance(imp, Resource):
+                if isinstance(imp, Resource) and hasattr(message.item, 'keyword'):
                     print(f"DEBUG: treeplugin.py Tree _item_renamed IMPORT message.item.name={message.item.keyword},"
                           f" old_name={message.old_name} resource name={imp.name}")
                     # print(f"DEBUG: treeplugin.py Tree _item_renamed IMPORT message.item.name={message},"
                     #       f" old_name={message.old_name} import={imp}")
                     self._rename_resource_kw(new_name=message.item.keyword, old_name=message.old_name, resource=imp)
-        # if node and hasattr(message, 'old_name'):
-        #     print(f"DEBUG: treeplugin.py Tree _item_renamed RENAMED node={node}, old_name={message.old_name}")
+        if node and hasattr(message, 'old_name'):
+            print(f"DEBUG: treeplugin.py Tree _item_renamed RENAMED node={node}, old_name={message.old_name}\n"
+                  f"new_name={message.new_name}")
+            # Here we need to rename all resourc prefixed occurrencees
+
         self.Refresh()
-        if node:
+        if node and hasattr(message.item, 'name'):
             self.EnsureVisible(node)
             self.SelectItem(node)
             self.SetItemText(node, message.item.name)