watir 6.10.3 → 6.11.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35bf21c910e97a772d03a1ec9711edebd7bfd9231bc2beb911542fd302a4b6ef
-  data.tar.gz: bc8595b914786c02087e0b7689885e1b0ed0c7e77487ff0b4796a00d5f381b69
+  metadata.gz: 656aad05e0cbe7226f3576b88f5a65ed0959c3672b322a5252d73ac3856f0acd
+  data.tar.gz: 8112b892320b500fdf4cb113ea2b420b8f24b90509edc00367fcb20c264ca2ef
 SHA512:
-  metadata.gz: 119768b890d1fc7daaff5b690619abbf66ac32e35b35fcde533df812d156815c8b8d4dbc742875ebb164f0002d44962c1b6b803c9914f1b9794af469ce5ac034
-  data.tar.gz: 352c1f1f616e64cdac24e1b98d771a96be911a932b3e5c9f490f1d8dcac6644b623a72705b4c4f81cbfcd0c4f3a1a296a734674d2a1c3733c2417b6fe07987a9
+  metadata.gz: 79f71a31ac314000ed7d1633290a808824881c690c6e05bbb161dfa55e77ee38dc63b2a2ebaae5f2c0f6e68f951e3646450db998fa623f34f6ac7cf6ef525470
+  data.tar.gz: dba7348f6003bd93ec9ccf83a3d158f6c289a86ee80e09dac7a1487183583f2052762b5ba009da4c0eeaf9995a9b4fe9ed7d2027dc3d35d46836edeac5bac68c

data/.travis.yml

@@ -9,6 +9,7 @@ notifications:
     secure: BLsBCm33R32VNRccrLx9F0P24X6BVpVHj1OWaN4Kyn6g9qXteIwC2VKVMnKNbifpojfMkrn0OeFQFK1O1DSOsC3mgzn/udoB+DnUGcSemFUn04xhbYF5SI+3zGPKPo0JLvjjdEKSSma84YwKdrj88pGUK34p01gL8hiaqjFzWdk=
 before_install:
   - gem update --system
+  - gem install bundler
 
 before_script:
   - support/travis.sh
@@ -17,18 +18,15 @@ before_script:
 script: bundle exec rake $RAKE_TASK
 
 _version:
-  two: &two
-    language: ruby
-    rvm: 2.2.9
   three: &three
     language: ruby
-    rvm: 2.3.6
+    rvm: 2.3.7
   four: &four
     language: ruby
-    rvm: 2.4.3
+    rvm: 2.4.4
   five: &five
     language: ruby
-    rvm: 2.5.0
+    rvm: 2.5.1
 
 _browsers:
   firefox: &firefox-latest
@@ -41,41 +39,38 @@ _browsers:
 matrix:
   include:
       - env: RAKE_TASK=spec:remote_firefox
-        <<: *four
+        <<: *five
         <<: *firefox-latest
       - env: RAKE_TASK=spec:remote_chrome
-        <<: *four
+        <<: *five
         <<: *chrome
       - env: RAKE_TASK=spec:firefox RELAXED_LOCATE=false
-        <<: *four
+        <<: *five
         <<: *firefox-latest
       - env: RAKE_TASK=spec:firefox
-        <<: *four
+        <<: *five
         <<: *firefox-latest
       - env: RAKE_TASK=spec:firefox
-        <<: *three
+        <<: *four
         <<: *firefox-latest
       - env: RAKE_TASK=spec:firefox
-        <<: *two
+        <<: *three
         <<: *firefox-latest
       - env: RAKE_TASK=spec:chrome
-        <<: *four
-        <<: *chrome
-      - env: RAKE_TASK=spec:chrome
-        <<: *three
+        <<: *five
         <<: *chrome
       - env: RAKE_TASK=spec:chrome
-        <<: *five
+        <<: *four
         <<: *chrome
       - env: RAKE_TASK=spec:chrome
-        <<: *two
+        <<: *three
         <<: *chrome
       - env: RAKE_TASK=spec:chrome RELAXED_LOCATE=false
