watir 6.14.0 → 6.15.0

data/lib/watir/js_snippets.rb

@@ -6,7 +6,7 @@ module Watir
 
     def execute_js(function_name, *arguments)
       file = File.expand_path("../js_snippets/#{function_name}.js", __FILE__)
-      raise Watir::Error, "Can not excute script as #{function_name}.js does not exist" unless File.exist?(file)
+      raise Exception::Error, "Can not excute script as #{function_name}.js does not exist" unless File.exist?(file)
 
       js = File.read(file)
       script = "return (#{js}).apply(null, arguments)"

data/lib/watir/js_snippets/elementObscured.js

@@ -0,0 +1,14 @@
+// Original Author: Florent B.
+// Source: https://stackoverflow.com/a/45244889/1200545
+function() {
+    var elem = arguments[0],
+        box = elem.getBoundingClientRect(),
+        cx = box.left + box.width / 2,
+        cy = box.top + box.height / 2,
+        e = document.elementFromPoint(cx, cy);
+    for (; e; e = e.parentElement) {
+        if (e === elem)
+            return false;
+    }
+    return true;
+}

data/lib/watir/js_snippets/selectedText.js

@@ -0,0 +1,17 @@
+// Code from https://stackoverflow.com/questions/5379120/get-the-highlighted-selected-text
+
+function() {
+    var text = "";
+    var activeEl = document.activeElement;
+    var activeElTagName = activeEl ? activeEl.tagName.toLowerCase() : null;
+    if (
+        (activeElTagName == "textarea") || (activeElTagName == "input" &&
+        /^(?:text|search|password|tel|url)$/i.test(activeEl.type)) &&
+        (typeof activeEl.selectionStart == "number")
+    ) {
+        text = activeEl.value.slice(activeEl.selectionStart, activeEl.selectionEnd);
+    } else if (window.getSelection) {
+        text = window.getSelection().toString();
+    }
+    return text;
+}

data/lib/watir/legacy_wait.rb

@@ -16,7 +16,7 @@ module Watir
     def method_missing(method, *args, &block)
       return super unless @element.respond_to?(method)
 
-      Watir::Wait.until(@timeout, @message) { wait_until }
+      Wait.until(@timeout, @message) { wait_until }
 
       @element.__send__(method, *args, &block)
     end
@@ -29,9 +29,9 @@ module Watir
 
   class WhenPresentDecorator < BaseDecorator
     def present?
-      Watir::Wait.until(@timeout, @message) { wait_until }
+      Wait.until(@timeout, @message) { wait_until }
       true
-    rescue Watir::Wait::TimeoutError
+    rescue Wait::TimeoutError
       false
     end
 
@@ -85,7 +85,7 @@ module Watir
       message = "waiting for #{selector_string} to become present"
 
       if block_given?
-        Watir::Wait.until(timeout, message) { present? }
+        Wait.until(timeout, message) { present? }
         yield self
       else
         WhenPresentDecorator.new(self, timeout, message)
@@ -112,7 +112,7 @@ module Watir
       message = "waiting for #{selector_string} to become enabled"
 
       if block_given?
-        Watir::Wait.until(timeout, message) { enabled? }
+        Wait.until(timeout, message) { enabled? }
         yield self
       else
         WhenEnabledDecorator.new(self, timeout, message)

data/lib/watir/locators.rb

@@ -1,8 +1,12 @@
 require 'watir/locators/element/locator'
 require 'watir/locators/element/selector_builder'
+require 'watir/locators/element/selector_builder/xpath_support'
+require 'watir/locators/element/selector_builder/regexp_disassembler'
 require 'watir/locators/element/selector_builder/xpath'
 require 'watir/locators/element/validator'
 
+require 'watir/locators/anchor/selector_builder'
+
 require 'watir/locators/button/locator'
 require 'watir/locators/button/selector_builder'
 require 'watir/locators/button/selector_builder/xpath'
@@ -10,12 +14,14 @@ require 'watir/locators/button/validator'
 
 require 'watir/locators/cell/locator'
 require 'watir/locators/cell/selector_builder'
+require 'watir/locators/cell/selector_builder/xpath'
 
 require 'watir/locators/row/locator'
 require 'watir/locators/row/selector_builder'
+require 'watir/locators/row/selector_builder/xpath'
 
-require 'watir/locators/text_area/locator'
 require 'watir/locators/text_area/selector_builder'
