watir 6.14.0 → 6.15.0

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

@@ -0,0 +1,27 @@
+module Watir
+  module Locators
+    class Element
+      class SelectorBuilder
+        module XpathSupport
+          UPPERCASE_LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞŸŽŠŒ'.freeze
+          LOWERCASE_LETTERS = 'abcdefghijklmnopqrstuvwxyzàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿžšœ'.freeze
+
+          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/validator.rb

@@ -2,15 +2,8 @@ module Watir
   module Locators
     class Element
       class Validator
-        def validate(element, selector)
-          selector_tag_name = selector[:tag_name]
-          element_tag_name = element.tag_name.downcase
-
-          if selector_tag_name
-            return unless element_tag_name =~ /#{selector_tag_name}/
-          end
-
-          element
+        def validate(element, tag_name)
+          element.tag_name.downcase =~ /#{tag_name}/
         end
       end
     end

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

@@ -2,30 +2,13 @@ module Watir
   module Locators
     class Row
       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?!')
-
-          expressions = generate_expressions(@query_scope.tag_name.downcase)
-
-          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]
+        def initialize(valid_attributes, scope_tag_name)
+          @scope_tag_name = scope_tag_name
+          super(valid_attributes)
         end
 
-        protected
-
-        def generate_expressions(tag_name)
-          expressions = %w[./tr]
-          expressions += %w[./tbody/tr ./thead/tr ./tfoot/tr] unless %w[tbody tfoot thead].include?(tag_name)
-          expressions
+        def build_wd_selector(selector)
+          Kernel.const_get("#{self.class.name}::XPath").new.build(selector, @scope_tag_name)
         end
       end
     end

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