-        <<: *four
+        <<: *five
         <<: *chrome
       - env: RAKE_TASK=spec:chrome HEADLESS=true
-        <<: *four
+        <<: *five
         <<: *chrome
       - env: RAKE_TASK=yard:doctest
-        <<: *four
+        <<: *five
         <<: *chrome

data/CHANGES.md

@@ -1,3 +1,7 @@
+### 6.11.0.beta1 (2018-05-04)
+
+* Significant performance updates
+
 ### 6.10.3 (2018-01-26)
 
 * Add special handling for `date_field` and `date_time_field` input types

data/lib/watir/browser.rb

@@ -58,11 +58,13 @@ module Watir
     end
 
     def inspect
-      '#<%s:0x%x url=%s title=%s>' % [self.class, hash*2, url.inspect, title.inspect]
+      if alert.exists?
+        '#<%s:0x%x alert=true>' % [self.class, hash*2]
+      else
+        '#<%s:0x%x url=%s title=%s>' % [self.class, hash * 2, url.inspect, title.inspect]
+      end
     rescue Errno::ECONNREFUSED
       '#<%s:0x%x closed=true>' % [self.class, hash*2]
-    rescue Selenium::WebDriver::Error::UnhandledAlertError, Selenium::WebDriver::Error::UnexpectedAlertOpenError
-      '#<%s:0x%x alert=true>' % [self.class, hash*2]
     end
     alias selector_string inspect
 

data/lib/watir/capabilities.rb

@@ -99,7 +99,7 @@ module Watir
         end
         if @browser == :firefox && @options.delete(:headless)
           args = @options.delete(:args) || @options.delete(:switches) || []
-          @options[Selenium::WebDriver::Firefox::Options.KEY] = {'args' => args + ['--headless']}
+          @options[Selenium::WebDriver::Firefox::Options::KEY] = {'args' => args + ['--headless']}
         end
         if @browser == :safari && @options.delete(:technology_preview)
           @options["safari.options"] = {'technologyPreview' => true}

data/lib/watir/element_collection.rb

@@ -70,12 +70,12 @@ module Watir
           elements.map.with_index do |e, idx|
             element = element_class.new(@query_scope, @selector.merge(element: e, index: idx))
             if [Watir::HTMLElement, Watir::Input].include? element.class
-              element = element.to_subtype
-              hash[element.class] ||= []
-              hash[element.class] << element
-              element.class.new(@query_scope, @selector.merge(element: e,
-                                                              tag_name: element.tag_name,
-                                                              index: hash[element.class].size - 1))
+              tag_name = element.tag_name.to_sym
+              hash[tag_name] ||= 0
+              hash[tag_name] += 1
+              Watir.tag_to_class[tag_name].new(@query_scope, @selector.merge(element: e,
+                                                                             tag_name: tag_name,
+                                                                             index: hash[tag_name] - 1))
             else
               element
             end

data/lib/watir/elements/element.rb

@@ -47,6 +47,7 @@ module Watir
     #
 
     def exists?
+      return false if @element && stale?
       assert_exists
       true
     rescue UnknownObjectException, UnknownFrameException
@@ -401,7 +402,10 @@ module Watir
     #
 
     def visible?
-      element_call(:assert_exists) { @element.displayed? }
+      assert_exists
+      @element.displayed?
+    rescue Selenium::WebDriver::Error::StaleElementReferenceError
+      raise unknown_exception
     end
 
     #
@@ -497,6 +501,12 @@ module Watir
 
     def stale?
       raise Watir::Exception::Error, "Can not check staleness of unused element" unless @element
+      return false unless stale_in_context?
+      @query_scope.ensure_context
+      stale_in_context?
+    end
+
+    def stale_in_context?
       @element.enabled? # any wire call will check for staleness
       false
     rescue Selenium::WebDriver::Error::ObsoleteElementError
@@ -566,15 +576,7 @@ module Watir
 
     # Ensure that the element exists, making sure that it is not stale and located if necessary
     def assert_exists
-      if @element && @selector.empty?
-        @query_scope.ensure_context
-        reset! if stale?
-      elsif @element && !stale?
-        return
-      else
-        @element = locate
-      end
-
+      locate unless @element
       assert_element_found
     end
 