+require 'watir/locators/text_area/selector_builder/xpath'
 
 require 'watir/locators/text_field/locator'
 require 'watir/locators/text_field/selector_builder'
@@ -29,21 +35,21 @@ module Watir
         class_from_string("#{browser.locator_namespace}::#{element_class_name}::Locator") ||
           class_from_string("Watir::Locators::#{element_class_name}::Locator") ||
           class_from_string("#{browser.locator_namespace}::Element::Locator") ||
-          Watir::Locators::Element::Locator
+          Locators::Element::Locator
       end
 
       def element_validator_class
         class_from_string("#{browser.locator_namespace}::#{element_class_name}::Validator") ||
           class_from_string("Watir::Locators::#{element_class_name}::Validator") ||
           class_from_string("#{browser.locator_namespace}::Element::Validator") ||
-          Watir::Locators::Element::Validator
+          Locators::Element::Validator
       end
 
       def selector_builder_class
         class_from_string("#{browser.locator_namespace}::#{element_class_name}::SelectorBuilder") ||
           class_from_string("Watir::Locators::#{element_class_name}::SelectorBuilder") ||
           class_from_string("#{browser.locator_namespace}::Element::SelectorBuilder") ||
-          Watir::Locators::Element::SelectorBuilder
+          Locators::Element::SelectorBuilder
       end
 
       def class_from_string(string)
@@ -57,8 +63,13 @@ module Watir
       end
 
       def build_locator
+        selector_builder = if element_class == Watir::Row
+                             scope_tag_name = @query_scope.selector[:tag_name]
+                             selector_builder_class.new(element_class.attribute_list, scope_tag_name)
+                           else
+                             selector_builder_class.new(element_class.attribute_list)
+                           end
         element_validator = element_validator_class.new
-        selector_builder = selector_builder_class.new(@query_scope, @selector.dup, element_class.attribute_list)
         locator_class.new(@query_scope, @selector.dup, selector_builder, element_validator)
       end
     end

data/lib/watir/locators/anchor/selector_builder.rb

@@ -0,0 +1,38 @@
+module Watir
+  module Locators
+    class Anchor
+      class SelectorBuilder < Element::SelectorBuilder
+        private
+
+        def build_wd_selector(selector)
+          build_link_text(selector) || build_partial_link_text(selector) || super
+        end
+
+        def build_link_text(selector)
+          return unless can_convert_to_link_text?(selector)
+
+          selector.delete(:tag_name)
+          {link_text: selector.delete(:visible_text)}
+        end
+
+        def can_convert_to_link_text?(selector)
+          selector.keys.sort == %i[tag_name visible_text] &&
+            selector[:visible_text].is_a?(String)
+        end
+
+        def build_partial_link_text(selector)
+          return unless convert_to_partial_link_text?(selector)
+
+          selector.delete(:tag_name)
+          {partial_link_text: selector.delete(:visible_text).source}
+        end
+
+        def convert_to_partial_link_text?(selector)
+          regex = selector[:visible_text]
+          selector.keys.sort == %i[tag_name visible_text] && !regex.casefold? &&
+            RegexpDisassembler.new(regex).substrings.first == regex.source
+        end
+      end
+    end
+  end
+end

data/lib/watir/locators/button/locator.rb

@@ -8,21 +8,23 @@ module Watir
           # force watir usage
         end
 
-        def can_convert_regexp_to_contains?
-          # regexp conversion won't work with the complex xpath selector
-          false
-        end
+        def matches_values?(element, values_to_match)
+          return super unless values_to_match.key?(:value)
+
+          copy = values_to_match.dup
+          value = copy.delete(:value)
 
-        def matches_selector?(element, selector)
-          if selector.key?(:value)
-            copy  = selector.dup
-            value = copy.delete(:value)
+          everything_except_value = super(element, copy)
 
