watir 6.13.0 → 6.14.0

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

@@ -5,7 +5,7 @@ module Watir
         class XPath < Element::SelectorBuilder::XPath
           def lhs_for(building, key)
             if building == :input && key == :text
-              "@value"
+              '@value'
             else
               super
             end

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

@@ -5,8 +5,8 @@ module Watir
         def validate(element, _selector)
           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)
+          # 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

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

@@ -2,13 +2,11 @@ module Watir
   module Locators
     class Cell
       class Locator < Element::Locator
-
         private
 
         def using_selenium(*)
           # force watir usage
         end
-
       end
     end
   end

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

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

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

@@ -5,24 +5,24 @@ module Watir
         attr_reader :selector_builder
         attr_reader :element_validator
 
-        W3C_FINDERS = [
-          :css,
-          :link,
-          :link_text,
-          :partial_link_text,
-          :tag_name,
-          :xpath
-        ]
+        W3C_FINDERS = %i[
+          css
+          link
+          link_text
+          partial_link_text
+          tag_name
+          xpath
+        ].freeze
 
         # Regular expressions that can be reliably converted to xpath `contains`
         # expressions in order to optimize the locator.
-        CONVERTABLE_REGEXP = %r{
+        CONVERTABLE_REGEXP = /
           \A
             ([^\[\]\\^$.|?*+()]*) # leading literal characters
             [^|]*?                # do not try to convert expressions with alternates
             ([^\[\]\\^$.|?*+()]*) # trailing literal characters
           \z
-        }x
+        /x
 
         def initialize(query_scope, selector, selector_builder, element_validator)
           @query_scope = query_scope # either element or browser
@@ -39,6 +39,7 @@ module Watir
 
         def locate_all
           return [@selector[:element]] if @selector.key?(:element)
+
           using_selenium(:all) || using_watir(:all)
         end
 
@@ -66,27 +67,18 @@ module Watir
           unless how
             raise Error, "internal error: unable to build Selenium selector from #{@normalized_selector.inspect}"
           end
+
           what = add_regexp_predicates(what) if how == :xpath
 
           if filter == :all || !@filter_selector.empty?
-            retries = 0
-            begin
-              elements = locate_elements(how, what, @driver_scope) || []
-              filter_elements(elements, 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"
-            end
+            locate_filtered_elements(how, what, filter)
           else
             locate_element(how, what, @driver_scope)
           end
         end
 
         def validate(elements, tag_name)
-          elements.compact.all? { |element| element_validator.validate(element, {tag_name: tag_name}) }
+          elements.compact.all? { |element| element_validator.validate(element, tag_name: tag_name) }
         end
 
         def fetch_value(element, how)
@@ -100,21 +92,19 @@ module Watir
           when :tag_name
             element.tag_name.downcase
           when :href
-            (href = element.attribute(:href)) && href.strip
+            element.attribute('href')&.strip
+          when String, ::Symbol
+            how = how.to_s.tr('_', '-') if how.is_a?(::Symbol)
+            element.attribute(how)
           else
-            element.attribute(how.to_s.tr("_", "-").to_sym)
+            raise Error::Exception, "Unable to fetch value for #{how}"
           end
         end
 
         def filter_elements(elements, filter: :first)
           selector = @filter_selector.dup
           if filter == :first
-            idx = selector.delete(:index) || 0
-            if idx < 0
-              elements.reverse!
-              idx = idx.abs - 1
-            end
-
+            idx = element_index(elements, selector)
             counter = 0
 
             # Lazy evaluation to avoid fetching values for elements that will be discarded
@@ -122,18 +112,26 @@ module Watir
               counter += 1
               matches_selector?(el, selector)
             end
-            val = matches.take(idx + 1).to_a[idx]
-            Watir.logger.debug "Filtered through #{counter} elements to locate #{@selector.inspect}"
-            val
+            msg = "Filtered 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) }
           end
         end
 
+        def element_index(elements, selector)
+          idx = selector.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
-          @driver_scope = ensure_scope_context
+
+          @driver_scope = @query_scope.wd
 
           @normalized_selector = selector_builder.normalized_selector
 
@@ -151,46 +149,56 @@ module Watir
           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
-          [:visible, :visible_text].each do |how|
+          %i[visible visible_text].each do |how|
             next unless @normalized_selector.key?(how)
+
             @filter_selector[how] = @normalized_selector.delete(how)
           end
 
-          if tag_validation_required?(@normalized_selector)
-            tag_name = @normalized_selector[:tag_name].is_a?(::Symbol) ? @normalized_selector[:tag_name].to_s : @normalized_selector[:tag_name]
-            @filter_selector[:tag_name] = tag_name
-          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 == 0
+            # 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
           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].kind_of?(Regexp)
