hyper-spec 0.1.2 → 0.99.0

data/lib/hyper-spec/time_cop.rb

@@ -1,6 +1,156 @@
-require 'timecop'
+if RUBY_ENGINE == 'opal'
+  # Wrap the Lolex js package
+  class Lolex
+    class << self
 
-module HyperSpec
+      # to avoid forcing us to require time we make our own Time.parse method
+      # copied from opal.rb master branch
+
+      def parse_time(str)
+        `new Date(Date.parse(str))`
+      end
+
+      def stack
+        @stack ||= []
+      end
+
+      def push(time, scale = 1, resolution = 10)
+        time = parse_time(time) if time.is_a? String
+        stack << [Time.now, @scale, @resolution]
+        update_lolex(time, scale, resolution)
+      end
+
+      def pop
+        update_lolex(*stack.pop) unless stack.empty?
+      end
+
+      def unmock(time, resolution)
+        push(time, 1, resolution)
+        @backup_stack = stack
+        @stack = []
+      end
+
+      def restore
+        @stack = @backup_stack
+        pop
+      end
+
+      def tick
+        real_clock = `(new #{@lolex}['_Date']).getTime()`
+        mock_clock = Time.now.to_f * 1000
+        real_elapsed_time = real_clock - @real_start_time
+        mock_elapsed_time = mock_clock - @mock_start_time
+
+        ticks = real_elapsed_time * @scale - mock_elapsed_time
+
+        `#{@lolex}.tick(#{ticks.to_i})`
+        nil
+      end
+
+      def create_ticker
+        return unless @scale && @scale > 0
+        ticker = %x{
+          #{@lolex}['_setInterval'].call(
+            window,
+            function() { #{tick} },
+            #{@resolution}
+          )
+        }
+        ticker
+      end
+
+      def update_lolex(time, scale, resolution)
+        `#{@lolex}.uninstall()` && return if scale.nil?
+        @mock_start_time = time.to_f * 1000
+
+        if @lolex
+          `#{@lolex}['_clearInterval'].call(window, #{@ticker})` if @ticker
+          @real_start_time = `(new #{@lolex}['_Date']).getTime()`
+          `#{@lolex}.tick(#{@mock_start_time - Time.now.to_f * 1000})`
+        else
+          @real_start_time = Time.now.to_f * 1000
+          @lolex = `lolex.install({ now: #{@mock_start_time} })`
+        end
+
+        @scale = scale
+        @resolution = resolution
+        @ticker = create_ticker
+        nil # must return nil otherwise we try to return a timer to server!
+      end
+    end
+  end
+
+else
+  require 'timecop'
+
+  # Interface to the Lolex package running on the client side
+  # Below we will monkey patch Timecop to call these methods
+  class Lolex
+    class << self
+      def init(page, client_time_zone, resolution)
+        @capybara_page = page
+        @resolution = resolution || 10
+        @client_time_zone = client_time_zone
+        run_pending_evaluations
+        @initialized = true
+      end
+
+      def initialized?
+        @initialized
+      end
+
+      def push(mock_type, *args)
+        scale = if mock_type == :freeze
+                  0
+                elsif mock_type == :scale
+                  args[0]
+                else
+                  1
+                end
+        evaluate_ruby do
+          "Lolex.push('#{time_string_in_zone}', #{scale}, #{@resolution})"
+        end
+      end
+
+      def pop
+        evaluate_ruby { 'Lolex.pop' }
+      end
+
+      def unmock
+        evaluate_ruby { "Lolex.unmock('#{time_string_in_zone}', #{@resolution})" }
+      end
+
+      def restore
+        evaluate_ruby { 'Lolex.restore' }
+      end
+
+      private
+
+      def time_string_in_zone
+        Time.now.in_time_zone(@client_time_zone).strftime('%Y/%m/%d %H:%M:%S %z')
+      end
+
+      def pending_evaluations
+        @pending_evaluations ||= []
+      end
+
+      def evaluate_ruby(&block)
+        if @capybara_page
+          @capybara_page.evaluate_ruby(yield)
+        else
+          pending_evaluations << block
+        end
+      end
+
+      def run_pending_evaluations
+        return if pending_evaluations.empty?
+        @capybara_page.evaluate_ruby(pending_evaluations.collect(&:call).join("\n"))
+        @pending_evaluations ||= []
+      end
+    end
+  end
+
+  # Monkey patches to call our Lolex interface
   class Timecop
     private
 

