watir-dom-wait 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ec015b0da5094d2d636dc167932acb2639d65554
-  data.tar.gz: 9fed0593eec77385cecc7331fdcc14b33d22dc7b
+  metadata.gz: 93e9ba59672d1b85a9b7068e6423683c6dc32046
+  data.tar.gz: dfb2a55dec1e3cec71669f0d4ed201109c6833d5
 SHA512:
-  metadata.gz: 2d1289a416ecab865fd4d6c237e74dc9a8aed91641529b326ad02a6ba4345475d6ae7c85ad3f7bedaea5a102a480131bdd3c22e69cc95844104cc1d9dc5e5771
-  data.tar.gz: b716cb205b6efb46839ca38b6cf1aea3ff9f9c5c4af4570dcbe7f909de16908f4a3105e9c6d24700e3e039e30b7c49576dcca460019dd0f2dc5d7fd9ef2f6815
+  metadata.gz: 739f87a17b60dfcb303041633cb35fd91a25761942990dfe4d107cbd2147d25d382d39460d0519fa3f7276604603761aa2c0a9824983dfd1a61a857670bdf891
+  data.tar.gz: 47edb3d7bee52504afd61a4501d37bd9410f2ff61ca2933899029e6d88ccf78e90fe28325996f0ff676bdc5c2f51537b6daaf8ce0c17baf27254aebb451a4149

data/.travis.yml

@@ -1,6 +1,8 @@
+sudo: false
 rvm:
-  - 1.9.3
-  - 2.0.0
+  - 2.3.0
 before_install:
-  - "export DISPLAY=:99.0"
-  - "sh -e /etc/init.d/xvfb start"
+  - export DISPLAY=:99.0
+  - sh -e /etc/init.d/xvfb start
+  - spec/support/travis.sh
+  - export PATH="$(pwd)/bin:$PATH"

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2013 Alex Rodionov
+Copyright (c) 2016 Alex Rodionov
 
 MIT License
 

data/README.md

@@ -1,6 +1,6 @@
-# watir-dom-wait [![Build Status](https://travis-ci.org/p0deje/watir-dom-wait.png?branch=master)](https://travis-ci.org/p0deje/watir-dom-wait) [![Gem Version](https://badge.fury.io/rb/watir-dom-wait.png)](http://badge.fury.io/rb/watir-dom-wait)
+# watir-dom-wait [![Build Status](https://travis-ci.org/p0deje/watir-dom-wait.svg?branch=master)](https://travis-ci.org/p0deje/watir-dom-wait) [![Gem Version](https://badge.fury.io/rb/watir-dom-wait.svg)](http://badge.fury.io/rb/watir-dom-wait)
 