-          return unless (regexp || label_key == :visible_label)  && selector_builder.should_use_label_element?
+          regexp = @normalized_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
@@ -218,9 +226,10 @@ module Watir
         def matches_selector?(element, selector)
           matches = selector.all? do |how, what|
             if how == :tag_name && what.is_a?(String)
-              element_validator.validate(element, {tag_name: what})
+              element_validator.validate(element, tag_name: what)
             else
-              what === fetch_value(element, how)
+              val = fetch_value(element, how)
+              what == val || val =~ /#{what}/
             end
           end
 
@@ -230,13 +239,15 @@ module Watir
         end
 
         def text_regexp_deprecation(element, selector, matches)
-          text_content = Watir::Element.new(@query_scope, element: element).send(:execute_js, :getTextContent, element).strip
-          text_content_matches = selector[:text] === text_content
-          unless matches == text_content_matches
-            key = @selector.key?(:text) ? "text" : "label"
-            Watir.logger.deprecate("Using :#{key} locator with RegExp #{selector[:text].inspect} to match an element that includes hidden text", ":visible_#{key}",
-                  ids: [:text_regexp])
-          end
+          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 can_convert_regexp_to_contains?
@@ -247,20 +258,18 @@ module Watir
           return what unless can_convert_regexp_to_contains?
 
           @filter_selector.each do |key, value|
-            next if [:tag_name, :text, :visible_text, :visible, :index].include?(key)
+            next if %i[tag_name text visible_text visible index].include?(key)
 
             predicates = regexp_selector_to_predicates(key, value)
-            unless predicates.empty?
-              what = "(#{what})[#{predicates.join(' and ')}]"
-            end
+            what = "(#{what})[#{predicates.join(' and ')}]" unless predicates.empty?
           end
           what
         end
 
-        def regexp_selector_to_predicates(key, re)
-          return [] if re.casefold?
+        def regexp_selector_to_predicates(key, regexp)
+          return [] if regexp.casefold?
 
-          match = re.source.match(CONVERTABLE_REGEXP)
+          match = regexp.source.match(CONVERTABLE_REGEXP)
           return [] unless match
 
           lhs = selector_builder.xpath_builder.lhs_for(nil, key)
@@ -273,10 +282,6 @@ module Watir
           (selector.key?(:css) || selector.key?(:xpath)) && selector.key?(:tag_name)
         end
 
-        def ensure_scope_context
-          @query_scope.wd
-        end
-
         def locate_element(how, what, scope = @query_scope.wd)
           scope.find_element(how, what)
         end
@@ -285,12 +290,28 @@ module Watir
           scope.find_elements(how, what)
         end
 
+        def locate_filtered_elements(how, what, filter)
+          retries = 0
+          begin
+            elements = locate_elements(how, what, @driver_scope) || []
+            filter_elements(elements, 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"
+          end
+        end
+
         def wd_supported?(how, what, tag)
           return false unless W3C_FINDERS.include? how
-          return false unless what.kind_of?(String)
+          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])
             return true if [:a, :link, nil].include?(tag)
+
             raise StandardError, "Can not use #{how} locator to find a #{what} element"
           elsif how == :tag_name
             return true

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

@@ -30,27 +30,19 @@ module Watir
         def check_type(how, what)
           case how
           when :index
-            unless what.is_a?(Integer)
-              raise TypeError, "expected Integer, got #{what.inspect}:#{what.class}"
-            end
+            raise_unless_int(what)
           when :visible
-            unless what.is_a?(TrueClass) || what.is_a?(FalseClass)
-              raise TypeError, "expected TrueClass or FalseClass, got #{what.inspect}:#{what.class}"
-            end
+            raise_unless_boolean(what)
           when :visible_text
-            unless what.is_a?(String) || what.is_a?(Regexp)
-              raise TypeError, "expected String or Regexp, got #{what.inspect}:#{what.class}"
-            end
+            raise_unless_str_regex(what)
           else
