watir 6.15.0 → 6.15.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d985e9510a911174b9ba60c5d3174eb67fc612b5
-  data.tar.gz: f7a5ba01ad7bea4f7fe8222c55f571e5340d8725
+  metadata.gz: 8c5ac0f3aeeeec1422ef300b30ffc292113a053e
+  data.tar.gz: a12b41e42257e86152ffb7e8b3c4e5777e657acf
 SHA512:
-  metadata.gz: 4ba1c06f7bfeaa9c8ac573ca2b023a23dc5222741d925db41d77e72bfaeb46d5a7f217560337d1afbf8e8d9204b050dcded5ff50218ba5129ba48ceff3adf3db
-  data.tar.gz: 98e3d14ab62868105c6e7af9108fbfd341fbc6f181baae28235b2aca8bafdad9c0c9e9b5c664c809a69bb84b80320e08adfd217751df0f4a87f2c30b794b5a04
+  metadata.gz: 057b9175188bef9121cb6bd5970db44ef90119e57e0c910c4fcec06762f66b9a8f8eebccc627826da31ba40bba0cf999fcf4110d07273b120879f3e93a3f7112
+  data.tar.gz: c7e93f0e181b4c11d3b20d7bd91e5a9f3fb4bb0fe8c0a98ad49a8daee676cf8fa35cb41c5d622714c6ee4c5dfc991b6dfbf010bd885b132e55d25d4d7df8c276

data/.rubocop.yml

@@ -35,6 +35,10 @@ Lint/HandleExceptions:
   Exclude:
     - 'lib/watirspec.rb'
 
+Lint/UnifiedInteger:
+  Exclude:
+  - 'lib/watir/locators/element/selector_builder.rb'
+
 # Configuration parameters: CountComments, ExcludedMethods.
 # ExcludedMethods: refine
 Metrics/BlockLength:

data/.travis.yml

@@ -20,13 +20,13 @@ script: bundle exec rake $RAKE_TASK
 _version:
   three: &three
     language: ruby
-    rvm: 2.3.7
+    rvm: 2.3.8
   four: &four
     language: ruby
-    rvm: 2.4.4
+    rvm: 2.4.5
   five: &five
     language: ruby
-    rvm: 2.5.1
+    rvm: 2.5.3
 
 _browsers:
   firefox: &firefox-latest

data/CHANGES.md

