watir 6.14.0 → 6.15.0

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

@@ -2,78 +2,113 @@ module Watir
   module Locators
     class Element
       class SelectorBuilder
+        include Exception
         attr_reader :custom_attributes
 
-        VALID_WHATS = [Array, String, Regexp, TrueClass, FalseClass, ::Symbol].freeze
+        VALID_WHATS = [String, Regexp, TrueClass, FalseClass].freeze
         WILDCARD_ATTRIBUTE = /^(aria|data)_(.+)$/
 
-        def initialize(query_scope, selector, valid_attributes)
-          @query_scope = query_scope # either element or browser
-          @selector = selector
+        def initialize(valid_attributes)
           @valid_attributes = valid_attributes
           @custom_attributes = []
         end
 
-        def normalized_selector
-          selector = {}
+        def build(selector)
+          inspected = selector.inspect
+          @selector = selector
+          normalize_selector
+
+          xpath_css = (@selector.keys & %i[xpath css]).each_with_object({}) do |key, hash|
+            hash[key] = @selector.delete(key)
+          end
+
+          built = if xpath_css.empty?
+                    build_wd_selector(@selector)
+                  else
+                    process_xpath_css(xpath_css)
+                    xpath_css
+                  end
 
-          @selector.each do |how, what|
-            check_type(how, what)
+          @selector.delete(:index) if @selector[:index]&.zero?
 
-            how, what = normalize_selector(how, what)
-            selector[how] = what
+          Watir.logger.debug "Converted #{inspected} to #{built}, with #{@selector.inspect} to match"
+          [built, @selector]
+        end
+
+        def normalize_selector
+          if @selector.key?(:class) && @selector.key?(:class_name)
+            raise LocatorException, 'Can not use both :class and :class_name locators'
           end
 
-          selector
+          if @selector[:adjacent] == :ancestor && @selector.key?(:text)
+            raise LocatorException, 'Can not find parent element with text locator'
+          end
+
+          @selector.keys.each do |key|
+            check_type(key, @selector[key])
+
+            how, what = normalize_locator(key, @selector.delete(key))
+            @selector[how] = what
+          end
         end
 
         def check_type(how, what)
           case how
+          when :adjacent
+            return raise_unless(what, ::Symbol)
+          when :xpath, :css
+            return raise_unless(what, String)
           when :index
-            raise_unless_int(what)
+            return raise_unless(what, Integer)
           when :visible
-            raise_unless_boolean(what)
-          when :visible_text
-            raise_unless_str_regex(what)
-          else
-            if what.is_a?(Array) && !%i[class class_name].include?(how)
-              raise TypeError, 'Only :class locator can have a value of an Array'
+            return raise_unless(what, :boolean)
+          when :tag_name
+            return raise_unless(what, :string_or_regexp_or_symbol)
+          when :visible_text, :text
+            return raise_unless(what, :string_or_regexp)
+          when :class, :class_name
+            if what.is_a?(Array)
+              raise LocatorException, 'Can not locate elements with an empty Array for :class' if what.empty?
+
+              what.each do |klass|
+                raise_unless(klass, :string_or_regexp)
+              end
+              return
             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
-
-        def should_use_label_element?
-          !valid_attribute?(:label)
-        end
 
-        def build(selector)
-          inspect = selector.inspect
-          return given_xpath_or_css(selector) if selector.key?(:xpath) || selector.key?(:css)
+          return if VALID_WHATS.any? { |t| what.is_a? t }
 
-          built = build_wd_selector(selector)
-          Watir.logger.debug "Converted #{inspect} to #{built}"
-          built
+          raise TypeError, "expected one of #{VALID_WHATS.inspect}, got #{what.inspect}:#{what.class}"
         end
 
-        def xpath_builder
-          @xpath_builder ||= xpath_builder_class.new(should_use_label_element?)
+        def should_use_label_element?
+          !valid_attribute?(:label)
         end
 
         private
 
-        def normalize_selector(how, what)
+        def normalize_locator(how, what)
           case how
-          when :tag_name, :text, :xpath, :index, :class, :label, :css, :visible, :visible_text, :adjacent
-            # include :class since the valid attribute is 'class_name'
-            # include :for since the valid attribute is 'html_for'
+          when 'text'
+            Watir.logger.deprecate "String 'text' as a locator", 'Symbol :text', ids: ['text_string']
+            [:text, what]
+          when :tag_name
+            what = what.to_s if what.is_a?(::Symbol)
+            [how, what]
+          when :text, :xpath, :index, :class, :css, :visible, :visible_text, :adjacent
             [how, what]
+          when :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])
             [:text, what]
           else
             check_custom_attribute how
@@ -87,65 +122,49 @@ module Watir
           @custom_attributes << attribute.to_s
         end
 