data/lib/hyper-spec/version.rb

@@ -1,3 +1,3 @@
 module HyperSpec
-  VERSION = '0.1.2'
+  VERSION = '0.99.0'
 end

data/lib/hyper-spec/wait_for_ajax.rb

@@ -10,21 +10,36 @@ module HyperSpec
     end
 
     def running?
-      result = page.evaluate_script('(function(active) { return active; })(jQuery.active)')
-      result && !result.zero?
+      jscode = <<-CODE
+      (function() {
+        if (typeof Opal !== "undefined" && Opal.Hyperloop !== undefined) {
+          try {
+            return Opal.Hyperloop.$const_get("HTTP")["$active?"]();
+          } catch(err) {
+            if (typeof jQuery !== "undefined" && jQuery.active !== undefined) {
+              return (jQuery.active > 0);
+            } else {
+              return false;
+            }
+          }
+        } else if (typeof jQuery !== "undefined" && jQuery.active !== undefined) {
+          return (jQuery.active > 0);
+        } else {
+          return false;
+        }
+      })();
+      CODE
+      page.evaluate_script(jscode)
     rescue Exception => e
-      puts "wait_for_ajax failed while testing state of jQuery.active: #{e}"
+      puts "wait_for_ajax failed while testing state of ajax requests: #{e}"
     end
 
     def finished_all_ajax_requests?
-      unless running?
-        sleep 0.25 # this was 1 second, not sure if its necessary to be so long...
-        !running?
-      end
+      !running?
     rescue Capybara::NotSupportedByDriverError
       true
     rescue Exception => e
-      e.message == 'jQuery is not defined'
+      e.message == 'either jQuery or Hyperloop::HTTP is not defined'
     end
   end
 end

data/lib/react/top_level_rails_component.rb

@@ -31,57 +31,47 @@ module React
     def component
       return @component if @component
       paths_searched = []
-
+      component = nil
       if params.component_name.start_with?('::')
-        paths_searched << params.component_name.gsub(/^\:\:/, '')
-
-        @component =
-          begin
-            params.component_name.gsub(/^\:\:/, '').split('::')
-                  .inject(Module) { |scope, next_const| scope.const_get(next_const, false) }
-          rescue
-            nil
-          end
-
-        return @component if @component && @component.method_defined?(:render)
+        # if absolute path of component is given, look it up and fail if not found
+        paths_searched << params.component_name
+        component = begin
+                      Object.const_get(params.component_name)
+                    rescue NameError
+                      nil
+                    end
       else
-        self.class.search_path.each do |path|
-          # try each path + params.controller + params.component_name
-          paths_searched << "#{path.name + '::' unless path == Module}"\
-                            "#{params.controller}::#{params.component_name}"
-
-          @component =
-            begin
-              [params.controller, params.component_name]
-                .join('::').split('::')
-                .inject(path) { |scope, next_const| scope.const_get(next_const, false) }
-            rescue
-              nil
-            end
-
-          return @component if @component && @component.method_defined?(:render)
+        # if relative path is given, look it up like this
+        # 1) we check each path + controller-name + component-name
+        # 2) if we can't find it there we check each path + component-name
+        # if we can't find it we just try const_get
+        # so (assuming controller name is Home)
+        # ::Foo::Bar will only resolve to some component named ::Foo::Bar
+        # but Foo::Bar will check (in this order) ::Home::Foo::Bar, ::Components::Home::Foo::Bar, ::Foo::Bar, ::Components::Foo::Bar
+        self.class.search_path.each do |scope|
+          paths_searched << "#{scope.name}::#{params.controller}::#{params.component_name}"
+          component = begin
+                        scope.const_get(params.controller, false).const_get(params.component_name, false)
+                      rescue NameError
+                        nil
+                      end
+          break if component != nil
         end