@@ -1,3 +1,11 @@
+### 6.15.1 (2018-12-04)
+
+* Locator value type check error message now returns array of allowed class types
+* Wire calls for `:label` locator happen after Selector is built
+* Improve error message for `Watir::Option` element when not found (#823)
+* Wrap `#wd` with `#element_call` to wait for element to exist (#813)
+* Remove automatic element reset in wait loop (#819)
+
 ### 6.15.0 (2018-11-07)
 
 * Add `Element#selected_text`

data/lib/watir/elements/element.rb

@@ -436,8 +436,7 @@ module Watir
     #
 
     def wd
-      assert_exists
-      @element
+      element_call { @element }
     end
 
     #

data/lib/watir/elements/select.rb

@@ -159,7 +159,7 @@ module Watir
         return selected_options.first.text if matching_option?(approach.downcase, str_or_rx)
       end
 
-      raise NoValueFoundException, "#{str_or_rx.inspect} not found in select list"
+      raise_no_value_found(str_or_rx)
     end
 
     def process_str_or_rx(str_or_rx)
@@ -213,9 +213,13 @@ module Watir
       # TODO: Remove conditional when remove relaxed_locate toggle
       return @found unless @found.empty?
 
-      raise NoValueFoundException, "#{str_or_rx.inspect} not found in select list"
+      raise_no_value_found(str_or_rx)
     rescue Wait::TimeoutError
-      raise NoValueFoundException, "#{str_or_rx.inspect} not found in select list"
+      raise_no_value_found(str_or_rx)
+    end
+
+    def raise_no_value_found(str_or_rx)
+      raise NoValueFoundException, "#{str_or_rx.inspect} not found in #{inspect}"
     end
 
     def select_matching(elements)

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

@@ -32,7 +32,7 @@ module Watir
             string << " and (#{input_types(type)})"
             if text
               string << " and #{process_attribute(:value, text)}"
-              @requires_matches.delete(:value)
+              @built.delete(:value)
             end
             string
           end
@@ -49,7 +49,7 @@ module Watir
               ''
             when Regexp
               res = "[#{predicate_conversion(:text, value)} or #{predicate_conversion(:value, value)}]"
-              @requires_matches.delete(:text)
+              @built.delete(:text)
               res
             else
               "[#{predicate_expression(:text, value)} or #{predicate_expression(:value, value)}]"
@@ -58,7 +58,7 @@ module Watir
 
           def predicate_conversion(key, regexp)
             res = key == :text ? super(:contains_text, regexp) : super
-            @requires_matches[key] = @requires_matches.delete(:contains_text) if @requires_matches.key?(:contains_text)
+            @built[key] = @built.delete(:contains_text) if @built.key?(:contains_text)
             res
           end
 

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

@@ -51,33 +51,30 @@ module Watir
         end
 
         def using_watir(filter = :first)
-          raise ArgumentError, "can't locate all elements by :index" if @selector.key?(:index) && filter == :all
+          selector = @selector.dup
+          raise ArgumentError, "can't locate all elements by :index" if selector.key?(:index) && filter == :all
 
-          begin
-            generate_scope
-          rescue LocatorException
-            return nil
-          end
+          @driver_scope ||= @query_scope.wd
+
+          built = selector_builder.build(selector)
 
-          selector, values_to_match = selector_builder.build(@selector)
+          validate_built_selector(built)
 
-          validate_built_selector(selector, values_to_match)
+          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(selector, values_to_match, filter)
+            locate_matching_elements(wd_locator, values_to_match, filter)
           else
-            locate_element(selector.keys.first, selector.values.first, @driver_scope)
+            locate_element(wd_locator.keys.first, wd_locator.values.first, @driver_scope)
           end
         end
 
-        def validate_built_selector(selector, values_to_match)
-          if selector.nil?
-            msg = "#{selector_builder.class} was unable to build selector from #{@selector.inspect}"
-            raise LocatorException, msg
-          elsif values_to_match.nil?
-            msg = "#{selector_builder.class}#build is not returning expected responses for the current version of Watir"
-            raise LocatorException, msg
-          end
+        def validate_built_selector(built)
+          return unless built.nil? || built.empty?
+
+          msg = "#{selector_builder.class} was unable to build selector from #{@selector.inspect}"
+          raise LocatorException, msg
         end
 
         def fetch_value(element, how)
@@ -98,6 +95,19 @@ module Watir
           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)
@@ -124,44 +134,6 @@ module Watir
           idx.abs - 1
         end
 
-        def generate_scope
-          return @driver_scope if @driver_scope
-
-          @driver_scope = @query_scope.wd
-
-          if @selector.key?(:label)
-            process_label :label
-          elsif @selector.key?(:visible_label)
-            process_label :visible_label
-          end
-        end
-
-        def process_label(label_key)
-          regexp = @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)
-          msg = "Unable to locate element with label #{label_key}: #{@selector[label_key]}"
-          raise LocatorException, msg unless label
-
-          id = label.attribute('for')
-          if id
-            @selector[:id] = id
-          else
-            @driver_scope = label
-          end
-        end
-
-        def label_from_text(label_key)
-          # TODO: this won't work correctly if @wd is a sub-element, write spec
-          # TODO: Figure out how to do this with find_element
-          label_text = @selector.delete(label_key)
-          locator_key = label_key.to_s.gsub('label', 'text').gsub('_element', '').to_sym
-          locate_elements(:tag_name, 'label', @driver_scope).find do |el|
-            matches_values?(el, locator_key => label_text)
-          end
-        end
-
         def matches_values?(element, values_to_match)
           matches = values_to_match.all? do |how, what|
             if how == :tag_name && what.is_a?(String)
@@ -201,6 +173,9 @@ module Watir
           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)
           rescue Selenium::WebDriver::Error::StaleElementReferenceError
             retries += 1

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