-        def given_xpath_or_css(selector)
-          locator = {}
-          locator[:xpath] = selector.delete(:xpath) if selector.key?(:xpath)
-          locator[:css] = selector.delete(:css) if selector.key?(:css)
-
-          return if locator.empty?
-          raise ArgumentError, ":xpath and :css cannot be combined (#{selector.inspect})" if locator.size > 1
+        def process_xpath_css(xpath_css)
+          raise LocatorException, ":xpath and :css cannot be combined (#{xpath_css})" if xpath_css.size > 1
 
-          return locator.first unless selector.any? && !can_be_combined_with_xpath_or_css?(selector)
+          return if combine_with_xpath_or_css?(@selector)
 
-          msg = "#{locator.keys.first} cannot be combined with other selectors (#{selector.inspect})"
-          raise ArgumentError, msg
+          msg = "#{xpath_css.keys.first} cannot be combined with all of these locators (#{@selector.inspect})"
+          raise LocatorException, msg
         end
 
-        def build_wd_selector(selectors)
-          return if selectors.values.any? { |e| e.is_a? Regexp }
-
-          build_xpath(selectors)
+        # Implement this method when creating a different selector builder
+        def build_wd_selector(selector)
+          Kernel.const_get("#{self.class.name}::XPath").new.build(selector)
         end
 
         def valid_attribute?(attribute)
           @valid_attributes&.include?(attribute)
         end
 
-        def can_be_combined_with_xpath_or_css?(selector)
+        def combine_with_xpath_or_css?(selector)
           keys = selector.keys
-          return true if keys == [:tag_name]
-
-          return keys.sort == %i[tag_name type] if selector[:tag_name] == 'input'
-
-          false
-        end
-
-        def build_xpath(selectors)
-          xpath_builder.build(selectors)
-        end
-
-        def xpath_builder_class
-          Kernel.const_get("#{self.class.name}::XPath")
-        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}"
+          keys.reject! { |key| %i[visible visible_text index].include? key }
+          if (keys - [:tag_name]).empty?
+            true
+          elsif selector[:tag_name] == 'input' && keys == %i[tag_name type]
+            true
+          else
+            false
+          end
         end
 
-        def raise_unless_str_regex(what)
-          return if what.is_a?(String) || what.is_a?(Regexp)
+        def raise_unless(what, type)
+          valid = if type == :boolean
+                    [TrueClass, FalseClass].include?(what.class)
+                  elsif type == :string_or_regexp
+                    [String, Regexp].include?(what.class)
+                  elsif type == :string_or_regexp_or_symbol
+                    [String, Regexp, ::Symbol].include?(what.class)
+                  else
+                    what.is_a?(type)
+                  end
+          return if valid
 
-          raise TypeError, "expected String or Regexp, got #{what.inspect}:#{what.class}"
+          raise TypeError, "expected #{type}, got #{what.inspect}:#{what.class}"
         end
       end
     end

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

@@ -0,0 +1,66 @@
+# Source: https://github.com/teamcapybara/capybara/blob/xpath_regexp/lib/capybara/selector/regexp_disassembler.rb
+require 'regexp_parser'
+
+module Watir
+  module Locators
+    class Element
+      class SelectorBuilder
+        class RegexpDisassembler
+          def initialize(regexp)
+            @regexp = regexp
+            @regexp_source = regexp.source
+          end
+
+          def substrings
+            @substrings ||= begin
+              strs = extract_strings(Regexp::Parser.parse(@regexp), [+''])
+              strs.map!(&:downcase) if @regexp.casefold?
+              strs.reject(&:empty?).uniq
+            end
+          end
+
+          private
+
+          def min_repeat(exp)
+            exp.quantifier&.min || 1
+          end
+
+          def fixed_repeat?(exp)
+            min_repeat(exp) == (exp.quantifier&.max || 1)
+          end
+
+          def optional?(exp)
+            min_repeat(exp).zero?
+          end
+
+          def extract_strings(expression, strings)
+            expression.each do |exp|
+              if optional?(exp)
+                strings.push(+'')
+                next
+              end
+              if %i[meta set].include?(exp.type)
+                strings.push(+'')
+                next
+              end
+              if exp.terminal?
+                case exp.type
+                when :literal
+                  strings.last << (exp.text * min_repeat(exp))
+                when :escape
+                  strings.last << (exp.char * min_repeat(exp))
+                else
+                  strings.push(+'')
+                end
+              else
+                min_repeat(exp).times { extract_strings(exp, strings) }
+              end
+              strings.push(+'') unless fixed_repeat?(exp)
+            end
+            strings
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,120 +3,233 @@ module Watir
     class Element
       class SelectorBuilder
         class XPath
