watir 6.11.0.beta1 → 6.11.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 656aad05e0cbe7226f3576b88f5a65ed0959c3672b322a5252d73ac3856f0acd
-  data.tar.gz: 8112b892320b500fdf4cb113ea2b420b8f24b90509edc00367fcb20c264ca2ef
+  metadata.gz: 37e5bd05d8b6ed813503264d89bcaf6aceb4b67d5ad2217569c4aef4b7762ca5
+  data.tar.gz: 49c34f4a6e37dec3788fdc5c91ae3d06368b6b0d34c5365387e46d2ee07fe922
 SHA512:
-  metadata.gz: 79f71a31ac314000ed7d1633290a808824881c690c6e05bbb161dfa55e77ee38dc63b2a2ebaae5f2c0f6e68f951e3646450db998fa623f34f6ac7cf6ef525470
-  data.tar.gz: dba7348f6003bd93ec9ccf83a3d158f6c289a86ee80e09dac7a1487183583f2052762b5ba009da4c0eeaf9995a9b4fe9ed7d2027dc3d35d46836edeac5bac68c
+  metadata.gz: b654a96f43a8d9dc84645cc595c018a6263f180f3bd2e8dc20f03ed8ff2d43c135a267d0cf65f7c87c5cfe1ac9d3524cd438a77d13830ebfb179c9cbb4802693
+  data.tar.gz: d358cfee80f3afae74f39f8aa1d91ba9e98ed6d231735ab19d535ccb3932a0ef273e29e5749dc3ca51778c6220a58e84e5774a26e44403ab0c1592db5fc1ade3

data/CHANGES.md