@@ -0,0 +1,53 @@
+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)
+
+            common_string = super(selector)[:xpath]
+            expressions = generate_expressions(scope_tag_name)
+            expressions.map! { |e| "#{e}#{common_string}" } unless common_string.empty?
+
+            xpath = expressions.join(' | ').to_s
+
+            xpath = index ? add_index(xpath, index) : xpath
+
+            @selector.merge! @requires_matches
+
+            {xpath: xpath}
+          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
+            @requires_matches[: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/text_area/selector_builder.rb

@@ -4,7 +4,7 @@ module Watir
       class SelectorBuilder < Element::SelectorBuilder
         private
 
-        def normalize_selector(how, what)
+        def normalize_locator(how, what)
           # We need to iterate through located elements and fetch
           # attribute value using Selenium because XPath doesn't understand
           # difference between IDL vs content attribute.

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

@@ -0,0 +1,19 @@
+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 predicate_conversion(key, regexp)
+            return super unless key == :value
+
+            @requires_matches[:value] = regexp
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,20 +8,23 @@ module Watir
           # force Watir usage
         end
 
-        def matches_selector?(element, rx_selector)
-          rx_selector = rx_selector.dup
+        def matches_values?(element, rx_selector)
+          conversions = %i[text value label visible_text] & rx_selector.keys
 
-          tag_name = element.tag_name.downcase
+          tag_name = nil
 
-          %i[text value label].each do |key|
-            if rx_selector.key?(key)
-              correct_key = tag_name == 'input' ? :value : :text
-              rx_selector[correct_key] = rx_selector.delete(key)
-            end
+          conversions.each do |key|
+            tag_name ||= element.tag_name.downcase
+            correct_key = tag_name == 'input' ? :value : :text
+            rx_selector[correct_key] = rx_selector.delete(key)
           end
 
           super
         end
+
+        def text_regexp_deprecation(*)
+          # does not apply to text_field
+        end
       end
     end
   end

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

@@ -2,29 +2,6 @@ module Watir
   module Locators
     class TextField
       class SelectorBuilder < Element::SelectorBuilder
-        def build_wd_selector(selectors)
-          return if selectors.values.any? { |e| e.is_a? Regexp }
-
-          selectors.delete(:tag_name)
-
-          input_attr_exp = xpath_builder.attribute_expression(:input, selectors)
-
-          xpath = ".//input[(not(@type) or (#{negative_type_expr}))"
-          xpath << " and #{input_attr_exp}" unless input_attr_exp.empty?
-          xpath << ']'
-
-          p build_wd_selector: xpath if $DEBUG
-
-          [:xpath, xpath]
-        end
-
-        private
-
-        def negative_type_expr
-          Watir::TextField::NON_TEXT_TYPES.map { |type|
-            format('%s!=%s', XpathSupport.downcase('@type'), type.inspect)
-          }.join(' and ')
-        end
       end
     end
   end

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

@@ -3,13 +3,42 @@ module Watir
     class TextField
       class SelectorBuilder
         class XPath < Element::SelectorBuilder::XPath
-          def lhs_for(building, key)
-            if building == :input && key == :text
-              '@value'
+          def text_string
+            return super if @adjacent
+
+            @requires_matches[:text] = @selector.delete(:text) if @selector.key?(:text)
+            ''
+          end
+
+          def additional_string
+            return '' if @adjacent
+
+            type_string(@selector.delete(:type))
+          end
+
+          def tag_string
+            @selector[:tag_name] = 'input' unless @adjacent
+            super
+          end
+
+          def type_string(type)
+            if type.eql?(true)
+              "[#{negative_type_text}]"
+            elsif Watir::TextField::NON_TEXT_TYPES.include?(type)
+              msg = "TextField Elements can not be located by type: #{type}"
+              raise LocatorException, msg
+            elsif type.nil?
+              "[not(@type) or (#{negative_type_text})]"
             else
-              super
+              "[#{process_attribute(:type, type)}]"
             end
           end
+
+          def negative_type_text
+            Watir::TextField::NON_TEXT_TYPES.map { |type|
+              "#{lhs_for(:type, true)}!=#{SelectorBuilder::XpathSupport.escape type}"
+            }.join(' and ')
+          end
         end
       end
     end

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

@@ -2,10 +2,10 @@ module Watir
   module Locators
     class TextField
       class Validator < Element::Validator
-        def validate(element, _selector)
-          return unless element.tag_name.casecmp('input').zero?
-
-          element
+        def validate(element, _tag_name)
+          # Zero for Ruby 2.3, Ruby 2.4+ this evaluates true/false
+          result = element.tag_name.casecmp('input')
+          result.zero? || result.eq(true)
         end
       end
     end

data/lib/watir/radio_set.rb

@@ -1,7 +1,7 @@
 module Watir
   class RadioSet
     extend Forwardable
-    include Watir::Exception
+    include Exception
     include Enumerable
 
     delegate %i[exists? present? visible? browser] => :source
@@ -12,7 +12,7 @@ module Watir
       raise ArgumentError, "invalid argument: #{selector.inspect}" unless selector.is_a? Hash
 
       @source = Radio.new(query_scope, selector)
-      @frame = @source.parent(tag_name: :form)
+      @frame = @source.parent(tag_name: 'form')
     end
 
     #
@@ -52,7 +52,7 @@ module Watir
       elsif n.empty?
         return source
       else
-        raise Watir::Exception::UnknownObjectException, "#{opt[:name]} does not match name of RadioSet: #{n}"
+        raise UnknownObjectException, "#{opt[:name]} does not match name of RadioSet: #{n}"
       end
     end
 
@@ -65,9 +65,9 @@ module Watir
       if !n.empty? && (!opt[:name] || opt[:name] == n)
         element_call(:wait_for_present) { frame.radios(opt.merge(name: n)) }
       elsif n.empty?
-        Watir::RadioCollection.new(frame, element: source.wd)
+        RadioCollection.new(frame, element: source.wd)
       else
-        raise Watir::Exception::UnknownObjectException, "#{opt[:name]} does not match name of RadioSet: #{n}"
+        raise UnknownObjectException, "#{opt[:name]} does not match name of RadioSet: #{n}"
       end
     end
 

data/lib/watir/row_container.rb

@@ -5,7 +5,7 @@ module Watir
     #
 
     def row(*args)
-      Row.new(self, extract_selector(args).merge(tag_name: 'tr'))
+      Row.new(self, extract_selector(args))
     end
 
     #
@@ -13,7 +13,7 @@ module Watir
     #
 
     def rows(*args)
-      RowCollection.new(self, extract_selector(args).merge(tag_name: 'tr'))
+      RowCollection.new(self, extract_selector(args))
     end
 
     #

data/lib/watir/user_editable.rb

@@ -33,7 +33,7 @@ module Watir
       append(input_value[-1])
       return if value == input_value
 
-      raise Watir::Exception::Error, "#set! value: '#{value}' does not match expected input: '#{input_value}'"
+      raise Exception::Error, "#set! value: '#{value}' does not match expected input: '#{input_value}'"
     end
 
     #
@@ -66,7 +66,7 @@ module Watir
       element_call { execute_js(:setText, @element, input_text) }
       return if text == input_text
 
-      raise Watir::Exception::Error, "#set! text: '#{text}' does not match expected input: '#{input_text}'"
+      raise Exception::Error, "#set! text: '#{text}' does not match expected input: '#{input_text}'"
     end
   end # UserEditable
 end # Watir

data/lib/watir/version.rb

@@ -1,3 +1,3 @@
 module Watir
-  VERSION = '6.14.0'.freeze
+  VERSION = '6.15.0'.freeze
 end

data/lib/watir/wait.rb

@@ -121,7 +121,7 @@ module Watir
 
       raise ArgumentError, "Unknown keyword(s): #{opt.keys} " if block_given? && !opt.empty?
 
-      proc = block_given? ? blk : create_proc(opt)
+      proc = create_proc(opt, &blk)
 
       Wait.until(timeout: timeout, message: message, interval: interval, object: self, &proc)
 
@@ -151,9 +151,7 @@ module Watir
       end
       message ||= proc { |obj| "waiting for false condition on #{obj.inspect}" }
 
-      raise ArgumentError, "Unknown keyword(s): #{opt.keys} " if block_given? && !opt.empty?
-
-      proc = block_given? ? blk : create_proc(opt)
+      proc = create_proc(opt, &blk)
 
       Wait.while(timeout: timeout, message: message, interval: interval, object: self, &proc)
 
@@ -176,22 +174,13 @@ module Watir
     #
 
     def wait_until_present(depr_timeout = nil, timeout: nil, interval: nil, message: nil)
-      if depr_timeout
-        Watir.logger.deprecate 'Using arguments for #wait_until_present', 'keywords', ids: [:timeout_arguments]
-        timeout = depr_timeout
-      end
-      if is_a? Watir::Element
-        message ||= proc { |obj| "waiting for element #{obj.inspect} to become present" }
-        wait_until(timeout: timeout, interval: interval, message: message) do
-          reset! if is_a? Watir::Element
-          present?
-        end
-      else
-        Watir.logger.deprecate "#{self.class}#wait_until_present",
-                               "#{self.class}#wait_until(&:present?)",
-                               ids: [:wait_until_present]
-        wait_until(timeout: timeout, interval: interval, message: message, &:present?)
-      end
+      timeout = depr_timeout if depr_timeout
+      Watir.logger.deprecate "#{self.class}#wait_until_present",
+                             "#{self.class}#wait_until(&:present?)",
+                             ids: [:wait_until_present]
+
+      message ||= proc { |obj| "waiting for #{obj.inspect} to become present" }
+      wait_until(timeout: timeout, interval: interval, message: message, &:present?)
     end
 
     #
@@ -210,31 +199,29 @@ module Watir
     #
 
     def wait_while_present(depr_timeout = nil, timeout: nil, interval: nil, message: nil)
-      if depr_timeout
-        Watir.logger.deprecate 'Using arguments for #wait_while_present', 'keywords', ids: [:timeout_arguments]
-        timeout = depr_timeout
-      end
-      if is_a? Watir::Element
-        message ||= proc { |obj| "waiting for element #{obj.inspect} not to be present" }
-        wait_while(timeout: timeout, interval: interval, message: message) do
-          reset! if is_a? Watir::Element
-          present?
-        end
-      else
-        Watir.logger.deprecate "#{self.class}#wait_while_present",
-                               "#{self.class}#wait_while(&:present?)",
-                               ids: [:wait_while_present]
-        wait_while(timeout: timeout, interval: interval, message: message, &:present?)
-      end
+      timeout = depr_timeout if depr_timeout
+      Watir.logger.deprecate "#{self.class}#wait_while_present",
+                             "#{self.class}#wait_while(&:present?)",
+                             ids: [:wait_while_present]
+
+      message ||= proc { |obj| "waiting for #{obj.inspect} not to be present" }
+      wait_while(timeout: timeout, interval: interval, message: message, &:present?)
     end
 
     private
 
     def create_proc(opt)
+      proc do
+        reset! if is_a?(Element)
+        (opt.empty? || match_attributes(opt).call) && (!block_given? || yield(self))
+      end
+    end
+
+    def match_attributes(opt)
       proc do
         opt.keys.all? do |key|
           expected = opt[key]
-          actual = if is_a?(Watir::Element) && !respond_to?(key)
+          actual = if is_a?(Element) && !respond_to?(key)
                      attribute_value(key)
                    else
                      send(key)