@@ -600,7 +602,7 @@ module Watir
 
     # Ensure the driver is in the desired browser context
     def ensure_context
-      assert_exists
+      locate unless exists?
     end
 
     private
@@ -643,43 +645,58 @@ module Watir
       end
     end
 
-    def element_call(exist_check = :wait_for_exists)
+    def element_call(precondition = nil, &block)
+      caller = caller_locations(1, 1)[0].label
       already_locked = Wait.timer.locked?
-      caller = caller_locations(1,1)[0].label
-      if already_locked
-        Watir.logger.info "-> `#{inspect}##{caller}` after `##{exist_check}` (as a prerequisite for a previously specified execution)"
-      else
-        Watir.logger.info "-> `#{inspect}##{caller}` after `##{exist_check}`"
+      unless already_locked
         Wait.timer = Wait::Timer.new(timeout: Watir.default_timeout)
       end
 
       begin
-        send exist_check
+        check_condition(precondition)
+        Watir.logger.info "-> `Executing #{inspect}##{caller}`"
         yield
       rescue unknown_exception => ex
+        if precondition.nil?
+          element_call(:wait_for_exists, &block)
+        end
         msg = ex.message
-        msg += "; Maybe look in an iframe?" if @query_scope.iframes.count > 0
+        msg += "; Maybe look in an iframe?" if @query_scope.ensure_context && @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
+        @query_scope.ensure_context
+        reset!
         retry
       rescue Selenium::WebDriver::Error::ElementNotVisibleError, Selenium::WebDriver::Error::ElementNotInteractableError
         raise_present unless Wait.timer.remaining_time > 0
-        raise_present unless exist_check == :wait_for_present || exist_check == :wait_for_enabled
+        raise_present unless precondition == :wait_for_present || precondition == :wait_for_enabled
         retry
       rescue Selenium::WebDriver::Error::InvalidElementStateError
         raise_disabled unless Wait.timer.remaining_time > 0
-        raise_disabled unless exist_check == :wait_for_writable || exist_check == :wait_for_enabled
+        raise_disabled unless precondition == :wait_for_writable || precondition == :wait_for_enabled
         retry
       rescue Selenium::WebDriver::Error::NoSuchWindowError
         raise Exception::NoMatchingWindowFoundException, "browser window was closed"
       ensure
-        Watir.logger.info "<- `#{inspect}##{caller}` has been completed"
+        Watir.logger.info "<- `Completed #{inspect}##{caller}`"
         Wait.timer.reset! unless already_locked
       end
     end
 
+    def check_condition(condition)
+      Watir.logger.info "<- `Verifying precondition #{inspect}##{condition}`"
+      begin
+        condition.nil? ? assert_exists : send(condition)
+        Watir.logger.info "<- `Verified precondition #{inspect}##{condition || 'assert_exists'}`"
+      rescue unknown_exception
+        raise unless condition.nil?
+        Watir.logger.info "<- `Unable to satisfy precondition #{inspect}##{condition}`"
+        check_condition(:wait_for_exists)
+      end
+    end
+
     def method_missing(meth, *args, &blk)
       method = meth.to_s
       if method =~ Locators::Element::SelectorBuilder::WILDCARD_ATTRIBUTE

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

@@ -3,9 +3,10 @@ module Watir
     class Button
       class Validator < Element::Validator
         def validate(element, _selector)
-          return unless %w[input button].include?(element.tag_name.downcase)
+          tag_name = element.tag_name.downcase
+          return unless %w[input button].include?(tag_name)
           # 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)
+          return if tag_name == "input" && !Watir::Button::VALID_TYPES.include?(element.attribute(:type).downcase)
 
           element
         end

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

@@ -59,7 +59,8 @@ module Watir
             if filter == :all
               found = locate_elements(sel, value)
               return found if sel == :tag_name
-              return filter_elements_by_locator(found, tag_name: tag_name, filter: filter).compact
+              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
@@ -69,28 +70,32 @@ module Watir
         end
 
         def using_watir(filter = :first)
+          query_scope = ensure_scope_context
           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[:label]