-
-        self.class.search_path.each do |path|
-          # then try each path + params.component_name
-          paths_searched << "#{path.name + '::' unless path == Module}#{params.component_name}"
-          @component =
-            begin
-              params.component_name.to_s.split('::')
-                    .inject(path) { |scope, next_const| scope.const_get(next_const, false) }
-            rescue
-              nil
-            end
-
-          return @component if @component && @component.method_defined?(:render)
+        unless component
+          self.class.search_path.each do |scope|
+            paths_searched << "#{scope.name}::#{params.component_name}"
+            component = begin
+                          scope.const_get(params.component_name, false)
+                        rescue NameError
+                          nil
+                        end
+            break if component != nil
+          end
         end
       end
-
-      @component = nil
-
-      raise "Could not find component class '#{params.component_name}' "\
-            "for params.controller '#{params.controller}' in any component directory. "\
-            "Tried [#{paths_searched.join(', ')}]"
+      @component = component
+      return @component if @component && @component.method_defined?(:render)
+      raise "Could not find component class '#{params.component_name}' for params.controller '#{params.controller}' in any component directory. Tried [#{paths_searched.join(", ")}]"
     end
 
     before_mount do
@@ -98,7 +88,7 @@ module React
     end
 
     def render
-      present component, @render_params
+      React::RenderingContext.render(component, @render_params)
     end
   end
 end

data/lib/selenium/web_driver/firefox/profile.rb

@@ -6,7 +6,7 @@ module Selenium
           attr_accessor :firebug_version
 
           def firebug_version
-            @firebug_version ||= '2.0.13-fx'
+            @firebug_version ||= '2.0.19-fx'
           end
         end
 
@@ -15,7 +15,7 @@ module Selenium
         end
 
         def frame_position=(position)
-          @frame_position = %w(left right top detached).detect do |side|
+          @frame_position = %w[left right top detached].detect do |side|
             position && position[0].downcase == side[0]
           end || 'detached'
         end
@@ -36,7 +36,7 @@ module Selenium
           self['extensions.firebug.allPagesActivation'] = 'on'
 
           # Enable all features.
-          %w(console net script).each do |feature|
+          %w[console net script].each do |feature|
             self["extensions.firebug.#{feature}.enableSites"] = true
           end
 

data/lib/sources/lolex.js