@@ -1,3 +1,8 @@
+### 6.11.0.beta2 (2018-05-10)
+
+* Additional performance updates
+* Fix bug with error message of unlocated parent element (#706)
+
 ### 6.11.0.beta1 (2018-05-04)
 
 * Significant performance updates

data/lib/watir/element_collection.rb

@@ -45,7 +45,7 @@ module Watir
     #
 
     def [](idx)
-      to_a[idx] || element_class.new(@query_scope, @selector.merge(index: idx))
+      element_class.new(@query_scope, @selector.merge(index: idx))
     end
 
     #
@@ -121,13 +121,8 @@ module Watir
     private
 
     def elements
-      @query_scope.send :ensure_context
-
-      element_validator = element_validator_class.new
-      selector_builder = selector_builder_class.new(@query_scope, @selector, element_class.attribute_list)
-      locator = locator_class.new(@query_scope, @selector, selector_builder, element_validator)
-
-      @elements ||= locator.locate_all
+      @locator ||= build_locator
+      @elements ||= @locator.locate_all
     end
 
     def element_class

data/lib/watir/elements/element.rb

@@ -389,8 +389,8 @@ module Watir
     #
 
     def wd
-      return driver if @element.is_a? FramedDriver
       assert_exists if @element.nil?
+      return driver if @element.is_a? FramedDriver
       @element
     end
 
@@ -577,21 +577,12 @@ module Watir
     # Ensure that the element exists, making sure that it is not stale and located if necessary
     def assert_exists
       locate unless @element
-      assert_element_found
-    end
-
-    def assert_element_found
       return if @element
       raise unknown_exception, "unable to locate element: #{inspect}"
     end
 
     def locate
-      @query_scope.ensure_context
-
-      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 = build_locator
       @element = @locator.locate
     end
 
@@ -662,7 +653,7 @@ module Watir
         end
         msg = ex.message
         msg += "; Maybe look in an iframe?" if @query_scope.ensure_context && @query_scope.iframes.count > 0
-        custom_attributes = @locator.selector_builder.custom_attributes
+        custom_attributes = @locator.nil? ? [] : @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

data/lib/watir/locators.rb

@@ -55,6 +55,14 @@ module Watir
       def element_class_name
         element_class.to_s.split('::').last
       end
+
+      def build_locator
+        @query_scope.send :ensure_context
+
+        element_validator = element_validator_class.new
+        selector_builder = selector_builder_class.new(@query_scope, @selector.dup, element_class.attribute_list)
+        locator_class.new(@query_scope, @selector.dup, selector_builder, element_validator)
+      end
     end
   end
 end

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

@@ -5,14 +5,10 @@ module Watir
         attr_reader :selector_builder
         attr_reader :element_validator
 
-        WD_FINDERS = [
-          :class,
-          :class_name,
+        W3C_FINDERS = [
           :css,
-          :id,
           :link,
           :link_text,
-          :name,
           :partial_link_text,
           :tag_name,
           :xpath
@@ -49,53 +45,34 @@ module Watir
         private
 
         def using_selenium(filter = :first)
-          selector = @selector.dup
-          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 found if sel == :tag_name
-              filter_selector = tag_name ? {tag_name: tag_name} : {}
-              return filter_elements(found, filter_selector, 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
+          tag = @selector[:tag_name].is_a?(::Symbol) ? @selector.delete(:tag_name).to_s : @selector.delete(:tag_name)
+          return if @selector.size > 1
 
-        def using_watir(filter = :first)
-          query_scope = ensure_scope_context
-          selector = selector_builder.normalized_selector
+          how = @selector.keys.first || :tag_name
+          what = @selector.values.first || tag
 
-          if selector[:label]
-            query_scope = convert_label_to_scope_or_selector(query_scope, selector)
-            return unless query_scope # stop, label not found
-          end
+          return unless wd_supported?(how, what, tag)
 
-          if selector.key?(:index) && filter == :all
-            raise ArgumentError, "can't locate all elements by :index"
-          end
+          filter == :all ? locate_elements(how, what) : locate_element(how, what)
+        end
+
+        def using_watir(filter = :first)
+          create_normalized_selector(filter)
+          return unless @normalized_selector
 
-          filter_selector = delete_filters_from(selector)
+          create_filter_selector
 
-          how, what = selector_builder.build(selector)
+          how, what = selector_builder.build(@normalized_selector.dup)
           unless how
-            raise Error, "internal error: unable to build Selenium selector from #{selector.inspect}"
+            raise Error, "internal error: unable to build Selenium selector from #{@normalized_selector.inspect}"
           end
-          what = add_regexp_predicates(what, filter_selector) if how == :xpath
+          what = add_regexp_predicates(what) if how == :xpath
 
-          needs_filtering = filter == :all || !filter_selector.empty?
-          if needs_filtering
-            elements = locate_elements(how, what, query_scope) || []
-            filter_elements(elements, filter_selector, filter: filter)
+          if filter == :all || !@filter_selector.empty?
+            elements = locate_elements(how, what, @driver_scope) || []
+            filter_elements(elements, filter: filter)
           else
-            locate_element(how, what, query_scope)
+            locate_element(how, what, @driver_scope)
           end
         end
 
@@ -125,7 +102,8 @@ module Watir
           end
         end
 
-        def filter_elements(elements, selector, filter: :first)
+        def filter_elements(elements, filter: :first)
+          selector = @filter_selector.dup
           if filter == :first
             idx = selector.delete(:index) || 0
             if idx < 0
@@ -141,57 +119,79 @@ module Watir
           end
         end
 
-        def delete_filters_from(selector)
-          filter_selector = {}
+        def create_normalized_selector(filter)
+          return @normalized_selector if @normalized_selector
+          @driver_scope = ensure_scope_context
+
+          @normalized_selector = selector_builder.normalized_selector
+
+          if @normalized_selector[:label]
+            process_label
+            return if @normalized_selector.nil?
+          end
+
+          if @normalized_selector.key?(:index) && filter == :all
+            raise ArgumentError, "can't locate all elements by :index"
+          end
+          @normalized_selector
+        end
+
+        def create_filter_selector
+          return @filter_selector if @filter_selector
+          @filter_selector = {}
 
           # Remove selectors that can never be used in XPath builder
           [:visible, :visible_text].each do |how|
-            next unless selector.key?(how)
-            filter_selector[how] = selector.delete(how)
+            next unless @normalized_selector.key?(how)
+            @filter_selector[how] = @normalized_selector.delete(how)
           end
 
-          if tag_validation_required?(selector)
-            tag_name = selector[:tag_name].is_a?(::Symbol) ? selector[:tag_name].to_s : selector[:tag_name]
-            filter_selector[:tag_name] = tag_name
+          if tag_validation_required?(@normalized_selector)
+            tag_name = @normalized_selector[:tag_name].is_a?(::Symbol) ? @normalized_selector[:tag_name].to_s : @normalized_selector[:tag_name]
+            @filter_selector[:tag_name] = tag_name
           end
 
           # Regexp locators currently need to be validated even if they are included in the XPath builder
           # TODO: Identify Regexp that can have an exact equivalent using XPath contains (ie would not require
           #  filtering) vs approximations (ie would still requiring filtering)
-          selector.dup.each do |how, what|
+          @normalized_selector.each do |how, what|
             next unless what.is_a?(Regexp)
-            filter_selector[how] = selector.delete(how)
+            @filter_selector[how] = @normalized_selector.delete(how)
           end
 
-          if selector[:index] && !selector[:adjacent]
-            idx = selector.delete(:index)
+          if @normalized_selector[:index] && !@normalized_selector[:adjacent]
+            idx = @normalized_selector.delete(:index)
 
             # Do not add {index: 0} filter if the only filter. This will allow using #find_element instead of #find_elements.
-            implicit_idx_filter = filter_selector.empty? && idx == 0
-            filter_selector[:index] = idx unless implicit_idx_filter
+            implicit_idx_filter = @filter_selector.empty? && idx == 0
+            @filter_selector[:index] = idx unless implicit_idx_filter
           end
 
-          filter_selector
+          @filter_selector
         end
 
-        def convert_label_to_scope_or_selector(query_scope, selector)
-          return query_scope unless selector[:label].kind_of?(Regexp) && selector_builder.should_use_label_element?
+        def process_label
+          return unless @normalized_selector[:label].kind_of?(Regexp) && selector_builder.should_use_label_element?
 
-          label = label_from_text(selector.delete(:label))
-          return unless label # label not found, stop looking for element
+          label = label_from_text
+          unless label # label not found, stop looking for element
+            @normalized_selector = nil
+            return
+          end
 
           if (id = label.attribute('for'))
-            selector[:id] = id
-            query_scope
+            @normalized_selector[:id] = id
           else
-            label
+            @driver_scope = label
           end
         end
 
-        def label_from_text(label_exp)
-          # TODO: this won't work correctly if @wd is a sub-element
-          locate_elements(:tag_name, 'label').find do |el|
-            matches_selector?(el, text: label_exp)
+        def label_from_text
+          # 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 = @normalized_selector.delete(:label)
+          locate_elements(:tag_name, 'label', @driver_scope).find do |el|
+            matches_selector?(el, text: label_text)
           end
         end
 
@@ -209,10 +209,10 @@ module Watir
           true
         end
 
-        def add_regexp_predicates(what, filter_selector)
+        def add_regexp_predicates(what)
           return what unless can_convert_regexp_to_contains?
 
-          filter_selector.each do |key, value|
+          @filter_selector.each do |key, value|
             next if [:tag_name, :text, :visible_text, :visible, :index].include?(key)
 
             predicates = regexp_selector_to_predicates(key, value)
@@ -251,12 +251,17 @@ module Watir
           scope.find_elements(how, what)
         end
 
-        def wd_supported?(how, what)
+        def wd_supported?(how, what, tag)
+          return false unless W3C_FINDERS.include? how
           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')
+          if %i[partial_link_text link_text link].include?(how)
+            Watir.logger.deprecate(":#{how} locator", ':visible_text')
+            return true if [:a, :link, nil].include?(tag)
+            raise StandardError, "Can not use #{how} locator to find a #{what} element"
+          elsif how == :tag_name
+            return true
+          else
+            return false unless tag.nil?
           end
           true
         end

data/spec/element_locator_spec.rb

@@ -88,7 +88,6 @@ describe Watir::Locators::Element::Locator do
               element(tag_name: "div", attributes: { class: "foo" })
           ]
 
-          expect_one(:xpath, './/*[@class="foo"]').and_return(elements.first)
           expect_all(:xpath, './/*[@class="foo"]').and_return(elements)
 
           selector = {
@@ -337,7 +336,6 @@ describe Watir::Locators::Element::Locator do
     end
 
     it "returns nil if found element didn't match the selector tag_name" do
-      expect_one(:xpath, "//div").and_return(element(tag_name: "div"))
       expect_all(:xpath, "//div").and_return([element(tag_name: "div")])
 
       selector = {

data/spec/spec_helper.rb

@@ -9,7 +9,7 @@ require 'webdrivers'
 require 'locator_spec_helper'
 require 'rspec'
 
-SELENIUM_SELECTORS = %i(class class_name css id tag_name xpath link_text partial_link_text link)
+SELENIUM_SELECTORS = %i(css tag_name xpath link_text partial_link_text link)
 
 if ENV['RELAXED_LOCATE'] == "false"
   Watir.relaxed_locate = false

data/spec/watirspec/relaxed_locate_spec.rb

@@ -23,6 +23,38 @@ describe 'Watir#relaxed_locate?' do
         end
       end
 
+      context 'when acting on an element whose parent is never present' do
+        it 'raises exception after timing out' do
+          begin
+            time_out = 2
+            Watir.default_timeout = time_out
+            element = browser.link(id: 'not_there')
+            start_time = ::Time.now
+            allow($stderr).to receive(:write).twice
+            expect { element.element.click }.to raise_exception(Watir::Exception::UnknownObjectException)
+            expect(::Time.now - start_time).to be > time_out
+          ensure
+            Watir.default_timeout = 30
+          end
+        end
+      end
+
+      context 'when acting on an element from a collection whose parent is never present' do
+        it 'raises exception after timing out' do
+          begin
+            time_out = 2
+            Watir.default_timeout = time_out
+            element = browser.link(id: 'not_there')
+            start_time = ::Time.now
+            allow($stderr).to receive(:write).twice
+            expect { element.elements[2].click }.to raise_exception(Watir::Exception::UnknownObjectException)
+            expect(::Time.now - start_time).to be > time_out
+          ensure
+            Watir.default_timeout = 30
+          end
+        end
+      end
+
       context 'when acting on an element that is already present' do
         it 'does not wait' do
           begin

data/watir.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'watir'
-  s.version     = '6.11.0.beta1'
+  s.version     = '6.11.0.beta2'
   s.platform    = Gem::Platform::RUBY
   s.authors     = ['Alex Rodionov', 'Titus Fortner']
   s.email       = ['p0deje@gmail.com', 'titusfortner@gmail.com']

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: watir
 version: !ruby/object:Gem::Version
-  version: 6.11.0.beta1
+  version: 6.11.0.beta2
 platform: ruby
 authors:
 - Alex Rodionov
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-04 00:00:00.000000000 Z
+date: 2018-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: selenium-webdriver