+            query_scope = convert_label_to_scope_or_selector(query_scope, selector)
+            return unless query_scope # stop, label not found
+          end
 
           if selector.key?(:index) && filter == :all
             raise ArgumentError, "can't locate all elements by :index"
           end
-          idx = selector.delete(:index) unless selector[:adjacent]
 
-          how, what = selector_builder.build(selector)
+          filter_selector = delete_filters_from(selector)
 
-          needs_filtering = idx && idx != 0 || !visible.nil? || !visible_text.nil? || validation_required || filter == :all
+          how, what = selector_builder.build(selector)
+          unless how
+            raise Error, "internal error: unable to build Selenium selector from #{selector.inspect}"
+          end
+          what = add_regexp_predicates(what, filter_selector) if how == :xpath
 
+          needs_filtering = filter == :all || !filter_selector.empty?
           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)
+            elements = locate_elements(how, what, query_scope) || []
+            filter_elements(elements, filter_selector, filter: filter)
           else
-            wd_find_by_regexp_selector(selector, :first)
+            locate_element(how, what, query_scope)
           end
         end
 
@@ -98,11 +103,6 @@ module Watir
           elements.compact.all? { |element| element_validator.validate(element, {tag_name: tag_name}) }
         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
@@ -112,6 +112,8 @@ module Watir
               Watir.logger.deprecate(':text locator with RegExp values to find elements based on only visible text', ":visible_text")
             end
             vis
+          when :visible
+            element.displayed?
           when :visible_text
             element.text
           when :tag_name
@@ -123,64 +125,67 @@ module Watir
           end
         end
 
-        def all_elements
-          locate_elements(:xpath, ".//*")
+        def filter_elements(elements, selector, filter: :first)
+          if filter == :first
+            idx = selector.delete(:index) || 0
+            if idx < 0
+              elements.reverse!
+              idx = idx.abs - 1
+            end
+
+            # Lazy evaluation to avoid fetching values for elements that will be discarded
+            matches = elements.lazy.select { |el| matches_selector?(el, selector) }
+            matches.take(idx + 1).to_a[idx]
+          else
+            elements.select { |el| matches_selector?(el, selector) }
+          end
         end
 
-        def wd_find_by_regexp_selector(selector, filter)
-          query_scope = ensure_scope_context
-          rx_selector = delete_regexps_from(selector)
+        def delete_filters_from(selector)
+          filter_selector = {}
 
-          if rx_selector.key?(:label) && selector_builder.should_use_label_element?
-            label = label_from_text(rx_selector.delete(:label)) || return
-            if (id = label.attribute('for'))
-              selector[:id] = id
-            else
-              query_scope = label
-            end
+          # 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)
           end
 
-          how, what = selector_builder.build(selector)
+          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
+          end
 
-          unless how
-            raise Error, "internal error: unable to build Selenium selector from #{selector.inspect}"
+          # 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|
+            next unless what.is_a?(Regexp)
+            filter_selector[how] = selector.delete(how)
           end
 
-          if how == :xpath && can_convert_regexp_to_contains?
-            rx_selector.each do |key, value|
-              next if key == :tag_name || key == :text
+          if selector[:index] && !selector[:adjacent]
+            idx = selector.delete(:index)
 
-              predicates = regexp_selector_to_predicates(key, value)
-              what = "(#{what})[#{predicates.join(' and ')}]" unless predicates.empty?
-            end
+            # 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
           end
 
-          elements = locate_elements(how, what, query_scope)
-          filter_elements_by_regex(elements, rx_selector, filter)
+          filter_selector
         end
 
-        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?
-          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 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 filter_elements_by_regex(elements, selector, filter)
-          method = filter == :first ? :find : :select
-          elements.__send__(method) { |el| matches_selector?(el, selector) }
-        end
+          label = label_from_text(selector.delete(:label))
+          return unless label # label not found, stop looking for element
 
-        def delete_regexps_from(selector)
-          rx_selector = {}
-
-          selector.dup.each do |how, what|
-            next unless what.is_a?(Regexp)
-            rx_selector[how] = what
-            selector.delete how
+          if (id = label.attribute('for'))
+            selector[:id] = id
+            query_scope
+          else
+            label
           end