@@ -0,0 +1,733 @@
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.lolex = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+(function (global){
+"use strict";
+
+var userAgent = global.navigator && global.navigator.userAgent;
+var isRunningInIE = userAgent && userAgent.indexOf("MSIE ") > -1;
+var maxTimeout = Math.pow(2, 31) - 1; //see https://heycam.github.io/webidl/#abstract-opdef-converttoint
+
+// Make properties writable in IE, as per
+// http://www.adequatelygood.com/Replacing-setTimeout-Globally.html
+if (isRunningInIE) {
+    global.setTimeout = global.setTimeout;
+    global.clearTimeout = global.clearTimeout;
+    global.setInterval = global.setInterval;
+    global.clearInterval = global.clearInterval;
+    global.Date = global.Date;
+}
+
+// setImmediate is not a standard function
+// avoid adding the prop to the window object if not present
+if (global.setImmediate !== undefined) {
+    global.setImmediate = global.setImmediate;
+    global.clearImmediate = global.clearImmediate;
+}
+
+// node expects setTimeout/setInterval to return a fn object w/ .ref()/.unref()
+// browsers, a number.
+// see https://github.com/cjohansen/Sinon.JS/pull/436
+
+var NOOP = function () { return undefined; };
+var timeoutResult = setTimeout(NOOP, 0);
+var addTimerReturnsObject = typeof timeoutResult === "object";
+var hrtimePresent = (global.process && typeof global.process.hrtime === "function");
+var nextTickPresent = (global.process && typeof global.process.nextTick === "function");
+var performancePresent = (global.performance && typeof global.performance.now === "function");
+
+clearTimeout(timeoutResult);
+
+var NativeDate = Date;
+var uniqueTimerId = 1;
+
+/**
+ * Parse strings like "01:10:00" (meaning 1 hour, 10 minutes, 0 seconds) into
+ * number of milliseconds. This is used to support human-readable strings passed
+ * to clock.tick()
+ */
+function parseTime(str) {
+    if (!str) {
+        return 0;
+    }
+
+    var strings = str.split(":");
+    var l = strings.length;
+    var i = l;
+    var ms = 0;
+    var parsed;
+
+    if (l > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) {
+        throw new Error("tick only understands numbers, 'm:s' and 'h:m:s'. Each part must be two digits");
+    }
+
+    while (i--) {
+        parsed = parseInt(strings[i], 10);
+
+        if (parsed >= 60) {
+            throw new Error("Invalid time " + str);
+        }
+
+        ms += parsed * Math.pow(60, (l - i - 1));
+    }
+
+    return ms * 1000;
+}
+
+/**
+ * Floor function that also works for negative numbers
+ */
+function fixedFloor(n) {
+    return (n >= 0 ? Math.floor(n) : Math.ceil(n));
+}
+
+/**
+ * % operator that also works for negative numbers
+ */
+function fixedModulo(n, m) {
+    return ((n % m) + m) % m;
+}
+
+/**
+ * Used to grok the `now` parameter to createClock.
+ * @param epoch {Date|number} the system time
+ */
+function getEpoch(epoch) {
+    if (!epoch) { return 0; }
+    if (typeof epoch.getTime === "function") { return epoch.getTime(); }
+    if (typeof epoch === "number") { return epoch; }
+    throw new TypeError("now should be milliseconds since UNIX epoch");
+}
+
+function inRange(from, to, timer) {
+    return timer && timer.callAt >= from && timer.callAt <= to;
+}
+
+function mirrorDateProperties(target, source) {
+    var prop;
+    for (prop in source) {
+        if (source.hasOwnProperty(prop)) {
+            target[prop] = source[prop];
+        }
+    }
+
+    // set special now implementation
+    if (source.now) {
+        target.now = function now() {
+            return target.clock.now;
+        };
+    } else {
+        delete target.now;
+    }
+
+    // set special toSource implementation
+    if (source.toSource) {
+        target.toSource = function toSource() {
+            return source.toSource();
+        };
+    } else {
+        delete target.toSource;
+    }
+
+    // set special toString implementation
+    target.toString = function toString() {
+        return source.toString();
+    };
+
+    target.prototype = source.prototype;
+    target.parse = source.parse;
+    target.UTC = source.UTC;
+    target.prototype.toUTCString = source.prototype.toUTCString;
+
+    return target;
+}
+
+function createDate() {
+    function ClockDate(year, month, date, hour, minute, second, ms) {
+        // Defensive and verbose to avoid potential harm in passing
+        // explicit undefined when user does not pass argument
+        switch (arguments.length) {
+            case 0:
+                return new NativeDate(ClockDate.clock.now);
+            case 1:
+                return new NativeDate(year);
+            case 2:
+                return new NativeDate(year, month);
+            case 3:
+                return new NativeDate(year, month, date);
+            case 4:
+                return new NativeDate(year, month, date, hour);
+            case 5:
+                return new NativeDate(year, month, date, hour, minute);
+            case 6:
+                return new NativeDate(year, month, date, hour, minute, second);
+            default:
+                return new NativeDate(year, month, date, hour, minute, second, ms);
+        }
+    }
+
+    return mirrorDateProperties(ClockDate, NativeDate);
+}
+
+
+function enqueueJob(clock, job) {
+    // enqueues a microtick-deferred task - ecma262/#sec-enqueuejob
+    if (!clock.jobs) {
+        clock.jobs = [];
+    }
+    clock.jobs.push(job);
+}
+
+function runJobs(clock) {
+    // runs all microtick-deferred tasks - ecma262/#sec-runjobs
+    if (!clock.jobs) {
+        return;
+    }
+    for (var i = 0; i < clock.jobs.length; i++) {
+        var job = clock.jobs[i];
+        job.func.apply(null, job.args);
+    }
+    clock.jobs = [];
+}
+
+function addTimer(clock, timer) {
+    if (timer.func === undefined) {
+        throw new Error("Callback must be provided to timer calls");
+    }
+
+    if (timer.hasOwnProperty("delay")) {
+        timer.delay = timer.delay > maxTimeout ? 1 : timer.delay;
+    }
+
+    if (timer.hasOwnProperty("interval")) {
+        timer.interval = timer.interval > maxTimeout ? 1 : timer.interval;
+    }
+
+    if (!clock.timers) {
+        clock.timers = {};
+    }
+
+    timer.id = uniqueTimerId++;
+    timer.createdAt = clock.now;
+    timer.callAt = clock.now + (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));
+
+    clock.timers[timer.id] = timer;
+
+    if (addTimerReturnsObject) {
+        return {
+            id: timer.id,
+            ref: NOOP,
+            unref: NOOP
+        };
+    }
+
+    return timer.id;
+}
+
+
+/* eslint consistent-return: "off" */
+function compareTimers(a, b) {
+    // Sort first by absolute timing
+    if (a.callAt < b.callAt) {
+        return -1;
+    }
+    if (a.callAt > b.callAt) {
+        return 1;
+    }
+
+    // Sort next by immediate, immediate timers take precedence
+    if (a.immediate && !b.immediate) {
+        return -1;
+    }
+    if (!a.immediate && b.immediate) {
+        return 1;
+    }
+
+    // Sort next by creation time, earlier-created timers take precedence
+    if (a.createdAt < b.createdAt) {
+        return -1;
+    }
+    if (a.createdAt > b.createdAt) {
+        return 1;
+    }
+
+    // Sort next by id, lower-id timers take precedence
+    if (a.id < b.id) {
+        return -1;
+    }
+    if (a.id > b.id) {
+        return 1;
+    }
+
+    // As timer ids are unique, no fallback `0` is necessary
+}
+
+function firstTimerInRange(clock, from, to) {
+    var timers = clock.timers;
+    var timer = null;
+    var id, isInRange;
+
+    for (id in timers) {
+        if (timers.hasOwnProperty(id)) {
+            isInRange = inRange(from, to, timers[id]);
+
+            if (isInRange && (!timer || compareTimers(timer, timers[id]) === 1)) {
+                timer = timers[id];
+            }
+        }
+    }
+
+    return timer;
+}
+
+function firstTimer(clock) {
+    var timers = clock.timers;
+    var timer = null;
+    var id;
+
+    for (id in timers) {
+        if (timers.hasOwnProperty(id)) {
+            if (!timer || compareTimers(timer, timers[id]) === 1) {
+                timer = timers[id];
+            }
+        }
+    }
+
+    return timer;
+}
+
+function lastTimer(clock) {
+    var timers = clock.timers;
+    var timer = null;
+    var id;
+
+    for (id in timers) {
+        if (timers.hasOwnProperty(id)) {
+            if (!timer || compareTimers(timer, timers[id]) === -1) {
+                timer = timers[id];
+            }
+        }
+    }
+
+    return timer;
+}
+
+function callTimer(clock, timer) {
+    if (typeof timer.interval === "number") {
+        clock.timers[timer.id].callAt += timer.interval;
+    } else {
+        delete clock.timers[timer.id];
+    }
+
+    if (typeof timer.func === "function") {
+        timer.func.apply(null, timer.args);
+    } else {
+        /* eslint no-eval: "off" */
+        eval(timer.func);
+    }
+}
+
+function timerType(timer) {
+    if (timer.immediate) {
+        return "Immediate";
+    }
+    if (timer.interval !== undefined) {
+        return "Interval";
+    }
+    return "Timeout";
+}
+
+function clearTimer(clock, timerId, ttype) {
+    if (!timerId) {
+        // null appears to be allowed in most browsers, and appears to be
+        // relied upon by some libraries, like Bootstrap carousel
+        return;
+    }
+
+    if (!clock.timers) {
+        clock.timers = [];
+    }
+
+    // in Node, timerId is an object with .ref()/.unref(), and
+    // its .id field is the actual timer id.
+    if (typeof timerId === "object") {
+        timerId = timerId.id;
+    }
+
+    if (clock.timers.hasOwnProperty(timerId)) {
+        // check that the ID matches a timer of the correct type
+        var timer = clock.timers[timerId];
+        if (timerType(timer) === ttype) {
+            delete clock.timers[timerId];
+        } else {
+            throw new Error("Cannot clear timer: timer created with set" + timerType(timer)
+                            + "() but cleared with clear" + ttype + "()");
+        }
+    }
+}
+
+function uninstall(clock, target, config) {
+    var method,
+        i,
+        l;
+    var installedHrTime = "_hrtime";
+    var installedNextTick = "_nextTick";
+
+    for (i = 0, l = clock.methods.length; i < l; i++) {
+        method = clock.methods[i];
+        if (method === "hrtime" && target.process) {
+            target.process.hrtime = clock[installedHrTime];
+        } else if (method === "nextTick" && target.process) {
+            target.process.nextTick = clock[installedNextTick];
+        } else {
+            if (target[method] && target[method].hadOwnProperty) {
+                target[method] = clock["_" + method];
+                if (method === "clearInterval" && config.shouldAdvanceTime === true) {
+                    target[method](clock.attachedInterval);
+                }
+            } else {
+                try {
+                    delete target[method];
+                } catch (ignore) { /* eslint empty-block: "off" */ }
+            }
+        }
+    }
+
+    // Prevent multiple executions which will completely remove these props
+    clock.methods = [];
+}
+
+function hijackMethod(target, method, clock) {
+    var prop;
+    clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(target, method);
+    clock["_" + method] = target[method];
+
+    if (method === "Date") {
+        var date = mirrorDateProperties(clock[method], target[method]);
+        target[method] = date;
+    } else {
+        target[method] = function () {
+            return clock[method].apply(clock, arguments);
+        };
+
+        for (prop in clock[method]) {
+            if (clock[method].hasOwnProperty(prop)) {
+                target[method][prop] = clock[method][prop];
+            }
+        }
+    }
+
+    target[method].clock = clock;
+}
+
+function doIntervalTick(clock, advanceTimeDelta) {
+    clock.tick(advanceTimeDelta);
+}
+
+var timers = {
+    setTimeout: setTimeout,
+    clearTimeout: clearTimeout,
+    setImmediate: global.setImmediate,
+    clearImmediate: global.clearImmediate,
+    setInterval: setInterval,
+    clearInterval: clearInterval,
+    Date: Date
+};
+
+if (hrtimePresent) {
+    timers.hrtime = global.process.hrtime;
+}
+
+if (nextTickPresent) {
+    timers.nextTick = global.process.nextTick;
+}
+
+if (performancePresent) {
+    timers.performance = global.performance;
+}
+
+var keys = Object.keys || function (obj) {
+    var ks = [];
+    var key;
+
+    for (key in obj) {
+        if (obj.hasOwnProperty(key)) {
+            ks.push(key);
+        }
+    }
+
+    return ks;
+};
+
+exports.timers = timers;
+
+/**
+ * @param now {Date|number} the system time
+ * @param loopLimit {number}  maximum number of timers that will be run when calling runAll()
+ */
+function createClock(now, loopLimit) {
+    loopLimit = loopLimit || 1000;
+
+    var clock = {
+        now: getEpoch(now),
+        hrNow: 0,
+        timeouts: {},
+        Date: createDate(),
+        loopLimit: loopLimit
+    };
+
+    clock.Date.clock = clock;
+
+    clock.setTimeout = function setTimeout(func, timeout) {
+        return addTimer(clock, {
+            func: func,
+            args: Array.prototype.slice.call(arguments, 2),
+            delay: timeout
+        });
+    };
+
+    clock.clearTimeout = function clearTimeout(timerId) {
+        return clearTimer(clock, timerId, "Timeout");
+    };
+    clock.nextTick = function nextTick(func) {
+        return enqueueJob(clock, {
+            func: func,
+            args: Array.prototype.slice.call(arguments, 1)
+        });
+    };
+    clock.setInterval = function setInterval(func, timeout) {
+        return addTimer(clock, {
+            func: func,
+            args: Array.prototype.slice.call(arguments, 2),
+            delay: timeout,
+            interval: timeout
+        });
+    };
+
+    clock.clearInterval = function clearInterval(timerId) {
+        return clearTimer(clock, timerId, "Interval");
+    };
+
+    clock.setImmediate = function setImmediate(func) {
+        return addTimer(clock, {
+            func: func,
+            args: Array.prototype.slice.call(arguments, 1),
+            immediate: true
+        });
+    };
+
+    clock.clearImmediate = function clearImmediate(timerId) {
+        return clearTimer(clock, timerId, "Immediate");
+    };
+
+    function updateHrTime(newNow) {
+        clock.hrNow += (newNow - clock.now);
+    }
+
+    clock.tick = function tick(ms) {
+        ms = typeof ms === "number" ? ms : parseTime(ms);
+        var tickFrom = clock.now;
+        var tickTo = clock.now + ms;
+        var previous = clock.now;
+        var timer = firstTimerInRange(clock, tickFrom, tickTo);
+        var oldNow, firstException;
+
+        clock.duringTick = true;
+        runJobs(clock);
+
+        while (timer && tickFrom <= tickTo) {
+            if (clock.timers[timer.id]) {
+                updateHrTime(timer.callAt);
+                tickFrom = timer.callAt;
+                clock.now = timer.callAt;
+                try {
+                    runJobs(clock);
+                    oldNow = clock.now;
+                    callTimer(clock, timer);
+                } catch (e) {
+                    firstException = firstException || e;
+                }
+
+                // compensate for any setSystemTime() call during timer callback
+                if (oldNow !== clock.now) {
+                    tickFrom += clock.now - oldNow;
+                    tickTo += clock.now - oldNow;
+                    previous += clock.now - oldNow;
+                }
+            }
+
+            timer = firstTimerInRange(clock, previous, tickTo);
+            previous = tickFrom;
+        }
+
+        runJobs(clock);
+        clock.duringTick = false;
+        updateHrTime(tickTo);
+        clock.now = tickTo;
+
+        if (firstException) {
+            throw firstException;
+        }
+
+        return clock.now;
+    };
+
+    clock.next = function next() {
+        runJobs(clock);
+        var timer = firstTimer(clock);
+        if (!timer) {
+            return clock.now;
+        }
+
+        clock.duringTick = true;
+        try {
+            updateHrTime(timer.callAt);
+            clock.now = timer.callAt;
+            callTimer(clock, timer);
+            runJobs(clock);
+            return clock.now;
+        } finally {
+            clock.duringTick = false;
+        }
+    };
+
+    clock.runAll = function runAll() {
+        var numTimers, i;
+        runJobs(clock);
+        for (i = 0; i < clock.loopLimit; i++) {
+            if (!clock.timers) {
+                return clock.now;
+            }
+
+            numTimers = keys(clock.timers).length;
+            if (numTimers === 0) {
+                return clock.now;
+            }
+
+            clock.next();
+        }
+
+        throw new Error("Aborting after running " + clock.loopLimit + " timers, assuming an infinite loop!");
+    };
+
+    clock.runToLast = function runToLast() {
+        var timer = lastTimer(clock);
+        if (!timer) {
+            runJobs(clock);
+            return clock.now;
+        }
+
+        return clock.tick(timer.callAt);
+    };
+
+    clock.reset = function reset() {
+        clock.timers = {};
+    };
+
+    clock.setSystemTime = function setSystemTime(systemTime) {
+        // determine time difference
+        var newNow = getEpoch(systemTime);
+        var difference = newNow - clock.now;
+        var id, timer;
+
+        // update 'system clock'
+        clock.now = newNow;
+
+        // update timers and intervals to keep them stable
+        for (id in clock.timers) {
+            if (clock.timers.hasOwnProperty(id)) {
+                timer = clock.timers[id];
+                timer.createdAt += difference;
+                timer.callAt += difference;
+            }
+        }
+    };
+
+    if (performancePresent) {
+        clock.performance = Object.create(global.performance);
+        clock.performance.now = function lolexNow() {
+            return clock.hrNow;
+        };
+    }
+    if (hrtimePresent) {
+        clock.hrtime = function (prev) {
+            if (Array.isArray(prev)) {
+                var oldSecs = (prev[0] + prev[1] / 1e9);
+                var newSecs = (clock.hrNow / 1000);
+                var difference = (newSecs - oldSecs);
+                var secs = fixedFloor(difference);
+                var nanosecs = fixedModulo(difference * 1e9, 1e9);
+                return [
+                    secs,
+                    nanosecs
+                ];
+            }
+            return [
+                fixedFloor(clock.hrNow / 1000),
+                fixedModulo(clock.hrNow * 1e6, 1e9)
+            ];
+        };
+    }
+
+    return clock;
+}
+exports.createClock = createClock;
+
+/**
+ * @param config {Object} optional config
+ * @param config.target {Object} the target to install timers in (default `window`)
+ * @param config.now {number|Date}  a number (in milliseconds) or a Date object (default epoch)
+ * @param config.toFake {string[]} names of the methods that should be faked.
+ * @param config.loopLimit {number} the maximum number of timers that will be run when calling runAll()
+ * @param config.shouldAdvanceTime {Boolean} tells lolex to increment mocked time automatically (default false)
+ * @param config.advanceTimeDelta {Number} increment mocked time every <<advanceTimeDelta>> ms (default: 20ms)
+ */
+exports.install = function install(config) {
+    if ( arguments.length > 1 || config instanceof Date || Array.isArray(config) || typeof config === "number") {
+        throw new TypeError("lolex.install called with " + String(config) +
+            " lolex 2.0+ requires an object parameter - see https://github.com/sinonjs/lolex");
+    }
+    config = typeof config !== "undefined" ? config : {};
+    config.shouldAdvanceTime = config.shouldAdvanceTime || false;
+    config.advanceTimeDelta = config.advanceTimeDelta || 20;
+
+    var i, l;
+    var target = config.target || global;
+    var clock = createClock(config.now, config.loopLimit);
+
+    clock.uninstall = function () {
+        uninstall(clock, target, config);
+    };
+
+    clock.methods = config.toFake || ["setTimeout", "clearTimeout", "setImmediate", "clearImmediate","setInterval", "clearInterval", "Date"];
+
+    if (clock.methods.length === 0) {
+        // do not fake nextTick by default - GitHub#126
+        clock.methods = keys(timers).filter(function (key) {return key !== "nextTick";});
+    }
+
+    for (i = 0, l = clock.methods.length; i < l; i++) {
+        if (clock.methods[i] === "hrtime") {
+            if (target.process && typeof target.process.hrtime === "function") {
+                hijackMethod(target.process, clock.methods[i], clock);
+            }
+        } else if (clock.methods[i] === "nextTick") {
+            if (target.process && typeof target.process.nextTick === "function") {
+                hijackMethod(target.process, clock.methods[i], clock);
+            }
+        } else {
+            if (clock.methods[i] === "setInterval" && config.shouldAdvanceTime === true) {
+                var intervalTick = doIntervalTick.bind(null, clock, config.advanceTimeDelta);
+                var intervalId = target[clock.methods[i]](
+                    intervalTick,
+                    config.advanceTimeDelta);
+                clock.attachedInterval = intervalId;
+            }
+            hijackMethod(target, clock.methods[i], clock);
+        }
+    }
+
+    return clock;
+};
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}]},{},[1])(1)
+});