-            if what.is_a?(Array) && how != :class && how != :class_name
-              raise TypeError, "Only :class locator can have a value of an Array"
-            end
-            if what.is_a?(Symbol) && how != :adjacent
-              raise TypeError, "Symbol is not a valid value"
-            end
-            unless VALID_WHATS.any? { |t| what.is_a? t }
-              raise TypeError, "expected one of #{VALID_WHATS.inspect}, got #{what.inspect}:#{what.class}"
+            if what.is_a?(Array) && !%i[class class_name].include?(how)
+              raise TypeError, 'Only :class locator can have a value of an Array'
             end
+            raise TypeError, 'Symbol is not a valid value' if what.is_a?(Symbol) && how != :adjacent
+            return if VALID_WHATS.any? { |t| what.is_a? t }
+
+            raise TypeError, "expected one of #{VALID_WHATS.inspect}, got #{what.inspect}:#{what.class}"
           end
         end
 
@@ -61,6 +53,7 @@ module Watir
         def build(selector)
           inspect = selector.inspect
           return given_xpath_or_css(selector) if selector.key?(:xpath) || selector.key?(:css)
+
           built = build_wd_selector(selector)
           Watir.logger.debug "Converted #{inspect} to #{built}"
           built
@@ -90,47 +83,39 @@ module Watir
 
         def check_custom_attribute(attribute)
           return if valid_attribute?(attribute) || attribute.to_s =~ WILDCARD_ATTRIBUTE
+
           @custom_attributes << attribute.to_s
         end
 
         def given_xpath_or_css(selector)
-          xpath = selector.delete(:xpath)
-          css   = selector.delete(:css)
-          return unless xpath || css
+          locator = {}
+          locator[:xpath] = selector.delete(:xpath) if selector.key?(:xpath)
+          locator[:css] = selector.delete(:css) if selector.key?(:css)
 
-          if xpath && css
-            raise ArgumentError, ":xpath and :css cannot be combined (#{selector.inspect})"
-          end
+          return if locator.empty?
+          raise ArgumentError, ":xpath and :css cannot be combined (#{selector.inspect})" if locator.size > 1
 
-          how, what = if xpath
-                        [:xpath, xpath]
-                      elsif css
-                        [:css, css]
-                      end
-
-          if selector.any? && !can_be_combined_with_xpath_or_css?(selector)
-            raise ArgumentError, "#{how} cannot be combined with other selectors (#{selector.inspect})"
-          end
+          return locator.first unless selector.any? && !can_be_combined_with_xpath_or_css?(selector)
 
-          [how, what]
+          msg = "#{locator.keys.first} cannot be combined with other selectors (#{selector.inspect})"
+          raise ArgumentError, msg
         end
 
         def build_wd_selector(selectors)
           return if selectors.values.any? { |e| e.is_a? Regexp }
+
           build_xpath(selectors)
         end
 
         def valid_attribute?(attribute)
-          @valid_attributes && @valid_attributes.include?(attribute)
+          @valid_attributes&.include?(attribute)
         end
 
         def can_be_combined_with_xpath_or_css?(selector)
           keys = selector.keys
           return true if keys == [:tag_name]
 
-          if selector[:tag_name] == "input"
-            return keys.sort == [:tag_name, :type]
-          end
+          return keys.sort == %i[tag_name type] if selector[:tag_name] == 'input'
 
           false
         end
@@ -141,10 +126,27 @@ module Watir
 
         def xpath_builder_class
           Kernel.const_get("#{self.class.name}::XPath")
-        rescue
+        rescue StandardError
           XPath
         end
 
+        def raise_unless_int(what)
+          return if what.is_a?(Integer)
+
+          raise TypeError, "expected Integer, got #{what.inspect}:#{what.class}"
+        end
+
+        def raise_unless_boolean(what)
+          return if what.is_a?(TrueClass) || what.is_a?(FalseClass)
+
+          raise TypeError, "expected TrueClass or FalseClass, got #{what.inspect}:#{what.class}"
+        end
+
+        def raise_unless_str_regex(what)
+          return if what.is_a?(String) || what.is_a?(Regexp)
+
+          raise TypeError, "expected String or Regexp, got #{what.inspect}:#{what.class}"
+        end
       end
     end
   end