Moving towards a working intermediate model for new locator element engine

On the way to complete a working model of the engine. This intermediate
model will have the default locator strategy hardcoded. Eventually this will be one
in the list of registered elementfinders. Committing now as I need to make
a change that may need to be reverted.

Author: emanlove

src/SeleniumLibrary/__init__.py

@@ -766,7 +766,7 @@ def find_element(
         :rtype: selenium.webdriver.remote.webelement.WebElement
         :raises SeleniumLibrary.errors.ElementNotFound: If element not found.
         """
-        return self._loc_elem_engine.find(locator, parent=parent)
+        return self._loc_elem_engine.parse_and_find(locator, parent=parent)
 
     def find_elements(
         self, locator: str, parent: WebElement = None
@@ -782,7 +782,7 @@ def find_elements(
         :return: list of found `WebElement` or e,mpty if elements are not found.
         :rtype: list[selenium.webdriver.remote.webelement.WebElement]
         """
-        return self._loc_elem_engine.find(
+        return self._loc_elem_engine.parse_and_find(
             locator, first_only=False, required=False, parent=parent
         )
 

src/SeleniumLibrary/base/context.py

@@ -79,7 +79,7 @@ def find_element(
         :raises SeleniumLibrary.errors.ElementNotFound: If element not found
             and `required` is true.
         """
-        return self.element_finder.find(locator, tag, True, required, parent)
+        return self.element_finder.parse_and_find(locator, tag, True, required, parent)
 
     def find_elements(
         self, locator: str, tag: Optional[str] = None, parent: WebElement = None
@@ -97,7 +97,7 @@ def find_elements(
         :return: list of found `WebElement` or empty if elements are not found.
         :rtype: list[selenium.webdriver.remote.webelement.WebElement]
         """
-        return self.element_finder.find(locator, tag, False, False, parent)
+        return self.element_finder.parse_and_find(locator, tag, False, False, parent)
 
     def is_text_present(self, text: str):
         locator = f"xpath://*[contains(., {escape_xpath_value(text)})]"

src/SeleniumLibrary/locators/elementfinder.py

@@ -15,11 +15,10 @@
 # limitations under the License.
 import re
 from typing import Union
+from typing import Protocol
 
 from robot.api import logger
 from robot.utils import NormalizedDict
-from selenium.webdriver.remote.webelement import WebElement
-from selenium.webdriver.support.event_firing_webdriver import EventFiringWebElement
 from selenium.webdriver.common.by import By
 
 from SeleniumLibrary.base import ContextAware
@@ -130,8 +129,25 @@ def __init__(self, ctx):
             r"|css ?[:|=]|class ?[:|=]|jquery ?[:|=]|sizzle ?[:|=]|tag ?[:|=]|scLocator ?[:|=])",
             re.IGNORECASE,
         )
+        # Should create a (empty?) list of ElementFinder here
+        # and register the default element finder (and others?) ...
+        # .. but for now hard code an instance of the defaultelementfinder
+        self._element_finder = DefaultElementFinder()
 
-    def find(
+
+# I am wanting to rename what was called the find method
+#   def find(
+# which would do the parsing of the locator string and then call
+# the elementfinder (_find)
+#
+# Thought I might call it execute_find_cycle but really that is
+# the name to give the looping through the element finder list
+#    def execute_find_cycle(
+#
+# Have a generic namer of request but seems too generic ..
+#    def request(...):
+# Going with
+    def parse_and_find(
         self,
         locator: Union[str, list],
         tag=None,
@@ -140,12 +156,18 @@ def find(
         parent=None,
     ):
         element = parent
+        # The _split_locator method could be architected as another class, parse_locator
         locators = self._split_locator(locator)
         for split_locator in locators[:-1]:
-            element = self._find(
-                split_locator, first_only=True, required=True, parent=element
-            )
-        return self._find(locators[-1], tag, first_only, required, element)
+            # This where we would loop through the list of element finders..
+            # .. but for now just call the find method on the default element finder.
+            element = self._element_finder.find(split_locator, first_only=True, required=True, parent=element)
+            #
+            # .. was ..
+            # element = self._find
+            #     split_locator, first_only=True, required=True, parent=element
+            # )
+        return self._element_finder.find(locators[-1], tag, first_only, required, element)
 
     def _split_locator(self, locator: Union[str, list]) -> list:
         if isinstance(locator, list):
@@ -164,25 +186,25 @@ def _split_locator(self, locator: Union[str, list]) -> list:
         parts.append(locator)
         return parts
 
-    def _find(self, locator, tag=None, first_only=True, required=True, parent=None):
-        element_type = "Element" if not tag else tag.capitalize()
-        if parent and not is_webelement(parent):
-            raise ValueError(
-                f"Parent must be Selenium WebElement but it was {type(parent)}."
-            )
-        if is_webelement(locator):
-            return locator
-        prefix, criteria = self._parse_locator(locator)
-        strategy = self._strategies[prefix]
-        tag, constraints = self._get_tag_and_constraints(tag)
-        elements = strategy(criteria, tag, constraints, parent=parent or self.driver)
-        if required and not elements:
-            raise ElementNotFound(f"{element_type} with locator '{locator}' not found.")
-        if first_only:
-            if not elements:
-                return None
-            return elements[0]
-        return elements
+    # def _find(self, locator, tag=None, first_only=True, required=True, parent=None):
+    #     element_type = "Element" if not tag else tag.capitalize()
+    #     if parent and not is_webelement(parent):
+    #         raise ValueError(
+    #             f"Parent must be Selenium WebElement but it was {type(parent)}."
+    #         )
+    #     if is_webelement(locator):
+    #         return locator
+    #     prefix, criteria = self._parse_locator(locator)
+    #     strategy = self._strategies[prefix]
+    #     tag, constraints = self._get_tag_and_constraints(tag)
+    #     elements = strategy(criteria, tag, constraints, parent=parent or self.driver)
+    #     if required and not elements:
+    #         raise ElementNotFound(f"{element_type} with locator '{locator}' not found.")
+    #     if first_only:
+    #         if not elements:
+    #             return None
+    #         return elements[0]
+    #     return elements
 
     def _get_tag_and_constraints(self, tag):
         if tag is None:

src/SeleniumLibrary/locators/utilities.py

@@ -13,12 +13,14 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from selenium.webdriver.remote.webelement import WebElement
+from selenium.webdriver.support.event_firing_webdriver import EventFiringWebElement
 
-def is_webelement(self, element):
+def is_webelement(element):
     # Hook for unit tests
     return isinstance(element, (WebElement, EventFiringWebElement))
 
-def disallow_webelement_parent(self, element):
+def disallow_webelement_parent(element):
     if is_webelement(element):
         raise ValueError("This method does not allow WebElement as parent")