-          def initialize(should_use_label_element)
-            @should_use_label_element = should_use_label_element
+          include Exception
+          include XpathSupport
+
+          CAN_NOT_BUILD = %i[visible visible_text].freeze
+
+          def build(selector)
+            @selector = selector
+
+            @requires_matches = (@selector.keys & CAN_NOT_BUILD).each_with_object({}) do |key, hash|
+              hash[key] = @selector.delete(key)
+            end
+
+            index = @selector.delete(:index)
+            @adjacent = @selector.delete(:adjacent)
+
+            xpath = start_string
+            xpath << adjacent_string
+            xpath << tag_string
+            xpath << class_string
+            xpath << text_string
+            xpath << additional_string
+            xpath << attribute_string
+
+            xpath = index ? add_index(xpath, index) : xpath
+
+            @selector.merge! @requires_matches
+
+            {xpath: xpath}
+          end
+
+          private
+
+          def process_attribute(key, value)
+            if value.is_a? Regexp
+              predicate_conversion(key, value)
+            else
+              predicate_expression(key, value)
+            end
+          end
+
+          def predicate_expression(key, val)
+            if val.eql? true
+              attribute_presence(key)
+            elsif val.eql? false
+              attribute_absence(key)
+            else
+              equal_pair(key, val)
+            end
+          end
+
+          def predicate_conversion(key, regexp)
+            # type attributes can be upper case - downcase them
+            # https://github.com/watir/watir/issues/72
+            downcase = key == :type || regexp.casefold?
+
+            lhs = lhs_for(key, downcase)
+
+            results = RegexpDisassembler.new(regexp).substrings
+
+            if results.empty?
+              add_to_matching(key, regexp)
+              return lhs
+            elsif results.size == 1 && starts_with?(results, regexp) && !visible?
+              return "starts-with(#{lhs}, '#{results.first}')"
+            end
+
+            add_to_matching(key, regexp, results)
+
+            results.map { |substring|
+              "contains(#{lhs}, '#{substring}')"
+            }.flatten.compact.join(' and ')
+          end
+
+          def start_string
+            @adjacent ? './' : './/*'
+          end
+
+          def adjacent_string
+            case @adjacent
+            when nil
+              ''
+            when :ancestor
+              'ancestor::*'
+            when :preceding
+              'preceding-sibling::*'
+            when :following
+              'following-sibling::*'
+            when :child
+              'child::*'
+            else
+              raise LocatorException, "Unable to process adjacent locator with #{@adjacent}"
+            end
+          end
+
+          def tag_string
+            tag_name = @selector.delete(:tag_name)
+            tag_name.nil? ? '' : "[#{process_attribute(:tag_name, tag_name)}]"
           end
 
-          def build(selectors)
-            adjacent = selectors.delete :adjacent
-            xpath = adjacent ? process_adjacent(adjacent) : './/*'
+          def class_string
+            class_name = @selector.delete(:class)
+            return '' if class_name.nil?
 
-            tag_name = selectors.delete(:tag_name).to_s
-            xpath << "[local-name()='#{tag_name}']" unless tag_name.empty?
+            deprecate_class_array(class_name) if class_name.is_a?(String) && class_name.strip.include?(' ')
 
-            index = selectors.delete(:index)
+            @requires_matches[:class] = []
 
-            # the remaining entries should be attributes
-            xpath << '[' << attribute_expression(nil, selectors) << ']' unless selectors.empty?
+            predicates = [class_name].flatten.map { |value| process_attribute(:class, value) }.compact
 
-            xpath << "[#{index + 1}]" if adjacent && index
+            @requires_matches.delete(:class) if @requires_matches[:class].empty?
 
-            p xpath: xpath, selectors: selectors if $DEBUG
+            predicates.empty? ? '' : "[#{predicates.join(' and ')}]"
+          end
+
+          def text_string
+            text = @selector.delete :text
 
-            [:xpath, xpath]
+            case text
+            when nil
+              ''
+            when Regexp
+              @requires_matches[:text] = text
+              ''
+            else
+              "[#{predicate_expression(:text, text)}]"
+            end
           end
 
-          # @todo Get rid of building
-          def attribute_expression(building, selectors)
-            f = selectors.map do |key, val|
-              if val.is_a?(Array) && key == :class
-                '(' + val.map { |v| build_class_match(v) }.join(' and ') + ')'
-              elsif val.is_a?(Array)
-                '(' + val.map { |v| equal_pair(building, key, v) }.join(' or ') + ')'
-              elsif val.eql? true
-                attribute_presence(key)
-              elsif val.eql? false
-                attribute_absence(key)
-              else
-                equal_pair(building, key, val)
-              end
+          def attribute_string
+            attributes = @selector.keys.map { |key|
+              process_attribute(key, @selector.delete(key))
+            }.flatten.compact
+            attributes.empty? ? '' : "[#{attributes.join(' and ')}]"
+          end
+
+          def additional_string
+            # to be used by subclasses as necessary
+            ''
+          end
+
+          # TODO: Remove this on refactor of index
+          def add_index(xpath, index)
+            if @adjacent
+              "#{xpath}[#{index + 1}]"
+            elsif index&.positive? && @requires_matches.empty?
+              "(#{xpath})[#{index + 1}]"
+            elsif index&.negative? && @requires_matches.empty?
+              last_value = 'last()'
+              last_value << (index + 1).to_s if index < -1
+              "(#{xpath})[#{last_value}]"
+            else
+              @requires_matches[:index] = index
+              xpath
             end
