watir-dom-wait 0.2.0 → 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ec015b0da5094d2d636dc167932acb2639d65554
+  data.tar.gz: 9fed0593eec77385cecc7331fdcc14b33d22dc7b
+SHA512:
+  metadata.gz: 2d1289a416ecab865fd4d6c237e74dc9a8aed91641529b326ad02a6ba4345475d6ae7c85ad3f7bedaea5a102a480131bdd3c22e69cc95844104cc1d9dc5e5771
+  data.tar.gz: b716cb205b6efb46839ca38b6cf1aea3ff9f9c5c4af4570dcbe7f909de16908f4a3105e9c6d24700e3e039e30b7c49576dcca460019dd0f2dc5d7fd9ef2f6815

data/lib/watir/dom/decorator.rb

@@ -0,0 +1,28 @@
+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/elements/element.rb

@@ -22,26 +22,22 @@ module Watir
     #   browser.div(id: 'test').when_dom_changed(delay: 5).a(id: 'link').click
     #
     # @param [Hash] opts
-    # @option opts [Fixnum] timeout seconds to wait before timing out
     # @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 in seconds. Defaults to 1
+    # @option opts [Float] delay How long to wait for DOM modifications to start
+    # @option opts [Fixnum] timeout seconds to wait before timing out
     #
 
     def when_dom_changed(opts = {})
       message = "waiting for DOM subtree to finish modifying in #{selector_string}"
-      opts[:timeout]  ||= Dom::Wait.timeout
       opts[:interval] ||= Dom::Wait.interval
       opts[:delay]    ||= Dom::Wait.delay
+      opts[:timeout]  ||= Dom::Wait.timeout
 
-      Dom::Wait.rescue do
-        if block_given?
-          js = Dom::Wait::JAVASCRIPT.dup
-          browser.execute_script js, self, opts[:interval], opts[:delay]
-          Wait.until(opts[:timeout], message) { browser.execute_script(Dom::Wait::DOM_READY) == 0 }
-          yield self
-        else
-          WhenDOMChangedDecorator.new(self, opts, message)
-        end
+      if block_given?
+        Dom::Wait.wait_for_dom(self, opts, message)
+        yield self
+      else
+        WhenDOMChangedDecorator.new(self, opts, message)
       end
     end
 
@@ -49,9 +45,9 @@ module Watir
     # Waits until DOM is changed within the element.
     #
     # @param [Hash] opts
-    # @option opts [Fixnum] timeout seconds to wait before timing out
     # @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 in seconds. Defaults to 1
+    # @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 = {})

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

@@ -1,145 +1,92 @@
+// 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
+}
+
 /**
- * There is a number of required functions provided by Underscore.js,
- * but since we don't want to depend on it, we just copy-paste required
- * things.
- *
- * See http://underscorejs.org/docs/underscore.html for explanation of functions.
+ * Copy-paste of Underscore.js debounce function.
+ * @see http://underscorejs.org/docs/underscore.html#section-67
  */
