watir 6.15.1 → 6.16.0

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

@@ -0,0 +1,40 @@
+module Watir
+  module Locators
+    class Button
+      class Matcher < Element::Matcher
+        def elements_match?(element, values_to_match)
+          copy_values_to_match = values_to_match.dup
+          value = copy_values_to_match.delete(:value)
+
+          if value
+            matching = matches_values?(fetch_value(element, :text), value)
+            deprecate_value_button if matching
+
+            matching ||= matches_values?(fetch_value(element, :value), value)
+
+            return false unless matching
+            return true if copy_values_to_match.empty?
+          end
+
+          super(element, copy_values_to_match)
+        end
+
+        def deprecate_value_button
+          Watir.logger.deprecate(':value locator key for finding button text',
+                                 'use :text locator',
+                                 ids: [:value_button])
+        end
+
+        def validate_tag(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)
+
+          element
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,9 @@ module Watir
   module Locators
     class Cell
       class SelectorBuilder < Element::SelectorBuilder
+        def use_scope?
+          false
+        end
       end
     end
   end

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

@@ -4,179 +4,45 @@ module Watir
       class Locator
         include Exception
 
-        attr_reader :selector_builder
-        attr_reader :element_validator
+        attr_reader :element_matcher, :driver_scope
 
-        W3C_FINDERS = %i[
-          css
-          link
-          link_text
-          partial_link_text
-          tag_name
-          xpath
-        ].freeze
-
-        def initialize(query_scope, selector, selector_builder, element_validator)
-          @query_scope = query_scope # either element or browser
-          @selector = selector
-          @selector_builder = selector_builder
-          @element_validator = element_validator
+        def initialize(element_matcher)
+          @query_scope = element_matcher.query_scope
+          @selector = element_matcher.selector
+          @element_matcher = element_matcher
         end
 
-        def locate
-          using_selenium(:first) || using_watir(:first)
-        rescue Selenium::WebDriver::Error::NoSuchElementError, Selenium::WebDriver::Error::StaleElementReferenceError
+        def locate(built)
+          @built = built.dup
+          @driver_scope = (@built.delete(:scope) || @query_scope.browser).wd
+          matching_elements(@built, :first)
+        rescue Selenium::WebDriver::Error::NoSuchElementError
           nil
         end
 
-        def locate_all
-          return [@selector[:element]] if @selector.key?(:element)
+        def locate_all(built)
+          @built = built.dup
+          @driver_scope = (@built.delete(:scope) || @query_scope.browser).wd
+          raise ArgumentError, "can't locate all elements by :index" if built.key?(:index)
 
-          using_selenium(:all) || using_watir(:all)
+          [matching_elements(@built, :all)].flatten
         end
 
         private
 
-        def using_selenium(filter = :first)
-          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
-
-          return unless wd_supported?(how, what, tag)
-
-          filter == :all ? locate_elements(how, what) : locate_element(how, what)
-        end
-
-        def using_watir(filter = :first)
-          selector = @selector.dup
-          raise ArgumentError, "can't locate all elements by :index" if selector.key?(:index) && filter == :all
-
-          @driver_scope ||= @query_scope.wd
-
-          built = selector_builder.build(selector)
-
-          validate_built_selector(built)
-
-          wd_locator = built.select { |key, _value| %i[css xpath link_text partial_link_text].include? key }
-          values_to_match = built.reject { |key, _value| %i[css xpath link_text partial_link_text].include? key }
-
-          if filter == :all || values_to_match.any?
-            locate_matching_elements(wd_locator, values_to_match, filter)
-          else
-            locate_element(wd_locator.keys.first, wd_locator.values.first, @driver_scope)
-          end
-        end
+        def matching_elements(built, filter)
+          return locate_element(*built.to_a.flatten) if built.size == 1 && filter == :first
 
-        def validate_built_selector(built)
-          return unless built.nil? || built.empty?
+          wd_locator_key = (Watir::Locators::W3C_FINDERS & built.keys).first
+          wd_locator = built.select { |k, _v| wd_locator_key == k }
+          match_values = built.reject { |k, _v| wd_locator_key == k }
 
