angular · Apr 24, 2014 · May 7, 2014 · May 7, 2014 · May 7, 2014 · May 7, 2014
diff --git a/README.md b/README.md
@@ -60,6 +60,13 @@ Hooks that you don't override when forking a zone are inherited from the existin
 See the [API docs](#api) below for more.
 
 
+## Usage
+
+To start using Zones, you need to include the `zone.js` script in this package onto
+your page. This script should appear in the `<head>` of your HTML file before any other
+scripts, including shims/polyfills.
+
+
 ## Examples
 
 There are two kinds of examples:
@@ -221,6 +228,16 @@ This hook will run even if the function passed to `run` throws.
 
 This hook is called when the function passed to `run` or the `beforeTask` hook throws.
 
+### `zone.enqueueTask`
+
+This hook is called when a function is registered with the VM.
+For instance `setTimeout` and `addEventListener`.
+
+### `zone.dequeueTask`
+
+This hook is called when a function is unregistered with the VM.
+For instance `clearTimeout` and `removeEventListener`.
+
 ### `zone.setTimeout`, `zone.setInterval`, `zone.alert`, `zone.prompt`
 
 These hooks allow you to change the behavior of `window.setTimeout`, `window.setInterval`, etc.

diff --git a/counting-zone.js b/counting-zone.js
@@ -1,22 +1,36 @@
 /*
  * See example/counting.html
  */
+
 Zone.countingZone = {
-  '-onZoneCreated': function () {
-    Zone.countingZone.counter += 1;
+
+  // setTimeout
+  '+enqueueTask': function () {
+    this.data.count += 1;
   },
+
+  // fires when...
+  // - clearTimeout
+  // - setTimeout finishes
+  '-dequeueTask': function () {
+    this.data.count -= 1;
+  },
+
   '+afterTask': function () {
-    Zone.countingZone.counter -= 1;
-    if (Zone.countingZone.counter <= 0) {
-      Zone.countingZone.counter = 0;
-      this.onFlush();
+    if (this.data.count === 0 && !this.data.flushed) {
+      this.data.flushed = true;
+      this.run(this.onFlush);
     }
   },
-  '-run': function () {
-    Zone.countingZone.counter = 0;
-  },
+
   counter: function () {
-    return Zone.countingZone.counter;
+    return this.data.count;
+  },
+
+  data: {
+    count: 0,
+    flushed: false
   },
+
   onFlush: function () {}
 };
diff --git a/example/counting.html b/example/counting.html
@@ -28,20 +28,20 @@ <h1>Counting Pending Tasks</h1>
      */
     var myCountingZone = zone.fork(Zone.countingZone).fork({
       '+onZoneCreated': function () {
-        Zone.countingZone.start || (Zone.countingZone.start = Date.now());
+        this.data.start || (this.data.start = Date.now());
         this.print();
       },
       '-afterTask': function (delegate) {
         this.print();
       },
       '+reset': function (delegate) {
-        Zone.countingZone.start = 0;
+        this.data.start = 0;
       },
       print: function () {
         counter = this.counter();
         output.innerHTML = counter ?
             'pending task count: ' + counter :
-            ' DONE! ' + (Date.now() - Zone.countingZone.start)/1000 + 's';
+            ' DONE! ' + (Date.now() - this.data.start)/1000 + 's';
       }
     });
 

diff --git a/karma.conf.js b/karma.conf.js
@@ -6,7 +6,7 @@ module.exports = function (config) {
     files: [
       'zone.js',
       '*-zone.js',
-      'test/*.spec.js'
+      'test/**/*.spec.js'
     ],
 
     reporters: ['progress'],

diff --git a/long-stack-trace-zone.js b/long-stack-trace-zone.js
@@ -8,13 +8,11 @@ Zone.Stacktrace = function (e) {
   this._e = e;
 };
 Zone.Stacktrace.prototype.get = function () {
-  var frames = this._e.stack.split('\n');
-
-  var markerIndex;
-  for (var markerIndex = frames.length - 1; markerIndex >= 0; markerIndex -= 1) {
-    if (frames[markerIndex].indexOf('marker@') === 0) {
-      return frames.slice(markerIndex+1).join('\n');
-    }
+  if (zone.stackFramesFilter) {
+    return this._e.stack.
+        split('\n').
+        filter(zone.stackFramesFilter).
+        join('\n');
   }
   return this._e.stack;
 }
@@ -46,8 +44,15 @@ Zone.getStacktrace = function () {
 
 Zone.longStackTraceZone = {
   getLongStacktrace: function (exception) {
-    var trace = [exception.stack];
+    var trace = [];
     var zone = this;
+    if (zone.stackFramesFilter) {
+      trace.push(exception.stack.split('\n').
+          filter(zone.stackFramesFilter).
+          join('\n'));
+    } else {
+      trace.push(exception.stack);
+    }
     var now = Date.now();
     while (zone && zone.constructedAtException) {
       trace.push(
@@ -59,6 +64,10 @@ Zone.longStackTraceZone = {
     return trace.join('\n');
   },
 
+  stackFramesFilter: function (line) {
+    return line.indexOf('zone.js') === -1;
+  },
+
   onError: function (exception) {
     var reporter = this.reporter || console.log.bind(console);
     reporter(exception.toString());

diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "zone.js",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Zones for JavaScript",
   "main": "zone.js",
   "directories": {
@@ -15,7 +15,7 @@
     "url": "git://github.com/btford/zone.js.git"
   },
   "author": "Brian Ford",
-  "license": "MIT",
+  "license": "Apache 2.0",
   "bugs": {
     "url": "https://github.com/btford/zone.js/issues"
   },

diff --git a/test/counting-zone.spec.js b/test/counting-zone.spec.js
@@ -1,34 +1,123 @@
 'use strict';
 
-
 describe('Zone.countingZone', function () {
-  var flushSpy = jasmine.createSpy('flush'),
-      countingZone = zone.fork(Zone.countingZone).fork({
-        onFlush: flushSpy
-      });
+  var flushSpy, countingZone;
 
   beforeEach(function () {
-    jasmine.Clock.useMock();
-    flushSpy.reset();
+    flushSpy = jasmine.createSpy('flush');
+    countingZone = zone.fork(Zone.longStackTraceZone).
+                        fork(Zone.countingZone).
+                        fork({
+                          onFlush: flushSpy
+                        });
   });
 
   it('should flush at the end of a run', function () {
-    countingZone.run(function () {});
-    expect(flushSpy).toHaveBeenCalled();
+    countingZone.run(function () {
+      expect(countingZone.counter()).toBe(0);
+    });
     expect(countingZone.counter()).toBe(0);
+    expect(flushSpy.calls.length).toBe(1);
+  });
+
+  it('should work with setTimeout', function () {
+    var latch;
+
+    runs(function () {
+      countingZone.run(function () {
+        setTimeout(function () {
+          latch = true;
+        }, 0);
+        expect(countingZone.counter()).toBe(1);
+      });
+    });
+
+    waitsFor(function () {
+      return latch;
+    });
+
+    runs(function () {
+      expect(countingZone.counter()).toBe(0);
+    })
+  });
+
+  it('should work with clearTimeout', function () {
+    var latch = false;
+    countingZone.run(function () {
+      var id = setTimeout(function () {
+        latch = true;
+      }, 0);
+      expect(countingZone.counter()).toBe(1);
+      clearTimeout(id);
+      expect(countingZone.counter()).toBe(0);
+    });
   });
 
-  it('should work', function () {
+  it('should work with setInterval', function () {
+    var latch = 0, id;
+
+    runs(function () {
+      countingZone.run(function () {
+        id = setInterval(function () {
+          latch += 1;
+        }, 0);
+        expect(countingZone.counter()).toBe(1);
+      });
+    });
+
+    waitsFor(function () {
+      return latch === 2;
+    }, 100, 'latch to increment');
+
+    runs(function () {
+      expect(countingZone.counter()).toBe(1);
+      clearInterval(id);
+    });
+  });
+
+  it('should work with clearInterval', function () {
+    var id;
     countingZone.run(function () {
+      id = setInterval(function () {
+        latch += 1;
+      }, 0);
+      expect(countingZone.counter()).toBe(1);
+      clearInterval(id);
+      expect(countingZone.counter()).toBe(0);
+    });
+  });
+
+  it('should work with addEventListener', function () {
+    var elt = document.createElement('button');
+    var clicked = false;
 
-      setTimeout(function () {}, 0);
+    runs(function () {
+      countingZone.run(main);
+    });
+
+    function main () {
+      expect(countingZone.counter()).toBe(0);
+      elt.addEventListener('click', onClick);
       expect(countingZone.counter()).toBe(1);
 
-      //jasmine.Clock.tick(0);
+      elt.click();
+      function onClick () {
+        expect(countingZone.counter()).toBe(1);
+        elt.removeEventListener('click', onClick);
+        expect(countingZone.counter()).toBe(0);
+        clicked = true;
+      }
+
+      expect(countingZone.counter()).toBe(0);
+    }
+
+    waitsFor(function () {
+      return clicked;
+    }, 10, 'the thing');
 
-      //expect(countingZone.counter()).toBe(0);
+    runs(function () {
+      expect(flushSpy.calls.length).toBe(1);
     });
 
-    //jasmine.Clock.tick(0);
   });
 });
diff --git a/test/long-stack-trace-zone.spec.js b/test/long-stack-trace-zone.spec.js
@@ -1,7 +1,6 @@
 'use strict';
 
-
-describe('Zone.patch', function () {
+describe('longStackTraceZone', function () {
   var log;
 
   var lstz = zone.fork(Zone.longStackTraceZone).fork({
@@ -29,4 +28,22 @@ describe('Zone.patch', function () {
     expect(log[0]).toBe('Error: hello');
     expect(log[1].split('--- ').length).toBe(4);
   });
+
+
+  it('should filter based on stackFramesFilter', function () {
+    lstz.fork({
+      stackFramesFilter: function (line) {
+        return line.indexOf('jasmine.js') === -1;
+      }
+    }).run(function () {
+      setTimeout(function () {
+        setTimeout(function () {
+          throw new Error('hello');
+        }, 0);
+      }, 0);
+    });
+
+    jasmine.Clock.tick(0);
+    expect(log[1]).not.toContain('jasmine.js');
+  });
 });