-            f.join(' and ')
           end
 
-          # @todo Get rid of building
-          def equal_pair(building, key, value)
+          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 visible?
+            !(@requires_matches.keys & CAN_NOT_BUILD).empty?
+          end
+
+          def starts_with?(results, regexp)
+            regexp.source[0] == '^' && results.first == regexp.source[1..-1]
+          end
+
+          def add_to_matching(key, regexp, results = nil)
+            return unless results.nil? || requires_matching?(results, regexp)
+
             if key == :class
-              if value.strip.include?(' ')
-                dep = "Using the :class locator to locate multiple classes with a String value (i.e. \"#{value}\")"
-                Watir.logger.deprecate dep,
-                                       "Array (e.g. #{value.split})",
-                                       ids: [:class_array]
-              end
-              build_class_match(value)
-            elsif key == :label && @should_use_label_element
-              # we assume :label means a corresponding label element, not the attribute
-              text = "normalize-space()=#{XpathSupport.escape value}"
-              "(@id=//label[#{text}]/@for or parent::label[#{text}])"
+              @requires_matches[key] << regexp
             else
-              "#{lhs_for(building, key)}=#{XpathSupport.escape value}"
+              @requires_matches[key] = regexp
             end
           end
 
-          # @todo Get rid of building
-          def lhs_for(_building, key)
+          def requires_matching?(results, regexp)
+            regexp.casefold? ? !results.first.casecmp(regexp.source).zero? : results.first != regexp.source
+          end
+
+          def lhs_for(key, downcase = false)
             case key
-            when :text, 'text'
-              'normalize-space()'
             when String
               "@#{key}"
+            when :tag_name
+              'local-name()'
             when :href
-              # TODO: change this behaviour?
               'normalize-space(@href)'
-            when :type
-              # type attributes can be upper case - downcase them
-              # https://github.com/watir/watir/issues/72
-              XpathSupport.downcase('@type')
+            when :text
+              'normalize-space()'
+            when :contains_text
+              'text()'
             when ::Symbol
-              "@#{key.to_s.tr('_', '-')}"
+              lhs = "@#{key.to_s.tr('_', '-')}"
+              downcase ? XpathSupport.downcase(lhs) : lhs
             else
-              raise Error::Exception, "Unable to build XPath using #{key}"
-            end
-          end
-
-          private
-
-          def process_adjacent(adjacent)
-            xpath = './'
-            xpath << case adjacent
-                     when :ancestor
-                       'ancestor::*'
-                     when :preceding
-                       'preceding-sibling::*'
-                     when :following
-                       'following-sibling::*'
-                     when :child
-                       'child::*'
-                     end
-            xpath
-          end
-
-          def build_class_match(value)
-            if value =~ /^!/
-              klass = XpathSupport.escape " #{value[1..-1]} "
-              "not(contains(concat(' ', @class, ' '), #{klass}))"
-            else
-              klass = XpathSupport.escape " #{value} "
-              "contains(concat(' ', @class, ' '), #{klass})"
+              raise LocatorException, "Unable to build XPath using #{key}:#{key.class}"
             end
           end
 
           def attribute_presence(attribute)
-            lhs_for(nil, attribute)
+            lhs_for(attribute, false)
           end
 
           def attribute_absence(attribute)
-            "not(#{lhs_for(nil, attribute)})"
+            lhs = lhs_for(attribute, false)
+            "not(#{lhs})"
+          end
+
+          def equal_pair(key, value)
+            if key == :label_element
+              # we assume :label means a corresponding label element, not the attribute
+              text = "#{lhs_for(:text)}=#{XpathSupport.escape value}"
+              "(@id=//label[#{text}]/@for or parent::label[#{text}])"
+            elsif key == :class
+              negate_xpath = value =~ /^!/ && value.slice!(0)
+              expression = "contains(concat(' ', @class, ' '), #{XpathSupport.escape " #{value} "})"
+
+              negate_xpath ? "not(#{expression})" : expression
+            else
+              "#{lhs_for(key, key == :type)}=#{XpathSupport.escape value}"
+            end
           end
         end
       end