-
-var Underscore = {
-  slice: Array.prototype.slice,
-
-  nativeBind: Function.prototype.bind,
-
-  once: function(func) {
-    var ran = false, memo;
-    return function() {
-      if (ran) return memo;
-      ran = true;
-      memo = func.apply(this, arguments);
-      func = null;
-      return memo;
-    };
-  },
-
-  delay: function(func, wait) {
-    var args = this.slice.call(arguments, 2);
-    return setTimeout(function(){ return func.apply(null, args); }, wait);
-  },
-
-  debounce: function(func, wait, immediate) {
-    var timeout, result;
-    return function() {
-      var context = this, args = arguments;
-      var later = function() {
+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;
-      clearTimeout(timeout);
-      timeout = setTimeout(later, wait);
-      if (callNow) result = func.apply(context, args);
-      return result;
-    };
-  },
-
-  bind: function(func, context) {
-    if (func.bind === this.nativeBind && this.nativeBind) return this.nativeBind.apply(func, this.slice.call(arguments, 1));
-    var args = this.slice.call(arguments, 2);
-    return function() {
-      return func.apply(context, args.concat(this.slice.call(arguments)));
+      }
     };
-  }
-};
-
-function Watir(options) {
-  this.set(options);
-
-  this.startedModifying = false;
-  this.domReady = 1;
-  this.observers = {
-    forceReady:     null,
-    startModifying: null
-  }
-
-  this.addObservers();
-  this.exitOnTimeout();
-};
-
-Watir.prototype.set = function(options) {
-  if (options == null) {
-    options = {};
-  }
-
-  this.el       = options.el;
-  this.interval = options.interval;
-  this.delay    = options.delay;
-
-  this.forceReady     = this.wrappedForceReady();
-  this.startModifying = this.wrappedStartModifying();
-}
-
-Watir.prototype.exitOnTimeout = function() {
-  var that = this;
-
-  Underscore.delay(function() {
-    if (!that.startedModifying) {
-      that._forceReady();
+    var callNow = immediate && !timeout;
+    if (!timeout) {
+      timeout = setTimeout(later, wait);
     }
-  }, this.delay);
-};
-
-Watir.prototype.addObservers = function() {
-  this.observers.forceReady     = this.observe(this.el, this.forceReady);
-  this.observers.startModifying = this.observe(this.el, this.startModifying);
-}
-
-Watir.prototype.removeObservers = function() {
-  this.unobserve(this.observers.forceReady);
-  this.unobserve(this.observers.startModifying);
-}
-
-Watir.prototype.observe = function(el, fn) {
-  var observer = new MutationObserver(function(mutations) {
-    fn();
-  });
-  var config = {
-    attributes:    true,
-    childList:     true,
-    characterData: true,
-    subtree:       true
+    if (callNow) result = func.apply(context, args);
+    return result;
   };
-  observer.observe(el, config);
-  return observer;
 };
 
-Watir.prototype.unobserve = function(observer) {
+/**
+ * Disconnects observer and
+ * invokes WebDriver's callback function
+ * to show that DOM has finished modifying.
+ */
+var exitOnModified = _debounce(function() {
+  clearTimeout(exitTimeout);
   observer.disconnect();
-};
+  exit(exits.modified);
+}, interval);
 
-Watir.prototype.wrappedForceReady = function() {
-  return Underscore.bind(Underscore.debounce(this._forceReady, this.interval), this);
-};
-
-Watir.prototype.wrappedStartModifying = function() {
-  return Underscore.bind(Underscore.once(this._startModifying, this.interval), this);
-}
-
-Watir.prototype._forceReady = function(mutations) {
-  var that = this;
-
-  Underscore.once(function() {
-    that.removeObservers();
-    that.domReady -= 1;
-  })();
+/**
+ * Disconnects observer and
+ * invokes WebDriver's callback function
+ * to show that DOM has started modifying
+ * but exceeded timeout.
+ */
+var exitOnTimeout = function() {
+  return setTimeout(function() {
+    observer.disconnect();
+    exit(exits.timeout);
+  }, timeout);
 }
 
-Watir.prototype._startModifying = function() {
-  this.startedModifying = true;
+/**
+ * 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);
 }
 
-window.watir = new Watir({
-  el:       arguments[0],
-  interval: arguments[1] * 1000,
-  delay:    arguments[2] * 1000,
+var observer = new MutationObserver(function() {
+  if (!startedModifying) startedModifying = true;
+  exitOnModified();
 });
+var config = { attributes: true, childList: true, characterData: true, subtree: true };
+observer.observe(element, config);
+var exitTimeout = exitOnTimeout();
+exitNoop();

data/lib/watir/dom/wait.rb

@@ -1,5 +1,6 @@
 require "watir-webdriver"
 require "watir/dom/wait/version"
+require "watir/dom/decorator"
 require "watir/dom/elements/element"
 
 module Watir
@@ -12,13 +13,9 @@ module Watir
 
       class << self
 
-        attr_writer :timeout
         attr_writer :interval
         attr_writer :delay
-
-        def timeout
-          @timeout ||= 30
-        end
+        attr_writer :timeout
 
         def interval
           @interval ||= 0.5
@@ -28,6 +25,42 @@ module Watir
           @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
@@ -38,16 +71,16 @@ module Watir
           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?(Watir::Exception::UnknownObjectException) && !error.message.include?(msg)
+          if error.is_a?(Exception::UnknownObjectException) && !error.message.include?(msg)
             raise error
           else
-            # element can become stale, so we just retry DOM waiting
+            # 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:   [#<Watir::Body:0x6bb2ccb9de06cb92 located=false selector={:element=>(webdriver element)}>, 300, 3000]    [el, interval, delay]
-          #   incorrect: [0.3, 3000, nil]                                                                                         [interval, delay, ?]
+          #   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
@@ -55,38 +88,4 @@ module Watir
       end # << self
     end # Wait
   end # Dom
-
-
-  #
-  # 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 = nil)
-      @element = element
-      @opts    = opts
-      @message = message
-      @js      = Dom::Wait::JAVASCRIPT.dup
-    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.rescue do
-        @element.browser.execute_script @js, @element, @opts[:interval], @opts[:delay]
-        Watir::Wait.until(@opts[:timeout], @message) { @element.browser.execute_script(Dom::Wait::DOM_READY) == 0 }
-
-        @element.__send__(m, *args, &block)
-      end
-    end
-
-    def respond_to?(*args)
-      @element.respond_to?(*args)
-    end
-
-  end # WhenDOMChangedDecorator
 end # Watir

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

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

data/spec/support/html/wait_for_dom.html

@@ -34,7 +34,6 @@
         var el = document.getElementById(id);
         el.style.opacity = '0.' + value;
         if (value < 9) {
-          console.log(value);
           value++;
           setTimeout(function() { fadeIn(id, value) }, 400);
         } else {

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

@@ -4,18 +4,11 @@ describe Watir::Element do
   describe "#when_dom_changed" do
     context "when DOM is changed" do
       context "when block is not given" do
-        it "waits using event handler" do
+        it "waits using mutation observer" do
           @browser.button(:id => "quick").click
           expect(@browser.div.when_dom_changed).to have(20).spans
         end
 
-        it "may be run more than one time" do
-          3.times do |i|
-            @browser.button(:id => "quick").click
-            expect(@browser.div.when_dom_changed).to have(20 * (i + 1)).spans
-          end
-        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
@@ -25,10 +18,20 @@ describe Watir::Element do
           @browser.button(:id => "quick").click
           expect { @browser.div.when_dom_changed(:timeout => 2).spans }.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
+            end
+          end
+        end
       end
 
       context "when block given" do
-        it "waits using event handler" 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

metadata

@@ -1,78 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: watir-dom-wait
 version: !ruby/object:Gem::Version
-  version: 0.2.0
-  prerelease: 
+  version: 0.2.1
 platform: ruby
 authors:
 - Alex Rodionov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-17 00:00:00.000000000 Z
+date: 2014-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: watir-webdriver
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Watir extension providing with DOM-based waiting
@@ -82,13 +73,14 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - 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
@@ -100,33 +92,26 @@ files:
 homepage: https://github.com/p0deje/watir-dom-wait
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -2698553052236191813
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -2698553052236191813
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.2.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Watir extension providing with DOM-based waiting
 test_files:
 - spec/spec_helper.rb