-
-          rx_selector
         end
 
         def label_from_text(label_exp)
@@ -192,7 +197,11 @@ module Watir
 
         def matches_selector?(element, selector)
           selector.all? do |how, what|
-            what === fetch_value(element, how)
+            if how == :tag_name && what.is_a?(String)
+              element_validator.validate(element, {tag_name: what})
+            else
+              what === fetch_value(element, how)
+            end
           end
         end
 
@@ -200,6 +209,20 @@ module Watir
           true
         end
 
+        def add_regexp_predicates(what, filter_selector)
+          return what unless can_convert_regexp_to_contains?
+
+          filter_selector.each do |key, value|
+            next if [:tag_name, :text, :visible_text, :visible, :index].include?(key)
+
+            predicates = regexp_selector_to_predicates(key, value)
+            unless predicates.empty?
+              what = "(#{what})[#{predicates.join(' and ')}]"
+            end
+          end
+          what
+        end
+
         def regexp_selector_to_predicates(key, re)
           return [] if re.casefold?
 
@@ -212,6 +235,10 @@ module Watir
           end
         end
 
+        def tag_validation_required?(selector)
+          (selector.key?(:css) || selector.key?(:xpath)) && selector.key?(:tag_name)
+        end
+
         def ensure_scope_context
           @query_scope.wd
         end

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

@@ -6,8 +6,9 @@ module Watir
           return if selectors.values.any? { |e| e.kind_of? Regexp }
           selectors.delete(:tag_name) || raise("internal error: no tag_name?!")
 
+          tag_name = @query_scope.tag_name.downcase
           expressions = %w[./tr]
-          unless %w[tbody tfoot thead].include?(@query_scope.tag_name.downcase)
+          unless %w[tbody tfoot thead].include?(tag_name)
             expressions += %w[./tbody/tr ./thead/tr ./tfoot/tr]
           end
 

data/spec/browser_spec.rb

@@ -206,14 +206,16 @@ describe Watir::Browser do
       expect(browser.text_field(id: "new_user_first_name").value).to eq "hello"
     end
 
-    it "sends keys to a frame" do
-      browser.goto WatirSpec.url_for "frames.html"
-      tf = browser.frame.text_field(id: "senderElement")
-      tf.clear
+    not_compliant_on(:firefox) do
+      it "sends keys to a frame" do
+        browser.goto WatirSpec.url_for "frames.html"
+        tf = browser.frame.text_field(id: "senderElement")
+        tf.clear
 
-      browser.frame.send_keys "hello"
+        browser.frame.send_keys "hello"
 
-      expect(tf.value).to eq "hello"
+        expect(tf.value).to eq "hello"
+      end
     end
   end
 

data/spec/element_locator_spec.rb

@@ -304,7 +304,7 @@ describe Watir::Locators::Element::Locator do
         div_elements = [element(tag_name: "div")]
 
         expect_all(:tag_name, "label").ordered.and_return(label_elements)
-        expect_all(:xpath, ".//div[@id='baz']").ordered.and_return(div_elements)
+        expect_one(:xpath, ".//div[@id='baz']").ordered.and_return(div_elements.first)
 
         allow(browser).to receive(:ensure_context).and_return(nil)
         allow(browser).to receive(:execute_script).and_return('foo', 'foob')

data/spec/element_spec.rb

@@ -20,13 +20,12 @@ describe Watir::Element do
     end
 
     it "returns false if the element is stale" do
-      wd_element = browser.div(id: "foo").wd
+      element = browser.div(id: "foo").tap(&:exists?)
 
-      # simulate element going stale during lookup
-      allow(browser.driver).to receive(:find_element).with(:id, 'foo') { wd_element }
       browser.refresh
 
-      expect(browser.div(:id, 'foo')).to_not be_present
+      expect(element).to be_stale
+      expect(element).to_not be_present
     end
 
   end
@@ -54,13 +53,13 @@ describe Watir::Element do
       browser.goto WatirSpec.url_for('removed_element.html')
     end
 