@@ -5,8 +5,16 @@ module Watir
         include Exception
         attr_reader :custom_attributes
 
-        VALID_WHATS = [String, Regexp, TrueClass, FalseClass].freeze
-        WILDCARD_ATTRIBUTE = /^(aria|data)_(.+)$/
+        WILDCARD_ATTRIBUTE = /^(aria|data)_(.+)$/.freeze
+        INTEGER_CLASS = Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.4') ? Fixnum : Integer
+        VALID_WHATS = Hash.new([String, Regexp, TrueClass, FalseClass]).merge(adjacent: [::Symbol],
+                                                                              xpath: [String],
+                                                                              css: [String],
+                                                                              index: [INTEGER_CLASS],
+                                                                              visible: [TrueClass, FalseClass],
+                                                                              tag_name: [String, Regexp, ::Symbol],
+                                                                              visible_text: [String, Regexp],
+                                                                              text: [String, Regexp]).freeze
 
         def initialize(valid_attributes)
           @valid_attributes = valid_attributes
@@ -18,21 +26,16 @@ module Watir
           @selector = selector
           normalize_selector
 
-          xpath_css = (@selector.keys & %i[xpath css]).each_with_object({}) do |key, hash|
-            hash[key] = @selector.delete(key)
-          end
+          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
 
-          built = if xpath_css.empty?
-                    build_wd_selector(@selector)
-                  else
-                    process_xpath_css(xpath_css)
-                    xpath_css
-                  end
+          built = xpath_css.empty? ? build_wd_selector(@selector) : @selector
 
-          @selector.delete(:index) if @selector[:index]&.zero?
+          built.delete(:index) if built[:index]&.zero?
 
           Watir.logger.debug "Converted #{inspected} to #{built}, with #{@selector.inspect} to match"
-          [built, @selector]
+          built
         end
 
         def normalize_selector
@@ -53,33 +56,14 @@ module Watir
         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
-            return raise_unless(what, Integer)
-          when :visible
-            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
-          end
-
-          return if VALID_WHATS.any? { |t| what.is_a? t }
+          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?
 
-          raise TypeError, "expected one of #{VALID_WHATS.inspect}, got #{what.inspect}:#{what.class}"
+            classes.each { |value| raise_unless(value, VALID_WHATS[how]) }
+          else
+            raise_unless(what, VALID_WHATS[how])
+          end
         end
 
         def should_use_label_element?
@@ -91,14 +75,14 @@ module Watir
         def normalize_locator(how, what)
           case how
           when 'text'
-            Watir.logger.deprecate "String 'text' as a locator", 'Symbol :text', ids: ['text_string']
+            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
+          when :label, :visible_label
             if should_use_label_element?
               ["#{how}_element".to_sym, what]
             else
@@ -122,15 +106,6 @@ module Watir
           @custom_attributes << attribute.to_s
         end
 
-        def process_xpath_css(xpath_css)
-          raise LocatorException, ":xpath and :css cannot be combined (#{xpath_css})" if xpath_css.size > 1
-
-          return if combine_with_xpath_or_css?(@selector)
-
-          msg = "#{xpath_css.keys.first} cannot be combined with all of these locators (#{@selector.inspect})"
-          raise LocatorException, msg
-        end
-
         # Implement this method when creating a different selector builder
         def build_wd_selector(selector)
           Kernel.const_get("#{self.class.name}::XPath").new.build(selector)
@@ -152,19 +127,10 @@ module Watir
           end
         end
 
-        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 #{type}, got #{what.inspect}:#{what.class}"
+        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

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

@@ -6,12 +6,12 @@ module Watir
           include Exception
           include XpathSupport
 
-          CAN_NOT_BUILD = %i[visible visible_text].freeze
+          CAN_NOT_BUILD = %i[visible visible_text visible_label_element].freeze
 
           def build(selector)
             @selector = selector
 