-          msg = "#{selector_builder.class} was unable to build selector from #{@selector.inspect}"
-          raise LocatorException, msg
-        end
-
-        def fetch_value(element, how)
-          case how
-          when :text
-            element.text
-          when :visible
-            element.displayed?
-          when :visible_text
-            element.text
-          when :tag_name
-            element.tag_name.downcase
-          when :href
-            element.attribute('href')&.strip
-          else
-            how = how.to_s.tr('_', '-') if how.is_a?(::Symbol)
-            element.attribute(how)
-          end
-        end
-
-        def matching_labels(elements, values_to_match, scope)
-          label_key = values_to_match.key?(:label_element) ? :label_element : :visible_label_element
-          label_value = values_to_match.delete(:label_element) || values_to_match.delete(:visible_label_element)
-          locator_key = label_key.to_s.gsub('label', 'text').gsub('_element', '').to_sym
-
-          Watir::LabelCollection.new(scope, tag_name: 'label').map { |label|
-            next unless matches_values?(label.wd, locator_key => label_value)
-
-            input = label.for.empty? ? label.input : Watir::Input.new(scope, id: label.for)
-            input.wd if elements.include?(input.wd)
-          }.compact
-        end
-
-        def matching_elements(elements, values_to_match, filter: :first)
-          if filter == :first
-            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_values?(el, values_to_match)
-            end
-            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_values?(el, values_to_match) }
-          end
-        end
-
-        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 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, what)
-            else
-              val = fetch_value(element, how)
-              what == val || val =~ /#{what}/
-            end
-          end
-
-          text_regexp_deprecation(element, values_to_match, matches) if values_to_match[:text]
-
-          matches
-        end
-
-        def text_regexp_deprecation(element, selector, matches)
-          new_element = Watir::Element.new(@query_scope, element: element)
-          text_content = new_element.execute_js(:getTextContent, element).strip
-          text_content_matches = text_content =~ /#{selector[:text]}/
-          return if matches == !!text_content_matches
-
-          key = @selector.key?(:text) ? 'text' : 'label'
-          selector_text = selector[:text].inspect
-          dep = "Using :#{key} locator with RegExp #{selector_text} to match an element that includes hidden text"
-          Watir.logger.deprecate(dep, ":visible_#{key}", ids: [:text_regexp])
-        end
-
-        def locate_element(how, what, scope = @query_scope.wd)
-          scope.find_element(how, what)
-        end
-
-        def locate_elements(how, what, scope = @query_scope.wd)
-          scope.find_elements(how, what)
-        end
-
-        def locate_matching_elements(selector, values_to_match, filter)
+          # TODO: Wrap this to continue trying until default timeout
           retries = 0
           begin
-            elements = locate_elements(selector.keys.first, selector.values.first, @driver_scope) || []
-            if values_to_match.key?(:label_element) || values_to_match.key?(:visible_label_element)
-              elements = matching_labels(elements, values_to_match, @query_scope)
-            end
-            matching_elements(elements, values_to_match, filter: filter)
+            elements = locate_elements(*wd_locator.to_a.flatten)
+
+            element_matcher.match(elements, match_values, filter)
           rescue Selenium::WebDriver::Error::StaleElementReferenceError
             retries += 1
             sleep 0.5
@@ -186,21 +52,12 @@ module Watir
           end
         end
 
-        def wd_supported?(how, what, tag)
-          return false unless W3C_FINDERS.include? how
-          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: [:link_text])
-            return true if [:a, :link, nil].include?(tag)
+        def locate_element(how, what, scope = driver_scope)
+          scope.find_element(how, what)
+        end
 
-            raise LocatorException, "Can not use #{how} locator to find a #{what} element"
-          elsif how == :tag_name
-            return true
-          else
-            return false unless tag.nil?
-          end
-          true
+        def locate_elements(how, what, scope = driver_scope)
+          scope.find_elements(how, what)
         end
       end
     end

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

