watir-dom-wait 0.1.0

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.ruby-version

data/.travis.yml

@@ -0,0 +1,6 @@
+rvm:
+  - 1.9.3
+  - 2.0.0
+before_install:
+  - "export DISPLAY=:99.0"
+  - "sh -e /etc/init.d/xvfb start"

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in watir-dom-wait.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Alex Rodionov
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,68 @@
+# 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 extension which provides DOM-based waiting.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'watir-dom-wait'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install watir-dom-wait
+
+## Usage
+
+With element returned:
+
+```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:
+
+```ruby
+browser.div(class: 'test').when_dom_changed(delay: 5).a(class: 'link').click
+```
+
+## How it works
+
+By attaching `DOMSubtreeModified` event to element. It's supported in all major browsers (except Presto-powered Opera).
+
+## Contributors
+
+* [Alex Rodionov](https://github.com/p0deje)
+* [Sasha Koss](https://github.com/kossnocorp)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.rspec_opts = %w(--color)
+  spec.pattern    = 'spec/**/*_spec.rb'
+end
+
+task default: :spec

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

@@ -0,0 +1,61 @@
+module Watir
+  class Element
+
+    #
+    # Waits until DOM is changed within the element and returns/yields self.
+    #
+    # @example With self returned
+    #   browser.div(id: 'test').when_dom_changed.a(id: 'link').click
+    #
+    # @example With passing block
+    #   browser.div(id: 'test').when_dom_changed do |div|
+    #     div.a(id: 'link').click
+    #   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 [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
+    #
+
+    def when_dom_changed(opts = {})
+      message = "waiting for DOM subtree to finish modifying in #{selector_string}"
+      opts[:timeout]  ||= 30
+      opts[:interval] ||= 0.5
+      opts[:delay]    ||= 1
+
+      if block_given?
+        js = Dom::Wait::JAVASCRIPT.dup
+        browser.execute_script js, self, opts[:interval], opts[:delay]
+        Watir::Wait.until(opts[:timeout], message) { browser.execute_script(Dom::Wait::DOM_READY) == 0 }
+        yield self
+      else
+        WhenDOMChangedDecorator.new(self, opts, message)
+      end
+    end
+
+    #
+    # 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
+    #
+
+    def wait_until_dom_changed(opts = {})
+      when_dom_changed(opts)
+      nil
+    end
+
+  end # Element
+end # Watir

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

@@ -0,0 +1,148 @@
+/**
+ * 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.
+ */
+
+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() {
+        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.bindDOMEvents();
+  this.exitOnTimeout();
+};
+
+Watir.prototype.set = function (options) {
+  if (options == null) options = {};
+
+  this.el = options.el;
+  this.event = options.event || 'DOMSubtreeModified';
+  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();
+    }
+  }, this.delay);
+};
+
+Watir.prototype.bindDOMEvents = function() {
+  this.addEventListener(this.forceReady);
+  this.addEventListener(this.startModifying);
+}
+
+Watir.prototype.unbindDOMEvents = function() {
+  this.removeEventListener(this.forceReady);
+  this.removeEventListener(this.startModifying);
+}
+
+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() {
+  var that = this;
+
+  Underscore.once(function() {
+    that.unbindDOMEvents();
+    that.domReady -= 1;
+  })();
+}
+
+Watir.prototype._startModifying = function() {
+  this.startedModifying = true;
+}
+
+Watir.prototype.addEventListener = (function() {
+  if (window.addEventListener) {
+    return function (fn) {
+      this.el.addEventListener(this.event, fn, false);
+    };
+
+  } else {
+    return function (fn) {
+      this.el.attachEvent('on' + this.event, fn)
+    };
+  }
+})();
+
+Watir.prototype.removeEventListener = (function() {
+  if (window.removeEventListener) {
+    return function (fn) {
+      this.el.removeEventListener(this.event, fn, false);
+    };
+
+  } else {
+    return function (fn) {
+      this.el.detachEvent('on' + this.event, fn)
+    };
+  }
+})();
+
+window.watir = new Watir({
+  el: arguments[0],
+  interval: arguments[1] * 1000,
+  delay: arguments[2] * 1000,
+});

data/lib/watir/dom/wait.rb

@@ -0,0 +1,46 @@
+require "watir-webdriver"
+require "watir/dom/wait/version"
+require "watir/dom/elements/element"
+
+module Watir
+  module Dom
+    module Wait
+
+      JAVASCRIPT = File.read("lib/watir/dom/extensions/js/waitForDom.js")
+      DOM_READY = "return watir.domReady;"
+
+    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
+
+      @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
+
+    def respond_to?(*args)
+      @element.respond_to?(*args)
+    end
+
+  end # WhenDOMChangedDecorator
+end # Watir

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

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

data/spec/html/wait_for_dom.html

@@ -0,0 +1,29 @@
+<!DOCTYPE HTML>
+<html>
+  <head>
+    <title>wait for dom test</title>
+    <script type="text/javascript" charset="utf-8">
+      function modifySubtree(number, timeout) {
+        var timer = setInterval(function() {
+          var div = document.getElementById("container");
+          var span = document.createElement("span");
+          span.innerHTML = "Hello!";
+          div.appendChild(span);
+          div.appendChild(document.createElement("br"));
+        }, timeout);
+
+        setTimeout(function() {
+          clearInterval(timer);
+        }, number * timeout);
+      }
+    </script>
+  </head>
+
+  <body>
+    <div id="container"></div>
+    <br />
+    <button onclick="modifySubtree(5, 1000);" id="long">Start modifying subtree with 5 node operations and 1000 ms delay between them</button>
+    <br />
+    <button onclick="modifySubtree(20, 100);" id="quick">Start modifying subtree with 20 node operations and 100 ms delay between them</button>
+  </body>
+</html>

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require "watir/dom/wait"
+
+RSpec.configure do |spec|
+  spec.before(:all) do
+    @browser = Watir::Browser.new
+    @browser.goto "data:text/html,#{File.read('spec/html/wait_for_dom.html')}"
+  end
+
+  spec.after(:all) do
+    @browser.quit
+  end
+
+  spec.after(:each) do
+    @browser.refresh
+  end
+end

data/spec/watir-dom-wait_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+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
+          @browser.button(:id, "quick").click
+          @browser.div.when_dom_changed.should have(20).spans
+        end
+
+        it "may be run more than one time" do
+          3.times do |i|
+            @browser.button(:id, "quick").click
+            @browser.div.when_dom_changed.should have(20 * (i + 1)).spans
+          end
+        end
+
+        it "waits using custom interval" do
+          @browser.button(:id, "long").click
+          @browser.div.when_dom_changed(:interval => 1.1).should have(5).spans
+        end
+
+        it "raises timeout error" do
+          @browser.button(:id, "quick").click
+          lambda { @browser.div.when_dom_changed(:timeout => 2).spans }.should raise_error(Watir::Wait::TimeoutError)
+        end
+      end
+
+      context "when block given" do
+        it "waits using event handler" do
+          @browser.button(:id, "quick").click
+          @browser.div.when_dom_changed do |div|
+            div.should 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|
+            div.should have(5).spans
+          end
+        end
+
+        it "raises timeout error" do
+          @browser.button(:id, "quick").click
+          lambda do
+            @browser.div.when_dom_changed(:timeout => 2) { |div| div.spans }
+          end.should raise_error(Watir::Wait::TimeoutError)
+        end
+      end
+    end
+
+    context "when DOM is not changed" do
+      it "doesn't raise any exception" do
+        @browser.div.when_dom_changed.should have(0).spans
+      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 }
+      div.should_receive(:when_dom_changed).with(opts)
+      div.wait_until_dom_changed(opts)
+    end
+
+    it "returns nil" do
+      @browser.div.wait_until_dom_changed.should == nil
+    end
+  end
+end

data/watir-dom-wait.gemspec

@@ -0,0 +1,26 @@
+# 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.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.homepage      = "https://github.com/p0deje/watir-dom-wait"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "watir-webdriver"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: watir-dom-wait
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Alex Rodionov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-27 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
+email:
+- p0deje@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- 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/html/wait_for_dom.html
+- spec/spec_helper.rb
+- spec/watir-dom-wait_spec.rb
+- watir-dom-wait.gemspec
+homepage: https://github.com/p0deje/watir-dom-wait
+licenses:
+- MIT
+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: 2355813797107009921
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2355813797107009921
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Watir extension providing with DOM-based waiting
+test_files:
+- spec/html/wait_for_dom.html
+- spec/spec_helper.rb
+- spec/watir-dom-wait_spec.rb