-            super(element, copy) &&
-              (fetch_value(element, :value) =~ /#{value}/ || fetch_value(element, :text) =~ /#{value}/)
-          else
-            super
+          matches_value = fetch_value(element, :value) =~ /#{value}/
+          matches_text = fetch_value(element, :text) =~ /#{value}/
+          if matches_text
+            Watir.logger.deprecate(':value locator key for finding button text',
+                                   'use :text locator',
+                                   ids: [:value_button])
           end
+
+          everything_except_value && (matches_value || matches_text)
         end
       end
     end

data/lib/watir/locators/button/selector_builder.rb

@@ -2,28 +2,6 @@ module Watir
   module Locators
     class Button
       class SelectorBuilder < Element::SelectorBuilder
-        def build_wd_selector(selectors)
-          return if selectors.values.any? { |e| e.is_a? Regexp }
-
-          selectors.delete(:tag_name) || raise('internal error: no tag_name?!')
-
-          button_attr_exp = xpath_builder.attribute_expression(:button, selectors)
-
-          xpath = './/button'
-          xpath << "[#{button_attr_exp}]" unless button_attr_exp.empty?
-
-          unless selectors[:type].eql? false
-            selectors[:type] = Watir::Button::VALID_TYPES if [nil, true].include?(selectors[:type])
-            input_attr_exp = xpath_builder.attribute_expression(:input, selectors)
-
-            xpath << ' | .//input'
-            xpath << "[#{input_attr_exp}]"
-          end
-
-          p build_wd_selector: xpath if $DEBUG
-
-          [:xpath, xpath]
-        end
       end
     end
   end

data/lib/watir/locators/button/selector_builder/xpath.rb

@@ -3,25 +3,80 @@ module Watir
     class Button
       class SelectorBuilder
         class XPath < Element::SelectorBuilder::XPath
-          def lhs_for(building, key)
-            if building == :input && key == :text
-              '@value'
-            else
-              super
+          private
+
+          def tag_string
+            return super if @adjacent
+
+            # Selector builder ignores tag name and builds for both button elements and input elements of type button
+            @selector.delete(:tag_name)
+
+            type = @selector.delete(:type)
+            text = @selector.delete(:text)
+
+            string = "(#{button_string(text: text, type: type)})"
+            string << " or (#{input_string(text: text, type: type)})" unless type.eql?(false)
+            "[#{string}]"
+          end
+
+          def button_string(text: nil, type: nil)
+            string = process_attribute(:tag_name, 'button')
+            string << " and #{process_attribute(:text, text)}" unless text.nil?
+            string << " and #{input_types(type)}" unless type.nil?
+            string
+          end
+
+          def input_string(text: nil, type: nil)
+            string = process_attribute(:tag_name, 'input')
+            type = nil if type.eql?(true)
+            string << " and (#{input_types(type)})"
+            if text
+              string << " and #{process_attribute(:value, text)}"
+              @requires_matches.delete(:value)
             end
+            string
           end
 
-          private
+          # value locator needs to match input value, button text or button value
+          def text_string
+            return super if @adjacent
+
+            # :text locator is already dealt with in #tag_name_string
+            value = @selector.delete(:value)
 
-          def equal_pair(building, key, value)
-            if building == :button && key == :value
-              # :value should look for both node text and @value attribute
-              text = XpathSupport.escape(value)
-              "(text()=#{text} or @value=#{text})"
+            case value
+            when nil
+              ''
+            when Regexp
+              res = "[#{predicate_conversion(:text, value)} or #{predicate_conversion(:value, value)}]"
+              @requires_matches.delete(:text)
+              res
             else
-              super
+              "[#{predicate_expression(:text, value)} or #{predicate_expression(:value, value)}]"
             end
           end
+
+          def predicate_conversion(key, regexp)
+            res = key == :text ? super(:contains_text, regexp) : super
+            @requires_matches[key] = @requires_matches.delete(:contains_text) if @requires_matches.key?(:contains_text)
+            res
+          end
+
+          def input_types(type = nil)
+            types = if type.eql?(nil)
+                      Watir::Button::VALID_TYPES
+                    elsif Watir::Button::VALID_TYPES.include?(type)
+                      [type]
+                    elsif type.eql?(true) || type.eql?(false)
+                      [type]
+                    else
+                      msg = "Button Elements can not be located by input type: #{type}"
+                      raise LocatorException, msg
+                    end
+            types.map { |button_type|
+              predicate_expression(:type, button_type)
+            }.compact.join(' or ')
+          end
         end
       end
     end

data/lib/watir/locators/button/validator.rb

@@ -2,9 +2,10 @@ module Watir
   module Locators
     class Button
       class Validator < Element::Validator
-        def validate(element, _selector)
+        def validate(element, _tag_name)
           tag_name = element.tag_name.downcase
           return unless %w[input button].include?(tag_name)
+
           # TODO: - Verify this is desired behavior based on https://bugzilla.mozilla.org/show_bug.cgi?id=1290963
           return if tag_name == 'input' && !Watir::Button::VALID_TYPES.include?(element.attribute(:type).downcase)
 

data/lib/watir/locators/cell/selector_builder.rb

@@ -2,20 +2,6 @@ module Watir
   module Locators
     class Cell
       class SelectorBuilder < Element::SelectorBuilder
-        def build_wd_selector(selectors)
-          return if selectors.values.any? { |e| e.is_a? Regexp }
-
-          expressions = %w[./th ./td]
-          attr_expr = xpath_builder.attribute_expression(nil, selectors)
-
-          expressions.map! { |e| "#{e}[#{attr_expr}]" } unless attr_expr.empty?
-
-          xpath = expressions.join(' | ')
-
-          p build_wd_selector: xpath if $DEBUG
-
-          [:xpath, xpath]
-        end
       end
     end
   end

data/lib/watir/locators/cell/selector_builder/xpath.rb

@@ -0,0 +1,21 @@
+module Watir
+  module Locators
+    class Cell
+      class SelectorBuilder
+        class XPath < Element::SelectorBuilder::XPath
+          private
+
+          def start_string
+            @adjacent ? './' : './*'
+          end
+
+          def tag_string
+            return super if @adjacent
+
+            "[#{process_attribute(:tag_name, 'th')} or #{process_attribute(:tag_name, 'td')}]"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/watir/locators/element/locator.rb

@@ -2,6 +2,8 @@ module Watir
   module Locators
     class Element
       class Locator
+        include Exception
+
         attr_reader :selector_builder
         attr_reader :element_validator
 
@@ -14,19 +16,9 @@ module Watir
           xpath
         ].freeze
 