@@ -0,0 +1,127 @@
+module Watir
+  module Locators
+    class Element
+      class Matcher
+        include Exception
+
+        attr_reader :query_scope, :selector
+
+        def initialize(query_scope, selector = {})
+          @query_scope = query_scope
+          @selector = selector
+        end
+
+        def match(elements, values_to_match, filter)
+          elements = matching_labels(elements, values_to_match)
+          matching_elements(elements, values_to_match, filter: filter)
+        end
+
+        private
+
+        def matching_labels(elements, values_to_match)
+          %i[label_element visible_label_element].each do |key|
+            label_value = values_to_match.delete(key)
+            next if label_value.nil?
+
+            locator_key = key.to_s.gsub('label', 'text').gsub('_element', '').to_sym
+            return label_collection(elements, locator_key => label_value).compact
+          end
+          elements
+        end
+
+        def label_collection(elements, locator)
+          @query_scope.labels.map do |label|
+            next unless elements_match?(label.wd, locator)
+
+            input = label.for.empty? ? label.input : Watir::Input.new(@query_scope, id: label.for)
+            input.wd if elements.include?(input.wd)
+          end
+        end
+
+        def matching_elements(elements, values_to_match, filter: :first)
+          if filter == :first
+            idx = element_index(elements, values_to_match)
+
+            # Lazy evaluation to avoid fetching values for elements that will be discarded
+            matches = elements.lazy.select do |el|
+              elements_match?(el, values_to_match)
+            end
+            Watir.logger.debug "Iterating through #{elements.size} elements to locate #{@selector.inspect}"
+            matches.take(idx + 1).to_a[idx]
+          else
+            Watir.logger.debug "Iterating through #{elements.size} elements to locate all #{@selector.inspect}"
+            elements.select { |el| elements_match?(el, values_to_match) }
+          end
+        end
+
+        def elements_match?(element, values_to_match)
+          matches = values_to_match.all? do |how, expected|
+            if how == :tag_name
+              validate_tag(element, expected)
+            # TODO: Can this be class_name here or does that get converted?
+            elsif %i[class class_name].include?(how)
+              value = fetch_value(element, how)
+              [expected].flatten.all? do |match|
+                value.split.any? do |class_value|
+                  matches_values?(class_value, match)
+                end
+              end
+            else
+              matches_values?(fetch_value(element, how), expected)
+            end
+          end
+
+          deprecate_text_regexp(element, values_to_match, matches) if values_to_match[:text]
+
+          matches
+        end
+
+        def matches_values?(found, expected)
+          expected.is_a?(Regexp) ? found =~ expected : found == expected
+        end
+
+        def fetch_value(element, how)
+          case how
+          when :text
+            element.text
+          when :visible
+            element.displayed?
+          when :visible_text
+            element.text
+          when :href
+            element.attribute('href')&.strip
+          when :class, :class_name
+            element.attribute('class')
+          else
+            how = how.to_s.tr('_', '-') if how.is_a?(::Symbol)
+            element.attribute(how)
+          end
+        end
+
+        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 validate_tag(element, tag_name)
+          matches_values?(element.tag_name.downcase, tag_name)
+        end
+
+        def deprecate_text_regexp(element, selector, matches)
+          new_element = Watir::Element.new(@query_scope, element: element)
+          text_content = new_element.text_content
+          text_content_matches = text_content =~ /#{selector[:text]}/
+          return if matches == !!text_content_matches
+
+          key = @selector.key?(:text) ? 'text' : 'label'
+          selector_text = selector[:text].inspect
+          dep = "Using :#{key} locator with RegExp #{selector_text} to match an element that includes hidden text"
+          Watir.logger.deprecate(dep, ":visible_#{key}", ids: [:text_regexp])
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@ module Watir
     class Element
       class SelectorBuilder
         include Exception
-        attr_reader :custom_attributes
+        attr_reader :custom_attributes, :built
 
         WILDCARD_ATTRIBUTE = /^(aria|data)_(.+)$/.freeze
         INTEGER_CLASS = Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.4') ? Fixnum : Integer
@@ -14,33 +14,53 @@ module Watir
                                                                               visible: [TrueClass, FalseClass],
                                                                               tag_name: [String, Regexp, ::Symbol],
                                                                               visible_text: [String, Regexp],
+                                                                              scope: [Hash],
                                                                               text: [String, Regexp]).freeze
 
-        def initialize(valid_attributes)
+        def initialize(valid_attributes, query_scope)
           @valid_attributes = valid_attributes
           @custom_attributes = []
+          @query_scope = query_scope
         end
 
         def build(selector)
-          inspected = selector.inspect
           @selector = selector
-          normalize_selector
 
-          xpath_css = @selector.select { |key, _value| %i[xpath css].include? key }
-
-          raise LocatorException, ":xpath and :css cannot be combined (#{xpath_css})" if xpath_css.size > 1
+          deprecated_locators
+          normalize_selector
+          inspected = selector.inspect
+          scope = @query_scope unless @selector.key?(:scope) || @query_scope.is_a?(Watir::Browser)
 