-            @requires_matches = (@selector.keys & CAN_NOT_BUILD).each_with_object({}) do |key, hash|
+            @built = (@selector.keys & CAN_NOT_BUILD).each_with_object({}) do |key, hash|
               hash[key] = @selector.delete(key)
             end
 
@@ -24,13 +24,11 @@ module Watir
             xpath << class_string
             xpath << text_string
             xpath << additional_string
+            xpath << label_element_string
             xpath << attribute_string
 
-            xpath = index ? add_index(xpath, index) : xpath
-
-            @selector.merge! @requires_matches
-
-            {xpath: xpath}
+            @built[:xpath] = index ? add_index(xpath, index) : xpath
+            @built
           end
 
           private
@@ -108,11 +106,11 @@ module Watir
 
             deprecate_class_array(class_name) if class_name.is_a?(String) && class_name.strip.include?(' ')
 
-            @requires_matches[:class] = []
+            @built[:class] = []
 
             predicates = [class_name].flatten.map { |value| process_attribute(:class, value) }.compact
 
-            @requires_matches.delete(:class) if @requires_matches[:class].empty?
+            @built.delete(:class) if @built[:class].empty?
 
             predicates.empty? ? '' : "[#{predicates.join(' and ')}]"
           end
@@ -124,13 +122,38 @@ module Watir
             when nil
               ''
             when Regexp
-              @requires_matches[:text] = text
+              @built[:text] = text
               ''
             else
               "[#{predicate_expression(:text, text)}]"
             end
           end
 
+          def label_element_string
+            label = @selector.delete :label_element
+
+            return '' if label.nil?
+
+            key = label.is_a?(Regexp) ? :contains_text : :text
+
+            value = process_attribute(key, label)
+
+            @built[:label_element] = @built.delete :contains_text if @built.key?(:contains_text)
+
+            # TODO: This conditional can be removed when we remove this deprecation
+            if label.is_a?(Regexp)
+              if @built.key?(:label_element)
+                dep = "Using :label locator with RegExp #{label} to match an element that includes hidden text"
+                Watir.logger.deprecate(dep, ":visible_#{key}", ids: [:text_regexp])
+              end
+
+              @built[:label_element] = label
+              ''
+            else
+              "[@id=//label[#{value}]/@for or parent::label[#{value}]]"
+            end
+          end
+
           def attribute_string
             attributes = @selector.keys.map { |key|
               process_attribute(key, @selector.delete(key))
@@ -143,18 +166,17 @@ module Watir
             ''
           end
 
-          # TODO: Remove this on refactor of index
           def add_index(xpath, index)
             if @adjacent
               "#{xpath}[#{index + 1}]"
-            elsif index&.positive? && @requires_matches.empty?
+            elsif index&.positive? && @built.empty?
               "(#{xpath})[#{index + 1}]"
-            elsif index&.negative? && @requires_matches.empty?
+            elsif index&.negative? && @built.empty?
               last_value = 'last()'
               last_value << (index + 1).to_s if index < -1
               "(#{xpath})[#{last_value}]"
             else
-              @requires_matches[:index] = index
+              @built[:index] = index
               xpath
             end
           end
@@ -167,7 +189,7 @@ module Watir
           end
 
           def visible?
-            !(@requires_matches.keys & CAN_NOT_BUILD).empty?
+            !(@built.keys & CAN_NOT_BUILD).empty?
           end
 
           def starts_with?(results, regexp)
@@ -178,9 +200,9 @@ module Watir
             return unless results.nil? || requires_matching?(results, regexp)
 
             if key == :class
-              @requires_matches[key] << regexp
+              @built[key] << regexp
             else
-              @requires_matches[key] = regexp
+              @built[key] = regexp
             end
           end
 
@@ -218,11 +240,7 @@ module Watir
           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
+            if key == :class
               negate_xpath = value =~ /^!/ && value.slice!(0)
               expression = "contains(concat(' ', @class, ' '), #{XpathSupport.escape " #{value} "})"