watir 6.9.1 → 6.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: df2330f15858aff8a2b86569ddc5d912bf98b0a0
-  data.tar.gz: '087b9e1452a7aba1db5ca249f37d0a54652a8b72'
+  metadata.gz: ec3596aac49e15a562c7085702a1e246fa0abb5e
+  data.tar.gz: c2d652b8c6de8895b0004581ca07fc69e42d4d8f
 SHA512:
-  metadata.gz: c9e0205fed4dda96b3fbff910a607cff10df4043c5c3c16c6a28a51d4ff46d6567a7ff14f1aa2707b4568e81e23a6d58ed7ad831174081964e3d01c398e1a5dc
-  data.tar.gz: b481f2d349f880e1c23d7d74a5309848200da4e311e158ad1b592f7ac680c894183336b7499b88543702f458a62eea5cc456404e4d812ecc7fd33d5a0f151102
+  metadata.gz: f8a5cca75e7d14deaaa47f6eba851a2ff082b6522bfef4f7d2b485f97040e2086142d58641ee51939e320c272bbc5a7fb3a6325b99db1c9cbbfc368b2ef95eb2
+  data.tar.gz: fe12a324b627005ddd14f8473c00f7b8fd6fa3ccac864196af5220cdbd07aaf9150bbe52d87e148b5741dae2b50735fcf6c28b7ac69324b55fd662975f3382a4

data/CHANGES.md