-        # Regular expressions that can be reliably converted to xpath `contains`
-        # expressions in order to optimize the locator.
-        CONVERTABLE_REGEXP = /
-          \A
-            ([^\[\]\\^$.|?*+()]*) # leading literal characters
-            [^|]*?                # do not try to convert expressions with alternates
-            ([^\[\]\\^$.|?*+()]*) # trailing literal characters
-          \z
-        /x
-
         def initialize(query_scope, selector, selector_builder, element_validator)
           @query_scope = query_scope # either element or browser
-          @selector = selector.dup
+          @selector = selector
           @selector_builder = selector_builder
           @element_validator = element_validator
         end
@@ -46,11 +38,12 @@ module Watir
         private
 
         def using_selenium(filter = :first)
-          tag = @selector[:tag_name].is_a?(::Symbol) ? @selector.delete(:tag_name).to_s : @selector.delete(:tag_name)
-          return if @selector.size > 1
+          selector = @selector.dup
+          tag = selector[:tag_name].is_a?(::Symbol) ? selector.delete(:tag_name).to_s : selector.delete(:tag_name)
+          return if selector.size > 1
 
-          how = @selector.keys.first || :tag_name
-          what = @selector.values.first || tag
+          how = selector.keys.first || :tag_name
+          what = selector.values.first || tag
 
           return unless wd_supported?(how, what, tag)
 
@@ -58,27 +51,33 @@ module Watir
         end
 
         def using_watir(filter = :first)
-          create_normalized_selector(filter)
-          return unless @normalized_selector
-
-          create_filter_selector
+          raise ArgumentError, "can't locate all elements by :index" if @selector.key?(:index) && filter == :all
 
-          how, what = selector_builder.build(@normalized_selector.dup)
-          unless how
-            raise Error, "internal error: unable to build Selenium selector from #{@normalized_selector.inspect}"
+          begin
+            generate_scope
+          rescue LocatorException
+            return nil
           end
 
-          what = add_regexp_predicates(what) if how == :xpath
+          selector, values_to_match = selector_builder.build(@selector)
+
+          validate_built_selector(selector, values_to_match)
 
-          if filter == :all || !@filter_selector.empty?
-            locate_filtered_elements(how, what, filter)
+          if filter == :all || values_to_match.any?
+            locate_matching_elements(selector, values_to_match, filter)
           else
-            locate_element(how, what, @driver_scope)
+            locate_element(selector.keys.first, selector.values.first, @driver_scope)
           end
         end
 
-        def validate(elements, tag_name)
-          elements.compact.all? { |element| element_validator.validate(element, tag_name: tag_name) }
+        def validate_built_selector(selector, values_to_match)
+          if selector.nil?
+            msg = "#{selector_builder.class} was unable to build selector from #{@selector.inspect}"
+            raise LocatorException, msg
+          elsif values_to_match.nil?
+            msg = "#{selector_builder.class}#build is not returning expected responses for the current version of Watir"
+            raise LocatorException, msg
+          end
         end
 
         def fetch_value(element, how)
