watir 1.4.1 → 7.3.0

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

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+module Watir
+  module Locators
+    class Element
+      class SelectorBuilder
+        class XPath
+          include Exception
+          include XpathSupport
+
+          CAN_NOT_BUILD = %i[visible visible_text visible_label_element].freeze
+
+          LOCATOR = :xpath
+
+          def build(selector)
+            @selector = selector
+            @valid_attributes = build_valid_attributes
+
+            @built = (@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)
+            @scope = @selector.delete(:scope)
+
+            xpath = "#{start_string}" \
+                    "#{adjacent_string}" \
+                    "#{tag_string}" \
+                    "#{class_string}" \
+                    "#{text_string}" \
+                    "#{additional_string}" \
+                    "#{label_element_string}" \
+                    "#{attribute_string}"
+
+            @built[:xpath] = index ? add_index(xpath, index) : xpath
+            @built
+          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)
+            case val
+            when true
+              attribute_presence(key)
+            when false
+              attribute_absence(key)
+            else
+              equal_pair(key, val)
+            end
+          end
+
+          def predicate_conversion(key, regexp)
+            downcase = case_insensitive_attribute?(key) || regexp.casefold?
+
+            lhs = lhs_for(key, downcase: 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 { |rhs|
+              rhs = "\"#{rhs}\""
+              rhs = XpathSupport.downcase(rhs) if downcase
+              "contains(#{lhs}, #{rhs})"
+            }.flatten.compact.join(' and ')
+          end
+
+          def start_string
+            start = @adjacent ? './' : './/*'
+            @scope ? "(#{@scope[:xpath]})[1]#{start.tr('.', '')}" : start
+          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 class_string
+            class_name = @selector.delete(:class)
+            return '' if class_name.nil?
+
+            @built[:class] = []
+
+            predicates = [class_name].flatten.filter_map { |value| process_attribute(:class, value) }
+
+            @built.delete(:class) if @built[:class].empty?
+
+            predicates.empty? ? '' : "[#{predicates.join(' and ')}]"
+          end
+
+          def text_string
+            result = equal_or_contains(@selector.delete(:text))
+            result.nil? ? '' : "[#{result}]"
+          end
+
+          def label_element_string
+            text = @selector.delete(:label_element)
+            return '' if text.nil?
+
+            result = equal_or_contains(text)
+            @built[:label_element] = @built.delete(:text) if @built.key?(:text)
+
+            result.nil? ? '' : "[@id=//label[#{result}]/@for or parent::label[#{result}]]"
+          end
+
+          def equal_or_contains(value)
+            return nil if value.nil? || (value.is_a?(String) && value.empty?) || value.inspect == '//'
+
+            process_attribute(:text, value)
+          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
+
+          def add_index(xpath, index)
+            if @adjacent
+              "#{xpath}[#{index + 1}]"
+            elsif index&.positive? && @built.empty?
+              "(#{xpath})[#{index + 1}]"
+            elsif index&.negative? && @built.empty?
+              last_value = "last()#{index < -1 ? index + 1 : ''}"
+              "(#{xpath})[#{last_value}]"
+            else
+              @built[:index] = index
+              xpath
+            end
+          end
+
+          def visible?
+            !(@built.keys & CAN_NOT_BUILD).empty?
+          end
+
+          def starts_with?(results, regexp)
+            regexp.source[0] == '^' && results.first == regexp.source[1..]
+          end
+
+          def add_to_matching(key, regexp, results = nil)
+            return unless results.nil? || requires_matching?(results, regexp)
+
+            if key == :class
+              @built[key] << regexp
+            else
+              @built[key] = regexp
+            end
+          end
+
+          def requires_matching?(results, regexp)
+            regexp.casefold? ? !results.first.casecmp(regexp.source).zero? : results.first != regexp.source
+          end
+
+          def lhs_for(key, downcase: false)
+            lhs = case key
+                  when String
+                    process_string key
+                  when :tag_name
+                    'local-name()'
+                  when :href
+                    'normalize-space(@href)'
+                  when :text
+                    'normalize-space()'
+                  when ::Symbol
+                    process_string key.to_s.tr('_', '-')
+                  else
+                    raise LocatorException, "Unable to build XPath using #{key}:#{key.class}"
+                  end
+            downcase ? XpathSupport.downcase(lhs) : lhs
+          end
+
+          def attribute_presence(attribute)
+            lhs_for(attribute)
+          end
+
+          def attribute_absence(attribute)
+            lhs = lhs_for(attribute)
+            "not(#{lhs})"
+          end
+
+          def equal_pair(key, value)
+            if key == :class
+              negate_xpath = value =~ /^!/
+              value = value[1..] if negate_xpath
+              expression = "contains(concat(' ', normalize-space(@class), ' '), #{XpathSupport.escape " #{value} "})"
+
+              negate_xpath ? "not(#{expression})" : expression
+            else
+              downcase = case_insensitive_attribute?(key)
+
+              lhs = lhs_for(key, downcase: downcase)
+              rhs = XpathSupport.escape(value)
+              rhs = XpathSupport.downcase(rhs) if downcase
+
+              "#{lhs}=#{rhs}"
+            end
+          end
+
+          def build_valid_attributes
+            tag_name = @selector[:tag_name]
+            if tag_name.is_a?(String) && Watir.tag_to_class[tag_name.to_sym]
+              Watir.tag_to_class[tag_name.to_sym].attribute_list
+            else
+              Watir::HTMLElement.attribute_list
+            end
+          end
+
+          def case_insensitive_attribute?(attribute)
+            # type attributes can be upper case - downcase them
+            # https://github.com/watir/watir/issues/72
+            return true if attribute == :type
+            return true if Watir::Element::CASE_INSENSITIVE_ATTRIBUTES.include?(attribute) &&
+                           @valid_attributes.include?(attribute)
+
+            false
+          end
+
+          def process_string(name)
+            if /^[a-zA-Z_:][a-zA-Z0-9_:.-]*$/.match?(name)
+              "@#{name}"
+            else
+              "(attribute::*[local-name(.) = '#{name}'])"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Watir
+  module Locators
+    class Element
+      class SelectorBuilder
+        module XpathSupport
+          UPPERCASE_LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞŸŽŠŒ'
+          LOWERCASE_LETTERS = 'abcdefghijklmnopqrstuvwxyzàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿžšœ'
+
+          def self.escape(value)
+            if value.include? "'"
+              parts = value.split("'", -1).map { |part| "'#{part}'" }
+              string = parts.join(%(,"'",))
+
+              "concat(#{string})"
+            else
+              "'#{value}'"
+            end
+          end
+
+          def self.downcase(value)
+            "translate(#{value},'#{UPPERCASE_LETTERS}','#{LOWERCASE_LETTERS}')"
+          end
+        end
+      end
+    end
+  end # XpathSupport
+end # Watir

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

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Watir
+  module Locators
+    class Element
+      class SelectorBuilder
+        include Exception
+        attr_reader :custom_attributes, :built
+
+        WILDCARD_ATTRIBUTE = /^(aria|data)_(.+)$/
+        VALID_WHATS = Hash.new([String, Regexp, TrueClass, FalseClass]).merge(adjacent: [::Symbol],
+                                                                              xpath: [String],
+                                                                              css: [String],
+                                                                              index: [Integer],
+                                                                              visible: [TrueClass, FalseClass],
+                                                                              tag_name: [String, Regexp, ::Symbol],
+                                                                              visible_text: [String, Regexp],
+                                                                              scope: [Hash],
+                                                                              text: [String, Regexp]).freeze
+
+        def initialize(valid_attributes, query_scope)
+          @valid_attributes = valid_attributes
+          @custom_attributes = []
+          @query_scope = query_scope
+        end
+
+        # rubocop:disable Metrics/PerceivedComplexity:
+        def build(selector)
+          @selector = selector
+
+          normalize_selector
+          inspected = selector.inspect
+          scope = @query_scope unless @selector.key?(:scope) || @query_scope.is_a?(Watir::Browser)
+
+          @built =
+            if scope.is_a? Watir::ShadowRoot
+              raise ArgumentError, ':xpath not supported when locating elements from shadow root' if @selector[:xpath]
+
+              @selector[:css] ||= '*'
+              @selector
+            else
+              wd_locators.empty? ? build_wd_selector(@selector) : @selector
+            end
+          @built.delete(:index) if @built[:index]&.zero?
+          @built[:scope] = scope if scope
+
+          Watir.logger.info "Converted #{inspected} to #{@built.inspect}"
+          @built
+        end
+        # rubocop:enable Metrics/PerceivedComplexity:
+
+        def wd_locators
+          Watir::Locators::W3C_FINDERS & @selector.keys
+        end
+
+        private
+
+        def normalize_selector
+          # TODO: This can be more specific now that only 2
+          raise LocatorException, "Can not locate element with #{wd_locators}" if wd_locators.size > 1
+
+          @selector[:scope] = @query_scope.selector_builder.built if merge_scope?
+
+          if @selector.key?(:class) || @selector.key?(:class_name)
+            @selector[:class] = ([@selector[:class]].flatten + [@selector.delete(:class_name)].flatten).compact
+          end
+
+          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 merge_scope?
+          return false unless ((Watir::Locators::W3C_FINDERS + [:adjacent]) & @selector.keys).empty?
+
+          return false if [Watir::Browser, Watir::IFrame, Watir::ShadowRoot].any? { |k| @query_scope.is_a?(k) }
+
+          scope_invalid_locators = @query_scope.selector_builder.built.keys.reject { |key| key == wd_locator }
+          scope_invalid_locators.empty?
+        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
+        end
+
+        def should_use_label_element?
+          !valid_attribute?(:label)
+        end
+
+        def normalize_locator(how, what)
+          case how
+          when :tag_name
+            what = what.to_s if what.is_a?(::Symbol)
+            [how, what]
+          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 :label, :visible_label
+            if should_use_label_element?
+              ["#{how}_element".to_sym, what]
+            else
+              [how, what]
+            end
+          else
+            check_custom_attribute how
+            [how, what]
+          end
+        end
+
+        def check_custom_attribute(attribute)
+          return if valid_attribute?(attribute) || attribute.to_s =~ WILDCARD_ATTRIBUTE
+
+          @custom_attributes << attribute.to_s
+        end
+
+        # Extensions implement this method when creating a different selector builder
+        def implementation_class
+          Watir.const_get("#{self.class.name}::XPath")
+        end
+
+        def build_wd_selector(selector)
+          implementation_class.new.build(selector)
+        end
+
+        def wd_locator
+          implementation_class::LOCATOR
+        end
+
+        def valid_attribute?(attribute)
+          @valid_attributes&.include?(attribute)
+        end
+
+        def combine_with_xpath_or_css?(selector)
+          keys = selector.keys
+          keys.reject! { |key| %i[visible visible_text index].include? key }
+          if (keys - [:tag_name]).empty?
+            true
+          else
+            selector[:tag_name] == 'input' && keys == %i[tag_name type]
+          end
+        end
+
+        def raise_unless(what, types)
+          return if types.include?(what.class)
+
+          raise TypeError, "expected one of #{types}, got #{what.inspect}:#{what.class}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Watir
+  module Locators
+    class Option
+      class Matcher < Element::Matcher
+        def fetch_value(element, how)
+          case how
+          when :any
+            [element.attribute(:value),
+             execute_js(:getTextContent, element).gsub(/\s+/, ' ').strip,
+             element.attribute(:label)]
+          else
+            super
+          end
+        end
+
+        def matches_values?(found, expected)
+          return super unless found.is_a?(Array)
+
+          found.find { |possible| matches_values?(possible, expected) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Watir
+  module Locators
+    class Option
+      class SelectorBuilder
+        class XPath < Element::SelectorBuilder::XPath
+          private
+
+          def attribute_string
+            result = if @selector.key?(:any)
+                       to_match = @selector.delete :any
+                       value = process_attribute(:value, to_match)
+                       text = process_attribute(:text, to_match)
+                       label = process_attribute(:label, to_match)
+                       "[#{value} or #{text} or #{label}]"
+                     else
+                       ''
+                     end
+
+            attributes = @selector.keys.map { |key|
+              process_attribute(key, @selector.delete(key))
+            }.flatten.compact
+            attribute_values = attributes.empty? ? '' : "[#{attributes.join(' and ')}]"
+            "#{result}#{attribute_values}"
+          end
+
+          def add_to_matching(key, regexp, results = nil)
+            return unless results.nil? || requires_matching?(results, regexp)
+
+            return super unless %i[value text label].include? key
+
+            @built[:any] = regexp
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Watir
+  module Locators
+    class Option
+      class SelectorBuilder < Element::SelectorBuilder
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Watir
+  module Locators
+    class Row
+      class SelectorBuilder
+        class XPath < Element::SelectorBuilder::XPath
+          def build(selector, scope_tag_name)
+            return super(selector) if selector.key?(:adjacent)
+
+            index = selector.delete(:index)
+
+            super(selector)
+            common_string = @built.delete(:xpath)
+            expressions = generate_expressions(scope_tag_name)
+            expressions.map! { |e| "#{e}#{common_string}" } unless common_string.empty?
+
+            xpath = expressions.join(' | ').to_s
+
+            @built[:xpath] = index ? add_index(xpath, index) : xpath
+            @built
+          end
+
+          private
+
+          def start_string
+            @adjacent ? './' : ''
+          end
+
+          def text_string
+            return super if @adjacent
+
+            # Can not directly locate a Row with Text because all text is in the Cells;
+            # needs to use Locator#locate_matching_elements
+            @built[:text] = @selector.delete(:text) if @selector.key?(:text)
+            ''
+          end
+
+          def generate_expressions(scope_tag_name)
+            if %w[tbody tfoot thead].include?(scope_tag_name)
+              ["./*[local-name()='tr']"]
+            else
+              ["./*[local-name()='tr']",
+               "./*[local-name()='tbody']/*[local-name()='tr']",
+               "./*[local-name()='thead']/*[local-name()='tr']",
+               "./*[local-name()='tfoot']/*[local-name()='tr']"]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Watir
+  module Locators
+    class Row
+      class SelectorBuilder < Element::SelectorBuilder
+        def build_wd_selector(selector)
+          scope_tag_name = @query_scope.selector[:tag_name] || @query_scope.tag_name
+          implementation_class.new.build(selector, scope_tag_name)
+        end
+
+        def merge_scope?
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Watir
+  module Locators
+    class TextArea
+      class SelectorBuilder
+        class XPath < Element::SelectorBuilder::XPath
+          private
+
+          # value always requires a wire call since we want the property not the attribute
+          def process_attribute(key, value)
+            return super unless key == :value
+
+            @built[:value] = value
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Watir
+  module Locators
+    class TextArea
+      class SelectorBuilder < Element::SelectorBuilder
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Watir
+  module Locators
+    class TextField
+      class Matcher < Element::Matcher
+        private
+
+        def elements_match?(element, values_to_match)
+          case fetch_value(element, :tag_name)
+          when 'input'
+            %i[text label visible_text].each do |key|
+              next unless values_to_match.key?(key)
+
+              values_to_match[:value] = values_to_match.delete(key)
+            end
+          when 'label'
+            %i[value label].each do |key|
+              next unless values_to_match.key?(key)
+
+              values_to_match[:text] = values_to_match.delete(key)
+            end
+          else
+            return false
+          end
+
+          super
+        end
+
+        def validate_tag(element, _expected)
+          tag_name = fetch_value(element, :tag_name)
+          matches_values?(tag_name, 'input')
+        end
+      end
+    end
+  end
+end