@@ -1,3 +1,11 @@
+### 6.10.0 (2017-11-23)
+
+* Add support for locating elements with custom attributes
+* Add new `:visible_text` locator (thanks Justin Ko)
+* Deprecate Selenium locators `:link`, `:link_text` and `:partial_link_text` in favor of `:visible_text`
+* Deprecate finding only visible text for `RegExp` values on `:text` locator (#342)
+* Improve support for finding elements with `:tag_name` along with `:xpath` or `:css` locators
+
 ### 6.9.1 (2017-11-20)
 
 * Fix bug preventing the use of `#exectue_script` in `AfterHook` (#684)

data/lib/watir/capabilities.rb

@@ -50,7 +50,7 @@ module Watir
 
       %i(open_timeout read_timeout client_timeout).each do |t|
         next if http_client.nil? || !respond_to?(t)
-        warn "You can now pass #{t} value directly into Watir::Browser opt without needing to use :http_client"
+        Watir.logger.warn "You can now pass #{t} value directly into Watir::Browser opt without needing to use :http_client"
       end
 
       http_client ||= Selenium::WebDriver::Remote::Http::Default.new
@@ -111,7 +111,7 @@ module Watir
       caps = @options.delete(:desired_capabilities)
 
       if caps
-        warn 'You can now pass values directly into Watir::Browser opt without needing to use :desired_capabilities'
+        Watir.logger.warn 'You can now pass values directly into Watir::Browser opt without needing to use :desired_capabilities'
         @selenium_opts.merge!(@options)
       else
         caps = Selenium::WebDriver::Remote::Capabilities.send @browser, @options

data/lib/watir/elements/element.rb

@@ -587,9 +587,9 @@ module Watir
 
       element_validator = element_validator_class.new
       selector_builder = selector_builder_class.new(@query_scope, @selector.dup, self.class.attribute_list)
-      locator = locator_class.new(@query_scope, @selector.dup, selector_builder, element_validator)
+      @locator = locator_class.new(@query_scope, @selector.dup, selector_builder, element_validator)
 
-      @element = locator.locate
+      @element = @locator.locate
     end
 
     def selector_string
@@ -657,7 +657,9 @@ module Watir
         yield
       rescue unknown_exception => ex
         msg = ex.message
-        msg += ". Maybe look in an iframe?" if @query_scope.iframes.count > 0
+        msg += "; Maybe look in an iframe?" if @query_scope.iframes.count > 0
+        custom_attributes = @locator.selector_builder.custom_attributes
+        msg += "; Watir treated #{custom_attributes} as a non-HTML compliant attribute, ensure that was intended" unless custom_attributes.empty?
         raise unknown_exception, msg
       rescue Selenium::WebDriver::Error::StaleElementReferenceError
         retry

data/lib/watir/elements/iframe.rb

@@ -8,9 +8,9 @@ module Watir
       selector = @selector.merge(tag_name: frame_tag)
       element_validator = element_validator_class.new
       selector_builder = selector_builder_class.new(@query_scope, selector, self.class.attribute_list)
-      locator = locator_class.new(@query_scope, selector, selector_builder, element_validator)
+      @locator = locator_class.new(@query_scope, selector, selector_builder, element_validator)
 
-      element = locator.locate
+      element = @locator.locate
       element or raise unknown_exception, "unable to locate #{@selector[:tag_name]} using #{selector_string}"
 
       @element = FramedDriver.new(element, browser)

data/lib/watir/exception.rb

@@ -7,7 +7,6 @@ module Watir
     class ObjectDisabledException < Error; end
     class ObjectReadOnlyException < Error; end
     class NoValueFoundException < Error; end
-    class MissingWayOfFindingObjectException < Error; end
     class UnknownCellException < Error; end
     class NoMatchingWindowFoundException < Error; end
     class UnknownFrameException < Error; end

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

@@ -2,19 +2,12 @@ module Watir
   module Locators
     class Button
       class Locator < Element::Locator
-        def locate_all
-          find_all_by_multiple
-        end
 
-        private
 
-        def wd_find_first_by(how, what)
-          if how == :tag_name
-            how  = :xpath
-            what = ".//button | .//input[#{selector_builder.xpath_builder.attribute_expression(:input, type: Watir::Button::VALID_TYPES)}]"
-          end
+        private
 
-          super
+        def using_selenium(*)
+          # force watir usage
         end
 
         def can_convert_regexp_to_contains?

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

@@ -2,7 +2,7 @@ module Watir
   module Locators
     class Button
       class Validator < Element::Validator
-        def validate(element, selector)
+        def validate(element, _selector)
           return unless %w[input button].include?(element.tag_name.downcase)
           # TODO - Verify this is desired behavior based on https://bugzilla.mozilla.org/show_bug.cgi?id=1290963
           return if element.tag_name.downcase == "input" && !Watir::Button::VALID_TYPES.include?(element.attribute(:type).downcase)

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

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

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

@@ -36,124 +36,82 @@ module Watir
         end
 
         def locate
-          e = by_id and return e # short-circuit if :id is given
-
-          element = if @selector.size == 1
-                      find_first_by_one
-                    else
-                      find_first_by_multiple
-                    end
-
-          # Validation not necessary if Watir builds the xpath
-          return element unless @selector.key?(:xpath) || @selector.key?(:css)
-          element_validator.validate(element, @selector) if element
+          using_selenium(:first) || using_watir(:first)
         rescue Selenium::WebDriver::Error::NoSuchElementError, Selenium::WebDriver::Error::StaleElementReferenceError
           nil
         end
 
         def locate_all
-          if @selector.size == 1
-            find_all_by_one
-          else
-            find_all_by_multiple
-          end
+          return [@selector[:element]] if @selector.key?(:element)
+          using_selenium(:all) || using_watir(:all)
         end
 
         private
 
-        def by_id
+        def using_selenium(filter = :first)
           selector = @selector.dup
-          id = selector.delete(:id)
-          return if !id.is_a?(String) || selector[:adjacent]
-
-          tag_name = selector.delete(:tag_name)
-          return unless selector.empty? # multiple attributes
-
-          element = locate_element(:id, id)
-          return if tag_name && !element_validator.validate(element, {tag_name: tag_name})
-
-          element
-        end
-
-        def find_first_by_one
-          how, what = @selector.to_a.first
-          selector_builder.check_type(how, what)
-
-          if wd_supported?(how, what)
-            wd_find_first_by(how, what)
-          else
-            find_first_by_multiple
+          tag_name = selector[:tag_name].is_a?(::Symbol) ? selector[:tag_name].to_s : selector[:tag_name]
+          selector.delete(:tag_name) if selector.size > 1
+
+          WD_FINDERS.each do |sel|
+            next unless (value = selector.delete(sel))
+            return unless selector.empty? && wd_supported?(sel, value)
+            if filter == :all
+              found = locate_elements(sel, value)
+              return filter_elements_by_locator(found, tag_name: tag_name, filter: filter).compact
+            else
+              found = locate_element(sel, value)
+              return sel != :tag_name && tag_name && !validate([found], tag_name) ? nil : found
+            end
           end
+          nil
         end
 
-        def find_first_by_multiple
+        def using_watir(filter = :first)
           selector = selector_builder.normalized_selector
+          visible = selector.delete(:visible)
+          visible_text = selector.delete(:visible_text)
+          tag_name = selector[:tag_name].is_a?(::Symbol) ? selector[:tag_name].to_s : selector[:tag_name]
+          validation_required = (selector.key?(:css) || selector.key?(:xpath)) && tag_name
 
+          if selector.key?(:index) && filter == :all
+            raise ArgumentError, "can't locate all elements by :index"
+          end
           idx = selector.delete(:index) unless selector[:adjacent]
-          visible = selector.delete(:visible)
 
           how, what = selector_builder.build(selector)
 
-          if how
-            # could build xpath/css for selector
-            if idx && idx != 0 || !visible.nil?
-              elements = locate_elements(how, what)
-              filter_elements elements, visible, idx, :single
-            else
-              locate_element(how, what)
-            end
-          else
-            # can't use xpath, probably a regexp in there
-            if idx && idx != 0 || !visible.nil?
-              elements = wd_find_by_regexp_selector(selector, :select)
-              filter_elements elements, visible, idx, :single
-            else
-              wd_find_by_regexp_selector(selector, :find)
-            end
-          end
-        end
+          needs_filtering = idx && idx != 0 || !visible.nil? || !visible_text.nil? || validation_required || filter == :all
 
-        def find_all_by_one
-          how, what = @selector.to_a.first
-          return [what] if how == :element
-          selector_builder.check_type how, what
-
-          if wd_supported?(how, what)
-            wd_find_all_by(how, what)
+          if needs_filtering
+            matching = matching_elements(how, what, selector)
+            return filter_elements_by_locator(matching, visible, visible_text, idx, tag_name: tag_name, filter: filter)
+          elsif how
+            locate_element(how, what)
           else
-            find_all_by_multiple
+            wd_find_by_regexp_selector(selector, :first)
           end
         end
 
-        def find_all_by_multiple
-          selector = selector_builder.normalized_selector
-          visible = selector.delete(:visible)
-
-          if selector.key? :index
-            raise ArgumentError, "can't locate all elements by :index"
-          end
-
-          how, what = selector_builder.build(selector)
-          found = if how
-                    locate_elements(how, what)
-                  else
-                    wd_find_by_regexp_selector(selector, :select)
-                  end
-          return [] if found.nil?
-          filter_elements found, visible, nil, :multiple
+        def validate(elements, tag_name)
+          elements.compact.all? { |element| element_validator.validate(element, {tag_name: tag_name}) }
         end
 
-        def wd_find_all_by(how, what)
-          if what.is_a? String
-            locate_elements(how, what)
-          else
-            all_elements.select { |element| fetch_value(element, how) =~ what }
-          end
+        def matching_elements(how, what, selector = nil)
+          found = how ? locate_elements(how, what) : wd_find_by_regexp_selector(selector, :all)
+          found || []
         end
 
         def fetch_value(element, how)
           case how
           when :text
+            vis = element.text
+            all = Watir::Element.new(@query_scope, element: element).send(:execute_js, :getTextContent, element).strip
+            unless all == vis.strip
+              Watir.logger.deprecate(':text locator with RegExp values to find elements based on only visible text', ":visible_text")
+            end
+            vis
+          when :visible_text
             element.text
           when :tag_name
             element.tag_name.downcase
@@ -168,15 +126,7 @@ module Watir
           locate_elements(:xpath, ".//*")
         end
 
-        def wd_find_first_by(how, what)
-          if what.is_a? String
-            locate_element(how, what)
-          else
-            all_elements.find { |element| fetch_value(element, how) =~ what }
-          end
-        end
-
-        def wd_find_by_regexp_selector(selector, method = :find)
+        def wd_find_by_regexp_selector(selector, filter)
           query_scope = ensure_scope_context
           rx_selector = delete_regexps_from(selector)
 
@@ -205,15 +155,18 @@ module Watir
           end
 
           elements = locate_elements(how, what, query_scope)
-          filter_elements_by_regex(elements, rx_selector, method)
+          filter_elements_by_regex(elements, rx_selector, filter)
         end
 
-        def filter_elements elements, visible, idx, number
+        def filter_elements_by_locator(elements, visible = nil, visible_text = nil, idx = nil, tag_name: nil, filter: :first)
           elements.select! { |el| visible == el.displayed? } unless visible.nil?
-          number == :single ? elements[idx || 0] : elements
+          elements.select! { |el| visible_text === el.text } unless visible_text.nil?
+          elements.select! { |el| element_validator.validate(el, {tag_name: tag_name}) } unless tag_name.nil?
+          filter == :first ? elements[idx || 0] : elements
         end
 
-        def filter_elements_by_regex(elements, selector, method)
+        def filter_elements_by_regex(elements, selector, filter)
+          method = filter == :first ? :find : :select
           elements.__send__(method) { |el| matches_selector?(el, selector) }
         end
 
@@ -262,8 +215,8 @@ module Watir
           @query_scope.wd
         end
 
-        def locate_element(how, what)
-          @query_scope.wd.find_element(how, what)
+        def locate_element(how, what, scope = @query_scope.wd)
+          scope.find_element(how, what)
         end
 
         def locate_elements(how, what, scope = @query_scope.wd)
@@ -271,9 +224,12 @@ module Watir
         end
 
         def wd_supported?(how, what)
-          return false unless WD_FINDERS.include?(how)
-          return false unless what.kind_of?(String) || what.kind_of?(Regexp)
-          return false if [:class, :class_name].include?(how) && what.kind_of?(String) && what.include?(' ')
+          return false unless what.kind_of?(String)
+          return false if [:class, :class_name].include?(how) && what.include?(' ')
+          %i[partial_link_text link_text link].each do |loc|
+            next unless how == loc
+            Watir.logger.deprecate(":#{loc} locator", ':visible_text')
+          end
           true
         end
       end

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

@@ -2,6 +2,8 @@ module Watir
   module Locators
     class Element
       class SelectorBuilder
+        attr_reader :custom_attributes
+
         VALID_WHATS = [Array, String, Regexp, TrueClass, FalseClass, ::Symbol].freeze
         WILDCARD_ATTRIBUTE = /^(aria|data)_(.+)$/
 
@@ -9,6 +11,7 @@ module Watir
           @query_scope = query_scope # either element or browser
           @selector = selector
           @valid_attributes = valid_attributes
+          @custom_attributes = []
         end
 
         def normalized_selector
@@ -34,6 +37,10 @@ module Watir
             unless what.is_a?(TrueClass) || what.is_a?(FalseClass)
               raise TypeError, "expected TrueClass or FalseClass, got #{what.inspect}:#{what.class}"
             end
+          when :visible_text
+            unless what.is_a?(String) || what.is_a?(Regexp)
+              raise TypeError, "expected String or Regexp, got #{what.inspect}:#{what.class}"
+            end
           else
             if what.is_a?(Array) && how != :class && how != :class_name
               raise TypeError, "Only :class locator can have a value of an Array"
@@ -66,7 +73,7 @@ module Watir
 
         def normalize_selector(how, what)
           case how
-          when :tag_name, :text, :xpath, :index, :class, :label, :css, :visible, :adjacent
+          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'
             [how, what]
@@ -75,14 +82,14 @@ module Watir
           when :caption
             [:text, what]
           else
-            assert_valid_as_attribute how
+            check_custom_attribute how
             [how, what]
           end
         end
 
-        def assert_valid_as_attribute(attribute)
+        def check_custom_attribute(attribute)
           return if valid_attribute?(attribute) || attribute.to_s =~ WILDCARD_ATTRIBUTE
-          raise Exception::MissingWayOfFindingObjectException, "invalid attribute: #{attribute.inspect}"
+          @custom_attributes << attribute.to_s
         end
 
         def given_xpath_or_css(selector)

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

@@ -2,15 +2,13 @@ module Watir
   module Locators
     class Row
       class Locator < Element::Locator
-        def locate_all
-          find_all_by_multiple
-        end
 
         private
 
-        def by_id
-          nil # avoid this
+        def using_selenium(*)
+          # force Watir usage
         end
+
       end
     end
   end