@@ -93,121 +92,61 @@ module Watir
             element.tag_name.downcase
           when :href
             element.attribute('href')&.strip
-          when String, ::Symbol
+          else
             how = how.to_s.tr('_', '-') if how.is_a?(::Symbol)
             element.attribute(how)
-          else
-            raise Error::Exception, "Unable to fetch value for #{how}"
           end
         end
 
-        def filter_elements(elements, filter: :first)
-          selector = @filter_selector.dup
+        def matching_elements(elements, values_to_match, filter: :first)
           if filter == :first
-            idx = element_index(elements, selector)
+            idx = element_index(elements, values_to_match)
             counter = 0
 
             # Lazy evaluation to avoid fetching values for elements that will be discarded
             matches = elements.lazy.select do |el|
               counter += 1
-              matches_selector?(el, selector)
+              matches_values?(el, values_to_match)
             end
-            msg = "Filtered through #{counter} elements to locate #{@selector.inspect}"
+            msg = "iterated through #{counter} elements to locate #{@selector.inspect}"
             matches.take(idx + 1).to_a[idx].tap { Watir.logger.debug msg }
           else
             Watir.logger.debug "Iterated through #{elements.size} elements to locate all #{@selector.inspect}"
-            elements.select { |el| matches_selector?(el, selector) }
+            elements.select { |el| matches_values?(el, values_to_match) }
           end
         end
 
-        def element_index(elements, selector)
-          idx = selector.delete(:index) || 0
+        def element_index(elements, values_to_match)
+          idx = values_to_match.delete(:index) || 0
           return idx unless idx.negative?
 
           elements.reverse!
           idx.abs - 1
         end
 
-        def create_normalized_selector(filter)
-          return @normalized_selector if @normalized_selector
+        def generate_scope
+          return @driver_scope if @driver_scope
 
           @driver_scope = @query_scope.wd
 
-          @normalized_selector = selector_builder.normalized_selector
-
-          if @normalized_selector.key?(:label)
-            label_key = :label
-          elsif @normalized_selector.key?(:visible_label)
-            label_key = :visible_label
-          end
-
-          if label_key
-            process_label(label_key)
-            return if @normalized_selector.nil?
-          end
-
-          if @normalized_selector.key?(:index) && filter == :all
-            raise ArgumentError, "can't locate all elements by :index"
-          end
-
-          @normalized_selector
-        end
-
-        def create_filter_selector
-          return @filter_selector if @filter_selector
-
-          @filter_selector = {}
-
-          # Remove selectors that can never be used in XPath builder
-          %i[visible visible_text].each do |how|
-            next unless @normalized_selector.key?(how)
-
-            @filter_selector[how] = @normalized_selector.delete(how)
-          end
-
-          set_tag_validation if tag_validation_required?(@normalized_selector)
-
-          # Regexp locators currently need to be validated even if they are included in the XPath builder
-          # TODO: Identify Regexp that can have an exact equivalent using XPath contains (ie would not require
-          #  filtering) vs approximations (ie would still requiring filtering)
-          @normalized_selector.each do |how, what|
-            next unless what.is_a?(Regexp)
-
-            @filter_selector[how] = @normalized_selector.delete(how)
-          end
-
-          if @normalized_selector[:index] && !@normalized_selector[:adjacent]
-            idx = @normalized_selector.delete(:index)
-
-            # Do not add {index: 0} filter if the only filter.
-            # This will allow using #find_element instead of #find_elements.
-            implicit_idx_filter = @filter_selector.empty? && idx.zero?
-            @filter_selector[:index] = idx unless implicit_idx_filter
+          if @selector.key?(:label)
+            process_label :label
+          elsif @selector.key?(:visible_label)
+            process_label :visible_label
           end
-
-          @filter_selector
-        end
-
-        def set_tag_validation
-          @filter_selector[:tag_name] = if @normalized_selector[:tag_name].is_a?(::Symbol)
-                                          @normalized_selector[:tag_name].to_s
-                                        else
-                                          @normalized_selector[:tag_name]
-                                        end
         end
 
         def process_label(label_key)
-          regexp = @normalized_selector[label_key].is_a?(Regexp)
+          regexp = @selector[label_key].is_a?(Regexp)
           return unless (regexp || label_key == :visible_label) && selector_builder.should_use_label_element?
 
           label = label_from_text(label_key)