-          built = xpath_css.empty? ? build_wd_selector(@selector) : @selector
+          @built = wd_locator(@selector.keys).nil? ? build_wd_selector(@selector) : @selector
+          @built.delete(:index) if @built[:index]&.zero?
+          @built[:scope] = scope if scope
 
-          built.delete(:index) if built[:index]&.zero?
+          Watir.logger.info "Converted #{inspected} to #{@built.inspect}"
+          @built
+        end
 
-          Watir.logger.debug "Converted #{inspected} to #{built}, with #{@selector.inspect} to match"
-          built
+        def wd_locator(keys)
+          (Watir::Locators::W3C_FINDERS & keys).first
         end
 
+        private
+
         def normalize_selector
-          if @selector.key?(:class) && @selector.key?(:class_name)
-            raise LocatorException, 'Can not use both :class and :class_name locators'
+          wd_locators = @selector.keys & Watir::Locators::W3C_FINDERS
+          raise LocatorException, "Can not locate element with #{wd_locators}" if wd_locators.size > 1
+
+          @selector[:scope] = @query_scope.selector_builder.built if use_scope?
+
+          if @selector.key?(:class) || @selector.key?(:class_name)
+            classes = ([@selector[:class]].flatten + [@selector.delete(:class_name)].flatten).compact
+
+            classes.each do |class_name|
+              next unless class_name.is_a?(String) && class_name.strip.include?(' ')
+
+              deprecate_class_array(class_name)
+            end
+
+            @selector[:class] = classes
           end
 
           if @selector[:adjacent] == :ancestor && @selector.key?(:text)
@@ -55,12 +75,25 @@ module Watir
           end
         end
 
-        def check_type(how, what)
-          if %i[class class_name].include?(how)
-            classes = [what].flatten
-            raise LocatorException, "Can not locate elements with an empty Array for :#{how}" if classes.empty?
+        def use_scope?
+          return false if @query_scope.is_a?(Browser)
+
+          !@selector.key?(:adjacent) &&
+            (Watir::Locators::W3C_FINDERS & @selector.keys).empty? &&
+            !(@query_scope.is_a?(Watir::IFrame) || @query_scope.is_a?(Watir::Radio)) &&
+            @query_scope.selector_builder.built&.size == 1
+        end
 
-            classes.each { |value| raise_unless(value, VALID_WHATS[how]) }
+        def deprecate_class_array(class_name)
+          dep = "Using the :class locator to locate multiple classes with a String value (i.e. \"#{class_name}\")"
+          Watir.logger.deprecate dep,
+                                 "Array (e.g. #{class_name.split})",
+                                 ids: [:class_array]
+        end
+
+        def check_type(how, what)
+          if %i[class class_name].include? how
+            [what].flatten.each { |value| raise_unless(value, VALID_WHATS[how]) }
           else
             raise_unless(what, VALID_WHATS[how])
           end
@@ -70,8 +103,6 @@ module Watir
           !valid_attribute?(:label)
         end
 
-        private
-
         def normalize_locator(how, what)
           case how
           when 'text'
@@ -80,16 +111,19 @@ module Watir
           when :tag_name
             what = what.to_s if what.is_a?(::Symbol)
             [how, what]
-          when :text, :xpath, :index, :class, :css, :visible, :visible_text, :adjacent
+          when :text, :xpath, :index, :css, :visible, :visible_text, :adjacent
+            [how, what]
+          when :class
+            what = false if what.tap { |arr| arr.delete('') }.empty?
             [how, what]
+          when :link
+            [:link_text, what]
           when :label, :visible_label
             if should_use_label_element?
               ["#{how}_element".to_sym, what]
             else
               [how, what]
             end
-          when :class_name
-            [:class, what]
           when :caption
             # This allows any element to be located with 'caption' instead of 'text'
             Watir.logger.deprecate('Locating elements with :caption', ':text locator', ids: [:caption])
@@ -132,6 +166,18 @@ module Watir
 
           raise TypeError, "expected one of #{types}, got #{what.inspect}:#{what.class}"
         end
+
+        def deprecated_locators
+          %i[partial_link_text link_text link].each do |locator|
+            next unless @selector.key?(locator)
+
+            Watir.logger.deprecate(":#{locator} locator", ':visible_text', ids: [:link_text])
+            tag = @selector[:tag_name]
+            next if tag.nil? || tag == 'a'
+
+            raise LocatorException, "Can not use #{locator} locator to find a #{tag} element"
+          end
+        end
       end
     end
   end