-Watir extension which provides DOM-based waiting.
+[Watir](https://github.com/watir/watir) extension which provides with method to check for DOM changes.
 
 ## Installation
 
@@ -30,58 +30,33 @@ Require to monkey patch `Watir::Element` instance:
 require 'watir-dom-wait'
 ```
 
-Simple DOM waiting:
+There is only one method added:
 
 ```ruby
-browser.div(class: 'test').wait_until_dom_changed
+browser.div(class: 'test').dom_changed?
 ```
 
-With element returned:
+which returns `true` if DOM is changed inside element or `false`
+if DOM is currently changing.
 
-```ruby
-browser.div(class: 'test').when_dom_changed.a(class: 'link').click
-```
-
-With passing block:
-
-```ruby
-browser.div(class: 'test').when_dom_changed do |div|
-  div.a(class: 'link').click
-end
-```
-
-With timeout of 10 seconds:
-
-```ruby
-browser.div(class: 'test').when_dom_changed(timeout: 10).a(class: 'link').click
-```
-
-With interval of checking for subtree modifications of 2 seconds:
-
-```ruby
-browser.div(class: 'test').when_dom_changed(interval: 2).a(class: 'link').click
-```
-
-With 5 seconds delay of how long to waiting for DOM to start modifying:
+Default delay of waiting until DOM starts changing is `1.1` seconds, but
+can be changed:
 
 ```ruby
-browser.div(class: 'test').when_dom_changed(delay: 5).a(class: 'link').click
+browser.div(class: 'test').dom_changed?(delay: 2.5)
 ```
 
-Timeouts can also be specified statically:
+You probably don't want to use the method directly. Instead, you can combine
+usage of the method with built-in Watir waiting mechanism:
 
 ```ruby
-Watir::Dom::Wait.timeout  = 1
-Watir::Dom::Wait.delay    = 1
-Watir::Dom::Wait.interval = 0.15
+browser.div(class: 'test').wait_until(&:dom_changed?)
 ```
 
 ## How it works
 
 Using [MutationObserver](https://developer.mozilla.org/en/docs/Web/API/MutationObserver).
 
-Note, that it also rescues `Selenium::WebDriver::Error::StaleElementReferenceError`, `Selenium::WebDriver::Error::JavascriptError` and `Watir::Exception::UnknownObjectException` (only when its message contains `Element not found in the cache - perhaps the page has changed since it was looked up`) when waits for DOM.
-
 ## Contributors
 
 * [Alex Rodionov](https://github.com/p0deje)

data/lib/watir-dom-wait.rb

@@ -1 +1,2 @@
-require 'watir/dom/wait'
+require 'watir'
+require 'watir/dom/elements/element'

data/lib/watir/dom/elements/element.rb

@@ -1,60 +1,28 @@
 module Watir
   class Element
+    DOM_WAIT_JS = File.read("#{File.dirname(__FILE__)}/../extensions/js/waitForDom.js").freeze
 
     #
-    # Waits until DOM is changed within the element and returns/yields self.
+    # Returns true if DOM is changed within the element.
     #
-    # @example With self returned
-    #   browser.div(id: 'test').when_dom_changed.a(id: 'link').click
+    # @example Wait until DOM is changed inside element with default delay
+    #   browser.div(id: 'test').wait_until(&:dom_changed?).click
     #
-    # @example With passing block
-    #   browser.div(id: 'test').when_dom_changed do |div|
-    #     div.a(id: 'link').click
+    # @example Wait until DOM is changed inside element with default delay
+    #   browser.div(id: 'test').wait_until do |element|
+    #     element.dom_changed?(delay: 5)
     #   end
     #
-    # @example With timeout of 10 seconds
-    #   browser.div(id: 'test').when_dom_changed(timeout: 10).a(id: 'link').click
-    #
-    # @example With interval of checking for subtree modifications of 2 seconds
-    #   browser.div(id: 'test').when_dom_changed(interval: 2).a(id: 'link').click
-    #
-    # @example With 5 seconds delay of how long to waiting for DOM to start modifying
-    #   browser.div(id: 'test').when_dom_changed(delay: 5).a(id: 'link').click
-    #
-    # @param [Hash] opts
-    # @option opts [Float] interval How long to wait between DOM nodes adding/removing in seconds. Defaults to 0.5
-    # @option opts [Float] delay How long to wait for DOM modifications to start
-    # @option opts [Fixnum] timeout seconds to wait before timing out
+    # @param delay [Integer, Float] how long to wait for DOM modifications to start
     #
 
-    def when_dom_changed(opts = {})
-      message = "waiting for DOM subtree to finish modifying in #{selector_string}"
-      opts[:interval] ||= Dom::Wait.interval
-      opts[:delay]    ||= Dom::Wait.delay
-      opts[:timeout]  ||= Dom::Wait.timeout
-
-      if block_given?
-        Dom::Wait.wait_for_dom(self, opts, message)
-        yield self
-      else
-        WhenDOMChangedDecorator.new(self, opts, message)
-      end
+    def dom_changed?(delay: 1.1)
+      driver.manage.timeouts.script_timeout = delay + 1
+      driver.execute_async_script(DOM_WAIT_JS, wd, delay)
+    ensure
+      # TODO: make sure we rollback to user-defined timeout
+      # blocked by https://code.google.com/p/selenium/issues/detail?id=6608
+      driver.manage.timeouts.script_timeout = 1
     end
-
-    #
-    # Waits until DOM is changed within the element.
-    #
-    # @param [Hash] opts
-    # @option opts [Float] interval How long to wait between DOM nodes adding/removing in seconds. Defaults to 0.5
-    # @option opts [Float] delay How long to wait for DOM modifications to start
-    # @option opts [Fixnum] timeout seconds to wait before timing out
-    #
-
-    def wait_until_dom_changed(opts = {})
-      when_dom_changed(opts) do
-        # just trigger waiting
-      end
-    end
-
   end # Element
 end # Watir

data/lib/watir/dom/extensions/js/waitForDom.js

@@ -1,92 +1,33 @@
-// arguments from WebDriver
-var element  = arguments[0];
-var interval = arguments[1] * 1000;
-var delay    = arguments[2] * 1000;
-var timeout  = arguments[3] * 1000;
-var exit     = arguments[4];
-
-// flag that DOM has started modifying
-var startedModifying = false;
-
-// exits codes
-var exits = {
-  modified: 0, // DOM modifications have started and successfully finished
-  timeout:  1, // DOM modifications have started but exceeded timeout
-  noop:     2, // DOM modifications have not started
-}
-
-/**
- * Copy-paste of Underscore.js debounce function.
- * @see http://underscorejs.org/docs/underscore.html#section-67
- */
-var _debounce = function(func, wait, immediate) {
-  var timeout, args, context, timestamp, result;
-  return function() {
-    context = this;
-    args = arguments;
-    timestamp = new Date();
-    var later = function() {
-      var last = (new Date()) - timestamp;
-      if (last < wait) {
-        timeout = setTimeout(later, wait - last);
-      } else {
-        timeout = null;
-        if (!immediate) result = func.apply(context, args);
-      }
-    };
-    var callNow = immediate && !timeout;
-    if (!timeout) {
-      timeout = setTimeout(later, wait);
-    }
-    if (callNow) result = func.apply(context, args);
-    return result;
-  };
-};
-
 /**
- * Disconnects observer and
- * invokes WebDriver's callback function
- * to show that DOM has finished modifying.
+ * Disconnects observer and invokes WebDriver's callback function
+ * to show that DOM has started modifying.
  */
-var exitOnModified = _debounce(function() {
-  clearTimeout(exitTimeout);
+var exitOnStartedModifying = function() {
+  clearTimeout(exitOnNotStartedModifying);
   observer.disconnect();
-  exit(exits.modified);
-}, interval);
+  callback(false);
+}
 
 /**
- * Disconnects observer and
- * invokes WebDriver's callback function
- * to show that DOM has started modifying
- * but exceeded timeout.
+ * Disconnects observer and invokes WebDriver's callback function
+ * to show that DOM has not started modifying.
  */
-var exitOnTimeout = function() {
+var exitOnNotStartedModifying = function() {
   return setTimeout(function() {
     observer.disconnect();
-    exit(exits.timeout);
-  }, timeout);
+    callback(true);
+  }, 1000);
 }
 
-/**
- * Disconnects observer and
- * invokes WebDriver's callback function
- * to show that DOM has not started modifying.
- */
-var exitNoop = function() {
-  setTimeout(function() {
-    if (!startedModifying) {
-      clearTimeout(exitTimeout);
-      observer.disconnect();
-      exit(exits.noop);
-    }
-  }, delay);
-}
+// arguments from WebDriver
+var element  = arguments[0];
+var delay    = arguments[1] * 1000;
+var callback = arguments[2];
 
-var observer = new MutationObserver(function() {
-  if (!startedModifying) startedModifying = true;
-  exitOnModified();
-});
+// start observer
+var observer = new MutationObserver(exitOnStartedModifying);
 var config = { attributes: true, childList: true, characterData: true, subtree: true };
 observer.observe(element, config);
-var exitTimeout = exitOnTimeout();
-exitNoop();
+
+// make sure we exit if DOM has not started modifying
+var exitOnNotStartedModifying = exitOnNotStartedModifying();

data/spec/spec_helper.rb

@@ -1,10 +1,16 @@
-require "watir/dom/wait"
+require "pry"
+require "watir-dom-wait"
 
 RSpec.configure do |spec|
   spec.filter_run_excluding bug: /\d+/
 
   spec.before(:all) do
-    @browser = Watir::Browser.new
+    opts = {}
+    if ENV['TRAVIS']
+      Selenium::WebDriver::Chrome.path = "#{File.dirname(__FILE__)}/../bin/google-chrome"
+      opts[:args] = ['no-sandbox']
+    end
+    @browser = Watir::Browser.new(:chrome, opts)
     @browser.goto "data:text/html,#{File.read('spec/support/html/wait_for_dom.html')}"
   end
 
@@ -12,7 +18,8 @@ RSpec.configure do |spec|
     @browser.quit
   end
 
-  spec.after(:each) do
+  spec.after(:each) do |example|
+    binding.pry if example.exception && ENV['DEBUG']
     @browser.refresh
   end
 end

data/spec/support/html/wait_for_dom.html

@@ -14,7 +14,7 @@
 
         setTimeout(function() {
           clearInterval(timer);
-        }, number * timeout);
+        }, number * timeout + 10);
       }
 
       function staleDiv(parent_id, child_id) {

data/spec/support/travis.sh

@@ -0,0 +1,14 @@
+#!/bin/bash -ex
+
+mkdir bin/
+
+# https://omahaproxy.appspot.com
+# https://commondatastorage.googleapis.com/chromium-browser-snapshots/index.html?prefix=Linux_x64/
+CHROME_REVISION=386257
+curl -L -O "http://commondatastorage.googleapis.com/chromium-browser-snapshots/Linux_x64/${CHROME_REVISION}/chrome-linux.zip"
+unzip chrome-linux.zip
+ln -s "$(pwd)/chrome-linux/chrome" "$(pwd)/bin/google-chrome"
+
+curl -L -O "http://chromedriver.storage.googleapis.com/2.21/chromedriver_linux64.zip"
+unzip chromedriver_linux64.zip
+ln -s "$(pwd)/chromedriver" "$(pwd)/bin/chromedriver"

data/spec/watir-dom-wait/element_spec.rb

@@ -5,112 +5,58 @@ describe Watir::Element do
     context "when DOM is changed" do
       context "when block is not given" do
         it "waits using mutation observer" do
-          @browser.button(:id => "quick").click
-          expect(@browser.div.when_dom_changed).to have(20).spans
+          @browser.button(id: "quick").click
+          expect(@browser.div.wait_until(&:dom_changed?).spans.count).to eq(20)
         end
 
         it "waits using custom interval" do
-          @browser.button(:id => "long").click
-          expect(@browser.div.when_dom_changed(:interval => 1.1)).to have(5).spans
+          @browser.button(id: "long").click
+          expect(@browser.div.wait_until(&:dom_changed?).spans.count).to eq(5)
         end
 
         it "raises timeout error" do
-          @browser.button(:id => "quick").click
-          expect { @browser.div.when_dom_changed(:timeout => 2).spans }.to raise_error(Watir::Wait::TimeoutError)
+          @browser.button(id: "quick").click
+          expect { @browser.div.wait_until(timeout: 1, &:dom_changed?) }.to raise_error(Watir::Wait::TimeoutError)
         end
 
         context "when run more than one time" do
           it "waits for DOM consecutively" do
             3.times do |i|
               sleep 1
-              @browser.button(:id => "quick").click
-              expect(@browser.div.when_dom_changed(:timeout => 5, :delay => 2)).to have(20 * (i + 1)).spans
+              @browser.button(id: "quick").click
+              expect(@browser.div.wait_until(&:dom_changed?).spans.count).to eq(20 * (i + 1))
             end
           end
         end
       end
-
-      context "when block given" do
-        it "waits using mutation observer" do
-          @browser.button(:id => "quick").click
-          @browser.div.when_dom_changed do |div|
-            expect(div).to have(20).spans
-          end
-        end
-
-        it "waits using custom interval" do
-          @browser.button(:id => "long").click
-          @browser.div.when_dom_changed(:interval => 1.1) do |div|
-            expect(div).to have(5).spans
-          end
-        end
-
-        it "raises timeout error" do
-          @browser.button(:id => "quick").click
-          expect {
-            @browser.div.when_dom_changed(:timeout => 2) { |div| div.spans }
-          }.to raise_error(Watir::Wait::TimeoutError)
-        end
-
-        it "returns block evaluation" do
-          @browser.button(:id => "quick").click
-          size = @browser.div.when_dom_changed do |div|
-            div.spans.size
-          end
-          expect(size).to eq(20)
-        end
-      end
     end
 
     context "when DOM is not changed" do
       it "doesn't raise any exception" do
-        expect(@browser.div.when_dom_changed).to have(0).spans
+        expect(@browser.div.wait_until(&:dom_changed?).spans.count).to eq(0)
       end
     end
 
     context "when effects are used" do
       it "properly handles fading" do
-        @browser.button(:id => 'fade').click
-        text = @browser.div(:id => 'container3').when_dom_changed.span.text
+        @browser.button(id: 'fade').click
+        text = @browser.div(id: 'container3').wait_until(&:dom_changed?).span.text
         expect(text).to eq('Faded')
       end
     end
 
     context "when element goes stale" do
-      before(:all) do
-        Watir.always_locate = false
-      end
-
-      after(:all) do
-        Watir.always_locate = true
-      end
-
       it "relocates element" do
-        div = @browser.div(:id => 'container2')
-        div.exists?
-        @browser.refresh
-        expect { div.when_dom_changed.text }.not_to raise_error
+        @browser.button(id: 'stale').click
+        expect { @browser.div(id: 'container2').wait_until(&:dom_changed?) }.not_to raise_error
       end
     end
 
     context "when element cannot be located" do
-      it "relocates element" do
-        div = @browser.div(:id => 'doesnotexist')
-        expect { div.when_dom_changed.text }.to raise_error(Watir::Exception::UnknownObjectException)
+      it "raises error" do
+        div = @browser.div(id: 'doesnotexist')
+        expect { div.wait_until(&:dom_changed?) }.to raise_error(Watir::Exception::UnknownObjectException)
       end
     end
   end
-
-  describe "#wait_until_dom_changed" do
-    it "calls #when_dom_changed" do
-      div = @browser.div
-      opts = { timeout: 1, interval: 2, delay: 3 }
-      expect(div).to receive(:when_dom_changed).with(opts)
-      div.wait_until_dom_changed(opts)
-    end
-
-    it "returns nil" do
-      expect(@browser.div.wait_until_dom_changed).to eq(nil)
-    end
-  end
 end

data/watir-dom-wait.gemspec

@@ -1,15 +1,14 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'watir/dom/wait/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "watir-dom-wait"
-  spec.version       = Watir::Dom::Wait::VERSION
+  spec.version       = "0.3.0"
   spec.authors       = ["Alex Rodionov"]
   spec.email         = %w(p0deje@gmail.com)
-  spec.description   = "Watir extension providing with DOM-based waiting"
-  spec.summary       = "Watir extension providing with DOM-based waiting"
+  spec.description   = "Watir extension which provides with method to check for DOM changes."
+  spec.summary       = "Watir extension which provides with method to check for DOM changes."
   spec.homepage      = "https://github.com/p0deje/watir-dom-wait"
   spec.license       = "MIT"
 
@@ -18,9 +17,10 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "watir-webdriver"
+  spec.add_dependency "watir", ">= 6.0"
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry"
 end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: watir-dom-wait
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Alex Rodionov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-13 00:00:00.000000000 Z
+date: 2016-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: watir-webdriver
+  name: watir
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -66,7 +66,21 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Watir extension providing with DOM-based waiting
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Watir extension which provides with method to check for DOM changes.
 email:
 - p0deje@gmail.com
 executables: []
@@ -80,13 +94,11 @@ files:
 - README.md
 - Rakefile
 - lib/watir-dom-wait.rb
-- lib/watir/dom/decorator.rb
 - lib/watir/dom/elements/element.rb
 - lib/watir/dom/extensions/js/waitForDom.js
-- lib/watir/dom/wait.rb
-- lib/watir/dom/wait/version.rb
 - spec/spec_helper.rb
 - spec/support/html/wait_for_dom.html
+- spec/support/travis.sh
 - spec/watir-dom-wait/element_spec.rb
 - watir-dom-wait.gemspec
 homepage: https://github.com/p0deje/watir-dom-wait
@@ -109,11 +121,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
-summary: Watir extension providing with DOM-based waiting
+summary: Watir extension which provides with method to check for DOM changes.
 test_files:
 - spec/spec_helper.rb
 - spec/support/html/wait_for_dom.html
+- spec/support/travis.sh
 - spec/watir-dom-wait/element_spec.rb

data/lib/watir/dom/decorator.rb

@@ -1,28 +0,0 @@
-module Watir
-  #
-  # Wraps an Element so that any subsequent method calls are
-  # put on hold until the DOM subtree is modified within the element.
-  #
-  class WhenDOMChangedDecorator
-
-    def initialize(element, opts, message)
-      @element = element
-      @opts    = opts
-      @message = message
-    end
-
-    def method_missing(m, *args, &block)
-      unless @element.respond_to?(m)
-        raise NoMethodError, "undefined method `#{m}' for #{@element.inspect}:#{@element.class}"
-      end
-
-      Dom::Wait.wait_for_dom(@element, @opts, @message)
-      @element.__send__(m, *args, &block)
-    end
-
-    def respond_to?(*args)
-      @element.respond_to?(*args)
-    end
-
-  end # WhenDOMChangedDecorator
-end # Watir

data/lib/watir/dom/wait.rb

@@ -1,91 +0,0 @@
-require "watir-webdriver"
-require "watir/dom/wait/version"
-require "watir/dom/decorator"
-require "watir/dom/elements/element"
-
-module Watir
-  module Dom
-    module Wait
-
-      JAVASCRIPT = File.read("#{File.dirname(__FILE__)}/extensions/js/waitForDom.js")
-      DOM_READY = "return watir.domReady;"
-
-
-      class << self
-
-        attr_writer :interval
-        attr_writer :delay
-        attr_writer :timeout
-
-        def interval
-          @interval ||= 0.5
-        end
-
-        def delay
-          @delay ||= 1
-        end
-
-        def timeout
-          @timeout ||= 30
-        end
-
-        #
-        # Waits until DOM is changed.
-        # @param [Watir::Element] element
-        # @param [Hash] opts
-        # @option opts [Float] interval How long to wait between DOM nodes adding/removing in seconds. Defaults to 0.5
-        # @option opts [Float] delay How long to wait for DOM modifications to start
-        # @option opts [Fixnum] timeout seconds to wait before timing out
-        # @api private
-        #
-
-        def wait_for_dom(element, opts, message)
-          response = self.rescue do
-            js = JAVASCRIPT.dup
-            driver = element.browser.driver
-            # TODO make sure we rollback to user-defined timeout
-            # blocked by https://code.google.com/p/selenium/issues/detail?id=6608
-            driver.manage.timeouts.script_timeout = opts[:timeout] + 1
-            response = driver.execute_async_script(js, element.wd, opts[:interval], opts[:delay], opts[:timeout])
-            driver.manage.timeouts.script_timeout = 1
-            
-            response
-          end
-          # Response statuses:
-          #   0: DOM modifications have started and successfully finished
-          #   1: DOM modifications have started but exceeded timeout
-          #   2: DOM modifications have not started
-          if response == 1
-            message = "timed out after #{opts[:timeout]} seconds, #{message}"
-            raise Watir::Wait::TimeoutError, message
-          end
-        end
-
-        #
-        # Executes block rescuing all necessary exceptions.
-        # @param [Proc] block
-        # @api private
-        #
-
-        def rescue(&block)
-          block.call
-        rescue Selenium::WebDriver::Error::StaleElementReferenceError, Exception::UnknownObjectException => error
-          msg = 'Element not found in the cache - perhaps the page has changed since it was looked up'
-          if error.is_a?(Exception::UnknownObjectException) && !error.message.include?(msg)
-            raise error
-          else
-            # element became stale so we just retry DOM waiting
-            retry
-          end
-        rescue Selenium::WebDriver::Error::JavascriptError
-          # in rare cases, args passed to execute script are not correct, for example:
-          #   correct:   [#<Selenium::WebDriver::Element:0x..fd5f048838948a830 id="{bdfa905e-b666-354c-9bf1-4dc693fd15a8}">, 300, 3000]    [el, interval, timeout]
-          #   incorrect: [0.3, 3000, nil]                                                                                                  [interval, timeout, ??]
-          # TODO there might be some logic (bug?) in Selenium which does this
-          retry
-        end
-
-      end # << self
-    end # Wait
-  end # Dom
-end # Watir

data/lib/watir/dom/wait/version.rb

@@ -1,7 +0,0 @@
-module Watir
-  module Dom
-    module Wait
-      VERSION = "0.2.1"
-    end # Wait
-  end # Dom
-end # Watir