-          unless label # label not found, stop looking for element
-            @normalized_selector = nil
-            return
-          end
+          msg = "Unable to locate element with label #{label_key}: #{@selector[label_key]}"
+          raise LocatorException, msg unless label
 
-          if (id = label.attribute('for'))
-            @normalized_selector[:id] = id
+          id = label.attribute('for')
+          if id
+            @selector[:id] = id
           else
             @driver_scope = label
           end
@@ -216,24 +155,24 @@ module Watir
         def label_from_text(label_key)
           # TODO: this won't work correctly if @wd is a sub-element, write spec
           # TODO: Figure out how to do this with find_element
-          label_text = @normalized_selector.delete(label_key)
-          locator_key = label_key.to_s.gsub('label', 'text').to_sym
+          label_text = @selector.delete(label_key)
+          locator_key = label_key.to_s.gsub('label', 'text').gsub('_element', '').to_sym
           locate_elements(:tag_name, 'label', @driver_scope).find do |el|
-            matches_selector?(el, locator_key => label_text)
+            matches_values?(el, locator_key => label_text)
           end
         end
 
-        def matches_selector?(element, selector)
-          matches = selector.all? do |how, what|
+        def matches_values?(element, values_to_match)
+          matches = values_to_match.all? do |how, what|
             if how == :tag_name && what.is_a?(String)
-              element_validator.validate(element, tag_name: what)
+              element_validator.validate(element, what)
             else
               val = fetch_value(element, how)
               what == val || val =~ /#{what}/
             end
           end
 
-          text_regexp_deprecation(element, selector, matches) if selector[:text]
+          text_regexp_deprecation(element, values_to_match, matches) if values_to_match[:text]
 
           matches
         end
@@ -250,38 +189,6 @@ module Watir
           Watir.logger.deprecate(dep, ":visible_#{key}", ids: [:text_regexp])
         end
 
-        def can_convert_regexp_to_contains?
-          true
-        end
-
-        def add_regexp_predicates(what)
-          return what unless can_convert_regexp_to_contains?
-
-          @filter_selector.each do |key, value|
-            next if %i[tag_name text visible_text visible index].include?(key)
-
-            predicates = regexp_selector_to_predicates(key, value)
-            what = "(#{what})[#{predicates.join(' and ')}]" unless predicates.empty?
-          end
-          what
-        end
-
-        def regexp_selector_to_predicates(key, regexp)
-          return [] if regexp.casefold?
-
-          match = regexp.source.match(CONVERTABLE_REGEXP)
-          return [] unless match
-
-          lhs = selector_builder.xpath_builder.lhs_for(nil, key)
-          match.captures.reject(&:empty?).map do |literals|
-            "contains(#{lhs}, #{XpathSupport.escape(literals)})"
-          end
-        end
-
-        def tag_validation_required?(selector)
-          (selector.key?(:css) || selector.key?(:xpath)) && selector.key?(:tag_name)
-        end
-
         def locate_element(how, what, scope = @query_scope.wd)
           scope.find_element(how, what)
         end
@@ -290,17 +197,17 @@ module Watir
           scope.find_elements(how, what)
         end
 
-        def locate_filtered_elements(how, what, filter)
+        def locate_matching_elements(selector, values_to_match, filter)
           retries = 0
           begin
-            elements = locate_elements(how, what, @driver_scope) || []
-            filter_elements(elements, filter: filter)
+            elements = locate_elements(selector.keys.first, selector.values.first, @driver_scope) || []
+            matching_elements(elements, values_to_match, filter: filter)
           rescue Selenium::WebDriver::Error::StaleElementReferenceError
             retries += 1
             sleep 0.5
             retry unless retries > 2
             target = filter == :all ? 'element collection' : 'element'
-            raise StandardError, "Unable to locate #{target} from #{@selector} due to changing page"
+            raise LocatorException, "Unable to locate #{target} from #{@selector} due to changing page"
           end
         end
 
@@ -309,10 +216,10 @@ module Watir
           return false unless what.is_a?(String)
 
           if %i[partial_link_text link_text link].include?(how)
-            Watir.logger.deprecate(":#{how} locator", ':visible_text', ids: [:visible_text])
+            Watir.logger.deprecate(":#{how} locator", ':visible_text', ids: [:link_text])
             return true if [:a, :link, nil].include?(tag)
 
-            raise StandardError, "Can not use #{how} locator to find a #{what} element"
+            raise LocatorException, "Can not use #{how} locator to find a #{what} element"
           elsif how == :tag_name
             return true
           else