-    it "relocates element from a collection when it becomes stale" do
-      watir_element = browser.divs(id: "text").first
-      expect(watir_element).to exist
+    it "element from a collection returns false when it becomes stale" do
+      element = browser.divs(id: "text").first.tap(&:exists?)
 
       browser.refresh
 
-      expect(watir_element).to exist
+      expect(element).to be_stale
+      expect(element).to_not exist
     end
 
     it "returns false when tag name does not match id" do
@@ -71,22 +70,15 @@ describe Watir::Element do
 
   describe "#element_call" do
 
-    it 'handles exceptions when taking an action on an element that goes stale during execution' do
+    it 'handles exceptions when taking an action on a stale element' do
       browser.goto WatirSpec.url_for('removed_element.html')
 
-      watir_element = browser.div(id: "text")
+      element = browser.div(id: "text").tap(&:exists?)
 
-      # simulate element going stale after assert_exists and before action taken, but not when block retried
-      allow(watir_element).to receive(:text) do
-        watir_element.send(:element_call) do
-          @already_stale ||= false
-          browser.refresh unless @already_stale
-          @already_stale = true
-          watir_element.instance_variable_get('@element').text
-        end
-      end
+      browser.refresh
 
-      expect { watir_element.text }.to_not raise_error
+      expect(element).to be_stale
+      expect { element.text }.to_not raise_error
     end
 
   end

data/spec/watirspec/elements/element_spec.rb

@@ -199,15 +199,12 @@ describe "Element" do
     end
 
     it "raises UnknownObjectException exception if the element is stale" do
-      wd_element = browser.text_field(id: "new_user_email").wd
+      element = browser.text_field(id: "new_user_email").tap(&:exists?)
 
-      # simulate element going stale during lookup
-      allow(browser.driver).to receive(:find_element).with(:css, '#new_user_email') { wd_element }
-      allow(browser.driver).to receive(:find_elements).with(:css, '#new_user_email') { [wd_element] }
-      allow(browser.driver).to receive(:find_elements).with(:tag_name, 'iframe') { [] }
       browser.refresh
 
-      expect { browser.text_field(css: '#new_user_email').visible? }.to raise_unknown_object_exception
+      expect(element).to be_stale
+      expect { element.visible? }.to raise_unknown_object_exception
     end
 
     it "returns true if the element has style='visibility: visible' even if parent has style='visibility: hidden'" do
@@ -298,6 +295,22 @@ describe "Element" do
       end
     end
 
+    context ":index locator" do
+      before { browser.goto WatirSpec.url_for("data_attributes.html") }
+
+      it "finds the first element by index: 0" do
+        expect(browser.element(index: 0).tag_name).to eq "html"
+      end
+
+      it "finds the second element by index: 1" do
+        expect(browser.element(index: 1).tag_name).to eq "head"
+      end
+
+      it "finds the last element by index: -1" do
+        expect(browser.element(index: -1).tag_name).to eq "p"
+      end
+    end
+
     it "doesn't raise when called on nested elements" do
       expect(browser.div(id: 'no_such_div').link(id: 'no_such_id')).to_not exist
     end

data/spec/watirspec/wait_spec.rb

@@ -247,10 +247,9 @@ describe Watir::Element do
     end
 
     it "does not error when element goes stale" do
-      element = browser.div(id: 'foo')
+      element = browser.div(id: 'foo').tap(&:exists?)
 
       allow(element).to receive(:stale?).and_return(false, true)
-      allow(element.wd).to receive(:displayed?).and_raise(Selenium::WebDriver::Error::StaleElementReferenceError)
 
       browser.a(id: 'hide_foo').click
       expect { element.wait_while_present(timeout: 1) }.to_not raise_exception

data/watir.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'watir'
-  s.version     = '6.10.3'
+  s.version     = '6.11.0.beta1'
   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.10.3
+  version: 6.11.0.beta1
 platform: ruby
 authors:
 - Alex Rodionov
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-26 00:00:00.000000000 Z
+date: 2018-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: selenium-webdriver
@@ -520,9 +520,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: watir
 rubygems_version: 2.7.3