cutting the 0.9.9 time-shift release

- don't update browser before and after eval instead
  - sync location properties before eval
  - sync location properties and update browser after eval
- added tests
- symplified the code
- removed $location.toString() because it was not idempotent and useless

This resolves the issue with issuing two $route.onHashChange calls
when the $location was updated with a hashPath that needs to be encoded

.gitignore

@@ -2,5 +2,6 @@ build/
 angularjs.netrc
 jstd.log
 .DS_Store
-regression/temp.html
+regression/temp*.html
+performance/temp*.html
 .idea/workspace.xml

CHANGELOG.md

@@ -1,3 +1,144 @@
+# <angular/> 0.9.9 time-shift (2011-01-13) #
+
+### Security
+- Added a just in case security check for JSON parsing. (commit 5f080193)
+- Completed security review with the Google Security Team.
+
+### Performance
+- $location and $cookies services are now lazily initialized to avoid the polling overhead when
+  not needed.
+- $location service now listens for `onhashchange` events (if supported by browser) instead of
+  constant polling. (commit 16086aa3)
+- input widgets known listens on keydown events instead of keyup which improves perceived
+  performance (commit 47c454a3)
+- angular boots significantly sooner by listening for DOMContentLoaded event instead of
+  window.load when supported by browser (commit c79aba92)
+- new service $updateView which may be used in favor of $root.$eval() to run a complete eval on
+  the entire document. This service bulks and throttles DOM updates to improve performance.
+  (commit 47c454a3)
+
+### Docs
+- Major improvements to the doc parser (commit 4f22d686)
+- Docs now offline enabled (all dependencies are bundled in the tarball) (commit 4f5d5029)
+- Added support for navigating the docs app with keyboard shortcuts (tab and ctrl+alt+s)
+
+### Bugfixes
+- `angular.Object.equals` now properly handless comparing an object with a null (commit b0be87f6)
+- Several issues were addressed in the `$location` service (commit 23875cb3)
+- angular.filter.date now properly handles some corner-cases (issue #159 - fix contributed by Vojta)
+
+### Breaking changes
+- API for accessing registered services — `scope.$inject` — was renamed to
+  [`scope.$service`](http://docs.angularjs.org/#!angular.scope.$service). (commit b2631f61)
+
+- Support for `eager-published` services was removed. This change was done to make explicit
+  dependency declaration always required in order to allow making relatively expensive services
+  lazily initialized (e.g. $cookie, $location), as well as remove 'magic' and reduce unnecessary
+  scope namespace pollution. (commit 3ea5941f)
+
+  Complete list of affected services:
+
+  - $location
+  - $route
+  - $cookies
+  - $window
+  - $document
+  - $exceptionHandler
+  - $invalidWidgets
+
+  To temporarily preserve the 'eager-published' status for these services, you may use `ng:init`
+  (e.g. `ng:init="$location = $service('$location'), ...`) in the view or more correctly create
+  a service like this:
+
+      angular.service('published-svc-shim', function() {
+        this.$location = this.$service('$location');
+        this.$route = this.$service('$route');
+        this.$cookies = this.$service('$cookies');
+        this.$window = this.$service('$window');
+        this.$document = this.$service('$document');
+        this.$exceptionHandler = this.$service('$exceptionHandler');
+        this.$invalidWidgets = this.$service('$invalidWidgets');
+      }, {$eager: true});
+
+- In the light of the `eager-published` change, to complete the cleanup we renamed `$creation`
+  property of services to `eager` with its value being a boolean.
+  To transition, please rename all `$creation: 'eager'` declarations to `$eager: true`.
+  (commit 1430c6d6)
+
+- `angular.foreach` was renamed to `angular.forEach` to make the api consistent. (commit 0a6cf70d)
+
+- The `toString` method of the `angular.service.$location` service was removed. (commit 23875cb3)
+
+
+# <angular/> 0.9.8 astral-projection (2010-12-23) #
+
+### Docs/Getting started
+- angular-seed project to get you hacking on an angular apps quickly
+  https://github.com/angular/angular-seed
+
+### Performance
+- Delegate JSON parsing to native parser (JSON.parse) if available
+
+### Bug Fixes
+- Ignore input widgets which have no name (issue #153)
+
+
+# <angular/> 0.9.7 sonic-scream (2010-12-10) #
+
+### Bug Fixes
+- $defer service should always call $eval on the root scope after a callback runs (issue #189)
+- fix for failed assignments of form obj[0].name=value (issue #169)
+- significant parser improvements that resulted in lower memory usage
+  (commit 23fc73081feb640164615930b36ef185c23a3526)
+
+### Docs
+- small docs improvements (mainly docs for the $resource service)
+
+### Breaking changes
+- Angular expressions in the view used to support regular expressions. This feature was rarely 
+  used and added unnecessary complexity. It not a good idea to have regexps in the view anyway, 
+  so we removed this support. If you had any regexp in your views, you will have to move them to 
+  your controllers. (commit e5e69d9b90850eb653883f52c76e28dd870ee067)
+
+
+# <angular/> 0.9.6 night-vision (2010-12-06) #
+
+### Security
+- several improvements in the HTML sanitizer code to prevent code execution via `href`s and other
+  attributes.
+  Commits:
+  - 41d5938883a3d06ffe8a88a51efd8d1896f7d747
+  - 2bbced212e2ee93948c45360fee00b2e3f960392
+
+### Docs
+- set up http://docs.angularjs.org domain, the docs for the latest release will from now on be
+  deployed here.
+- docs app UI polishing with dual scrolling and other improvements
+
+### Bug Fixes
+- `select` widget now behaves correctly when it's `option` items are created via `ng:repeat` 
+  (issue #170)
+- fix for async xhr cache issue #152 by adding `$browser.defer` and `$defer` service
+
+### Breaking Changes
+- Fix for issue #152 might break some tests that were relying on the incorrect behavior. The
+  breakage will usually affect code that tests resources, xhr or services/widgets build on top of
+  these. All that is typically needed to resolve the issue is adding a call to
+  `$browser.defer.flush()` in your test just before the point where you expect all cached
+  resource/xhr requests to return any results. Please see 011fa39c2a0b5da843395b538fc4e52e5ade8287
+  for more info.
+- The HTML sanitizer is slightly more strinct now. Please see info in the "Security" section above.
+
+
+# <angular/> 0.9.5 turkey-blast (2010-11-25) #
+
+### Docs
+- 99% of the content from the angular wiki is now in the docs
+
+### Api
+- added `angular.Array.limitTo` to make it easy to select first or last few items of an array
+
+
 # <angular/> 0.9.4 total-recall (2010-11-18) #
 
 ### Docs

Rakefile

@@ -158,7 +158,7 @@ end
 
 desc 'Generate docs'
 task :docs do
-  `node docs/collect.js`
+  `node docs/src/gen-docs.js`
 end
 
 

docs/angular.directive.ngdoc

@@ -0,0 +1,53 @@
+@workInProgress
+@ngdoc overview
+@name angular.directive
+@namespace Namespace for all directives.
+
+@description
+A directive is an HTML attribute that you can use in an existing HTML element type or in a
+DOM element type that you create as {@link angular.widget}, to modify that element's
+properties. You can use any number of directives per element.
+
+For example, you can add the ng:bind directive as an attribute of an HTML span element, as in
+`<span ng:bind="1+2"></span>`. How does this work? The compiler passes the attribute value
+`1+2` to the ng:bind extension, which in turn tells the {@link angular.scope} to watch that
+expression and report changes. On any change it sets the span text to the expression value.
+
+Here's how to define {@link angular.directive.ng:bind ng:bind}:
+<pre>
+  angular.directive('ng:bind', function(expression, compiledElement) {
+    var compiler = this;
+    return function(linkElement) {
+      var currentScope = this;
+      currentScope.$watch(expression, function(value) {
+        linkElement.text(value);
+      });
+    };
+  });
+</pre>
+
+# Directive vs. Attribute Widget
+Both [attribute widgets](#!angular.widget) and directives can compile a DOM element
+attribute. So why have two different ways to do the same thing? The answer is that order
+matters, but we have no control over the order in which attributes are read. To solve this
+we apply attribute widget before the directive.
+
+For example, consider this piece of HTML, which uses the directives `ng:repeat`, `ng:init`,
+and `ng:bind`:
+<pre>
+  <ul ng:init="people=['mike', 'mary']">
+    <li ng:repeat="person in people" ng:init="a=a+1" ng:bind="person"></li>
+  </ul>
+</pre>
+
+Notice that the order of execution matters here. We need to execute
+{@link angular.directive.ng:repeat ng:repeat} before we run the
+{@link angular.directive.ng:init ng:init} and `ng:bind` on the `<li/>;`. This is because we
+want to run the `ng:init="a=a+1` and `ng:bind="person"` once for each person in people. We
+could not have used directive to create this template because attributes are read in an
+unspecified order and there is no way of guaranteeing that the repeater attribute would
+execute first. Using the `ng:repeat` attribute directive ensures that we can transform the
+DOM element into a template.
+
+Widgets run before directives. Widgets may manipulate the DOM whereas directives are not
+expected to do so, and so they run last.

docs/angular.element.ngdoc

@@ -0,0 +1,43 @@
+@workInProgress
+@ngdoc function
+@name angular.element
+@function
+
+@description
+Wraps a raw DOM element or HTML string as [jQuery](http://jquery.com) element.
+`angular.element` is either an alias for [jQuery](http://api.jquery.com/jQuery/) function if
+jQuery is loaded or a function that wraps the element or string in angular's jQuery lite
+implementation.
+
+Real jQuery always takes precedence if it was loaded before angular.
+
+Angular's jQuery lite implementation is a tiny API-compatible subset of jQuery which allows
+angular to manipulate DOM.  The functions implemented are usually just the basic versions of
+them and might not support arguments and invocation styles.
+
+NOTE: All element references in angular are always wrapped with jQuery (lite) and are never
+raw DOM references.
+
+Angular's jQuery lite implements these functions:
+
+- [addClass()](http://api.jquery.com/addClass/)
+- [after()](http://api.jquery.com/after/)
+- [append()](http://api.jquery.com/append/)
+- [attr()](http://api.jquery.com/attr/)
+- [bind()](http://api.jquery.com/bind/)
+- [children()](http://api.jquery.com/children/)
+- [clone()](http://api.jquery.com/clone/)
+- [css()](http://api.jquery.com/css/)
+- [data()](http://api.jquery.com/data/)
+- [hasClass()](http://api.jquery.com/hasClass/)
+- [parent()](http://api.jquery.com/parent/)
+- [remove()](http://api.jquery.com/remove/)
+- [removeAttr()](http://api.jquery.com/removeAttr/)
+- [removeClass()](http://api.jquery.com/removeClass/)
+- [removeData()](http://api.jquery.com/removeData/)
+- [replaceWith()](http://api.jquery.com/replaceWith/)
+- [text()](http://api.jquery.com/text/)
+- [trigger()](http://api.jquery.com/trigger/)
+
+@param {string|DOMElement} element HTML string or DOMElement to be wrapped into jQuery.
+@returns {Object} jQuery object.

docs/angular.filter.ngdoc

@@ -0,0 +1,76 @@
+@workInProgress
+@ngdoc overview
+@name angular.filter
+@namespace Namespace for all filters.
+@description
+# Overview
+Filters are a standard way to format your data for display to the user. For example, you
+might have the number 1234.5678 and would like to display it as US currency: $1,234.57.
+Filters allow you to do just that. In addition to transforming the data, filters also modify
+the DOM. This allows the filters to for example apply css styles to the filtered output if
+certain conditions were met.
+
+
+# Standard Filters
+
+The Angular framework provides a standard set of filters for common operations, including:
+{@link angular.filter.currency currency}, {@link angular.filter.json json},
+{@link angular.filter.number number}, and {@link angular.filter.html html}. You can also add
+your own filters.
+
+
+# Syntax
+
+Filters can be part of any {@link angular.scope} evaluation but are typically used with
+{{bindings}}. Filters typically transform the data to a new data type, formating the data in
+the process. Filters can be chained and take optional arguments. Here are few examples:
+
+* No filter: {{1234.5678}} => 1234.5678
+* Number filter: {{1234.5678|number}} => 1,234.57. Notice the “,” and rounding to two
+  significant digits.
+* Filter with arguments: {{1234.5678|number:5}} => 1,234.56780. Filters can take optional
+  arguments, separated by colons in a binding. To number, the argument “5” requests 5 digits
+  to the right of the decimal point.
+
+
+# Writing your own Filters
+
+Writing your own filter is very easy: just define a JavaScript function on `angular.filter`.
+The framework passes in the input value as the first argument to your function. Any filter
+arguments are passed in as additional function arguments.
+
+You can use these variables in the function:
+
+* `this` — The current scope.
+* `this.$element` — The DOM element containing the binding. This allows the filter to manipulate
+  the DOM in addition to transforming the input.
+
+
+@exampleDescription
+ The following example filter reverses a text string. In addition, it conditionally makes the
+ text upper-case (to demonstrate optional arguments) and assigns color (to demonstrate DOM
+ modification).
+
+@example
+   <script type="text/javascript">
+     angular.filter('reverse', function(input, uppercase, color) {
+       var out = "";
+       for (var i = 0; i < input.length; i++) {
+         out = input.charAt(i) + out;
+       }
+       if (uppercase) {
+         out = out.toUpperCase();
+       }
+       if (color) {
+         this.$element.css('color', color);
+       }
+       return out;
+     });
+   </script>
+
+   <input name="text" type="text" value="hello" /><br>
+   No filter: {{text}}<br>
+   Reverse: {{text|reverse}}<br>
+   Reverse + uppercase: {{text|reverse:true}}<br>
+   Reverse + uppercase + blue:  {{text|reverse:true:"blue"}}
+

docs/angular.formatter.ngdoc

@@ -0,0 +1,78 @@
+@workInProgress
+@ngdoc overview
+@name angular.formatter
+@namespace Namespace for all formats.
+@description
+# Overview
+The formatters are responsible for translating user readable text in an input widget to a
+data model stored in an application.
+
+# Writting your own Formatter
+Writing your own formatter is easy. Just register a pair of JavaScript functions with 
+`angular.formatter`. One function for parsing user input text to the stored form, 
+and one for formatting the stored data to user-visible text.
+
+Here is an example of a "reverse" formatter: The data is stored in uppercase and in 
+reverse, while it is displayed in lower case and non-reversed. User edits are 
+automatically parsed into the internal form and data changes are automatically 
+formatted to the viewed form.
+
+<pre>
+function reverse(text) {
+  var reversed = [];
+  for (var i = 0; i < text.length; i++) {
+    reversed.unshift(text.charAt(i));
+  }
+  return reversed.join('');
+}
+
+angular.formatter('reverse', {
+  parse: function(value){
+    return reverse(value||'').toUpperCase();
+  },
+  format: function(value){
+    return reverse(value||'').toLowerCase();
+  }
+});
+</pre>
+
+@example
+<script type="text/javascript">
+function reverse(text) {
+  var reversed = [];
+  for (var i = 0; i < text.length; i++) {
+    reversed.unshift(text.charAt(i));
+  }
+  return reversed.join('');
+}
+
+angular.formatter('reverse', {
+  parse: function(value){
+    return reverse(value||'').toUpperCase();
+  },
+  format: function(value){
+    return reverse(value||'').toLowerCase();
+  }
+});
+</script>
+
+Formatted: 
+<input type="text" name="data" value="angular" ng:format="reverse"/>
+<br/>
+
+Stored: 
+<input type="text" name="data"/><br/>
+<pre>{{data}}</pre>
+
+
+@scenario
+it('should store reverse', function(){
+ expect(element('.doc-example input:first').val()).toEqual('angular');
+ expect(element('.doc-example input:last').val()).toEqual('RALUGNA');
+ 
+ this.addFutureAction('change to XYZ', function($window, $document, done){
+   $document.elements('.doc-example input:last').val('XYZ').trigger('change');
+   done();
+ });
+ expect(element('.doc-example input:first').val()).toEqual('zyx');
+});

docs/angular.ngdoc

@@ -0,0 +1,4 @@
+@workInProgress
+@ngdoc overview
+@name angular
+@namespace The exported angular namespace.

docs/angular.service.ngdoc

@@ -0,0 +1,159 @@
+@workInProgress
+@ngdoc overview
+@name angular.service
+
+@description
+# Overview
+Services are substituable objects, which are wired together using dependency injection.
+Each service could have dependencies (other services), which are passed in constructor.
+Because JS is dynamicaly typed language, dependency injection can not use static types
+to satisfy these dependencies, so each service must explicitely define its dependencies.
+This is done by `$inject` property.
+
+For now, life time of all services is the same as the life time of page.
+
+
+# Built-in services
+The Angular framework provides a standard set of services for common operations.
+You can write your own services and rewrite these standard services as well.
+Like other core angular variables, the built-in services always start with $.
+
+  * `angular.service.$browser`
+  * `angular.service.$window`
+  * `angular.service.$document`
+  * `angular.service.$location`
+  * `angular.service.$log`
+  * `angular.service.$exceptionHandler`
+  * `angular.service.$hover`
+  * `angular.service.$invalidWidgets`
+  * `angular.service.$route`
+  * `angular.service.$xhr`
+  * `angular.service.$xhr.error`
+  * `angular.service.$xhr.bulk`
+  * `angular.service.$xhr.cache`
+  * `angular.service.$resource`
+  * `angular.service.$cookies`
+  * `angular.service.$cookieStore`
+
+# Writing your own custom services
+Angular provides only set of basic services, so you will probably need to write your custom
+service very soon. To do so, you need to write a factory function and register this function
+to angular's dependency injector. This factory function must return an object - your service
+(it is not called with new operator).
+
+**angular.service** has three parameters:
+
+  - `{string} name` - Name of the service
+  - `{function()} factory` - Factory function (called just once by DI)
+  - `{Object} config` -  Hash of configuration (`$inject`, `$creation`)
+
+If your service requires - depends on other services, you need to specify them 
+in config hash - property $inject. This property is an array of strings (service names).
+These dependencies will be passed as parameters to the factory function by DI.
+This approach is very useful when testing, as you can inject mocks/stubs/dummies.
+
+Here is an example of very simple service. This service requires $window service (it's
+passed as a parameter to factory function) and it's just a function.
+
+This service simple stores all notifications and after third one, it displays all of them by
+window alert.
+<pre>
+       angular.service('notify', function(win) {
+         var msgs = [];
+         return function(msg) {
+           msgs.push(msg);
+           if (msgs.length == 3) {
+             win.alert(msgs.join("\n"));
+             msgs = [];
+           }
+         };
+       }, {$inject: ['$window']});
+</pre>
+ 
+And here is a unit test for this service. We use Jasmine spy (mock) instead of real browser's alert.
+<pre>
+var mock, notify;
+
+beforeEach(function() {
+  mock = {alert: jasmine.createSpy()};
+  notify = angular.service('notify')(mock);
+});
+ 
+it('should not alert first two notifications', function() {
+  notify('one');
+  notify('two');
+  expect(mock.alert).not.toHaveBeenCalled();
+});
+
+it('should alert all after third notification', function() {
+  notify('one');
+  notify('two');
+  notify('three');
+  expect(mock.alert).toHaveBeenCalledWith("one\ntwo\nthree");
+});
+
+it('should clear messages after alert', function() {
+  notify('one');
+  notify('two');
+  notify('third');
+  notify('more');
+  notify('two');
+  notify('third');
+  expect(mock.alert.callCount).toEqual(2);
+  expect(mock.alert.mostRecentCall.args).toEqual(["more\ntwo\nthird"]);
+});
+</pre>
+
+# Injecting services into controllers
+Using services in a controllers is very similar to using service in other service.
+Again, we will use dependency injection.
+
+JavaScript is dynamic language, so DI is not able to figure out which services to inject by
+static types (like in static typed languages). Therefore you must specify the service name
+by the `$inject` property - it's an array that contains strings with names of services to be
+injected. The name must match the id that service has been registered as with angular.
+The order of the services in the array matters, because this order will be used when calling
+the factory function with injected parameters. The names of parameters in factory function
+don't matter, but by convention they match the service ids.
+<pre>
+function myController($loc, $log) {
+  this.firstMethod = function() {
+    // use $location service
+    $loc.setHash();
+  };
+  this.secondMethod = function() {
+    // use $log service
+    $log.info('...');
+  };
+}
+// which services to inject ?
+myController.$inject = ['$location', '$log']; 
+</pre>
+
+@example
+<script type="text/javascript">
+ angular.service('notify', function(win) {
+   var msgs = [];
+   return function(msg) {
+     msgs.push(msg);
+     if (msgs.length == 3) {
+       win.alert(msgs.join("\n"));
+       msgs = [];
+     }
+   };
+ }, {$inject: ['$window']});
+ 
+ function myController(notifyService) {
+   this.callNotify = function(msg) {
+     notifyService(msg);
+   };
+ }
+ 
+ myController.$inject = ['notify'];
+</script>
+
+<div ng:controller="myController">
+<p>Let's try this simple notify service, injected into the controller...</p>
+<input ng:init="message='test'" type="text" name="message" />
+<button ng:click="callNotify(message);">NOTIFY</button>
+</div>

docs/angular.validator.ngdoc

@@ -0,0 +1,73 @@
+@workInProgress
+@ngdoc overview
+@name angular.validator
+@namespace Namespace for all filters.
+@description
+# Overview
+Validators are a standard way to check the user input against a specific criteria. For 
+example, you might need to check that an input field contains a well-formed phone number.
+
+# Syntax
+Attach a validator on user input widgets using the `ng:validate` attribute.
+
+<doc:example>
+  <doc:source>
+    Change me: &lt;input type="text" name="number" ng:validate="integer" value="123"&gt;
+  </doc:source>
+  <doc:scenario>
+    it('should validate the default number string', function() {
+      expect(element('input[name=number]').attr('class')).
+         not().toMatch(/ng-validation-error/);
+    });
+    it('should not validate "foo"', function() {
+      input('number').enter('foo');
+      expect(element('input[name=number]').attr('class')).
+         toMatch(/ng-validation-error/);
+    });
+  </doc:scenario>
+</doc:example>
+
+
+# Writing your own Validators
+Writing your own validator is easy. To make a function available as a 
+validator, just define the JavaScript function on the `angular.validator` 
+object. <angular/> passes in the input to validate as the first argument 
+to your function. Any additional validator arguments are passed in as 
+additional arguments to your function.
+
+You can use these variables in the function:
+
+* `this` — The current scope.
+* `this.$element` — The DOM element containing the binding. This allows the filter to manipulate
+  the DOM in addition to transforming the input.
+  
+In this example we have written a upsTrackingNo validator. 
+It marks the input text "valid" only when the user enters a well-formed 
+UPS tracking number.
+
+@css ng-validation-error
+  When validation fails, this css class is applied to the binding, making its borders red by
+  default.
+
+@example
+<script>
+ angular.validator('upsTrackingNo', function(input, format) {
+   var regexp = new RegExp("^" + format.replace(/9/g, '\\d') + "$");
+   return input.match(regexp)?"":"The format must match " + format;
+ });
+</script>
+<input type="text" name="trackNo" size="40"
+      ng:validate="upsTrackingNo:'1Z 999 999 99 9999 999 9'" 
+      value="1Z 123 456 78 9012 345 6"/>
+
+@scenario
+it('should validate correct UPS tracking number', function() {
+  expect(element('input[name=trackNo]').attr('class')).
+     not().toMatch(/ng-validation-error/);
+});
+
+it('should not validate in correct UPS tracking number', function() {
+  input('trackNo').enter('foo');
+  expect(element('input[name=trackNo]').attr('class')).
+     toMatch(/ng-validation-error/);
+});

docs/angular.widget.ngdoc

@@ -0,0 +1,73 @@
+@workInProgress
+@ngdoc overview
+@name angular.widget
+@namespace Namespace for all widgets.
+@description
+# Overview
+Widgets allow you to create DOM elements that the browser doesn't 
+already understand. You create the widget in your namespace and 
+assign it behavior. You can only bind one widget per DOM element 
+(unlike directives, in which you can use any number per DOM 
+element). Widgets are expected to manipulate the DOM tree by 
+adding new elements whereas directives are expected to only modify
+element properties.
+
+Widgets come in two flavors: element and attribute.
+
+# Element Widget
+Let's say we would like to create a new element type in the 
+namespace `my` that can watch an expression and alert() the user 
+with each new value.
+
+<pre>
+&lt;my:watch exp="name"/&gt;
+</pre>
+
+You can implement `my:watch` like this:
+<pre>
+angular.widget('my:watch', function(compileElement) {
+  var compiler = this;
+  var exp = compileElement.attr('exp');
+  return function(linkElement) {
+    var currentScope = this;
+    currentScope.$watch(exp, function(value){
+      alert(value);
+    }};
+  };
+});
+</pre>
+
+# Attribute Widget
+Let's implement the same widget, but this time as an attribute 
+that can be added to any existing DOM element.
+<pre>
+&lt;div my-watch="name"&gt;text&lt;/div&gt;
+</pre>
+You can implement `my:watch` attribute like this:
+<pre>
+angular.widget('@my:watch', function(expression, compileElement) {
+  var compiler = this;
+  return function(linkElement) {
+    var currentScope = this;
+    currentScope.$watch(expression, function(value){
+      alert(value);
+    });
+  };
+});
+</pre>
+
+@example
+<script>
+  angular.widget('my:time', function(compileElement){
+    compileElement.css('display', 'block');
+    return function(linkElement){
+      function update(){
+        linkElement.text('Current time is: ' + new Date());
+        setTimeout(update, 1000);
+      }
+      update();
+    };
+  });
+</script>
+<my:time></my:time>
+     

docs/collect.js

@@ -1,393 +0,0 @@
-require.paths.push("./lib");
-require.paths.push(__dirname);
-var fs       = require('fs'),
-    spawn    = require('child_process').spawn,
-    mustache = require('mustache'),
-    callback = require('callback'),
-    Showdown = require('showdown').Showdown;
-
-var documentation = {
-    pages:[],
-    byName: {}
-};
-var keywordPages = [];
-
-
-var SRC_DIR = "docs/";
-var OUTPUT_DIR = "build/docs/";
-var NEW_LINE = /\n\r?/;
-
-var work = callback.chain(function () {
-  console.log('Parsing Angular Reference Documentation');
-  mkdirPath(OUTPUT_DIR, work.waitFor(function(){
-    findJsFiles('src', work.waitMany(function(file) {
-      //console.log('reading', file, '...');
-      findNgDoc(file, work.waitMany(function(doc) {
-        parseNgDoc(doc);
-        processNgDoc(documentation, doc);
-      }));
-    }));
-  }));
-}).onError(function(err){
-  console.log('ERROR:', err.stack || err);
-}).onDone(function(){
-  keywordPages.sort(function(a,b){
-    // supper ugly comparator that orders all utility methods and objects before all the other stuff
-    // like widgets, directives, services, etc.
-    // Mother of all beatiful code please forgive me for the sin that this code certainly is.
-
-    if (a.name === b.name) return 0;
-    if (a.name === 'angular') return -1;
-    if (b.name === 'angular') return 1;
-
-    function namespacedName(page) {
-      return (page.name.match(/\./g).length === 1 && page.type !== 'overview' ? '0' : '1') + page.name;
-    }
-
-    var namespacedA = namespacedName(a),
-        namespacedB = namespacedName(b);
-
-    return namespacedA < namespacedB ? -1 : 1;
-  });
-  writeDoc(documentation.pages);
-  mergeTemplate('docs-data.js', 'docs-data.js', {JSON:JSON.stringify(keywordPages)}, callback.chain());
-  mergeTemplate('docs-scenario.js', 'docs-scenario.js', documentation, callback.chain());
-  copy('docs-scenario.html', callback.chain());
-  copy('index.html', callback.chain());
-  copy('docs.css', callback.chain());
-  mergeTemplate('docs.js', 'docs.js', documentation, callback.chain());
-  mergeTemplate('doc_widgets.css', 'doc_widgets.css', documentation, callback.chain());
-  mergeTemplate('doc_widgets.js', 'doc_widgets.js', documentation, callback.chain());
-  console.log('DONE');
-});
-if (!this.testmode) work();
-////////////////////
-
-function keywords(text){
-  var keywords = {};
-  var words = [];
-  var tokens = text.toLowerCase().split(/[,\.\`\'\"\s]+/mg);
-  tokens.forEach(function(key){
-    var match = key.match(/^(([a-z]|ng\:)[\w\_\-]{2,})/);
-    if (match){
-      key = match[1];
-      if (!keywords[key]) {
-        keywords[key] = true;
-        words.push(key);
-      }
-    }
-  });
-  words.sort();
-  return words.join(' ');
-}
-
-function noop(){}
-function mkdirPath(path, callback) {
-  var parts = path.split(/\//);
-  path = '.';
-  (function next(){
-    if (parts.length) {
-      path += '/' + parts.shift();
-      fs.mkdir(path, 0777, next);
-    } else {
-      callback();
-    }
-  })();
-}
-
-function copy(name, callback){
-  fs.readFile(SRC_DIR + name, callback.waitFor(function(err, content){
-    if (err) return this.error(err);
-    fs.writeFile(OUTPUT_DIR + name, content, callback);
-  }));
-}
-
-function mergeTemplate(template, output, doc, callback){
-  fs.readFile(SRC_DIR + template,
-    callback.waitFor(function(err, template){
-      if (err) return this.error(err);
-      var content = mustache.to_html(template.toString(), doc);
-      fs.writeFile(OUTPUT_DIR + output, content, callback);
-    }));
-}
-
-
-function trim(text) {
-  var MAX = 9999;
-  var empty = RegExp.prototype.test.bind(/^\s*$/);
-  var lines = text.split('\n');
-  var minIndent = MAX;
-  lines.forEach(function(line){
-    minIndent = Math.min(minIndent, indent(line));
-  });
-  for ( var i = 0; i < lines.length; i++) {
-    lines[i] = lines[i].substring(minIndent);
-  }
-  // remove leading lines
-  while (empty(lines[0])) {
-    lines.shift();
-  }
-  // remove trailing
-  while (empty(lines[lines.length - 1])) {
-    lines.pop();
-  }
-  return lines.join('\n');
-  
-  function indent(line) {
-    for(var i = 0; i < line.length; i++) {
-      if (line.charAt(i) != ' ')  {
-        return i;
-      }
-    }
-    return MAX;
-  }
-}
-
-function unknownTag(doc, name) {
-  var error = "[" + doc.raw.file + ":" + doc.raw.line + "]: unknown tag: " + name;
-  console.log(error);
-  throw new Error(error);
-}
-
-function valueTag(doc, name, value) {
-  doc[name] = value;
-}
-
-function escapedHtmlTag(doc, name, value) {
-  doc[name] = value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-}
-
-function markdownTag(doc, name, value) {
-  doc[name] = markdown(value.replace(/^#/gm, '##')).
-    replace(/\<pre\>/gmi, '<div ng:non-bindable><pre class="brush: js; html-script: true;">').
-    replace(/\<\/pre\>/gmi, '</pre></div>');
-}
-
-R_LINK = /{@link ([^\s}]+)((\s|\n)+(.+?))?\s*}/m
-        //       1       123     3 4     42
-
-function markdown(text) {
-  var parts = text.split(/(<pre>[\s\S]*?<\/pre>)/),
-      match;
-
-  parts.forEach(function(text, i){
-    if (!text.match(/^<pre>/)) {
-      text = text.replace(/<angular\/>/gm, '<tt>&lt;angular/&gt;</tt>');
-      text = new Showdown.converter().makeHtml(text);
-
-      while (match = text.match(R_LINK)) {
-        text = text.replace(match[0], '<a href="#!' + match[1] + '"><code>' +
-                                        (match[4] || match[1]) +
-                                      '</code></a>');
-      }
-
-      parts[i] = text;
-    }
-  });
-  return parts.join('');
-}
-
-function markdownNoP(text) {
-  var lines = markdown(text).split(NEW_LINE);
-  var last = lines.length - 1;
-  lines[0] = lines[0].replace(/^<p>/, '');
-  lines[last] = lines[last].replace(/<\/p>$/, '');
-  return lines.join('\n');
-}
-
-function requiresTag(doc, name, value) {
-  doc.requires = doc.requires || [];
-  doc.requires.push({name: value});
-}
-
-function propertyTag(doc, name, value) {
-  doc[name] = doc[name] || [];
-  var match = value.match(/^({(\S+)}\s*)?(\S+)(\s+(.*))?/);
-  
-  if (match) {
-    var tag = {
-      type: match[2],
-      name: match[3],
-      description: match[5] || false
-    };
-  } else {
-    throw "[" + doc.raw.file + ":" + doc.raw.line +
-          "]: @" + name + " must be in format '{type} name description' got: " + value;
-  }
-  return doc[name].push(tag);
-}
-
-function returnsTag(doc, name, value) {
-  var match = value.match(/^{(\S+)}\s+(.*)?/);
-  
-  if (match) {
-    var tag = {
-      type: match[1],
-      description: markdownNoP(match[2]) || false
-    };
-  } else {
-    throw "[" + doc.raw.file + ":" + doc.raw.line +
-          "]: @" + name + " must be in format '{type} description' got: " + value;
-  }
-  return doc[name] = tag;
-}
-
-var TAG = {
-  ngdoc: valueTag,
-  example: escapedHtmlTag,
-  scenario: valueTag,
-  namespace: valueTag,
-  css: valueTag,
-  see: valueTag,
-  deprecated: valueTag,
-  workInProgress: function(doc, name, value) {
-    doc[name] = {description: markdown(value)};
-  },
-  usageContent: valueTag,
-  'function': valueTag,
-  description: markdownTag,
-  TODO: markdownTag,
-  paramDescription: markdownTag,
-  exampleDescription: markdownTag,
-  element: valueTag,
-  methodOf: valueTag,
-  name: function(doc, name, value) {
-    doc.name = value;
-    doc.shortName  = value.split(/\./).pop();
-    doc.depth = value.split(/\./).length - 1;
-  },
-  param: function(doc, name, value){
-    doc.param = doc.param || [];
-    doc.paramRest = doc.paramRest || [];
-    var match = value.match(/^{([^}=]+)(=)?}\s+(([^\s=]+)|\[(\S+)=([^\]]+)\])\s+(.*)/);
-                           //  1      12 2     34       4   5   5 6      6  3   7  7
-    if (match) {
-      var param = {
-          type: match[1],
-          name: match[5] || match[4],
-          optional: !!match[2],
-          'default':match[6],
-          description:markdownNoP(value.replace(match[0], match[7]))
-        };
-      doc.param.push(param);
-      if (!doc.paramFirst) {
-        doc.paramFirst = param;
-      } else {
-        doc.paramRest.push(param);
-      }
-    } else {
-      throw "[" + doc.raw.file + ":" + doc.raw.line +
-            "]: @param must be in format '{type} name=value description' got: " + value;
-    }
-  },
-  property: propertyTag,
-  requires: requiresTag,
-  returns: returnsTag
-};
-
-function parseNgDoc(doc){
-  var atName;
-  var atText;
-  var match;
-  doc.raw.text.split(NEW_LINE).forEach(function(line, lineNumber){
-    if (match = line.match(/^\s*@(\w+)(\s+(.*))?/)) {
-      // we found @name ...
-      // if we have existing name
-      if (atName) {
-        (TAG[atName] || unknownTag)(doc, atName, trim(atText.join('\n')));
-      }
-      atName = match[1];
-      atText = [];
-      if(match[3]) atText.push(match[3]);
-    } else {
-      if (atName) {
-        atText.push(line);
-      } else {
-        // ignore
-      }
-    }
-  });
-  if (atName) {
-    (TAG[atName] || unknownTag)(doc, atName, atText.join('\n'));
-  }
-}
-
-function findNgDoc(file, callback) {
-  fs.readFile(file, callback.waitFor(function(err, content){
-    var lines = content.toString().split(NEW_LINE);
-    var doc;
-    var match;
-    var inDoc = false;
-    lines.forEach(function(line, lineNumber){
-      lineNumber++;
-      // is the comment starting?
-      if (!inDoc && (match = line.match(/^\s*\/\*\*\s*(.*)$/))) {
-        line = match[1];
-        inDoc = true;
-        doc = {raw:{file:file, line:lineNumber, text:[]}};
-      }
-      // are we done?
-      if (inDoc && line.match(/\*\//)) {
-        doc.raw.text = doc.raw.text.join('\n');
-        doc.raw.text = doc.raw.text.replace(/^\n/, '');
-        if (doc.raw.text.match(/@ngdoc/)){
-          callback(doc);
-        }
-        doc = null;
-        inDoc = false;
-      }
-      // is the comment add text
-      if (inDoc){
-        doc.raw.text.push(line.replace(/^\s*\*\s?/, ''));
-      }
-    });
-    callback.done();
-  }));
-}
-
-function findJsFiles(dir, callback){
-  fs.readdir(dir, callback.waitFor(function(err, files){
-    if (err) return this.error(err);
-    files.forEach(function(file){
-      var path = dir + '/' + file;
-      fs.lstat(path, callback.waitFor(function(err, stat){
-        if (err) return this.error(err);
-        if (stat.isDirectory())
-          findJsFiles(path, callback.waitMany(callback));
-        else if (/\.js$/.test(path))
-          callback(path);
-      }));
-    });
-    callback.done();
-  }));
-}
-
-function processNgDoc(documentation, doc) {
-  if (!doc.ngdoc) return;
-  console.log('Found:', doc.ngdoc + ':' + doc.name);
-  
-  documentation.byName[doc.name] = doc;
-  
-  if (doc.methodOf) {
-    if (parent = documentation.byName[doc.methodOf]) {
-      (parent.method = parent.method || []).push(doc);
-    } else {
-      throw 'Owner "' + doc.methodOf + '" is not defined.';
-    }
-  } else {
-    documentation.pages.push(doc);
-    keywordPages.push({
-      name:doc.name,
-      type: doc.ngdoc,
-      keywords:keywords(doc.raw.text)
-    });
-  }
-}
-
-function writeDoc(pages) {
-  pages.forEach(function(doc) {
-    mergeTemplate(
-        doc.ngdoc + '.template',
-        doc.name + '.html', doc, callback.chain());
-  });
-}

docs/directive.template

@@ -1,58 +0,0 @@
-<h1>{{name}}</h1>
-
-{{#workInProgress}}
-<fieldset class="workInProgress">
-  <legend>Work In Progress</legend>
-  This page is currently being revised. It might be incomplete or contain inaccuracies.
-  {{{workInProgress.description}}}
-</fieldset>
-{{/workInProgress}}
-
-{{#deprecated}}
-<fieldset class="deprecated">
-  <legend>Deprecated API</legend>
-  {{deprecated}}
-</fieldset>
-{{/deprecated}}
-
-<h2>Description</h2>
-{{{description}}}
-
-<h2>Usage</h2>
-<h3>In HTML Template Binding</h3>
-<tt>
-  <pre>
-&lt;{{element}} {{shortName}}="{{paramFirst.name}}"&gt;
-  ...
-&lt;/{{element}}&gt;
-  </pre>
-</tt>
-
-<h3>Parameters</h3>
-<ul>
-  {{#param}}
-  <li><tt>{{name}}</tt> –
-      <tt>&#123;{{#type}}{{type}}{{/type}}{{^type}}*{{/type}}{{#optional}}={{/optional}}&#125;</tt>
-      <tt>{{#default}}[{{default}}]{{/default}}</tt>
-      – {{{description}}}</li>
-  {{/param}}
-</ul>
-{{{paramDescription}}}
-
-{{#css}}
-<h3>CSS</h3>
-{{{css}}}
-{{/css}}
-
-{{#example}}
-<h2>Example</h2>
-{{{exampleDescription}}}
-<doc:example>
-  <doc:source>
-{{/example}}
-    {{{example}}}
-{{#example}}
-  </doc:source>
-  <doc:scenario>{{{scenario}}}</doc:scenario>
-</doc:example>
-{{/example}}

docs/docs-data.js

@@ -1 +0,0 @@
-NG_PAGES={{{JSON}}};

docs/docs-scenario.js

@@ -1,9 +0,0 @@
-{{#pages}}
-describe('{{name}}', function(){
-  beforeEach(function(){
-    browser().navigateTo('index.html#!{{name}}');
-  });
-  // {{raw.file}}:{{raw.line}}
-{{{scenario}}}
-});
-{{/pages}}

docs/filter.template

@@ -1,65 +0,0 @@
-<h1>{{name}}</h1>
-
-{{#workInProgress}}
-<fieldset class="workInProgress">
-  <legend>Work In Progress</legend>
-  This page is currently being revised. It might be incomplete or contain inaccuracies.
-  {{{workInProgress.description}}}
-</fieldset>
-{{/workInProgress}}
-
-{{#deprecated}}
-<fieldset class="deprecated">
-  <legend>Deprecated API</legend>
-  {{deprecated}}
-</fieldset>
-{{/deprecated}}
-
-<h2>Description</h2>
-{{{description}}}
-
-<h2>Usage</h2>
-<h3>In HTML Template Binding</h3>
-<tt>
-  <span>{{</span>
-  {{paramFirst.name}}_expression
-  | {{shortName}}{{#paramRest}}{{^default}}:{{name}}{{/default}}{{#default}}<i>[:{{name}}={{default}}]</i>{{/default}}{{/paramRest}}
-  <span> }}</span>
-</tt>
-<h3>In JavaScript</h3>
-<tt ng:non-bindable>
-angular.filter.{{shortName}}({{paramFirst.name}}{{#paramRest}}, {{name}}{{/paramRest}} );
-</tt>
-
-<h3>Parameters</h3>
-<ul>
-  {{#param}}
-  <li><tt>{{name}}</tt> –
-      <tt>&#123;{{#type}}{{type}}{{/type}}{{^type}}*{{/type}}{{#optional}}={{/optional}}&#125;</tt>
-      <tt>{{#default}}[{{default}}]{{/default}}</tt>
-      – {{{description}}}</li>
-  {{/param}}
-</ul>
-
-{{#returns}}
-<h3>Returns</h3>
-<tt>&#123;{{{type}}}&#125;</tt> {{{description}}}
-{{/returns}}
-
-{{#css}}
-<h3>CSS</h3>
-{{{css}}}
-{{/css}}
-
-{{#example}}
-<h2>Example</h2>
-{{{exampleDescription}}}
-<doc:example>
-  <doc:source>
-{{/example}}
-    {{{example}}}
-{{#example}}
-  </doc:source>
-  <doc:scenario>{{{scenario}}}</doc:scenario>
-</doc:example>
-{{/example}}

docs/formatter.template

@@ -1,53 +0,0 @@
-<h1>{{name}}</h1>
-
-{{#workInProgress}}
-<fieldset class="workInProgress">
-  <legend>Work In Progress</legend>
-  This page is currently being revised. It might be incomplete or contain inaccuracies.
-  {{{workInProgress.description}}}
-</fieldset>
-{{/workInProgress}}
-
-{{#deprecated}}
-<fieldset class="deprecated">
-  <legend>Deprecated API</legend>
-  {{deprecated}}
-</fieldset>
-{{/deprecated}}
-
-<h2>Description</h2>
-{{{description}}}
-
-<h2>Usage</h2>
-<h3>In HTML Template Binding</h3>
-<tt>
-  &lt;input type="text" ng:format="{{shortName}}"&gt;
-</tt>
-<h3>In JavaScript</h3>
-<tt ng:non-bindable>
-var userInputString = angular.formatter.{{shortName}}.format(modelValue);<br/>
-var modelValue = angular.formatter.{{shortName}}.parse(userInputString);
-</tt>
-
-{{#returns}}
-<h3>Returns</h3>
-<tt>&#123;{{{type}}}&#125;</tt> {{{description}}}
-{{/returns}}
-
-{{#css}}
-<h3>CSS</h3>
-{{{css}}}
-{{/css}}
-
-{{#example}}
-<h2>Example</h2>
-{{{exampleDescription}}}
-<doc:example>
-  <doc:source>
-{{/example}}
-    {{{example}}}
-{{#example}}
-  </doc:source>
-  <doc:scenario>{{{scenario}}}</doc:scenario>
-</doc:example>
-{{/example}}

docs/function.template

@@ -1,52 +0,0 @@
-<h1>{{name}}</h1>
-
-{{#workInProgress}}
-<fieldset class="workInProgress">
-  <legend>Work In Progress</legend>
-  This page is currently being revised. It might be incomplete or contain inaccuracies.
-  {{{workInProgress.description}}}
-</fieldset>
-{{/workInProgress}}
-
-{{#deprecated}}
-<fieldset class="deprecated">
-  <legend>Deprecated API</legend>
-  {{deprecated}}
-</fieldset>
-{{/deprecated}}
-
-<h2>Description</h2>
-{{{description}}}
-
-<h2>Usage</h2>
-<tt ng:non-bindable>
-{{name}}({{paramFirst.name}}{{#paramRest}}, {{name}}{{/paramRest}} );
-</tt>
-
-<h3>Parameters</h3>
-<ul>
-  {{#param}}
-  <li><tt>{{name}}</tt> –
-      <tt>&#123;{{#type}}{{type}}{{/type}}{{^type}}*{{/type}}{{#optional}}={{/optional}}&#125;</tt>
-      <tt>{{#default}}[{{default}}]{{/default}}</tt>
-      – {{{description}}}</li>
-  {{/param}}
-</ul>
-
-{{#returns}}
-<h3>Returns</h3>
-<tt>&#123;{{{type}}}&#125;</tt> {{{description}}}
-{{/returns}}
-
-{{#example}}
-<h2>Example</h2>
-{{{exampleDescription}}}
-<doc:example>
-  <doc:source>
-{{/example}}
-    {{{example}}}
-{{#example}}
-  </doc:source>
-  <doc:scenario>{{{scenario}}}</doc:scenario>
-</doc:example>
-{{/example}}

docs/index.html

@@ -1,47 +0,0 @@
-<!DOCTYPE HTML>
-<html xmlns:ng="http://angularjs.org/" xmlns:doc="http://docs.angularjs.org/" ng:controller="DocsController">
-<head>
-  <title ng:bind-template="&lt;angular/&gt;: {{getTitle()}}">&lt;angular/&gt;</title>
-
-  <meta name="fragment" content="!">
-
-  <link rel="stylesheet" href="doc_widgets.css" type="text/css" />
-  <link rel="stylesheet" href="docs.css" type="text/css"/>
-  <link rel="stylesheet" href="http://alexgorbatchev.com/pub/sh/current/styles/shCore.css" type="text/css"/>
-  <link rel="stylesheet" href="http://alexgorbatchev.com/pub/sh/current/styles/shThemeDefault.css" type="text/css"/>
-
-  <script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/jquery/1.4.3/jquery.min.js"></script>
-  <script type="text/javascript" src="http://alexgorbatchev.com/pub/sh/current/scripts/shCore.js"></script>
-  <script type="text/javascript" src="http://alexgorbatchev.com/pub/sh/current/scripts/shBrushJScript.js"></script>
-  <script type="text/javascript" src="http://alexgorbatchev.com/pub/sh/current/scripts/shBrushXml.js"></script>
-
-  <script type="text/javascript" src="../angular.min.js" ng:autobind></script>
-  <script type="text/javascript" src="docs.js"></script>
-  <script type="text/javascript" src="doc_widgets.js"></script>
-  <script type="text/javascript" src="docs-data.js"></script>
-</head>
-<body>
-  <div id="header">
-    <h1>
-      <span class="section-title">{{getTitle()}}</span>
-      <a href="index.html"><span class="angular">&lt;angular/&gt;</span> Docs</a>
-    </h1>
-  </div>
-  <div id="page">
-	  <div id="sidebar" class="nav">
-	   <div class="doc-list">
-	     <input type="text" name="filterText" placeholder="search documentaiton"/>
-		   <ul>
-		     <li ng:repeat="page in pages.$filter(filterText)" ng:class="getClass(page)">
-		       <a href="{{getUrl(page)}}" ng:click="">{{page.name | short}}</a>
-		     </li>
-		   </ul>
-	   </div>
-	  </div>
-	  <div id="section">
-        <a id="feedback" ng:href="{{getFeedbackUrl()}}">Report an Issue or Ask a Question</a>
-	    <ng:include src="getCurrentPartial()" onload="afterPartialLoaded()"></ng:include>
-	  </div>
-  </div>
-</body>
-</html>

docs/overview.template

@@ -1,31 +0,0 @@
-<h1>{{name}}</h1>
-
-{{#workInProgress}}
-<fieldset class="workInProgress">
-  <legend>Work In Progress</legend>
-  This page is currently being revised. It might be incomplete or contain inaccuracies.
-  {{{workInProgress.description}}}
-</fieldset>
-{{/workInProgress}}
-
-{{#deprecated}}
-<fieldset class="deprecated">
-  <legend>Deprecated API</legend>
-  {{deprecated}}
-</fieldset>
-{{/deprecated}}
-
-{{{description}}}
-
-{{#example}}
-<h2>Example</h2>
-{{{exampleDescription}}}
-<doc:example>
-  <doc:source>
-{{/example}}
-    {{{example}}}
-{{#example}}
-  </doc:source>
-  <doc:scenario>{{{scenario}}}</doc:scenario>
-</doc:example>
-{{/example}}

docs/service.template

@@ -25,19 +25,23 @@
   {{/requires}}
 </ul>
 
+{{#method.length}}
 <h2>Methods</h2>
 <ul>
   {{#method}}
-  <li><tt>{{shortName}}</tt>: {{{description}}}</li>
+  <li><tt>{{shortName}}()</tt>: {{{description}}}</li>
   {{/method}}
 </ul>
+{{/method.length}}
 
+{{#property.length}}
 <h2>Properties</h2>
 <ul>
   {{#property}}
   <li><tt>{{name}}:{{#type}}{{type}}{{/type}}</tt>{{#description}}: {{{description}}}{{/description}}</li>
   {{/property}}
 </ul>
+{{/property.length}}
 
 {{#example}}
 <h2>Example</h2>

docs/spec/collectSpec.js

@@ -1,277 +0,0 @@
-console.log(__dirname);
-require.paths.push(__dirname + "/../");
-require.paths.push(__dirname + "/../../");
-var fs = require('fs');
-var Script = process.binding('evals').Script;
-var collect = load('docs/collect.js');
-
-describe('collect', function(){
-  describe('markdown', function(){
-    it('should replace angular in markdown', function(){
-      expect(collect.markdown('<angular/>')).
-        toEqual('<p><tt>&lt;angular/&gt;</tt></p>');
-    });
-    
-    it('should not replace anything in <pre>', function(){
-      expect(collect.markdown('bah x\n<pre>\nangular.k\n</pre>\n asdf x')).
-        toEqual(
-            '<p>bah x</p>' +
-            '<pre>\nangular.k\n</pre>' + 
-            '<p>asdf x</p>');
-    });
-  });
-  
-  describe('processNgDoc', function() {
-    var processNgDoc = collect.processNgDoc,
-        documentation;
-
-    beforeEach(function() {
-      documentation = {
-        pages: [],
-        byName: {}
-      };
-    });
-    
-    it('should store references to docs by name', function() {
-      var doc = {ngdoc: 'section', name: 'fake', raw: {text:''}};
-      processNgDoc(documentation, doc);
-      expect(documentation.byName.fake).toBe(doc);
-    });
-    
-    it('should connect doc to owner (specified by @methodOf)', function() {
-      var parentDoc = {ngdoc: 'section', name: 'parent', raw: {text:''}};
-      var doc = {ngdoc: 'section', name: 'child', methodOf: 'parent', raw: {text:''}};
-      processNgDoc(documentation, parentDoc);
-      processNgDoc(documentation, doc);
-      expect(documentation.byName.parent.method).toBeDefined();
-      expect(documentation.byName.parent.method[0]).toBe(doc);
-    });
-    
-    it('should not add doc to sections if @memberOf specified', function() {
-      var parentDoc = {ngdoc: 'parent', name: 'parent', raw: {text:''}};
-      var doc = {ngdoc: 'child', name: 'child', methodOf: 'parent', raw: {text:''}};
-      processNgDoc(documentation, parentDoc);
-      processNgDoc(documentation, doc);
-      expect(documentation.pages.child).not.toBeDefined();
-    });
-    
-    it('should throw exception if owner does not exist', function() {
-      expect(function() {
-        processNgDoc(documentation, {ngdoc: 'section', methodOf: 'not.exist', raw: {text:''}});
-      }).toThrow('Owner "not.exist" is not defined.');
-    });
-    
-    it('should ignore non-ng docs', function() {
-      var doc = {name: 'anything'};
-      expect(function() {
-        processNgDoc(documentation, doc);
-      }).not.toThrow();
-      expect(documentation.pages).not.toContain(doc);
-    });
-  });
-  
-  describe('TAG', function(){
-    var TAG = collect.TAG;
-    var doc;
-    beforeEach(function(){
-      doc = {};
-    });
-    
-    describe('@param', function(){
-      it('should parse with no default', function(){
-        TAG.param(doc, 'param', 
-            '{(number|string)} number Number \n to format.');
-        expect(doc.param).toEqual([{ 
-          type : '(number|string)', 
-          name : 'number',
-          optional: false,
-          'default' : undefined, 
-          description : 'Number \n to format.' }]);
-      });
-      it('should parse with default and optional', function(){
-        TAG.param(doc, 'param', 
-            '{(number|string)=} [fractionSize=2] desc');
-        expect(doc.param).toEqual([{ 
-          type : '(number|string)', 
-          name : 'fractionSize',
-          optional: true,
-          'default' : '2', 
-          description : 'desc' }]);
-      });
-    });
-    
-    describe('@requires', function() {
-      it('should parse more @requires tag into array', function() {
-        TAG.requires(doc, 'requires', '$service');
-        TAG.requires(doc, 'requires', '$another');
-        
-        expect(doc.requires).toEqual([
-          {name: '$service'},
-          {name: '$another'}
-        ]);
-      });
-    });
-
-    describe('@property', function() {
-      it('should parse @property tags into array', function() {
-        TAG.property(doc, 'property', '{type} name1 desc');
-        TAG.property(doc, 'property', '{type} name2 desc');
-        expect(doc.property.length).toEqual(2);
-      });
-      
-      it('should parse @property with only name', function() {
-        TAG.property(doc, 'property', 'fake');
-        expect(doc.property[0].name).toEqual('fake');
-      });
-      
-      it('should parse @property with optional type', function() {
-        TAG.property(doc, 'property', '{string} name');
-        expect(doc.property[0].name).toEqual('name');
-        expect(doc.property[0].type).toEqual('string');
-      });
-      
-      it('should parse @property with optional description', function() {
-        TAG.property(doc, 'property', 'name desc rip tion');
-        expect(doc.property[0].name).toEqual('name');
-        expect(doc.property[0].description).toEqual('desc rip tion');
-      });
-      
-      it('should parse @property with type and description both', function() {
-        TAG.property(doc, 'property', '{bool} name desc rip tion');
-        expect(doc.property[0].name).toEqual('name');
-        expect(doc.property[0].type).toEqual('bool');
-        expect(doc.property[0].description).toEqual('desc rip tion');
-      });
-      
-      /**
-       * If property description is undefined, this variable is not set in the template,
-       * so the whole @description tag is used instead
-       */
-      it('should set undefined description to "false"', function() {
-        TAG.property(doc, 'property', 'name');
-        expect(doc.property[0].description).toBe(false);
-      });
-    });
-    
-    describe('@methodOf', function() {
-      it('should parse @methodOf tag', function() {
-        expect(function() {
-          TAG.methodOf(doc, 'methodOf', 'parentName');
-        }).not.toThrow();
-        expect(doc.methodOf).toEqual('parentName');
-      });
-    });
-    
-    describe('@returns', function() {
-      it('should not parse @returns without type', function() {
-      expect(function() {TAG.returns(doc, 'returns', 'lala');})
-        .toThrow();
-      });
-      
-      it('should parse @returns with type and description', function() {
-        TAG.returns(doc, 'returns', '{string} descrip tion');
-        expect(doc.returns).toEqual({type: 'string', description: 'descrip tion'});
-      });
-
-      it('should transform description of @returns with markdown', function() {
-        TAG.returns(doc, 'returns', '{string} descrip *tion*');
-        expect(doc.returns).toEqual({type: 'string', description: 'descrip <em>tion</em>'});
-      });
-    });
-    
-    describe('@description', function(){
-      it('should support pre blocks', function(){
-        TAG.description(doc, 'description', '<pre>abc</pre>');
-        expect(doc.description).
-          toBe('<div ng:non-bindable><pre class="brush: js; html-script: true;">abc</pre></div>');
-      });
-
-      it('should support multiple pre blocks', function() {
-        TAG.description(doc, 'description', 'foo \n<pre>abc</pre>\n#bah\nfoo \n<pre>cba</pre>');
-        expect(doc.description).
-          toBe('<p>foo </p>' +
-               '<div ng:non-bindable><pre class="brush: js; html-script: true;">abc</pre></div>' +
-               '<h2>bah</h2>\n\n' +
-               '<p>foo </p>' +
-               '<div ng:non-bindable><pre class="brush: js; html-script: true;">cba</pre></div>');
-
-      });
-
-      it('should support nested @link annotations with or without description', function() {
-        TAG.description(doc, 'description',
-            'foo {@link angular.foo}\n\n da {@link angular.foo bar foo bar } \n\n' +
-            'dad{@link angular.foo}\n\n' +
-            '{@link angular.directive.ng:foo ng:foo}');
-        expect(doc.description).
-          toBe('<p>foo <a href="#!angular.foo"><code>angular.foo</code></a></p>\n\n' +
-               '<p>da <a href="#!angular.foo"><code>bar foo bar</code></a> </p>\n\n' +
-               '<p>dad<a href="#!angular.foo"><code>angular.foo</code></a></p>\n\n' +
-               '<p><a href="#!angular.directive.ng:foo"><code>ng:foo</code></a></p>');
-      });
-
-      it('should increment all headings by one', function() {
-        TAG.description(doc, 'description', '# foo\nabc');
-        expect(doc.description).
-          toBe('<h2>foo</h2>\n\n<p>abc</p>');
-      });
-    });
-
-    describe('@example', function(){
-      it('should not remove {{}}', function(){
-        TAG.example(doc, 'example', 'text {{ abc }}');
-        expect(doc.example).toEqual('text {{ abc }}');
-      });
-    });
-
-    describe('@deprecated', function() {
-      it('should parse @deprecated', function() {
-        TAG.deprecated(doc, 'deprecated', 'Replaced with foo.');
-        expect(doc.deprecated).toBe('Replaced with foo.');
-      })
-    });
-
-    describe('@workInProgress', function() {
-      it('should parse @workInProgress without a description and default to true', function() {
-        TAG.workInProgress(doc, 'workInProgress', '');
-        expect(doc.workInProgress).toEqual({description: ''});
-      });
-
-      it('should parse @workInProgress with a description', function() {
-        TAG.workInProgress(doc, 'workInProgress', 'my description');
-        expect(doc.workInProgress).toEqual({description: '<p>my description</p>'});
-      });
-    });
-
-  });
-  
-  describe('trim', function(){
-    var trim = collect.trim;
-    it('should remove leading/trailing space', function(){
-      expect(trim('  \nabc\n  ')).toEqual('abc');
-    });
-    
-    it('should remove leading space on every line', function(){
-      expect(trim('\n 1\n  2\n   3\n')).toEqual('1\n 2\n  3');
-    });
-  });
-  
-  describe('keywords', function(){
-    var keywords = collect.keywords;
-    it('should collect keywords', function(){
-      expect(keywords('\nHello: World! @ignore.')).toEqual('hello world');
-      expect(keywords('The `ng:class-odd` and ')).toEqual('and ng:class-odd the');
-    });
-  });
-
-});
-
-function load(path){
-  var sandbox = {
-      require: require,
-      console: console,
-      __dirname: __dirname,
-      testmode: true
-  };
-  Script.runInNewContext(fs.readFileSync(path), sandbox, path);
-  return sandbox;
-}

docs/spec/ngdocSpec.js

@@ -0,0 +1,257 @@
+var ngdoc = require('ngdoc.js');
+
+describe('ngdoc', function(){
+  var Doc = ngdoc.Doc;
+  describe('Doc', function(){
+    describe('metadata', function(){
+      
+      it('should find keywords', function(){
+        expect(new Doc('\nHello: World! @ignore.').keywords()).toEqual('hello world');
+        expect(new Doc('The `ng:class-odd` and').keywords()).toEqual('and ng:class-odd the');
+      });
+    });
+    
+    describe('parse', function(){
+      it('should convert @names into properties', function(){
+        var doc = new Doc('\n@name name\n@desc\ndesc\ndesc2\n@dep\n');
+        doc.parse();
+        expect(doc.name).toEqual('name');
+        expect(doc.desc).toEqual('desc\ndesc2');
+        expect(doc.dep).toEqual('');
+      });
+      
+      it('should parse parameters', function(){
+        var doc = new Doc(
+            '@param {*} a short\n' +
+            '@param {Type} b med\n' +
+            '@param {Class=} [c=2] long\nline');
+        doc.parse();
+        expect(doc.param).toEqual([
+           {name:'a', description:'short', type:'*', optional:false, 'default':undefined},
+           {name:'b', description:'med', type:'Type', optional:false, 'default':undefined},
+           {name:'c', description:'long\nline', type:'Class', optional:true, 'default':'2'}
+         ]);
+      });
+      
+      it('should parse return', function(){
+        var doc = new Doc('@returns {Type} text *bold*.');
+        doc.parse();
+        expect(doc.returns).toEqual({
+          type: 'Type',
+          description: 'text <em>bold</em>.'
+        });
+      });
+    });
+    
+    
+  });
+  
+  describe('markdown', function(){
+    var markdown = ngdoc.markdown;
+    
+    it('should replace angular in markdown', function(){
+      expect(markdown('<angular/>')).
+        toEqual('<p><tt>&lt;angular/&gt;</tt></p>');
+    });
+    
+    it('should not replace anything in <pre>', function(){
+      expect(markdown('bah x\n<pre>\nangular.k\n</pre>\n asdf x')).
+        toEqual(
+            '<p>bah x</p>' +
+            '<div ng:non-bindable><pre class="brush: js; html-script: true;">\n' + 
+            'angular.k\n' + 
+            '</pre></div>' + 
+            '<p>asdf x</p>');
+    });
+    
+    it('should replace text between two <pre></pre> tags', function() {
+      expect(markdown('<pre>x</pre># One<pre>b</pre>')).
+        toMatch('</div><h3>One</h3><div');
+    });
+  });
+
+  describe('trim', function(){
+    var trim = ngdoc.trim;
+    it('should remove leading/trailing space', function(){
+      expect(trim('  \nabc\n  ')).toEqual('abc');
+    });
+    
+    it('should remove leading space on every line', function(){
+      expect(trim('\n 1\n  2\n   3\n')).toEqual('1\n 2\n  3');
+    });
+  });
+  
+  describe('merge', function(){
+    it('should merge child with parent', function(){
+      var parent = new Doc({name:'angular.service.abc'});
+      var methodA = new Doc({name:'methodA', methodOf:'angular.service.abc'});
+      var methodB = new Doc({name:'methodB', methodOf:'angular.service.abc'});
+      var propA = new Doc({name:'propA', propertyOf:'angular.service.abc'});
+      var propB = new Doc({name:'propB', propertyOf:'angular.service.abc'});
+      ;var docs = [methodB, methodA, propB, propA, parent]; // keep wrong order;
+      ngdoc.merge(docs);
+      expect(docs.length).toEqual(1);
+      expect(docs[0].name).toEqual('angular.service.abc');
+      expect(docs[0].methods).toEqual([methodA, methodB]);
+      expect(docs[0].properties).toEqual([propA, propB]);
+    });
+    
+  });
+  
+  ////////////////////////////////////////
+  
+  describe('TAG', function(){
+    describe('@param', function(){
+      it('should parse with no default', function(){
+        var doc = new Doc('@param {(number|string)} number Number \n to format.');
+        doc.parse();
+        expect(doc.param).toEqual([{ 
+          type : '(number|string)', 
+          name : 'number',
+          optional: false,
+          'default' : undefined, 
+          description : 'Number \n to format.' }]);
+      });
+      
+      it('should parse with default and optional', function(){
+        var doc = new Doc('@param {(number|string)=} [fractionSize=2] desc');
+        doc.parse();
+        expect(doc.param).toEqual([{ 
+          type : '(number|string)', 
+          name : 'fractionSize',
+          optional: true,
+          'default' : '2', 
+          description : 'desc' }]);
+      });
+    });
+    
+    describe('@requires', function() {
+      it('should parse more @requires tag into array', function() {
+        var doc = new Doc('@requires $service\n@requires $another');
+        doc.parse();
+        expect(doc.requires).toEqual(['$service', '$another']);
+      });
+    });
+
+    describe('@property', function() {
+      it('should parse @property tags into array', function() {
+        var doc = new Doc("@property {type} name1 desc\n@property {type} name2 desc");
+        doc.parse();
+        expect(doc.properties.length).toEqual(2);
+      });
+      
+      it('should parse @property with only name', function() {
+        var doc = new Doc("@property fake");
+        doc.parse();
+        expect(doc.properties[0].name).toEqual('fake');
+      });
+      
+      it('should parse @property with optional type', function() {
+        var doc = new Doc("@property {string} name");
+        doc.parse();
+        expect(doc.properties[0].name).toEqual('name');
+        expect(doc.properties[0].type).toEqual('string');
+      });
+      
+      it('should parse @property with optional description', function() {
+        var doc = new Doc("@property name desc rip tion");
+        doc.parse();
+        expect(doc.properties[0].name).toEqual('name');
+        expect(doc.properties[0].description).toEqual('desc rip tion');
+      });
+      
+      it('should parse @property with type and description both', function() {
+        var doc = new Doc("@property {bool} name desc rip tion");
+        doc.parse();
+        expect(doc.properties[0].name).toEqual('name');
+        expect(doc.properties[0].type).toEqual('bool');
+        expect(doc.properties[0].description).toEqual('desc rip tion');
+      });
+      
+    });
+    
+    describe('@returns', function() {
+      it('should not parse @returns without type', function() {
+        var doc = new Doc("@returns lala");
+        expect(doc.parse).toThrow();
+      });
+      
+      it('should parse @returns with type and description', function() {
+        var doc = new Doc("@returns {string} descrip tion");
+        doc.parse();
+        expect(doc.returns).toEqual({type: 'string', description: 'descrip tion'});
+      });
+
+      it('should transform description of @returns with markdown', function() {
+        var doc = new Doc("@returns {string} descrip *tion*");
+        doc.parse();
+        expect(doc.returns).toEqual({type: 'string', description: 'descrip <em>tion</em>'});
+      });
+
+      it('should support multiline content', function() {
+        var doc = new Doc("@returns {string} description\n new line\n another line");
+        doc.parse();
+        expect(doc.returns).
+          toEqual({type: 'string', description: 'description\n new line\n another line'});
+      });
+    });
+    
+    describe('@description', function(){
+      it('should support pre blocks', function(){
+        var doc = new Doc("@description <pre>abc</pre>");
+        doc.parse();
+        expect(doc.description).
+          toBe('<div ng:non-bindable><pre class="brush: js; html-script: true;">abc</pre></div>');
+      });
+
+      it('should support multiple pre blocks', function() {
+        var doc = new Doc("@description foo \n<pre>abc</pre>\n#bah\nfoo \n<pre>cba</pre>");
+        doc.parse();
+        expect(doc.description).
+          toBe('<p>foo </p>' +
+               '<div ng:non-bindable><pre class="brush: js; html-script: true;">abc</pre></div>' +
+               '<h3>bah</h3>\n\n' +
+               '<p>foo </p>' +
+               '<div ng:non-bindable><pre class="brush: js; html-script: true;">cba</pre></div>');
+
+      });
+
+      it('should support nested @link annotations with or without description', function() {
+        var doc = new Doc("@description " +
+            'foo {@link angular.foo}\n\n da {@link angular.foo bar foo bar } \n\n' +
+            'dad{@link angular.foo}\n\n' +
+            '{@link angular.directive.ng:foo ng:foo}');
+        doc.parse();
+        expect(doc.description).
+          toBe('<p>foo <a href="#!angular.foo"><code>angular.foo</code></a></p>\n\n' +
+               '<p>da <a href="#!angular.foo"><code>bar foo bar</code></a> </p>\n\n' +
+               '<p>dad<a href="#!angular.foo"><code>angular.foo</code></a></p>\n\n' +
+               '<p><a href="#!angular.directive.ng:foo"><code>ng:foo</code></a></p>');
+      });
+
+      it('should increment all headings by two', function() {
+        var doc = new Doc('@description # foo\nabc\n## bar \n xyz');
+        doc.parse();
+        expect(doc.description).
+          toBe('<h3>foo</h3>\n\n<p>abc</p>\n\n<h4>bar</h4>\n\n<p>xyz</p>');
+      });
+    });
+
+    describe('@example', function(){
+      it('should not remove {{}}', function(){
+        var doc = new Doc('@example text {{ abc }}');
+        doc.parse();
+        expect(doc.example).toEqual('text {{ abc }}');
+      });
+    });
+
+    describe('@deprecated', function() {
+      it('should parse @deprecated', function() {
+        var doc = new Doc('@deprecated Replaced with foo.');
+        doc.parse();
+        expect(doc.deprecated).toBe('Replaced with foo.');
+      });
+    });
+  });
+
+});

docs/spec/specs.js

@@ -0,0 +1,39 @@
+if (global.jasmine) return;
+
+require.paths.push(__dirname + "/../../lib");
+require.paths.push(__dirname + '/../src');
+var jasmine = require('jasmine-1.0.1');
+var sys = require('util');
+
+for(var key in jasmine) {
+  global[key] = jasmine[key];
+}
+
+//Patch Jasmine for proper stack traces
+jasmine.Spec.prototype.fail = function (e) {
+  var expectationResult = new jasmine.ExpectationResult({
+    passed: false,
+    message: e ? jasmine.util.formatException(e) : 'Exception'
+  });
+  // PATCH
+  if (e) {
+   expectationResult.trace = e;
+  }
+  this.results_.addResult(expectationResult);
+};
+
+
+
+var isVerbose = false;
+var showColors = true;
+process.argv.forEach(function(arg){
+  switch(arg) {
+  case '--color': showColors = true; break;
+  case '--noColor': showColors = false; break;
+  case '--verbose': isVerbose = true; break;
+  }
+});
+
+jasmine.executeSpecsInFolder(__dirname, function(runner, log){
+  process.exit(runner.results().failedCount);
+}, isVerbose, showColors);

docs/spec/writerSpec.js

@@ -0,0 +1,18 @@
+var writer = require('writer.js');
+describe('writer', function(){
+  describe('toString', function(){
+    var toString = writer.toString;
+    
+    it('should merge string', function(){
+      expect(toString('abc')).toEqual('abc');
+    });
+    
+    it('should merge obj', function(){
+      expect(toString({a:1})).toEqual('{"a":1}');
+    });
+    
+    it('should merge array', function(){
+      expect(toString(['abc',{}])).toEqual('abc{}');
+    });
+  });
+});

docs/specs.js

@@ -1,21 +0,0 @@
-require.paths.push("./lib");
-var jasmine = require('jasmine-1.0.1');
-var sys = require('util');
-
-for(var key in jasmine) {
-  global[key] = jasmine[key];
-}
-
-var isVerbose = false;
-var showColors = true;
-process.argv.forEach(function(arg){
-  switch(arg) {
-  case '--color': showColors = true; break;
-  case '--noColor': showColors = false; break;
-  case '--verbose': isVerbose = true; break;
-  }
-});
-
-jasmine.executeSpecsInFolder(__dirname + '/spec', function(runner, log){
-  process.exit(runner.results().failedCount);
-}, isVerbose, showColors);

docs/src/callback.js

@@ -2,7 +2,10 @@ function noop(){}
 
 function chain(delegateFn, explicitDone){
   var onDoneFn = noop;
-  var onErrorFn = noop;
+  var onErrorFn = function(e){
+    console.error(e.stack || e);
+    process.exit(-1);
+  };
   var waitForCount = 1;
   delegateFn = delegateFn || noop;
   var stackError = new Error('capture stack');

docs/src/dom.js

@@ -0,0 +1,123 @@
+/**
+ * DOM generation class
+ */
+
+exports.DOM = DOM;
+
+//////////////////////////////////////////////////////////
+
+function DOM(){
+  this.out = [];
+  this.headingDepth = 1;
+}
+
+var INLINE_TAGS = {
+    i: true,
+    b: true
+};
+
+DOM.prototype = { 
+  toString: function() {
+    return this.out.join('');
+  },
+  
+  text: function(content) {
+    if (typeof content == "string") {
+      this.out.push(content.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;'));
+    } else if (typeof content == 'function') {
+      content.call(this, this);
+    } else if (content instanceof Array) {
+      this.ul(content);
+    }
+  },
+
+  html: function(html) {
+    if (html) {
+      this.out.push(html);
+    }
+  },
+
+  tag: function(name, attr, text) {
+    if (!text) {
+      text = attr;
+      attr = {};
+      if (name == 'code')
+        attr['ng:non-bindable'] = '';
+    }
+    this.out.push('<' + name);
+    for(var key in attr) {
+      this.out.push(" " + key + '="' + attr[key] + '"');
+    }
+    this.out.push('>');
+    this.text(text);
+    this.out.push('</' + name + '>');
+    if (!INLINE_TAGS[name]) 
+      this.out.push('\n');
+  },
+  
+  code: function(text) {
+    this.tag('div', {'ng:non-bindable':''}, function(){
+      this.tag('pre', {'class':"brush: js; html-script: true;"}, text);
+    });
+  },
+  
+  example: function(source, scenario) {
+    if (source || scenario) {
+      this.h('Example', function(){
+        if (scenario === false) {
+          this.code(source);
+        } else {
+          this.tag('doc:example', function(){
+            if (source) this.tag('doc:source', source);
+            if (scenario) this.tag('doc:scenario', scenario);
+          });
+        }
+      });
+    }
+  },
+  
+  h: function(heading, content, fn){
+    if (content==undefined || content && content.legth == 0) return;
+    this.tag('h' + this.headingDepth, heading);
+    this.headingDepth++;
+    if (content instanceof Array) {
+      this.ul(content, {'class': heading.toLowerCase()}, fn);
+    } else if (fn) {
+      fn.call(this, content);
+    } else {
+      this.text(content);
+    } 
+    this.headingDepth--;
+  },
+  
+  h1: function(attr, text) {
+    this.tag('h1', attr, text);
+  },
+  
+  h2: function(attr, text) {
+    this.tag('h2', attr, text);
+  },
+  
+  h3: function(attr, text) {
+    this.tag('h3', attr, text);
+  },
+  
+  p: function(attr, text) {
+    this.tag('p', attr, text);
+  },
+  
+  ul: function(list, attr, fn) {
+    if (typeof attr == 'function') {
+      fn = attr;
+      attr = {};
+    }
+    this.tag('ul', attr, function(dom){
+      list.forEach(function(item){
+        dom.out.push('<li>');
+        dom.text(fn ? fn(item) : item);
+        dom.out.push('</li>\n');
+      });
+    });
+  }
+  
+};

docs/src/gen-docs.js

@@ -0,0 +1,48 @@
+require.paths.push(__dirname);
+require.paths.push('lib');
+var reader = require('reader.js'),
+    ngdoc = require('ngdoc.js'),
+    writer = require('writer.js'),
+    callback = require('callback.js');
+
+var docs = [];
+var start;
+var work = callback.chain(function(){
+  start = now();
+  console.log('Generating Angular Reference Documentation...');
+  reader.collect(work.waitMany(function(text, file, line){
+    var doc = new ngdoc.Doc(text, file, line);
+    docs.push(doc);
+    doc.parse();
+  }));
+});
+var writes = callback.chain(function(){
+  ngdoc.merge(docs);
+  docs.forEach(function(doc){
+    writer.output(doc.name + '.html', doc.html(), writes.waitFor());
+  });
+  var metadata = ngdoc.metadata(docs);
+  writer.output('docs-keywords.js', ['NG_PAGES=', JSON.stringify(metadata), ';'], writes.waitFor());
+  writer.copy('index.html', writes.waitFor());
+  writer.copy('docs.js', writes.waitFor());
+  writer.copy('docs.css', writes.waitFor());
+  writer.copy('doc_widgets.js', writes.waitFor());
+  writer.copy('doc_widgets.css', writes.waitFor());
+  writer.copy('docs-scenario.html', writes.waitFor());
+  writer.output('docs-scenario.js', ngdoc.scenarios(docs), writes.waitFor());
+  writer.copy('syntaxhighlighter/shBrushJScript.js', writes.waitFor());
+  writer.copy('syntaxhighlighter/shBrushXml.js', writes.waitFor());
+  writer.copy('syntaxhighlighter/shCore.css', writes.waitFor());
+  writer.copy('syntaxhighlighter/shCore.js', writes.waitFor());
+  writer.copy('syntaxhighlighter/shThemeDefault.css', writes.waitFor());
+  writer.copy('jquery.min.js', writes.waitFor());
+});
+writes.onDone(function(){
+  console.log('DONE. Generated ' + docs.length + ' pages in ' + 
+      (now()-start) + 'ms.' );
+});
+work.onDone(writes);
+writer.makeDir('build/docs/syntaxhighlighter', work);
+
+///////////////////////////////////
+function now(){ return new Date().getTime(); }

docs/src/ngdoc.js

@@ -0,0 +1,614 @@
+/**
+ * All parsing/transformation code goes here. All code here should be sync to ease testing.
+ */
+
+var Showdown = require('showdown').Showdown;
+var DOM = require('dom.js').DOM;
+var NEW_LINE = /\n\r?/;
+
+exports.markdown = markdown;
+exports.markdownNoP = markdownNoP;
+exports.trim = trim;
+exports.metadata = metadata;
+exports.scenarios = scenarios;
+exports.merge = merge;
+exports.Doc = Doc;
+
+//////////////////////////////////////////////////////////
+function Doc(text, file, line) {
+  if (typeof text == 'object') {
+    for ( var key in text) {
+      this[key] = text[key];
+    }
+  } else {
+    this.text = text;
+    this.file = file;
+    this.line = line;
+  }
+}
+Doc.METADATA_IGNORE = (function(){
+  var words = require('fs').readFileSync(__dirname + '/ignore.words', 'utf8');
+  return words.toString().split(/[,\s\n\r]+/gm);
+})();
+
+
+
+Doc.prototype = {
+  keywords: function keywords(){
+    var keywords = {};
+    Doc.METADATA_IGNORE.forEach(function(ignore){ keywords[ignore] = true; });
+    var words = [];
+    var tokens = this.text.toLowerCase().split(/[,\.\`\'\"\s]+/mg);
+    tokens.forEach(function(key){
+      var match = key.match(/^(([a-z]|ng\:)[\w\_\-]{2,})/);
+      if (match){
+        key = match[1];
+        if (!keywords[key]) {
+          keywords[key] = true;
+          words.push(key);
+        }
+      }
+    });
+    words.sort();
+    return words.join(' ');
+  },
+  
+  parse: function(){
+    var atName;
+    var atText;
+    var match;
+    var self = this;
+    self.text.split(NEW_LINE).forEach(function(line){
+      if (match = line.match(/^\s*@(\w+)(\s+(.*))?/)) {
+        // we found @name ...
+        // if we have existing name
+        flush();
+        atName = match[1];
+        atText = [];
+        if(match[3]) atText.push(match[3]);
+      } else {
+        if (atName) {
+          atText.push(line);
+        }
+      }
+    });
+    flush();
+    this.shortName = (this.name || '').split(/[\.#]/).pop();
+    this.description = markdown(this.description);
+    
+    function flush(){
+      if (atName) {
+        var text = trim(atText.join('\n'));
+        if (atName == 'param') {
+          var match = text.match(/^{([^}=]+)(=)?}\s+(([^\s=]+)|\[(\S+)=([^\]]+)\])\s+(.*)/);
+                                //  1      12 2     34       4   5   5 6      6  3   7  7
+          if (!match) {
+            throw new Error("Not a valid 'param' format: " + text);
+          }
+          var param = {
+            name: match[5] || match[4],
+            description:markdownNoP(text.replace(match[0], match[7])),
+            type: match[1],
+            optional: !!match[2],
+            'default':match[6]
+          };
+          self.param = self.param || [];
+          self.param.push(param);
+        } else if (atName == 'returns') {
+          var match = text.match(/^{([^}=]+)}\s+(.*)/);
+          if (!match) {
+            throw new Error("Not a valid 'returns' format: " + text);
+          }
+          self.returns = {
+            type: match[1],
+            description: markdownNoP(text.replace(match[0], match[2]))
+          };
+        } else if(atName == 'requires') {
+          self.requires = self.requires || [];
+          self.requires.push(text);
+        } else if(atName == 'property') {
+          var match = text.match(/^({(\S+)}\s*)?(\S+)(\s+(.*))?/);
+          if (!match) {
+            throw new Error("Not a valid 'property' format: " + text);
+          }
+          var property = {
+              type: match[2],
+              name: match[3],
+              description: match[5] || ''
+            };
+          self.properties = self.properties || [];
+          self.properties.push(property);
+        } else {
+          self[atName] = text;
+        }
+      }
+    }
+  },
+  
+  html: function(){
+    var dom = new DOM(),
+        self = this;
+    
+    dom.h(this.name, function(){
+      notice('workInProgress', 'Work in Progress', 
+          'This page is currently being revised. It might be incomplete or contain inaccuracies.');
+      notice('depricated', 'Depricated API');
+      dom.h('Description', self.description, html);
+      dom.h('Dependencies', self.requires);
+      
+      usage();
+      
+      dom.h('Methods', self.methods, function(method){
+        var signature = (method.param || []).map(property('name'));
+        dom.h(method.shortName + '(' + signature.join(', ') + ')', method, function(){
+          dom.html(method.description);
+          method.html_usage_parameters(dom);
+          dom.example(method.example, false);
+        });
+      });
+      dom.h('Properties', self.properties, function(property){
+        dom.h(property.name, function(){
+         dom.text(property.description); 
+         dom.example(property.example, false);
+        });
+      });
+      
+      dom.example(self.example, self.scenario);
+    });
+    
+    return dom.toString();
+    
+    //////////////////////////
+    
+    function html(text){
+      this.html(text);
+    }
+    
+    function usage(){
+      (self['html_usage_' + self.ngdoc] || function(){
+        throw new Error("Don't know how to format @ngdoc: " + self.ngdoc);
+      }).call(self, dom);
+    }
+    
+    function section(name, property, fn) {
+      var value = self[property];
+      if (value) {
+        dom.h2(name);
+        if (typeof value == 'string') {
+          value = markdown(value) + '\n';
+          fn ? fn(value) : dom.html(value);
+        } else if (value instanceof Array) {
+          dom.ul(value, fn);
+        }
+      }
+    }
+    
+    function notice(name, legend, msg){
+      if (self[name] == undefined) return;
+      dom.tag('fieldset', {'class':name}, function(dom){
+        dom.tag('legend', legend);
+        dom.text(msg);
+      });
+    }
+    
+  },
+  
+  html_usage_parameters: function(dom) {
+    dom.h('Parameters', this.param, function(param){
+      dom.tag('code', function(){
+        dom.text(param.name);
+        if (param.optional) {
+          dom.tag('i', function(){
+            dom.text('(optional');
+            if(param['default']) {
+              dom.text('=' + param['default']);
+            }
+            dom.text(')');
+          });
+        }
+        dom.text(' – {');
+        dom.text(param.type);
+        dom.text('} – ');
+      });
+      dom.html(param.description);
+    });
+  },
+  
+  html_usage_returns: function(dom) {
+    var self = this;
+    if (self.returns) {
+      dom.h('Returns', function(){
+        dom.tag('code', self.returns.type);
+        dom.text('– ');
+        dom.html(self.returns.description);
+      });
+    }
+  },
+  
+  html_usage_function: function(dom){
+    var self = this;
+    dom.h('Usage', function(){
+      dom.code(function(){
+        dom.text(self.name);
+        dom.text('(');
+        var first = true;
+        (self.param || []).forEach(function(param){
+          if (first) {
+            first = false;
+          } else {
+            dom.text(', ');
+          }
+          dom.text(param.name);
+        });
+        dom.text(');');
+      });
+      
+      self.html_usage_parameters(dom);
+      self.html_usage_returns(dom);
+    });
+  },
+    
+  html_usage_directive: function(dom){
+    var self = this;
+    dom.h('Usage', function(){
+      dom.tag('pre', {'class':"brush: js; html-script: true;"}, function(){
+        dom.text('<' + self.element + ' ');
+        dom.text(self.shortName);
+        if (self.param) {
+          dom.text('="' + self.param[0].name + '"');
+        }
+        dom.text('>\n   ...\n');
+        dom.text('</' + self.element + '>');
+      });
+      self.html_usage_parameters(dom);
+    });
+  },
+    
+  html_usage_filter: function(dom){
+    var self = this;
+    dom.h('Usage', function(){
+      dom.h('In HTML Template Binding', function(){
+        dom.tag('code', function(){
+          dom.text('{{ ');
+          dom.text(self.shortName);
+          dom.text('_expression | ');
+          dom.text(self.shortName);
+          var first = true;
+          (self.param||[]).forEach(function(param){
+            if (first) {
+              first = false;
+            } else {
+              if (param.optional) {
+                dom.tag('i', function(){
+                  dom.text('[:' + param.name + ']');
+                });
+              } else {
+                dom.text(':' + param.name);
+              }
+            }
+          });
+          dom.text(' }}');
+        });
+      });
+      
+      dom.h3('In JavaScript', function(){
+        dom.tag('code', function(){
+          dom.text('angular.filter.');
+          dom.text(self.shortName);
+          dom.text('(');
+          var first = true;
+          (self.param||[]).forEach(function(param){
+            if (first) {
+              first = false;
+              dom.text(param.name);
+            } else {
+              if (param.optional) {
+                dom.tag('i', function(){
+                  dom.text('[, ' + param.name + ']');
+                });
+              } else {
+                dom.text(', ' + param.name);
+              }
+            }
+          });
+          dom.text(')');
+        });
+      });
+      
+      self.html_usage_parameters(dom);
+      self.html_usage_returns(dom);
+    });
+  },
+    
+  html_usage_formatter: function(dom){
+    var self = this;
+    dom.h('Usage', function(){
+      dom.h('In HTML Template Binding', function(){
+        dom.code(function(){
+          dom.text('<input type="text" ng:format="');
+          dom.text(self.shortName);
+          dom.text('">');
+        });
+      });
+      
+      dom.h3('In JavaScript', function(){
+        dom.code(function(){
+          dom.text('var userInputString = angular.formatter.');
+          dom.text(self.shortName);
+          dom.text('.format(modelValue);');
+        });
+        dom.html('<br/>');
+        dom.code(function(){
+          dom.text('var modelValue = angular.formatter.');
+          dom.text(self.shortName);
+          dom.text('.parse(userInputString);');
+        });
+      });
+      
+      self.html_usage_returns(dom);  
+    });
+  },
+
+  html_usage_validator: function(dom){
+    var self = this;
+    dom.h('Usage', function(){
+      dom.h('In HTML Template Binding', function(){
+        dom.code(function(){
+          dom.text('<input type="text" ng:validate="');
+          dom.text(self.shortName);
+          var first = true;
+          (self.param||[]).forEach(function(param){
+            if (first) {
+              first = false;
+            } else {
+              if (param.optional) {
+                dom.text('[:' + param.name + ']');
+              } else {
+                dom.text(':' + param.name);
+              }
+            }
+          });
+          dom.text('"/>');
+        });
+      });
+      
+      dom.h('In JavaScript', function(){
+        dom.code(function(){
+          dom.text('angular.validator.');
+          dom.text(self.shortName);
+          dom.text('(');
+          var first = true;
+          (self.param||[]).forEach(function(param){
+            if (first) {
+              first = false;
+              dom.text(param.name);
+            } else {
+              if (param.optional) {
+                dom.text('[, ' + param.name + ']');
+              } else {
+                dom.text(', ' + param.name);
+              }
+            }
+          });
+          dom.text(')');
+        });
+      });
+      
+      self.html_usage_parameters(dom);
+      self.html_usage_returns(dom);
+    });
+  },
+  
+  html_usage_widget: function(dom){
+    var self = this;
+    dom.h('Usage', function(){
+      dom.h('In HTML Template Binding', function(){
+        dom.code(function(){
+          if (self.shortName.match(/^@/)) {
+            dom.text('<');
+            dom.text(self.element);
+            dom.text(' ');
+            dom.text(self.shortName.substring(1));
+            if (self.param) {
+              dom.text('="');
+              dom.text(self.param[0].name);
+              dom.text('"');
+            }
+            dom.text('>\n   ...\n</');
+            dom.text(self.element);
+            dom.text('>');
+          } else {
+            dom.text('<');
+            dom.text(self.shortName);
+            (self.param||[]).forEach(function(param){
+              if (param.optional) {
+                dom.text(' [' + param.name + '="..."]');
+              } else {
+                dom.text(' ' + param.name + '="..."');
+              }
+            });
+            dom.text('></');
+            dom.text(self.shortName);
+            dom.text('>');
+          }
+        });
+      });
+      
+      self.html_usage_parameters(dom);
+      self.html_usage_returns(dom);
+    });
+  },
+    
+  html_usage_overview: function(dom){
+  },
+    
+  html_usage_service: function(dom){
+  }
+
+};
+//////////////////////////////////////////////////////////
+
+
+//////////////////////////////////////////////////////////
+function markdown (text) {
+  if (!text) return text;
+  var parts = text.split(/(<pre>[\s\S]*?<\/pre>)/),
+      match;
+
+  parts.forEach(function(text, i){
+    if (text.match(/^<pre>/)) {
+      text = text.
+        replace(/^<pre>/, '<div ng:non-bindable><pre class="brush: js; html-script: true;">').
+        replace(/<\/pre>/, '</pre></div>');
+    } else {
+      text = text.replace(/<angular\/>/gm, '<tt>&lt;angular/&gt;</tt>');
+      text = new Showdown.converter().makeHtml(text.replace(/^#/gm, '###'));
+
+      while (match = text.match(R_LINK)) {
+        text = text.replace(match[0], '<a href="#!' + match[1] + '"><code>' +
+                                        (match[4] || match[1]) +
+                                      '</code></a>');
+      }
+    }
+    parts[i] = text;
+  });
+  return parts.join('');
+};
+var R_LINK = /{@link ([^\s}]+)((\s|\n)+(.+?))?\s*}/m;
+            //       1       123     3 4     42
+function markdownNoP(text) {
+  var lines = markdown(text).split(NEW_LINE);
+  var last = lines.length - 1;
+  lines[0] = lines[0].replace(/^<p>/, '');
+  lines[last] = lines[last].replace(/<\/p>$/, '');
+  return lines.join('\n');
+}
+
+
+//////////////////////////////////////////////////////////
+function scenarios(docs){
+  var specs = [];
+  docs.forEach(function(doc){
+    if (doc.scenario) {
+      specs.push('describe("');
+      specs.push(doc.name);
+      specs.push('", function(){\n');
+      specs.push('  beforeEach(function(){\n');
+      specs.push('    browser().navigateTo("index.html#!' + doc.name + '");');
+      specs.push('  });\n\n');
+      specs.push(doc.scenario);
+      specs.push('\n});\n\n');
+    }
+  });
+  return specs;
+}
+
+
+//////////////////////////////////////////////////////////
+function metadata(docs){
+  var words = [];
+  docs.forEach(function(doc){
+    words.push({
+      name:doc.name,
+      type: doc.ngdoc,
+      keywords:doc.keywords()
+    });
+  });
+  words.sort(keywordSort);
+  return words;
+}
+
+function keywordSort(a,b){
+  // supper ugly comparator that orders all utility methods and objects before all the other stuff
+  // like widgets, directives, services, etc.
+  // Mother of all beautiful code please forgive me for the sin that this code certainly is.
+
+  if (a.name === b.name) return 0;
+  if (a.name === 'angular') return -1;
+  if (b.name === 'angular') return 1;
+
+  function namespacedName(page) {
+    return (page.name.match(/\./g).length === 1 && page.type !== 'overview' ? '0' : '1') + page.name;
+  }
+
+  var namespacedA = namespacedName(a),
+      namespacedB = namespacedName(b);
+
+  return namespacedA < namespacedB ? -1 : 1;
+}
+
+
+//////////////////////////////////////////////////////////
+function trim(text) {
+  var MAX = 9999;
+  var empty = RegExp.prototype.test.bind(/^\s*$/);
+  var lines = text.split('\n');
+  var minIndent = MAX;
+  lines.forEach(function(line){
+    minIndent = Math.min(minIndent, indent(line));
+  });
+  for ( var i = 0; i < lines.length; i++) {
+    lines[i] = lines[i].substring(minIndent);
+  }
+  // remove leading lines
+  while (empty(lines[0])) {
+    lines.shift();
+  }
+  // remove trailing
+  while (empty(lines[lines.length - 1])) {
+    lines.pop();
+  }
+  return lines.join('\n');
+  
+  function indent(line) {
+    for(var i = 0; i < line.length; i++) {
+      if (line.charAt(i) != ' ')  {
+        return i;
+      }
+    }
+    return MAX;
+  }
+}
+
+//////////////////////////////////////////////////////////
+function merge(docs){
+  var byName = {};
+  docs.forEach(function(doc){
+    byName[doc.name] = doc;
+  });
+  for(var i=0; i<docs.length;) {
+    if (findParent(docs[i], 'method') ||
+          findParent(docs[i], 'property')) {
+      docs.splice(i, 1);
+    } else {
+      i++;
+    }
+  }
+  
+  function findParent(doc, name){
+    var parentName = doc[name+'Of'];
+    if (!parentName) return false;
+    
+    var parent = byName[parentName];
+    if (!parent) 
+      throw new Error("No parent named '" + parentName + "' for '" + 
+          doc.name + "' in @" + name + "Of.");
+    
+    var listName = (name + 's').replace(/ys$/, 'ies');
+    var list = parent[listName] = (parent[listName] || []);
+    list.push(doc);
+    list.sort(orderByName);
+    return true;
+  }
+  
+  function orderByName(a, b){
+    return a.name < b.name ? -1 : (a.name > b.name ? 1 : 0);
+  }
+}
+//////////////////////////////////////////////////////////
+
+function property(name) {
+  return function(value){ 
+    return value[name];
+  };
+} 

docs/src/reader.js

@@ -0,0 +1,91 @@
+/**
+ * All reading related code here. This is so that we can separate the async code from sync code
+ * for testability
+ */
+require.paths.push(__dirname);
+var fs       = require('fs'),
+    callback = require('callback');
+
+var NEW_LINE = /\n\r?/;
+
+function collect(callback){
+  findJsFiles('src', callback.waitMany(function(file) {
+    //console.log('reading', file, '...');
+    findNgDocInJsFile(file, callback.waitMany(function(doc, line) {
+      callback(doc, file, line);
+    }));
+  }));
+  findNgDocInDir('docs/', callback.waitMany(callback));
+  callback.done();
+}
+
+function findJsFiles(dir, callback){
+  fs.readdir(dir, callback.waitFor(function(err, files){
+    if (err) return this.error(err);
+    files.forEach(function(file){
+      var path = dir + '/' + file;
+      fs.lstat(path, callback.waitFor(function(err, stat){
+        if (err) return this.error(err);
+        if (stat.isDirectory())
+          findJsFiles(path, callback.waitMany(callback));
+        else if (/\.js$/.test(path))
+          callback(path);
+      }));
+    });
+    callback.done();
+  }));
+}
+
+function findNgDocInDir(directory, docNotify) {
+  fs.readdir(directory, docNotify.waitFor(function(err, files){
+    if (err) return this.error(err);
+    files.forEach(function(file){
+      //console.log('reading', directory + file, '...');
+      if (!file.match(/\.ngdoc$/)) return;
+      fs.readFile(directory + file, docNotify.waitFor(function(err, content){
+        if (err) return this.error(err);
+        docNotify(content.toString(), directory + file, 1);
+      }));
+    });
+    docNotify.done();
+  }));
+}
+
+function findNgDocInJsFile(file, callback) {
+  fs.readFile(file, callback.waitFor(function(err, content){
+    var lines = content.toString().split(NEW_LINE);
+    var text;
+    var startingLine ;
+    var match;
+    var inDoc = false;
+    lines.forEach(function(line, lineNumber){
+      lineNumber++;
+      // is the comment starting?
+      if (!inDoc && (match = line.match(/^\s*\/\*\*\s*(.*)$/))) {
+        line = match[1];
+        inDoc = true;
+        text = [];
+        startingLine = lineNumber;
+      }
+      // are we done?
+      if (inDoc && line.match(/\*\//)) {
+        text = text.join('\n');
+        text = text.replace(/^\n/, '');
+        if (text.match(/@ngdoc/)){
+          callback(text, startingLine);
+        }
+        doc = null;
+        inDoc = false;
+      }
+      // is the comment add text
+      if (inDoc){
+        text.push(line.replace(/^\s*\*\s?/, ''));
+      }
+    });
+    callback.done();
+  }));
+}
+
+
+
+exports.collect = collect;

docs/src/templates/docs.css

@@ -1,3 +1,5 @@
+/* Common Style */
+
 body {
   font-family: Arial, sans-serif;
   font-size: 14px;
@@ -5,28 +7,49 @@ body {
   padding: 0;
 }
 
-#page {
-  display: table-row;
-}
-
-#sidebar,
-#section {
-  display: table-cell;
-}
-
 a {
   color: blue;
 }
 
-.nav-section {
-  margin-left: 1em;
-  margin-top: 0.5em;
+
+/* Main Layout */
+
+#header {
+  height: 3.5em;
 }
 
-.section-title {
-  float: right;
+#sidebar,
+#main {
+  position: absolute;
+  top: 3.5em;
+  bottom: 0;
+  margin-top: 1px;
+  overflow-x: hidden;
 }
 
+#sidebar {
+  width: 13.8em;
+  padding: 0.8em 0em 1.5em 0.8em;
+}
+
+#main {
+  left: 14.6em;
+  right: 0;
+  padding: 1em;
+  overflow-y: scroll;
+}
+
+#api-list {
+  position: absolute;
+  top: 3em;
+  bottom: 1em;
+  overflow-y: scroll;
+  padding-right: 0.8em;
+}
+
+
+/* App Header */
+
 #header {
   background-color: #F2C200;
   border-bottom: 1px solid #957800;
@@ -42,7 +65,7 @@ a {
 }
 
 #header .angular {
-  font-family: Courier New, monospace;
+  font-family: "Courier New", monospace;
   font-weight: bold;
 }
 
@@ -55,36 +78,54 @@ a {
   text-decoration: underline;
 }
 
-#section {
-  padding: 1em;
-  width: 100%;
-}
 
-#section h1 {
+/* Main main Style */
+
+#main h1 {
   font-family: monospace;
   margin-top: 0;
   padding-bottom: 5px;
   border-bottom: 1px solid #CCC;
 }
 
-#section h2 {
+#main h2 {
   margin-top: 1.8em;
 }
 
-#section h1 + h2 {
+#main h1 + h2 {
   margin-top: 1.3em;
 }
 
-#section h3 {
+#main h3 {
   margin-top: 1.5em;
 }
 
-#sidebar {
-  padding: 10px 10px 20px 10px;
-  background-color: #EEE;
+#main ul.methods h3,
+#main ul.properties h3 {
+  margin-top: 1.5em;
+  font-family: "Courier New", monospace;
+}
+
+.main-title {
+  float: right;
+}
+
+
+/* Searchbox & Sidebar Style */
+
+#search-box, #sidebar {
   border-right: 1px solid #DDD;
 }
 
+#sidebar {
+  background-color: #EEE;
+}
+
+#search-box {
+  width: 16em;
+  margin-bottom: 1em;
+}
+
 #sidebar a {
   text-decoration: none;
 }
@@ -93,16 +134,12 @@ a {
   text-decoration: underline;
 }
 
-#sidebar input {
-  width: 175px;
-  margin-bottom: 1em;
-}
-
 #sidebar ul {
   list-style-type: none;
   /*TODO(esprehn): Can we just reset globally and not break examples?*/
   margin: 0;
-  padding: 0;
+  padding: 0 0.8em 0 0;
+  width: 13em;
 }
 
 #sidebar ul li {
@@ -152,6 +189,9 @@ a {
   font-family: monospace;
 }
 
+
+/* Warning and Info Banners */
+
 .deprecated {
   border: 2px solid red;
 }
@@ -170,8 +210,53 @@ a {
   color: orange;
 }
 
+
+/* Feedback Link */
+
 #feedback {
   float: right;
   width: 10em;
   text-align: right;
-}
+}
+
+
+/* Live Example Style */
+
+.doc-example-live table td {
+  padding: 0 1.5em;
+}
+
+
+/* Scrollbars */
+
+::-webkit-scrollbar{
+  width:0.8em;
+  margin: 0.2em 0em;
+}
+
+::-webkit-scrollbar:hover{
+  background-color:#eee;
+}
+
+::-webkit-scrollbar-thumb{
+  min-height:0.8em;
+  min-width:0.8em;
+  -webkit-border-radius:0.5em;
+  background-color: #ddd;
+}
+
+::-webkit-scrollbar-thumb:hover{
+  background-color: #bbb;
+}
+
+::-webkit-scrollbar-thumb:active{
+  background-color:#888;
+}
+
+#sidebar::-webkit-scrollbar {
+  background-color:#eee;
+}
+
+#main::-webkit-scrollbar {
+  background-color:#fff;
+}

docs/src/templates/docs.js

@@ -1,5 +1,3 @@
-SyntaxHighlighter['defaults'].toolbar = false;
-
 DocsController.$inject = ['$location', '$browser', '$window'];
 function DocsController($location, $browser, $window) {
   this.pages = NG_PAGES;
@@ -31,7 +29,6 @@ function DocsController($location, $browser, $window) {
   };
 
   this.afterPartialLoaded = function() {
-    $window.scroll(0,0);
     SyntaxHighlighter.highlight();
   };
 
@@ -39,10 +36,12 @@ function DocsController($location, $browser, $window) {
     return "mailto:angular@googlegroups.com?" +
            "subject=" + escape("Feedback on " + $location.href) + "&" +
            "body=" + escape("Hi there,\n\nI read " + $location.href + " and wanted to ask ....");
-  }
+  };
   
 }
 
 angular.filter('short', function(name){
   return (name||'').split(/\./).pop();
-});
+});
+
+SyntaxHighlighter['defaults'].toolbar = false;

docs/src/templates/index.html

@@ -0,0 +1,46 @@
+<!doctype html>
+<html xmlns:ng="http://angularjs.org/"
+      xmlns:doc="http://docs.angularjs.org/"
+      ng:controller="DocsController">
+<head>
+  <title ng:bind-template="&lt;angular/&gt;: {{getTitle()}}">&lt;angular/&gt;</title>
+
+  <meta name="fragment" content="!">
+
+  <link rel="stylesheet" href="doc_widgets.css" type="text/css" />
+  <link rel="stylesheet" href="docs.css" type="text/css"/>
+  <link rel="stylesheet" href="syntaxhighlighter/shCore.css" type="text/css"/>
+  <link rel="stylesheet" href="syntaxhighlighter/shThemeDefault.css" type="text/css"/>
+
+  <script src="jquery.min.js"></script>
+  <script src="syntaxhighlighter/shCore.js"></script>
+  <script src="syntaxhighlighter/shBrushJScript.js"></script>
+  <script src="syntaxhighlighter/shBrushXml.js"></script>
+
+  <script src="../angular.min.js" ng:autobind></script>
+  <script src="docs.js"></script>
+  <script src="doc_widgets.js"></script>
+  <script src="docs-keywords.js"></script>
+</head>
+<body style="display:none;" ng:show="true">
+  <div id="header">
+    <h1>
+      <span class="main-title">{{getTitle()}}</span>
+      <a href="#" tabindex="0"><span class="angular">&lt;angular/&gt;</span> Docs</a>
+    </h1>
+  </div>
+  <div id="sidebar">
+    <input type="text" name="search" id="search-box" placeholder="search the docs"
+           tabindex="1" accesskey="s"/>
+    <ul id="api-list">
+      <li ng:repeat="page in pages.$filter(search)" ng:class="getClass(page)">
+        <a href="{{getUrl(page)}}" ng:click="" tabindex="2">{{page.name | short}}</a>
+      </li>
+    </ul>
+  </div>
+  <div id="main">
+    <a id="feedback" ng:href="{{getFeedbackUrl()}}">Report an Issue or Ask a Question</a>
+    <ng:include src="getCurrentPartial()" onload="afterPartialLoaded()"></ng:include>
+  </div>
+</body>
+</html>

docs/src/templates/jquery.min.js

@@ -0,0 +1 @@
+../../../lib/jquery/jquery-1.4.2.min.js

docs/src/templates/syntaxhighlighter/shBrushJScript.js

@@ -0,0 +1,52 @@
+/**
+ * SyntaxHighlighter
+ * http://alexgorbatchev.com/SyntaxHighlighter
+ *
+ * SyntaxHighlighter is donationware. If you are using it, please donate.
+ * http://alexgorbatchev.com/SyntaxHighlighter/donate.html
+ *
+ * @version
+ * 3.0.83 (July 02 2010)
+ * 
+ * @copyright
+ * Copyright (C) 2004-2010 Alex Gorbatchev.
+ *
+ * @license
+ * Dual licensed under the MIT and GPL licenses.
+ */
+;(function()
+{
+	// CommonJS
+	typeof(require) != 'undefined' ? SyntaxHighlighter = require('shCore').SyntaxHighlighter : null;
+
+	function Brush()
+	{
+		var keywords =	'break case catch continue ' +
+						'default delete do else false  ' +
+						'for function if in instanceof ' +
+						'new null return super switch ' +
+						'this throw true try typeof var while with'
+						;
+
+		var r = SyntaxHighlighter.regexLib;
+		
+		this.regexList = [
+			{ regex: r.multiLineDoubleQuotedString,					css: 'string' },			// double quoted strings
+			{ regex: r.multiLineSingleQuotedString,					css: 'string' },			// single quoted strings
+			{ regex: r.singleLineCComments,							css: 'comments' },			// one line comments
+			{ regex: r.multiLineCComments,							css: 'comments' },			// multiline comments
+			{ regex: /\s*#.*/gm,									css: 'preprocessor' },		// preprocessor tags like #region and #endregion
+			{ regex: new RegExp(this.getKeywords(keywords), 'gm'),	css: 'keyword' }			// keywords
+			];
+	
+		this.forHtmlScript(r.scriptScriptTags);
+	};
+
+	Brush.prototype	= new SyntaxHighlighter.Highlighter();
+	Brush.aliases	= ['js', 'jscript', 'javascript'];
+
+	SyntaxHighlighter.brushes.JScript = Brush;
+
+	// CommonJS
+	typeof(exports) != 'undefined' ? exports.Brush = Brush : null;
+})();

docs/src/templates/syntaxhighlighter/shBrushXml.js

@@ -0,0 +1,69 @@
+/**
+ * SyntaxHighlighter
+ * http://alexgorbatchev.com/SyntaxHighlighter
+ *
+ * SyntaxHighlighter is donationware. If you are using it, please donate.
+ * http://alexgorbatchev.com/SyntaxHighlighter/donate.html
+ *
+ * @version
+ * 3.0.83 (July 02 2010)
+ * 
+ * @copyright
+ * Copyright (C) 2004-2010 Alex Gorbatchev.
+ *
+ * @license
+ * Dual licensed under the MIT and GPL licenses.
+ */
+;(function()
+{
+	// CommonJS
+	typeof(require) != 'undefined' ? SyntaxHighlighter = require('shCore').SyntaxHighlighter : null;
+
+	function Brush()
+	{
+		function process(match, regexInfo)
+		{
+			var constructor = SyntaxHighlighter.Match,
+				code = match[0],
+				tag = new XRegExp('(&lt;|<)[\\s\\/\\?]*(?<name>[:\\w-\\.]+)', 'xg').exec(code),
+				result = []
+				;
+		
+			if (match.attributes != null) 
+			{
+				var attributes,
+					regex = new XRegExp('(?<name> [\\w:\\-\\.]+)' +
+										'\\s*=\\s*' +
+										'(?<value> ".*?"|\'.*?\'|\\w+)',
+										'xg');
+
+				while ((attributes = regex.exec(code)) != null) 
+				{
+					result.push(new constructor(attributes.name, match.index + attributes.index, 'color1'));
+					result.push(new constructor(attributes.value, match.index + attributes.index + attributes[0].indexOf(attributes.value), 'string'));
+				}
+			}
+
+			if (tag != null)
+				result.push(
+					new constructor(tag.name, match.index + tag[0].indexOf(tag.name), 'keyword')
+				);
+
+			return result;
+		}
+	
+		this.regexList = [
+			{ regex: new XRegExp('(\\&lt;|<)\\!\\[[\\w\\s]*?\\[(.|\\s)*?\\]\\](\\&gt;|>)', 'gm'),			css: 'color2' },	// <![ ... [ ... ]]>
+			{ regex: SyntaxHighlighter.regexLib.xmlComments,												css: 'comments' },	// <!-- ... -->
+			{ regex: new XRegExp('(&lt;|<)[\\s\\/\\?]*(\\w+)(?<attributes>.*?)[\\s\\/\\?]*(&gt;|>)', 'sg'), func: process }
+		];
+	};
+
+	Brush.prototype	= new SyntaxHighlighter.Highlighter();
+	Brush.aliases	= ['xml', 'xhtml', 'xslt', 'html'];
+
+	SyntaxHighlighter.brushes.Xml = Brush;
+
+	// CommonJS
+	typeof(exports) != 'undefined' ? exports.Brush = Brush : null;
+})();

docs/src/templates/syntaxhighlighter/shCore.css

@@ -0,0 +1,226 @@
+/**
+ * SyntaxHighlighter
+ * http://alexgorbatchev.com/SyntaxHighlighter
+ *
+ * SyntaxHighlighter is donationware. If you are using it, please donate.
+ * http://alexgorbatchev.com/SyntaxHighlighter/donate.html
+ *
+ * @version
+ * 3.0.83 (July 02 2010)
+ * 
+ * @copyright
+ * Copyright (C) 2004-2010 Alex Gorbatchev.
+ *
+ * @license
+ * Dual licensed under the MIT and GPL licenses.
+ */
+.syntaxhighlighter a,
+.syntaxhighlighter div,
+.syntaxhighlighter code,
+.syntaxhighlighter table,
+.syntaxhighlighter table td,
+.syntaxhighlighter table tr,
+.syntaxhighlighter table tbody,
+.syntaxhighlighter table thead,
+.syntaxhighlighter table caption,
+.syntaxhighlighter textarea {
+  -moz-border-radius: 0 0 0 0 !important;
+  -webkit-border-radius: 0 0 0 0 !important;
+  background: none !important;
+  border: 0 !important;
+  bottom: auto !important;
+  float: none !important;
+  height: auto !important;
+  left: auto !important;
+  line-height: 1.1em !important;
+  margin: 0 !important;
+  outline: 0 !important;
+  overflow: visible !important;
+  padding: 0 !important;
+  position: static !important;
+  right: auto !important;
+  text-align: left !important;
+  top: auto !important;
+  vertical-align: baseline !important;
+  width: auto !important;
+  box-sizing: content-box !important;
+  font-family: "Consolas", "Bitstream Vera Sans Mono", "Courier New", Courier, monospace !important;
+  font-weight: normal !important;
+  font-style: normal !important;
+  font-size: 1em !important;
+  min-height: inherit !important;
+  min-height: auto !important;
+}
+
+.syntaxhighlighter {
+  width: 100% !important;
+  margin: 1em 0 1em 0 !important;
+  position: relative !important;
+  overflow: auto !important;
+  font-size: 1em !important;
+}
+.syntaxhighlighter.source {
+  overflow: hidden !important;
+}
+.syntaxhighlighter .bold {
+  font-weight: bold !important;
+}
+.syntaxhighlighter .italic {
+  font-style: italic !important;
+}
+.syntaxhighlighter .line {
+  white-space: pre !important;
+}
+.syntaxhighlighter table {
+  width: 100% !important;
+}
+.syntaxhighlighter table caption {
+  text-align: left !important;
+  padding: .5em 0 0.5em 1em !important;
+}
+.syntaxhighlighter table td.code {
+  width: 100% !important;
+}
+.syntaxhighlighter table td.code .container {
+  position: relative !important;
+}
+.syntaxhighlighter table td.code .container textarea {
+  box-sizing: border-box !important;
+  position: absolute !important;
+  left: 0 !important;
+  top: 0 !important;
+  width: 100% !important;
+  height: 100% !important;
+  border: none !important;
+  background: white !important;
+  padding-left: 1em !important;
+  overflow: hidden !important;
+  white-space: pre !important;
+}
+.syntaxhighlighter table td.gutter .line {
+  text-align: right !important;
+  padding: 0 0.5em 0 1em !important;
+}
+.syntaxhighlighter table td.code .line {
+  padding: 0 1em !important;
+}
+.syntaxhighlighter.nogutter td.code .container textarea, .syntaxhighlighter.nogutter td.code .line {
+  padding-left: 0em !important;
+}
+.syntaxhighlighter.show {
+  display: block !important;
+}
+.syntaxhighlighter.collapsed table {
+  display: none !important;
+}
+.syntaxhighlighter.collapsed .toolbar {
+  padding: 0.1em 0.8em 0em 0.8em !important;
+  font-size: 1em !important;
+  position: static !important;
+  width: auto !important;
+  height: auto !important;
+}
+.syntaxhighlighter.collapsed .toolbar span {
+  display: inline !important;
+  margin-right: 1em !important;
+}
+.syntaxhighlighter.collapsed .toolbar span a {
+  padding: 0 !important;
+  display: none !important;
+}
+.syntaxhighlighter.collapsed .toolbar span a.expandSource {
+  display: inline !important;
+}
+.syntaxhighlighter .toolbar {
+  position: absolute !important;
+  right: 1px !important;
+  top: 1px !important;
+  width: 11px !important;
+  height: 11px !important;
+  font-size: 10px !important;
+  z-index: 10 !important;
+}
+.syntaxhighlighter .toolbar span.title {
+  display: inline !important;
+}
+.syntaxhighlighter .toolbar a {
+  display: block !important;
+  text-align: center !important;
+  text-decoration: none !important;
+  padding-top: 1px !important;
+}
+.syntaxhighlighter .toolbar a.expandSource {
+  display: none !important;
+}
+.syntaxhighlighter.ie {
+  font-size: .9em !important;
+  padding: 1px 0 1px 0 !important;
+}
+.syntaxhighlighter.ie .toolbar {
+  line-height: 8px !important;
+}
+.syntaxhighlighter.ie .toolbar a {
+  padding-top: 0px !important;
+}
+.syntaxhighlighter.printing .line.alt1 .content,
+.syntaxhighlighter.printing .line.alt2 .content,
+.syntaxhighlighter.printing .line.highlighted .number,
+.syntaxhighlighter.printing .line.highlighted.alt1 .content,
+.syntaxhighlighter.printing .line.highlighted.alt2 .content {
+  background: none !important;
+}
+.syntaxhighlighter.printing .line .number {
+  color: #bbbbbb !important;
+}
+.syntaxhighlighter.printing .line .content {
+  color: black !important;
+}
+.syntaxhighlighter.printing .toolbar {
+  display: none !important;
+}
+.syntaxhighlighter.printing a {
+  text-decoration: none !important;
+}
+.syntaxhighlighter.printing .plain, .syntaxhighlighter.printing .plain a {
+  color: black !important;
+}
+.syntaxhighlighter.printing .comments, .syntaxhighlighter.printing .comments a {
+  color: #008200 !important;
+}
+.syntaxhighlighter.printing .string, .syntaxhighlighter.printing .string a {
+  color: blue !important;
+}
+.syntaxhighlighter.printing .keyword {
+  color: #006699 !important;
+  font-weight: bold !important;
+}
+.syntaxhighlighter.printing .preprocessor {
+  color: gray !important;
+}
+.syntaxhighlighter.printing .variable {
+  color: #aa7700 !important;
+}
+.syntaxhighlighter.printing .value {
+  color: #009900 !important;
+}
+.syntaxhighlighter.printing .functions {
+  color: #ff1493 !important;
+}
+.syntaxhighlighter.printing .constants {
+  color: #0066cc !important;
+}
+.syntaxhighlighter.printing .script {
+  font-weight: bold !important;
+}
+.syntaxhighlighter.printing .color1, .syntaxhighlighter.printing .color1 a {
+  color: gray !important;
+}
+.syntaxhighlighter.printing .color2, .syntaxhighlighter.printing .color2 a {
+  color: #ff1493 !important;
+}
+.syntaxhighlighter.printing .color3, .syntaxhighlighter.printing .color3 a {
+  color: red !important;
+}
+.syntaxhighlighter.printing .break, .syntaxhighlighter.printing .break a {
+  color: black !important;
+}

docs/src/templates/syntaxhighlighter/shThemeDefault.css

@@ -0,0 +1,117 @@
+/**
+ * SyntaxHighlighter
+ * http://alexgorbatchev.com/SyntaxHighlighter
+ *
+ * SyntaxHighlighter is donationware. If you are using it, please donate.
+ * http://alexgorbatchev.com/SyntaxHighlighter/donate.html
+ *
+ * @version
+ * 3.0.83 (July 02 2010)
+ * 
+ * @copyright
+ * Copyright (C) 2004-2010 Alex Gorbatchev.
+ *
+ * @license
+ * Dual licensed under the MIT and GPL licenses.
+ */
+.syntaxhighlighter {
+  background-color: white !important;
+}
+.syntaxhighlighter .line.alt1 {
+  background-color: white !important;
+}
+.syntaxhighlighter .line.alt2 {
+  background-color: white !important;
+}
+.syntaxhighlighter .line.highlighted.alt1, .syntaxhighlighter .line.highlighted.alt2 {
+  background-color: #e0e0e0 !important;
+}
+.syntaxhighlighter .line.highlighted.number {
+  color: black !important;
+}
+.syntaxhighlighter table caption {
+  color: black !important;
+}
+.syntaxhighlighter .gutter {
+  color: #afafaf !important;
+}
+.syntaxhighlighter .gutter .line {
+  border-right: 3px solid #6ce26c !important;
+}
+.syntaxhighlighter .gutter .line.highlighted {
+  background-color: #6ce26c !important;
+  color: white !important;
+}
+.syntaxhighlighter.printing .line .content {
+  border: none !important;
+}
+.syntaxhighlighter.collapsed {
+  overflow: visible !important;
+}
+.syntaxhighlighter.collapsed .toolbar {
+  color: blue !important;
+  background: white !important;
+  border: 1px solid #6ce26c !important;
+}
+.syntaxhighlighter.collapsed .toolbar a {
+  color: blue !important;
+}
+.syntaxhighlighter.collapsed .toolbar a:hover {
+  color: red !important;
+}
+.syntaxhighlighter .toolbar {
+  color: white !important;
+  background: #6ce26c !important;
+  border: none !important;
+}
+.syntaxhighlighter .toolbar a {
+  color: white !important;
+}
+.syntaxhighlighter .toolbar a:hover {
+  color: black !important;
+}
+.syntaxhighlighter .plain, .syntaxhighlighter .plain a {
+  color: black !important;
+}
+.syntaxhighlighter .comments, .syntaxhighlighter .comments a {
+  color: #008200 !important;
+}
+.syntaxhighlighter .string, .syntaxhighlighter .string a {
+  color: blue !important;
+}
+.syntaxhighlighter .keyword {
+  color: #006699 !important;
+}
+.syntaxhighlighter .preprocessor {
+  color: gray !important;
+}
+.syntaxhighlighter .variable {
+  color: #aa7700 !important;
+}
+.syntaxhighlighter .value {
+  color: #009900 !important;
+}
+.syntaxhighlighter .functions {
+  color: #ff1493 !important;
+}
+.syntaxhighlighter .constants {
+  color: #0066cc !important;
+}
+.syntaxhighlighter .script {
+  font-weight: bold !important;
+  color: #006699 !important;
+  background-color: none !important;
+}
+.syntaxhighlighter .color1, .syntaxhighlighter .color1 a {
+  color: gray !important;
+}
+.syntaxhighlighter .color2, .syntaxhighlighter .color2 a {
+  color: #ff1493 !important;
+}
+.syntaxhighlighter .color3, .syntaxhighlighter .color3 a {
+  color: red !important;
+}
+
+.syntaxhighlighter .keyword {
+  font-weight: bold !important;
+}

docs/src/templates/syntaxhighlighter/version.txt

@@ -0,0 +1,2 @@
+3.0.83
+

docs/src/writer.js

@@ -0,0 +1,61 @@
+/**
+ * All writing related code here. This is so that we can separate the async code from sync code
+ * for testability
+ */
+require.paths.push(__dirname);
+var fs         = require('fs');
+var OUTPUT_DIR = "build/docs/";
+
+function output(docs, content, callback){
+  callback();
+}
+
+exports.output = function(file, content, callback){
+  //console.log('writing', OUTPUT_DIR + file, '...');
+  fs.writeFile(
+      OUTPUT_DIR + file, 
+      exports.toString(content), 
+      callback);
+};
+
+
+exports.toString = function toString(obj){
+  switch (typeof obj) {
+  case 'string': 
+    return obj;
+  case 'object': 
+    if (obj instanceof Array) {
+      obj.forEach(function (value, key){
+        obj[key] = toString(value);
+      });
+      return obj.join('');
+    } else {
+      return JSON.stringify(obj);
+    }
+  }
+  return obj;
+};
+
+exports.makeDir = function (path, callback) {
+  var parts = path.split(/\//);
+  path = '.';
+  (function next(){
+    if (parts.length) {
+      path += '/' + parts.shift();
+      fs.mkdir(path, 0777, next);
+    } else {
+      callback();
+    }
+  })();
+};
+
+exports.copy = function(filename, callback){
+  //console.log('writing', OUTPUT_DIR + filename, '...');
+  fs.readFile('docs/src/templates/' + filename, function(err, content){
+    if (err) return callback.error(err);
+    fs.writeFile(
+        OUTPUT_DIR + filename, 
+        content, 
+        callback);
+  });
+};

docs/validator.template

@@ -1,59 +0,0 @@
-<h1>{{name}}</h1>
-
-{{#workInProgress}}
-<fieldset class="workInProgress">
-  <legend>Work In Progress</legend>
-  This page is currently being revised. It might be incomplete or contain inaccuracies.
-  {{{workInProgress.description}}}
-</fieldset>
-{{/workInProgress}}
-
-{{#deprecated}}
-<fieldset class="deprecated">
-  <legend>Deprecated API</legend>
-  {{deprecated}}
-</fieldset>
-{{/deprecated}}
-
-<h2>Description</h2>
-{{{description}}}
-
-<h2>Usage</h2>
-<h3>In HTML Template Binding</h3>
-<tt>
-  &lt;input type="text" ng:validate="{{shortName}}{{#paramRest}}{{^default}}:{{name}}{{/default}}{{#default}}<i>[:{{name}}]</i>{{/default}}{{/paramRest}}"/>
-</tt>
-
-<h3>In JavaScript</h3>
-<tt ng:non-bindable>
-angular.validator.{{shortName}}({{paramFirst.name}}{{#paramRest}}{{^default}}, {{name}}{{/default}}{{#default}}<i>[, {{name}}]</i>{{/default}}{{/paramRest}} );
-</tt>
-
-<h3>Parameters</h3>
-<ul>
-  {{#param}}
-  <li><tt>{{name}}</tt> –
-      <tt>&#123;{{#type}}{{type}}{{/type}}{{^type}}*{{/type}}{{#optional}}={{/optional}}&#125;</tt>
-      <tt>{{#default}}[{{default}}]{{/default}}</tt>
-      – {{{description}}}</li>
-  {{/param}}
-</ul>
-{{{paramDescription}}}
-
-{{#css}}
-<h3>CSS</h3>
-{{{css}}}
-{{/css}}
-
-{{#example}}
-<h2>Example</h2>
-{{{exampleDescription}}}
-<doc:example>
-  <doc:source>
-{{/example}}
-    {{{example}}}
-{{#example}}
-  </doc:source>
-  <doc:scenario>{{{scenario}}}</doc:scenario>
-</doc:example>
-{{/example}}

docs/widget.template

@@ -1,68 +0,0 @@
-<h1>{{name}}</h1>
-
-{{#workInProgress}}
-<fieldset class="workInProgress">
-  <legend>Work In Progress</legend>
-  This page is currently being revised. It might be incomplete or contain inaccuracies.
-  {{{workInProgress.description}}}
-</fieldset>
-{{/workInProgress}}
-
-{{#deprecated}}
-<fieldset class="deprecated">
-  <legend>Deprecated API</legend>
-  {{deprecated}}
-</fieldset>
-{{/deprecated}}
-
-<h2>Description</h2>
-{{{description}}}
-
-<h2>Usage</h2>
-<h3>In HTML Template Binding</h3>
-<tt>
-{{^element}}
-  <pre>
-&lt;{{shortName}}{{#param}} {{#default}}<i>[</i>{{/default}}{{name}}="..."{{#default}}<i>]</i>{{/default}}{{/param}}&gt;{{#usageContent}} 
-
-  {{usageContent}}
-{{/usageContent}}&lt;/{{shortName}}&gt;
-  </pre>
-{{/element}}
-{{#element}}
-  <pre>
-&lt;{{element}} {{shortName}}{{#paramFirst}}="{{paramFirst.name}}{{/paramFirst}}"&gt;
-  ...
-&lt;/{{element}}&gt;
-  </pre>
-{{/element}}
-</tt>
-
-<h3>Parameters</h3>
-<ul>
-  {{#param}}
-  <li><tt>{{name}}</tt> –
-      <tt>&#123;{{#type}}{{type}}{{/type}}{{^type}}*{{/type}}{{#optional}}={{/optional}}&#125;</tt>
-      <tt>{{#default}}[{{default}}]{{/default}}</tt>
-      – {{{description}}}</li>
-  {{/param}}
-</ul>
-{{{paramDescription}}}
-
-{{#css}}
-<h3>CSS</h3>
-{{{css}}}
-{{/css}}
-
-{{#example}}
-<h2>Example</h2>
-{{{exampleDescription}}}
-<doc:example>
-  <doc:source>
-{{/example}}
-    {{{example}}}
-{{#example}}
-  </doc:source>
-  <doc:scenario>{{{scenario}}}</doc:scenario>
-</doc:example>
-{{/example}}

example/personalLog/personalLog.html

@@ -9,7 +9,7 @@
 
   <!-- TODO: we need to expose $root so that we can delete cookies in the scenario runner, there
              must be a better way to do this -->
-  <body ng:controller="example.personalLog.LogCtrl" ng:init="$window.$root = $root">
+  <body ng:controller="example.personalLog.LogCtrl">
 
     <form action="" ng:submit="addLog(newMsg)">
       <input type="text" name="newMsg" />

example/personalLog/scenario/personalLogScenario.js

@@ -81,15 +81,14 @@ angular.scenario.dsl('clearCookies', function() {
    */
   return function() {
     this.addFutureAction('clear all cookies', function($window, $document, done) {
-      //TODO: accessing angular services is pretty nasty, we need a better way to reach them
-      var $cookies = $window.$root.$cookies,
+      var rootScope = $window.angular.element($document[0]).data('$scope'),
+          $cookies = rootScope.$service('$cookies'),
           cookieName;
 
       for (cookieName in $cookies) {
-        console.log('deleting cookie: ' + cookieName);
         delete $cookies[cookieName];
       }
-      $window.$root.$eval();
+      rootScope.$eval();
 
       done();
     });

example/personalLog/test/personalLogSpec.js

@@ -3,6 +3,7 @@ describe('example.personalLog.LogCtrl', function() {
 
   function createNotesCtrl() {
     var scope = angular.scope();
+    scope.$cookies = scope.$service('$cookies');
     return scope.$new(example.personalLog.LogCtrl);
   }
 

gen_docs.sh

@@ -1,3 +1,3 @@
-#!/bin/sh
-
-node docs/specs.js --noColor && node docs/collect.js
+#!/bin/bash 
+. ~/.bashrc
+node docs/spec/specs.js --noColor && node docs/src/gen-docs.js

jsTestDriver-jquery.conf

@@ -8,6 +8,7 @@ load:
   - src/Angular.js
   - src/JSON.js
   - src/*.js
+  - example/personalLog/*.js
   - test/testabilityPatch.js
   - src/scenario/Scenario.js
   - src/scenario/output/*.js
@@ -16,6 +17,7 @@ load:
   - test/scenario/*.js
   - test/scenario/output/*.js
   - test/*.js
+  - example/personalLog/test/*.js
 
 exclude:
   - src/angular.prefix

jsTestDriver-perf.conf

@@ -0,0 +1,13 @@
+server: http://localhost:9876
+
+load:
+  - lib/jasmine-1.0.1/jasmine.js
+  - lib/jasmine-jstd-adapter/JasmineAdapter.js
+  - lib/jquery/jquery-1.4.2.js
+  - test/jquery_remove.js
+  - build/angular.min.js
+  - perf/data/*.js
+  - perf/testUtils.js
+  - perf/*.js
+
+exclude:

lib/jasmine-jstd-adapter/JasmineAdapter.js

@@ -1,111 +1,176 @@
 /**
  * @fileoverview Jasmine JsTestDriver Adapter.
- * @author ibolmo@gmail.com (Olmo Maldonado)
  * @author misko@hevery.com (Misko Hevery)
  */
+(function(window) {
+  var rootDescribes = new Describes(window);
+  var describePath = [];
+  rootDescribes.collectMode();
+  
+  var jasmineTest = TestCase('Jasmine Adapter Tests');
+  
+  var jasminePlugin = {
+      name:'jasmine',
+      runTestConfiguration: function(testRunConfiguration, onTestDone, onTestRunConfigurationComplete){
+        if (testRunConfiguration.testCaseInfo_.template_ !== jasmineTest) return;
+        
+        var jasmineEnv = jasmine.currentEnv_ = new jasmine.Env();
+        rootDescribes.playback();
+        var specLog = jstestdriver.console.log_ = [];
+        var start;
+        jasmineEnv.specFilter = function(spec) {
+          return rootDescribes.isExclusive(spec);
+        };
+        jasmineEnv.reporter = {
+          log: function(str){
+            specLog.push(str);
+          },
 
-(function() {
+          reportRunnerStarting: function(runner) { },
 
-  function bind(_this, _function){
-    return function(){
-      return _function.call(_this);
-    };
+          reportSpecStarting: function(spec) {
+            specLog = jstestdriver.console.log_ = [];
+            start = new Date().getTime();
+          },
+
+          reportSpecResults: function(spec) {
+            var suite = spec.suite;
+            var results = spec.results();
+            if (results.skipped) return;
+            var end = new Date().getTime();
+            var messages = [];
+            var resultItems = results.getItems();
+            var state = 'passed';
+            for ( var i = 0; i < resultItems.length; i++) {
+              if (!resultItems[i].passed()) {
+                state = resultItems[i].message.match(/AssertionError:/) ? 'error' : 'failed';
+                messages.push(resultItems[i].toString());
+                messages.push(formatStack(resultItems[i].trace.stack));
+              }
+            }
+            onTestDone(
+              new jstestdriver.TestResult(
+                suite.getFullName(), 
+                spec.description, 
+                state, 
+                messages.join('\n'), 
+                specLog.join('\n'),
+                end - start));
+          },
+
+          reportSuiteResults: function(suite) {},
+          
+          reportRunnerResults: function(runner) {
+            onTestRunConfigurationComplete();
+          }
+        };
+        jasmineEnv.execute();
+        return true;
+      },
+      onTestsFinish: function(){
+        jasmine.currentEnv_ = null;
+        rootDescribes.collectMode();
+      }
+  };
+  jstestdriver.pluginRegistrar.register(jasminePlugin);
+
+  function formatStack(stack) {
+    var lines = (stack||'').split(/\r?\n/);
+    var frames = [];
+    for (i = 0; i < lines.length; i++) {
+      if (!lines[i].match(/\/jasmine[\.-]/)) {
+        frames.push(lines[i].replace(/https?:\/\/\w+(:\d+)?\/test\//, '').replace(/^\s*/, '      '));
+      }
+    }
+    return frames.join('\n');
   }
 
-  var currentFrame = frame(null, null);
-
-  function frame(parent, name){
-    var caseName = (parent && parent.caseName ? parent.caseName + " " : '') + (name ? name : '');
-    var frame = {
-      name: name,
-      caseName: caseName,
-      parent: parent,
-      testCase: TestCase(caseName),
-      before: [],
-      after: [],
-      runBefore: function(){
-        if (parent) parent.runBefore.apply(this);
-        for ( var i = 0; i < frame.before.length; i++) {
-          frame.before[i].apply(this);
-        }
-      },
-      runAfter: function(){
-        for ( var i = 0; i < frame.after.length; i++) {
-          frame.after[i].apply(this);
-        }
-        if (parent) parent.runAfter.apply(this);
-      }
-    };
-    return frame;
-  };
-
-  jasmine.Env.prototype.describe = (function(describe){
-    return function(description){
-      currentFrame = frame(currentFrame, description);
-      var val = describe.apply(this, arguments);
-      currentFrame = currentFrame.parent;
-      return val;
-    };
-
-  })(jasmine.Env.prototype.describe);
-
-  var id = 0;
-
-  jasmine.Env.prototype.it = (function(it){
-    return function(desc, itFn){
-      var self = this;
-      var spec = it.apply(this, arguments);
-      var currentSpec = this.currentSpec;
-      if (!currentSpec.$id) {
-        currentSpec.$id = id++;
-      }
-      var frame = this.jstdFrame = currentFrame;
-      var name = 'test that it ' + desc;
-      if (this.jstdFrame.testCase.prototype[name])
-        throw "Spec with name '" + desc + "' already exists.";
-      this.jstdFrame.testCase.prototype[name] = function(){
-        jasmine.getEnv().currentSpec = currentSpec;
-        frame.runBefore.apply(currentSpec);
-        try {
-          itFn.apply(currentSpec);
-        } finally {
-          frame.runAfter.apply(currentSpec);
+  function noop(){}
+  function Describes(window){
+    var describes = {};
+    var beforeEachs = {};
+    var afterEachs = {};
+    var exclusive;
+    var collectMode = true;
+    intercept('describe', describes);
+    intercept('xdescribe', describes);
+    intercept('beforeEach', beforeEachs);
+    intercept('afterEach', afterEachs);
+    
+    function intercept(functionName, collection){
+      window[functionName] = function(desc, fn){
+        if (collectMode) {
+          collection[desc] = function(){
+            jasmine.getEnv()[functionName](desc, fn);
+          };
+        } else {
+          jasmine.getEnv()[functionName](desc, fn);
         }
       };
-      return spec;
+    }
+    window.ddescribe = function(name, fn){
+      exclusive = true;
+      console.log('ddescribe', name);
+      window.describe(name, function(){
+        var oldIt = window.it;
+        window.it = window.iit;
+        try {
+          fn.call(this);
+        } finally {
+          window.it = oldIt;
+        };
+      });
     };
-
-  })(jasmine.Env.prototype.it);
-
-
-  jasmine.Env.prototype.beforeEach = (function(beforeEach){
-    return function(beforeEachFunction) {
-      beforeEach.apply(this, arguments);
-      currentFrame.before.push(beforeEachFunction);
+    window.iit = function(name, fn){
+      exclusive = fn.exclusive = true;
+      console.log(fn);
+      jasmine.getEnv().it(name, fn);
     };
-
-  })(jasmine.Env.prototype.beforeEach);
-
-
-  jasmine.Env.prototype.afterEach = (function(afterEach){
-    return function(afterEachFunction) {
-      afterEach.apply(this, arguments);
-      currentFrame.after.push(afterEachFunction);
+    
+    
+    this.collectMode = function() {
+      collectMode = true;
+      exclusive = false;
     };
-
-  })(jasmine.Env.prototype.afterEach);
-
-
-  jasmine.NestedResults.prototype.addResult = (function(addResult){
-    return function(result) {
-      addResult.call(this, result);
-      if (result.type != 'MessageResult' && !result.passed()) fail(result.message);
+    this.playback = function(){
+      collectMode = false;
+      playback(beforeEachs);
+      playback(afterEachs);
+      playback(describes);
+      
+      function playback(set) {
+        for ( var name in set) {
+          set[name]();
+        }
+      }
     };
+    
+    this.isExclusive = function(spec) {
+      if (exclusive) {
+        var blocks = spec.queue.blocks;
+        for ( var i = 0; i < blocks.length; i++) {
+          if (blocks[i].func.exclusive) {
+            return true;
+          }
+        }
+        return false;
+      }
+      return true;
+    };
+  }
+  
+})(window);
 
-  })(jasmine.NestedResults.prototype.addResult);
+// Patch Jasmine for proper stack traces
+jasmine.Spec.prototype.fail = function (e) {
+  var expectationResult = new jasmine.ExpectationResult({
+    passed: false,
+    message: e ? jasmine.util.formatException(e) : 'Exception'
+  });
+  // PATCH
+  if (e) {
+    expectationResult.trace = e;
+  }
+  this.results_.addResult(expectationResult);
+};
 
-  // Reset environment with overriden methods.
-  jasmine.currentEnv_ = null;
-  jasmine.getEnv();
-
-})();

lib/mustache/LICENSE

@@ -1,21 +0,0 @@
-Copyright (c) 2009 Chris Wanstrath (Ruby)
-Copyright (c) 2010 Jan Lehnardt (JavaScript)
-
-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.

lib/mustache/index.js

@@ -1,344 +0,0 @@
-/*
- * CommonJS-compatible mustache.js module
- *
- * See http://github.com/janl/mustache.js for more info.
- */
-/*
-  mustache.js Ñ Logic-less templates in JavaScript
-
-  See http://mustache.github.com/ for more info.
-*/
-
-var Mustache = function() {
-  var Renderer = function() {};
-
-  Renderer.prototype = {
-    otag: "{{",
-    ctag: "}}",
-    pragmas: {},
-    buffer: [],
-    pragmas_implemented: {
-      "IMPLICIT-ITERATOR": true
-    },
-    context: {},
-
-    render: function(template, context, partials, in_recursion) {
-      // reset buffer & set context
-      if(!in_recursion) {
-        this.context = context;
-        this.buffer = []; // TODO: make this non-lazy
-      }
-
-      // fail fast
-      if(!this.includes("", template)) {
-        if(in_recursion) {
-          return template;
-        } else {
-          this.send(template);
-          return;
-        }
-      }
-
-      template = this.render_pragmas(template);
-      var html = this.render_section(template, context, partials);
-      if(in_recursion) {
-        return this.render_tags(html, context, partials, in_recursion);
-      }
-
-      this.render_tags(html, context, partials, in_recursion);
-    },
-
-    /*
-      Sends parsed lines
-    */
-    send: function(line) {
-      if(line != "") {
-        this.buffer.push(line);
-      }
-    },
-
-    /*
-      Looks for %PRAGMAS
-    */
-    render_pragmas: function(template) {
-      // no pragmas
-      if(!this.includes("%", template)) {
-        return template;
-      }
-
-      var that = this;
-      var regex = new RegExp(this.otag + "%([\\w-]+) ?([\\w]+=[\\w]+)?" +
-            this.ctag);
-      return template.replace(regex, function(match, pragma, options) {
-        if(!that.pragmas_implemented[pragma]) {
-          throw({message:
-            "This implementation of mustache doesn't understand the '" +
-            pragma + "' pragma"});
-        }
-        that.pragmas[pragma] = {};
-        if(options) {
-          var opts = options.split("=");
-          that.pragmas[pragma][opts[0]] = opts[1];
-        }
-        return "";
-        // ignore unknown pragmas silently
-      });
-    },
-
-    /*
-      Tries to find a partial in the curent scope and render it
-    */
-    render_partial: function(name, context, partials) {
-      name = this.trim(name);
-      if(!partials || partials[name] === undefined) {
-        throw({message: "unknown_partial '" + name + "'"});
-      }
-      if(typeof(context[name]) != "object") {
-        return this.render(partials[name], context, partials, true);
-      }
-      return this.render(partials[name], context[name], partials, true);
-    },
-
-    /*
-      Renders inverted (^) and normal (#) sections
-    */
-    render_section: function(template, context, partials) {
-      if(!this.includes("#", template) && !this.includes("^", template)) {
-        return template;
-      }
-
-      var that = this;
-      // CSW - Added "+?" so it finds the tighest bound, not the widest
-      var regex = new RegExp(this.otag + "(\\^|\\#)\\s*(.+)\\s*" + this.ctag +
-              "\n*([\\s\\S]+?)" + this.otag + "\\/\\s*\\2\\s*" + this.ctag +
-              "\\s*", "mg");
-
-      // for each {{#foo}}{{/foo}} section do...
-      return template.replace(regex, function(match, type, name, content) {
-        var value = that.find(name, context);
-        if(type == "^") { // inverted section
-          if(!value || that.is_array(value) && value.length === 0) {
-            // false or empty list, render it
-            return that.render(content, context, partials, true);
-          } else {
-            return "";
-          }
-        } else if(type == "#") { // normal section
-          if(that.is_array(value)) { // Enumerable, Let's loop!
-            return that.map(value, function(row) {
-              return that.render(content, that.create_context(row),
-                partials, true);
-            }).join("");
-          } else if(that.is_object(value)) { // Object, Use it as subcontext!
-            return that.render(content, that.create_context(value),
-              partials, true);
-          } else if(typeof value === "function") {
-            // higher order section
-            return value.call(context, content, function(text) {
-              return that.render(text, context, partials, true);
-            });
-          } else if(value) { // boolean section
-            return that.render(content, context, partials, true);
-          } else {
-            return "";
-          }
-        }
-      });
-    },
-
-    /*
-      Replace {{foo}} and friends with values from our view
-    */
-    render_tags: function(template, context, partials, in_recursion) {
-      // tit for tat
-      var that = this;
-
-      var new_regex = function() {
-        return new RegExp(that.otag + "(=|!|>|\\{|%)?([^\\/#\\^]+?)\\1?" +
-          that.ctag + "+", "g");
-      };
-
-      var regex = new_regex();
-      var tag_replace_callback = function(match, operator, name) {
-        switch(operator) {
-        case "!": // ignore comments
-          return "";
-        case "=": // set new delimiters, rebuild the replace regexp
-          that.set_delimiters(name);
-          regex = new_regex();
-          return "";
-        case ">": // render partial
-          return that.render_partial(name, context, partials);
-        case "{": // the triple mustache is unescaped
-          return that.find(name, context);
-        default: // escape the value
-          return that.escape(that.find(name, context));
-        }
-      };
-      var lines = template.split("\n");
-      for(var i = 0; i < lines.length; i++) {
-        lines[i] = lines[i].replace(regex, tag_replace_callback, this);
-        if(!in_recursion) {
-          this.send(lines[i]);
-        }
-      }
-
-      if(in_recursion) {
-        return lines.join("\n");
-      }
-    },
-
-    set_delimiters: function(delimiters) {
-      var dels = delimiters.split(" ");
-      this.otag = this.escape_regex(dels[0]);
-      this.ctag = this.escape_regex(dels[1]);
-    },
-
-    escape_regex: function(text) {
-      // thank you Simon Willison
-      if(!arguments.callee.sRE) {
-        var specials = [
-          '/', '.', '*', '+', '?', '|',
-          '(', ')', '[', ']', '{', '}', '\\'
-        ];
-        arguments.callee.sRE = new RegExp(
-          '(\\' + specials.join('|\\') + ')', 'g'
-        );
-      }
-      return text.replace(arguments.callee.sRE, '\\$1');
-    },
-
-    /*
-      find `name` in current `context`. That is find me a value
-      from the view object
-    */
-    find: function(name, context) {
-      name = this.trim(name);
-
-      // Checks whether a value is thruthy or false or 0
-      function is_kinda_truthy(bool) {
-        return bool === false || bool === 0 || bool;
-      }
-
-      var value = context;
-      var path = name.split(/\./);
-      for(var i = 0; i < path.length; i++) {
-        name = path[i];
-        if(value && is_kinda_truthy(value[name])) {
-          value = value[name];
-        } else if(i == 0 && is_kinda_truthy(this.context[name])) {
-          value = this.context[name];
-        } else {
-          value = undefined;
-        }
-      }
-
-      if(typeof value === "function") {
-        return value.apply(context);
-      }
-      if(value !== undefined) {
-        return value;
-      }
-      // silently ignore unkown variables
-      return "";
-    },
-
-    // Utility methods
-
-    /* includes tag */
-    includes: function(needle, haystack) {
-      return haystack.indexOf(this.otag + needle) != -1;
-    },
-
-    /*
-      Does away with nasty characters
-    */
-    escape: function(s) {
-      s = String(s === null ? "" : s);
-      return s.replace(/&(?!\w+;)|["'<>\\]/g, function(s) {
-        switch(s) {
-        case "&": return "&amp;";
-        case "\\": return "\\\\";
-        case '"': return '&quot;';
-        case "'": return '&#39;';
-        case "<": return "&lt;";
-        case ">": return "&gt;";
-        default: return s;
-        }
-      });
-    },
-
-    // by @langalex, support for arrays of strings
-    create_context: function(_context) {
-      if(this.is_object(_context)) {
-        return _context;
-      } else {
-        var iterator = ".";
-        if(this.pragmas["IMPLICIT-ITERATOR"]) {
-          iterator = this.pragmas["IMPLICIT-ITERATOR"].iterator;
-        }
-        var ctx = {};
-        ctx[iterator] = _context;
-        return ctx;
-      }
-    },
-
-    is_object: function(a) {
-      return a && typeof a == "object";
-    },
-
-    is_array: function(a) {
-      return Object.prototype.toString.call(a) === '[object Array]';
-    },
-
-    /*
-      Gets rid of leading and trailing whitespace
-    */
-    trim: function(s) {
-      return s.replace(/^\s*|\s*$/g, "");
-    },
-
-    /*
-      Why, why, why? Because IE. Cry, cry cry.
-    */
-    map: function(array, fn) {
-      if (typeof array.map == "function") {
-        return array.map(fn);
-      } else {
-        var r = [];
-        var l = array.length;
-        for(var i = 0; i < l; i++) {
-          r.push(fn(array[i]));
-        }
-        return r;
-      }
-    }
-  };
-
-  return({
-    name: "mustache.js",
-    version: "0.3.1-dev",
-
-    /*
-      Turns a template and view into HTML
-    */
-    to_html: function(template, view, partials, send_fun) {
-      var renderer = new Renderer();
-      if(send_fun) {
-        renderer.send = send_fun;
-      }
-      renderer.render(template, view, partials);
-      if(!send_fun) {
-        return renderer.buffer.join("\n");
-      }
-    }
-  });
-}();
-
-
-exports.name = Mustache.name;
-exports.version = Mustache.version;
-
-exports.to_html = function() {
-  return Mustache.to_html.apply(this, arguments);
-};

perf/DCLvsWindowOnLoad.html

@@ -0,0 +1,37 @@
+<!doctype html>
+<!--
+
+This test demonstrates the time difference between document's DOMContentLoaded and window's load events.
+
+-->
+<html>
+  <head>
+    <script>
+      startTS = new Date().getTime();
+      onDOMContentLoadedTS = 0; // default for browsers where DOMCL is not supported
+    </script>
+    <title>DOMContentLoaded test</title>
+    <script src="../build/angular.min.js" ng:autobind></script>
+    <script>
+      angular.element(document).bind('DOMContentLoaded', function(e) {onDOMContentLoadedTS = new Date().getTime()});
+      angular.element(window).bind('load', function(e) {
+          onloadTS = new Date().getTime();
+          log.innerHTML = 'start: ' + new Date(startTS) + '<br/>DOMContentLoaded: +' + (onDOMContentLoadedTS - startTS) +  'ms<br/> load: +' + (onloadTS - startTS) + 'ms';
+        });
+    </script>
+  </head>
+  <body>
+    <h1>DOMContentLoaded test</h1>
+    <p>{{ 'yay!' || 'angular starting...' }}</p>
+
+    <img width="100px" src="http://lh5.ggpht.com/_BLyMhylclm0/TST_bbGH0zI/AAAAAAAAATY/oNUn9kivKN8/s912/1020047.jpg" />
+    <img width="100px" src="http://lh5.ggpht.com/_MqEybfAuUFk/TSOOiegUlPI/AAAAAAAADHY/AEwEWc64_-M/s800/IMG_7294.JPG" />
+    <img width="100px" src="http://lh3.ggpht.com/_LdjD3ua8rpE/TSOW99rwjZI/AAAAAAAAFC0/0qJRhhN45RM/s912/Saison%2010%20%2834%29.JPG" />
+    <img width="100px" src="http://lh6.ggpht.com/_oy_-am3CVUw/TSOQBddZpwI/AAAAAAAACaw/ogFgoD79bVE/s912/P1100886.JPG" />
+    <img width="100px" src="http://lh4.ggpht.com/_srSaA7ZN7oc/TDdxXbA_i1I/AAAAAAAAQ2w/ii3vgrnfCrM/s800/Urlaub10%20157.jpg" />
+    <img width="100px" src="http://lh5.ggpht.com/_y6vXu6iRrfM/SIaYhRQBYNI/AAAAAAAAAmE/lV2NYwxtsQM/s912/North%20Dakota%20Trip%20014.JPG" />
+    <img width="100px" src="http://lh5.ggpht.com/_Jjv9cIn9cS8/RuwZCgfOl6I/AAAAAAAAAOc/QrrMe8vpawg/s800/Shark%20Trip%20-%20day%202%20513.JPG" />
+
+    <p id="log"></p>
+  </body>
+</html>

perf/data/jsonParserPayload.rb

@@ -0,0 +1,49 @@
+def generate_object(f, objName, iterations)
+  f.write("var #{objName}='[");
+ 
+  iterations.times do |i| 
+    f.write('{')
+
+    f.write('"simpleStringProperty":')     #23
+    f.write('"some string value ' + ('%07d' % i) + '"')  #27
+    f.write(',')
+    
+    f.write('"stringWithQuotes":')         #19
+    f.write('"some string with \\\\"quotes\\\\" ' + ('%07d' % i) + '"')  #36
+    f.write(',')
+ 
+    f.write('"stringWithUnicode":')
+    f.write('"short string with \\u1234 unicode \\u2345 chars ' +  ('%07d' % i) + '"')
+    f.write(',')
+
+    f.write('"aNumber":')  #10
+    f.write(i)  #?
+    f.write(',')
+   
+    f.write('"smallArray":')
+    f.write('["a",23,"b",42,' + i.to_s + ']')
+    f.write(',')
+
+    f.write('"smallObj":')
+    f.write('{"foo":"bar","baz":543,"num":' + i.to_s + ',"fuz":"fuz buz huz duz ' + i.to_s + '"}')
+    f.write(',')
+
+    f.write('"timeStamp":')
+    f.write('"2010-12-22T04:58:01.' + ("%03d" % (i%1000)) + '"')
+
+    f.write('},')
+  end
+
+  f.write('"just a padding string"]\';' + "\n\n");
+end
+
+file_path = File.join(File.dirname(__FILE__), 'jsonParserPayload.js')
+
+File.open(file_path, 'w') do |f|
+  generate_object(f, 'superTinyJsonString', 1)  #~300b
+  generate_object(f, 'tinyJsonString', 3)       #~1kb
+  generate_object(f, 'smallJsonString', 30)     #~10kb
+  generate_object(f, 'mediumJsonString', 600)   #~200kb
+  generate_object(f, 'largeJsonString', 2000)   #~650kb
+end
+

perf/jsonPerfSpec.js

@@ -0,0 +1,28 @@
+describe('json', function() {
+
+  it('angular parser', function() {
+    var duration = time(function() {
+      expect(angular.fromJson(largeJsonString)).toBeTruthy();
+    }, 1);
+
+    dump(duration/1 + ' ms per iteration');
+  });
+
+
+  it('angular delegating to native parser', function() {
+    var duration = time(function() {
+      expect(angular.fromJson(largeJsonString, true)).toBeTruthy();
+    }, 100);
+
+    dump(duration/100 + ' ms per iteration');
+  });
+
+
+  it('native json', function() {
+    var duration = time(function() {
+      expect(JSON.parse(largeJsonString)).toBeTruthy();
+    }, 100);
+
+    dump(duration/100 + ' ms per iteration');
+  });
+});

perf/noangular.html

@@ -0,0 +1,19 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
+<html xmlns:ng="http://angularjs.org">
+  <head>
+    <script>
+      function el(id) {
+        return document.getElementById(id);
+      }
+      function update() {
+        el("output").innerHTML = el("input").value;
+      }
+    </script>
+  </head>
+  <body>
+    Your name: <input id="input" type="text" value="World"
+    onkeydown="setTimeout(update,0)"/>
+    <hr/>
+    Hello <span id="output">{{yourname}}</span>!
+  </body>
+</html>

perf/testUtils.js

@@ -0,0 +1,20 @@
+if (window.jstestdriver) {
+  jstd = jstestdriver;
+  dump = angular.bind(jstd.console, jstd.console.log);
+}
+
+function time(fn, times) {
+  times = times || 1;
+
+  var i,
+      start,
+      duration = 0;
+
+  for (i=0; i<times; i++) {
+    start = Date.now();
+    fn();
+    duration += Date.now() - start;
+  }
+
+  return duration;
+}

regression/issue-169.html

@@ -0,0 +1,10 @@
+<!DOCTYPE HTML>
+<html xmlns:ng="http://angularjs.org">
+  <script type="text/javascript" src="../src/angular-bootstrap.js" ng:autobind></script>
+  <body>
+    <span ng:init='x = {d:3}; x1 = {bar:[x,5]}; x1.bar[0].d = 4'>
+        <input name="x1.bar[0].d" type="text"></input>
+        <input name="x.d" type="text"></input>
+    <span> {{x1}} -- {{x1.bar[0].d}}</span>
+  </body>
+</html>

regression/issue-170.html

@@ -0,0 +1,28 @@
+<!DOCTYPE HTML>
+<html xmlns:ng="http://angularjs.org">
+<head>
+  <script type="text/javascript" src="../lib/jquery/jquery-1.4.2.js"></script>
+  <script type="text/javascript" src="../src/angular-bootstrap.js" ng:autobind></script>
+<head>
+<body>
+  <select name='selection0' style="display:block;">
+      <option ng:repeat='value in ["FOO","BAR"]'">{{value}}</option>
+  </select>
+  {{selection0}} &lt;-- FOO should be shown here
+  
+  <hr/>
+  
+  <select ng:init="selection1='ignore'" name='selection1' style="display:block;">
+      <option ng:repeat='value in ["FOO","BAR"]' ng:bind-attr="{selected:'{{value==\'BAR\'}}'}">{{value}}</option>
+  </select>
+  {{selection1}} &lt;-- BAR should be shown here
+  
+  <hr/>
+
+  <select ng:init="selection2=1" name="selection2" style="display:block;">
+    <option value="{{$index}}" ng:repeat="opt in ['zero', 'one']">{{opt}}</option>
+  </select>
+  {{selection2}} &lt;-- 1 should be shown here
+  
+</body>
+</html>

regression/sanitizer.html

@@ -0,0 +1,8 @@
+<!DOCTYPE HTML>
+<html xmlns:ng="http://angularjs.org">
+  <script type="text/javascript" src="../src/angular-bootstrap.js" ng:autobind></script>
+  <body>
+   <textarea name="html" rows="10" cols="100"></textarea>
+   <div>{{html|html}}</div>
+  </body>
+</html>

server.sh

@@ -1 +1,3 @@
-java -jar lib/jstestdriver/JsTestDriver.jar --port 9876 --browserTimeout 20000
+#!/bin/bash
+
+java -jar lib/jstestdriver/JsTestDriver.jar --port 9876 --browserTimeout 90000

src/Angular.js

@@ -53,6 +53,9 @@ function fromCharCode(code) { return String.fromCharCode(code); }
 var _undefined        = undefined,
     _null             = null,
     $$element         = '$element',
+    $$update          = '$update',
+    $$scope           = '$scope',
+    $$validate        = '$validate',
     $angular          = 'angular',
     $array            = 'array',
     $boolean          = 'boolean',
@@ -69,6 +72,8 @@ var _undefined        = undefined,
     $number           = 'number',
     $object           = 'object',
     $string           = 'string',
+    $value            = 'value',
+    $selected         = 'selected',
     $undefined        = 'undefined',
     NG_EXCEPTION      = 'ng-exception',
     NG_VALIDATION_ERROR = 'ng-validation-error',
@@ -87,440 +92,55 @@ var _undefined        = undefined,
     push              = Array.prototype.push,
     error             = window[$console] ? bind(window[$console], window[$console]['error'] || noop) : noop,
 
-    /**
-     * @workInProgress
-     * @ngdoc overview
-     * @name angular
-     * @namespace The exported angular namespace.
-     */
     angular           = window[$angular]    || (window[$angular] = {}),
     angularTextMarkup = extensionMap(angular, 'markup'),
     angularAttrMarkup = extensionMap(angular, 'attrMarkup'),
-    /**
-     * @workInProgress
-     * @ngdoc overview
-     * @name angular.directive
-     * @namespace Namespace for all directives.
-     *
-     * @description
-     * A directive is an HTML attribute that you can use in an existing HTML element type or in a
-     * DOM element type that you create as {@link angular.widget}, to modify that element's
-     * properties. You can use any number of directives per element.
-     * 
-     * For example, you can add the ng:bind directive as an attribute of an HTML span element, as in
-     * `<span ng:bind="1+2"></span>`. How does this work? The compiler passes the attribute value
-     * `1+2` to the ng:bind extension, which in turn tells the {@link angular.scope} to watch that
-     * expression and report changes. On any change it sets the span text to the expression value.
-     * 
-     * Here's how to define {@link angular.directive.ng:bind ng:bind}:
-     * <pre>
-        angular.directive('ng:bind', function(expression, compiledElement) {
-          var compiler = this;
-          return function(linkElement) {
-            var currentScope = this;
-            currentScope.$watch(expression, function(value) {
-              linkElement.text(value);
-            });
-          };
-        });
-     * </pre>
-     * 
-     * # Directive vs. Attribute Widget
-     * Both [attribute widgets](#!angular.widget) and directives can compile a DOM element
-     * attribute. So why have two different ways to do the same thing? The answer is that order
-     * matters, but we have no control over the order in which attributes are read. To solve this
-     * we apply attribute widget before the directive.
-     * 
-     * For example, consider this piece of HTML, which uses the directives `ng:repeat`, `ng:init`,
-     * and `ng:bind`:
-     * <pre>
-        <ul ng:init="people=['mike', 'mary']">
-          <li ng:repeat="person in people" ng:init="a=a+1" ng:bind="person"></li>
-        </ul>
-     * </pre>
-     * 
-     * Notice that the order of execution matters here. We need to execute
-     * {@link angular.directive.ng:repeat ng:repeat} before we run the
-     * {@link angular.directive.ng:init ng:init} and `ng:bind` on the `<li/>;`. This is because we
-     * want to run the `ng:init="a=a+1` and `ng:bind="person"` once for each person in people. We
-     * could not have used directive to create this template because attributes are read in an
-     * unspecified order and there is no way of guaranteeing that the repeater attribute would
-     * execute first. Using the `ng:repeat` attribute directive ensures that we can transform the
-     * DOM element into a template.
-     * 
-     * Widgets run before directives. Widgets may manipulate the DOM whereas directives are not
-     * expected to do so, and so they run last.
-     */
+    /** @name angular.directive */
     angularDirective  = extensionMap(angular, 'directive'),
-
-    /**
-     * @workInProgress
-     * @ngdoc overview
-     * @name angular.widget
-     * @namespace Namespace for all widgets.
-     * @description
-     * # Overview
-     * Widgets allow you to create DOM elements that the browser doesn't 
-     * already understand. You create the widget in your namespace and 
-     * assign it behavior. You can only bind one widget per DOM element 
-     * (unlike directives, in which you can use any number per DOM 
-     * element). Widgets are expected to manipulate the DOM tree by 
-     * adding new elements whereas directives are expected to only modify
-     * element properties.
-     * 
-     * Widgets come in two flavors: element and attribute.
-     * 
-     * # Element Widget
-     * Let's say we would like to create a new element type in the 
-     * namespace `my` that can watch an expression and alert() the user 
-     * with each new value.
-     * 
-     * <pre>
-     * &lt;my:watch exp="name"/&gt;
-     * </pre>
-     * 
-     * You can implement `my:watch` like this:
-     * <pre>
-     * angular.widget('my:watch', function(compileElement) {
-     *   var compiler = this;
-     *   var exp = compileElement.attr('exp');
-     *   return function(linkElement) {
-     *     var currentScope = this;
-     *     currentScope.$watch(exp, function(value){
-     *       alert(value);
-     *     }};
-     *   };
-     * });
-     * </pre>
-     * 
-     * # Attribute Widget
-     * Let's implement the same widget, but this time as an attribute 
-     * that can be added to any existing DOM element.
-     * <pre>
-     * &lt;div my-watch="name"&gt;text&lt;/div&gt;
-     * </pre>
-     * You can implement `my:watch` attribute like this:
-     * <pre>
-     * angular.widget('@my:watch', function(expression, compileElement) {
-     *   var compiler = this;
-     *   return function(linkElement) {
-     *     var currentScope = this;
-     *     currentScope.$watch(expression, function(value){
-     *       alert(value);
-     *     });
-     *   };
-     * });
-     * </pre>
-     * 
-     * @example
-     * <script>
-     *   angular.widget('my:time', function(compileElement){
-     *     compileElement.css('display', 'block');
-     *     return function(linkElement){
-     *       function update(){
-     *         linkElement.text('Current time is: ' + new Date());
-     *         setTimeout(update, 1000);
-     *       }
-     *       update();
-     *     };
-     *   });
-     * </script>
-     * <my:time></my:time>
-     */
+    /** @name angular.widget */
     angularWidget     = extensionMap(angular, 'widget', lowercase),
-    
-    /**
-     * @workInProgress
-     * @ngdoc overview
-     * @name angular.validator
-     * @namespace Namespace for all filters.
-     * @description
-     * # Overview
-     * Validators are a standard way to check the user input against a specific criteria. For 
-     * example, you might need to check that an input field contains a well-formed phone number.
-     * 
-     * # Syntax
-     * Attach a validator on user input widgets using the `ng:validate` attribute.
-     * 
-     * <doc:example>
-     *   <doc:source>
-     *     Change me: &lt;input type="text" name="number" ng:validate="integer" value="123"&gt;
-     *   </doc:source>
-     *   <doc:scenario>
-     *     it('should validate the default number string', function() {
-     *       expect(element('input[name=number]').attr('class')).
-     *          not().toMatch(/ng-validation-error/);
-     *     });
-     *     it('should not validate "foo"', function() {
-     *       input('number').enter('foo');
-     *       expect(element('input[name=number]').attr('class')).
-     *          toMatch(/ng-validation-error/);
-     *     });
-     *   </doc:scenario>
-     * </doc:example>
-     * 
-     *
-     * # Writing your own Validators
-     * Writing your own validator is easy. To make a function available as a 
-     * validator, just define the JavaScript function on the `angular.validator` 
-     * object. <angular/> passes in the input to validate as the first argument 
-     * to your function. Any additional validator arguments are passed in as 
-     * additional arguments to your function.
-     * 
-     * You can use these variables in the function:
-     *
-     * * `this` — The current scope.
-     * * `this.$element` — The DOM element containing the binding. This allows the filter to manipulate
-     *   the DOM in addition to transforming the input.
-     *   
-     * In this example we have written a upsTrackingNo validator. 
-     * It marks the input text "valid" only when the user enters a well-formed 
-     * UPS tracking number.
-     *
-     * @css ng-validation-error
-     *   When validation fails, this css class is applied to the binding, making its borders red by
-     *   default.
-     * 
-     * @example
-     * <script>
-     *  angular.validator('upsTrackingNo', function(input, format) {
-     *    var regexp = new RegExp("^" + format.replace(/9/g, '\\d') + "$");
-     *    return input.match(regexp)?"":"The format must match " + format;
-     *  });
-     * </script>
-     * <input type="text" name="trackNo" size="40"
-     *       ng:validate="upsTrackingNo:'1Z 999 999 99 9999 999 9'" 
-     *       value="1Z 123 456 78 9012 345 6"/>
-     *
-     * @scenario
-     * it('should validate correct UPS tracking number', function() {
-     *   expect(element('input[name=trackNo]').attr('class')).
-     *      not().toMatch(/ng-validation-error/);
-     * });
-     *
-     * it('should not validate in correct UPS tracking number', function() {
-     *   input('trackNo').enter('foo');
-     *   expect(element('input[name=trackNo]').attr('class')).
-     *      toMatch(/ng-validation-error/);
-     * });
-     *
-     */
+    /** @name angular.validator */
     angularValidator  = extensionMap(angular, 'validator'),
-
-    /**
-     * @workInProgress
-     * @ngdoc overview
-     * @name angular.filter
-     * @namespace Namespace for all filters.
-     * @description
-     * # Overview
-     * Filters are a standard way to format your data for display to the user. For example, you
-     * might have the number 1234.5678 and would like to display it as US currency: $1,234.57.
-     * Filters allow you to do just that. In addition to transforming the data, filters also modify
-     * the DOM. This allows the filters to for example apply css styles to the filtered output if
-     * certain conditions were met.
-     *
-     *
-     * # Standard Filters
-     *
-     * The Angular framework provides a standard set of filters for common operations, including:
-     * {@link angular.filter.currency currency}, {@link angular.filter.json json},
-     * {@link angular.filter.number number}, and {@link angular.filter.html html}. You can also add
-     * your own filters.
-     *
-     *
-     * # Syntax
-     *
-     * Filters can be part of any {@link angular.scope} evaluation but are typically used with
-     * {{bindings}}. Filters typically transform the data to a new data type, formating the data in
-     * the process. Filters can be chained and take optional arguments. Here are few examples:
-     *
-     * * No filter: {{1234.5678}} => 1234.5678
-     * * Number filter: {{1234.5678|number}} => 1,234.57. Notice the “,” and rounding to two
-     *   significant digits.
-     * * Filter with arguments: {{1234.5678|number:5}} => 1,234.56780. Filters can take optional
-     *   arguments, separated by colons in a binding. To number, the argument “5” requests 5 digits
-     *   to the right of the decimal point.
-     *
-     *
-     * # Writing your own Filters
-     *
-     * Writing your own filter is very easy: just define a JavaScript function on `angular.filter`.
-     * The framework passes in the input value as the first argument to your function. Any filter
-     * arguments are passed in as additional function arguments.
-     *
-     * You can use these variables in the function:
-     *
-     * * `this` — The current scope.
-     * * `this.$element` — The DOM element containing the binding. This allows the filter to manipulate
-     *   the DOM in addition to transforming the input.
-     *
-     *
-     * @exampleDescription
-     *  The following example filter reverses a text string. In addition, it conditionally makes the
-     *  text upper-case (to demonstrate optional arguments) and assigns color (to demonstrate DOM
-     *  modification).
-     *
-     * @example
-         <script type="text/javascript">
-           angular.filter('reverse', function(input, uppercase, color) {
-             var out = "";
-             for (var i = 0; i < input.length; i++) {
-               out = input.charAt(i) + out;
-             }
-             if (uppercase) {
-               out = out.toUpperCase();
-             }
-             if (color) {
-               this.$element.css('color', color);
-             }
-             return out;
-           });
-         </script>
-
-         <input name="text" type="text" value="hello" /><br>
-         No filter: {{text}}<br>
-         Reverse: {{text|reverse}}<br>
-         Reverse + uppercase: {{text|reverse:true}}<br>
-         Reverse + uppercase + blue:  {{text|reverse:true:"blue"}}
-
-     */
+    /** @name angular.fileter */
     angularFilter     = extensionMap(angular, 'filter'),
-    /**
-     * @workInProgress
-     * @ngdoc overview
-     * @name angular.formatter
-     * @namespace Namespace for all formats.
-     * @description
-     * # Overview
-     * The formatters are responsible for translating user readable text in an input widget to a
-     * data model stored in an application.
-     * 
-     * # Writting your own Formatter
-     * Writing your own formatter is easy. Just register a pair of JavaScript functions with 
-     * `angular.formatter`. One function for parsing user input text to the stored form, 
-     * and one for formatting the stored data to user-visible text.
-     * 
-     * Here is an example of a "reverse" formatter: The data is stored in uppercase and in 
-     * reverse, while it is displayed in lower case and non-reversed. User edits are 
-     * automatically parsed into the internal form and data changes are automatically 
-     * formatted to the viewed form.
-     * 
-     * <pre>
-     * function reverse(text) {
-     *   var reversed = [];
-     *   for (var i = 0; i < text.length; i++) {
-     *     reversed.unshift(text.charAt(i));
-     *   }
-     *   return reversed.join('');
-     * }
-     * 
-     * angular.formatter('reverse', {
-     *   parse: function(value){
-     *     return reverse(value||'').toUpperCase();
-     *   },
-     *   format: function(value){
-     *     return reverse(value||'').toLowerCase();
-     *   }
-     * });
-     * </pre>
-     * 
-     * @example
-     * <script type="text/javascript">
-     * function reverse(text) {
-     *   var reversed = [];
-     *   for (var i = 0; i < text.length; i++) {
-     *     reversed.unshift(text.charAt(i));
-     *   }
-     *   return reversed.join('');
-     * }
-     * 
-     * angular.formatter('reverse', {
-     *   parse: function(value){
-     *     return reverse(value||'').toUpperCase();
-     *   },
-     *   format: function(value){
-     *     return reverse(value||'').toLowerCase();
-     *   }
-     * });
-     * </script>
-     *
-     * Formatted: 
-     * <input type="text" name="data" value="angular" ng:format="reverse"/>
-     * <br/>
-     * 
-     * Stored: 
-     * <input type="text" name="data"/><br/>
-     * <pre>{{data}}</pre>
-     *
-     * 
-     * @scenario
-     * it('should store reverse', function(){
-     *  expect(element('.doc-example input:first').val()).toEqual('angular');
-     *  expect(element('.doc-example input:last').val()).toEqual('RALUGNA');
-     *  
-     *  this.addFutureAction('change to XYZ', function($window, $document, done){
-     *    $document.elements('.doc-example input:last').val('XYZ').trigger('change');
-     *    done();
-     *  });
-     *  expect(element('.doc-example input:first').val()).toEqual('zyx');
-     * });
-     */
+    /** @name angular.formatter */
     angularFormatter  = extensionMap(angular, 'formatter'),
-    
-    /**
-     * @workInProgress
-     * @ngdoc overview
-     * @name angular.service
-     * 
-     * @description
-     * # Overview
-     * Services are substituable objects, which are wired together using dependency injection.
-     * Each service could have dependencies (other services), which are passed in constructor.
-     * Because JS is dynamicaly typed language, dependency injection can not use static types
-     * to satisfy these dependencies, so each service must explicitely define its dependencies.
-     * This is done by $inject property.
-     * 
-     * For now, life time of all services is the same as the life time of page.
-     * 
-     * 
-     * # Standard services
-     * The Angular framework provides a standard set of services for common operations.
-     * You can write your own services and rewrite these standard services as well.
-     * Like other core angular variables, standard services always start with $.
-     * 
-     *   * `angular.service.$window`
-     *   * `angular.service.$document`
-     *   * `angular.service.$location`
-     *   * `angular.service.$log`
-     *   * `angular.service.$exceptionHandler`
-     *   * `angular.service.$hover`
-     *   * `angular.service.$invalidWidgets`
-     *   * `angular.service.$route`
-     *   * `angular.service.$xhr`
-     *   * `angular.service.$xhr.error`
-     *   * `angular.service.$xhr.bulk`
-     *   * `angular.service.$xhr.cache`
-     *   * `angular.service.$resource`
-     *   * `angular.service.$cookies`
-     *   * `angular.service.$cookieStore`
-     * 
-     * # Writing your own services
-     * <pre>
-     * angular.service('notify', function(location) {
-     *   this.one = function() {
-     *   }
-     * }, {$inject: ['$location']});
-     * </pre>
-     * 
-     * # Using services in controller
-     */
+    /** @name angular.service */
     angularService    = extensionMap(angular, 'service'),
     angularCallbacks  = extensionMap(angular, 'callbacks'),
-    nodeName,
-    rngScript         = /^(|.*\/)angular(-.*?)?(\.min)?.js(\?[^#]*)?(#(.*))?$/;
+    nodeName_,
+    rngScript         = /^(|.*\/)angular(-.*?)?(\.min)?.js(\?[^#]*)?(#(.*))?$/,
+    DATE_ISOSTRING_LN = 24;
 
-function foreach(obj, iterator, context) {
+/**
+ * @workInProgress
+ * @ngdoc function
+ * @name angular.forEach
+ * @function
+ *
+ * @description
+ * Invokes the `iterator` function once for each item in `obj` collection. The collection can either
+ * be an object or an array. The `iterator` function is invoked with `iterator(value, key)`, where
+ * `value` is the value of an object property or an array element and `key` is the object property
+ * key or array element index. Optionally, `context` can be specified for the iterator function.
+ *
+ * Note: this function was previously known as `angular.foreach`.
+ *
+   <pre>
+     var values = {name: 'misko', gender: 'male'};
+     var log = [];
+     angular.forEach(values, function(value, key){
+       this.push(key + ': ' + value);
+     }, log);
+     expect(log).toEqual(['name: misko', 'gender:male']);
+   </pre>
+ *
+ * @param {Object|Array} obj Object to iterate over.
+ * @param {function()} iterator Iterator function.
+ * @param {Object} context Object to become context (`this`) for the iterator function.
+ * @returns {Objet|Array} Reference to `obj`.
+ */
+function forEach(obj, iterator, context) {
   var key;
   if (obj) {
     if (isFunction(obj)){
@@ -529,7 +149,7 @@ function foreach(obj, iterator, context) {
           iterator.call(context, obj[key], key);
         }
       }
-    } else if (obj.forEach) {
+    } else if (obj.forEach && obj.forEach !== forEach) {
       obj.forEach(iterator, context);
     } else if (isObject(obj) && isNumber(obj.length)) {
       for (key = 0; key < obj.length; key++)
@@ -542,7 +162,7 @@ function foreach(obj, iterator, context) {
   return obj;
 }
 
-function foreachSorted(obj, iterator, context) {
+function forEachSorted(obj, iterator, context) {
   var keys = [];
   for (var key in obj) keys.push(key);
   keys.sort();
@@ -565,10 +185,23 @@ function formatError(arg) {
 }
 
 
+/**
+ * @workInProgress
+ * @ngdoc function
+ * @name angular.extend
+ * @function
+ *
+ * @description
+ * Extends the destination object `dst` by copying all of the properties from the `src` objects to
+ * `dst`. You can specify multiple `src` objects.
+ *
+ * @param {Object} dst The destination object.
+ * @param {...Object} src The source object(s).
+ */
 function extend(dst) {
-  foreach(arguments, function(obj){
+  forEach(arguments, function(obj){
     if (obj !== dst) {
-      foreach(obj, function(value, key){
+      forEach(obj, function(value, key){
         dst[key] = value;
       });
     }
@@ -576,12 +209,50 @@ function extend(dst) {
   return dst;
 }
 
+
 function inherit(parent, extra) {
   return extend(new (extend(function(){}, {prototype:parent}))(), extra);
 }
 
+
+/**
+ * @workInProgress
+ * @ngdoc function
+ * @name angular.noop
+ * @function
+ *
+ * @description
+ * Empty function that performs no operation whatsoever. This function is useful when writing code
+ * in the functional style.
+   <pre>
+     function foo(callback) {
+       var result = calculateResult();
+       (callback || angular.noop)(result);
+     }
+   </pre>
+ */
 function noop() {}
+
+
+/**
+ * @workInProgress
+ * @ngdoc function
+ * @name angular.identity
+ * @function
+ *
+ * @description
+ * A function that does nothing except for returning its first argument. This function is useful
+ * when writing code in the functional style.
+ *
+   <pre>
+     function transformer(transformationFn, value) {
+       return (transformationFn || identity)(value);
+     };
+   </pre>
+ */
 function identity($) {return $;}
+
+
 function valueFn(value) {return function(){ return value; };}
 
 function extensionMap(angular, name, transform) {
@@ -589,12 +260,6 @@ function extensionMap(angular, name, transform) {
   return angular[name] || (extPoint = angular[name] = function (name, fn, prop){
     name = (transform || identity)(name);
     if (isDefined(fn)) {
-      if (isDefined(extPoint[name])) {
-        foreach(extPoint[name], function(property, key) {
-          if (key.charAt(0) == '$' && isUndefined(fn[key]))
-            fn[key] = property;
-        });
-      }
       extPoint[name] = extend(fn, prop || {});
     }
     return extPoint[name];
@@ -608,22 +273,148 @@ function jqLiteWrap(element) {
       var div = document.createElement('div');
       div.innerHTML = element;
       element = new JQLite(div.childNodes);
-    } else if (!(element instanceof JQLite) && isElement(element)) {
+    } else if (!(element instanceof JQLite)) {
       element =  new JQLite(element);
     }
   }
   return element;
 }
+
+
+/**
+ * @workInProgress
+ * @ngdoc function
+ * @name angular.isUndefined
+ * @function
+ *
+ * @description
+ * Checks if a reference is undefined.
+ *
+ * @param {*} value Reference to check.
+ * @returns {boolean} True if `value` is undefined.
+ */
 function isUndefined(value){ return typeof value == $undefined; }
+
+
+/**
+ * @workInProgress
+ * @ngdoc function
+ * @name angular.isDefined
+ * @function
+ *
+ * @description
+ * Checks if a reference is defined.
+ *
+ * @param {*} value Reference to check.
+ * @returns {boolean} True if `value` is defined.
+ */
 function isDefined(value){ return typeof value != $undefined; }
+
+
+/**
+ * @workInProgress
+ * @ngdoc function
+ * @name angular.isObject
+ * @function
+ *
+ * @description
+ * Checks if a reference is an `Object`. Unlike in JavaScript `null`s are not considered to be
+ * objects.
+ *
+ * @param {*} value Reference to check.
+ * @returns {boolean} True if `value` is an `Object` but not `null`.
+ */
 function isObject(value){ return value!=_null && typeof value == $object;}
+
+
+/**
+ * @workInProgress
+ * @ngdoc function
+ * @name angular.isString
+ * @function
+ *
+ * @description
+ * Checks if a reference is a `String`.
+ *
+ * @param {*} value Reference to check.
+ * @returns {boolean} True if `value` is a `String`.
+ */
 function isString(value){ return typeof value == $string;}
+
+
+/**
+ * @workInProgress
+ * @ngdoc function
+ * @name angular.isNumber
+ * @function
+ *
+ * @description
+ * Checks if a reference is a `Number`.
+ *
+ * @param {*} value Reference to check.
+ * @returns {boolean} True if `value` is a `Number`.
+ */
 function isNumber(value){ return typeof value == $number;}
+
+
+/**
+ * @workInProgress
+ * @ngdoc function
+ * @name angular.isDate
+ * @function
+ *
+ * @description
+ * Checks if value is a date.
+ *
+ * @param {*} value Reference to check.
+ * @returns {boolean} True if `value` is a `Date`.
+ */
 function isDate(value){ return value instanceof Date; }
+
+
+/**
+ * @workInProgress
+ * @ngdoc function
+ * @name angular.isArray
+ * @function
+ *
+ * @description
+ * Checks if a reference is an `Array`.
+ *
+ * @param {*} value Reference to check.
+ * @returns {boolean} True if `value` is an `Array`.
+ */
 function isArray(value) { return value instanceof Array; }
+
+
+/**
+ * @workInProgress
+ * @ngdoc function
+ * @name angular.isFunction
+ * @function
+ *
+ * @description
+ * Checks if a reference is a `Function`.
+ *
+ * @param {*} value Reference to check.
+ * @returns {boolean} True if `value` is a `Function`.
+ */
 function isFunction(value){ return typeof value == $function;}
+
+
+/**
+ * Checks if `obj` is a window object.
+ *
+ * @private
+ * @param {*} obj Object to check
+ * @returns {boolean} True if `obj` is a window obj.
+ */
+function isWindow(obj) {
+  return obj && obj.document && obj.location && obj.alert && obj.setInterval;
+}
+
 function isBoolean(value) { return typeof value == $boolean;}
-function isTextNode(node) { return nodeName(node) == '#text'; }
+function isTextNode(node) { return nodeName_(node) == '#text'; }
 function trim(value) { return isString(value) ? value.replace(/^\s*/, '').replace(/\s*$/, '') : value; }
 function isElement(node) {
   return node && (node.nodeName || node instanceof JQLite || (jQuery && node instanceof jQuery));
@@ -647,12 +438,12 @@ function HTML(html, option) {
 }
 
 if (msie) {
-  nodeName = function(element) {
+  nodeName_ = function(element) {
     element = element.nodeName ? element : element[0];
     return (element.scopeName && element.scopeName != 'HTML' ) ? uppercase(element.scopeName + ':' + element.nodeName) : element.nodeName;
   };
 } else {
-  nodeName = function(element) {
+  nodeName_ = function(element) {
     return element.nodeName ? element.nodeName : element[0].nodeName;
   };
 }
@@ -670,11 +461,32 @@ function isVisible(element) {
 
 function map(obj, iterator, context) {
   var results = [];
-  foreach(obj, function(value, index, list) {
+  forEach(obj, function(value, index, list) {
     results.push(iterator.call(context, value, index, list));
   });
   return results;
 }
+
+
+/**
+ * @workInProgress
+ * @ngdoc function
+ * @name angular.Object.size
+ * @function
+ *
+ * @description
+ * Determines the number of elements in an array or number of properties of an object.
+ *
+ * Note: this function is used to augment the Object type in angular expressions. See
+ * {@link angular.Object} for more info.
+ *
+ * @param {Object|Array} obj Object or array to inspect.
+ * @returns {number} The size of `obj` or `0` if `obj` is not an object or array.
+ *
+ * @example
+ * Number of items in array: {{ [1,2].$size() }}<br/>
+ * Number of items in object: {{ {a:1, b:2, c:3}.$size() }}<br/>
+ */
 function size(obj) {
   var size = 0;
   if (obj) {
@@ -714,19 +526,40 @@ function isLeafNode (node) {
 }
 
 /**
- * Copies stuff.
+ * @workInProgress
+ * @ngdoc function
+ * @name angular.Object.copy
+ * @function
  *
- * If destination is not provided and source is an object or an array, a copy is created & returned,
- * otherwise the source is returned.
+ * @description
+ * Creates a deep copy of `source`.
  *
- * If destination is provided, all of its properties will be deleted and if source is an object or
- * an array, all of its members will be copied into the destination object. Finally the destination
- * is returned just for kicks.
+ * If `destination` is not provided and `source` is an object or an array, a copy is created &
+ * returned, otherwise the `source` is returned.
  *
- * @param {*} source The source to be used during copy.
- *                   Can be any type including primitives, null and undefined.
- * @param {(Object|Array)=} destination Optional destination into which the source is copied
- * @returns {*}
+ * If `destination` is provided, all of its properties will be deleted.
+ *
+ * If `source` is an object or an array, all of its members will be copied into the `destination`
+ * object.
+ *
+ * Note: this function is used to augment the Object type in angular expressions. See
+ * {@link angular.Object} for more info.
+ *
+ * @param {*} source The source to be used to make a copy.
+ *                   Can be any type including primitives, `null` and `undefined`.
+ * @param {(Object|Array)=} destination Optional destination into which the source is copied.
+ * @returns {*} The copy or updated `destination` if `destination` was specified.
+ *
+ * @example
+   Salutation: <input type="text" name="master.salutation" value="Hello" /><br/>
+   Name: <input type="text" name="master.name" value="world"/><br/>
+   <button ng:click="form = master.$copy()">copy</button>
+   <hr/>
+
+   Master is <span ng:hide="master.$equals(form)">NOT</span> same as form.
+
+   <pre>master={{master}}</pre>
+   <pre>form={{form}}</pre>
  */
 function copy(source, destination){
   if (!destination) {
@@ -749,7 +582,7 @@ function copy(source, destination){
         destination.push(copy(source[i]));
       }
     } else {
-      foreach(destination, function(value, key){
+      forEach(destination, function(value, key){
         delete destination[key];
       });
       for ( var key in source) {
@@ -760,8 +593,45 @@ function copy(source, destination){
   return destination;
 }
 
+
+/**
+ * @workInProgress
+ * @ngdoc function
+ * @name angular.Object.equals
+ * @function
+ *
+ * @description
+ * Determines if two objects or value are equivalent.
+ *
+ * To be equivalent, they must pass `==` comparison or be of the same type and have all their
+ * properties pass `==` comparison.
+ *
+ * Supports values types, arrays and objects.
+ *
+ * For objects `function` properties and properties that start with `$` are not considered during
+ * comparisons.
+ *
+ * Note: this function is used to augment the Object type in angular expressions. See
+ * {@link angular.Object} for more info.
+ *
+ * @param {*} o1 Object or value to compare.
+ * @param {*} o2 Object or value to compare.
+ * @returns {boolean} True if arguments are equal.
+ *
+ * @example
+   Salutation: <input type="text" name="master.salutation" value="Hello" /><br/>
+   Name: <input type="text" name="master.name" value="world"/><br/>
+   <button ng:click="form = master.$copy()">copy</button>
+   <hr/>
+
+   Master is <span ng:hide="master.$equals(form)">NOT</span> same as form.
+
+   <pre>master={{master}}</pre>
+   <pre>form={{form}}</pre>
+ */
 function equals(o1, o2) {
   if (o1 == o2) return true;
+  if (o1 === null || o2 === null) return false;
   var t1 = typeof o1, t2 = typeof o2, length, key, keySet;
   if (t1 == t2 && t1 == 'object') {
     if (o1 instanceof Array) {
@@ -823,16 +693,33 @@ function concat(array1, array2, index) {
   return array1.concat(slice.call(array2, index, array2.length));
 }
 
+
+/**
+ * @workInProgress
+ * @ngdoc function
+ * @name angular.bind
+ * @function
+ *
+ * @description
+ * Returns function which calls function `fn` bound to `self` (`self` becomes the `this` for `fn`).
+ * Optional `args` can be supplied which are prebound to the function, also known as
+ * [function currying](http://en.wikipedia.org/wiki/Currying).
+ *
+ * @param {Object} self Context in which `fn` should be evaluated in.
+ * @param {function()} fn Function to be bound.
+ * @param {...*} args Optional arguments to be prebound to the `fn` function call.
+ * @returns {function()} Function that wraps the `fn` with all the specified bindings.
+ */
 function bind(self, fn) {
   var curryArgs = arguments.length > 2 ? slice.call(arguments, 2, arguments.length) : [];
-  if (typeof fn == $function) {
+  if (typeof fn == $function && !(fn instanceof RegExp)) {
     return curryArgs.length ? function() {
       return arguments.length ? fn.apply(self, curryArgs.concat(slice.call(arguments, 0, arguments.length))) : fn.apply(self, curryArgs);
     }: function() {
       return arguments.length ? fn.apply(self, arguments) : fn.call(self);
     };
   } else {
-    // in IE, native methods ore not functions and so they can not be bound (but they don't need to be)
+    // in IE, native methods are not functions and so they can not be bound (but they don't need to be)
     return fn;
   }
 }
@@ -860,10 +747,31 @@ function merge(src, dst) {
   }
 }
 
-function compile(element, existingScope) {
+
+/**
+ * @workInProgress
+ * @ngdoc function
+ * @name angular.compile
+ * @function
+ *
+ * @description
+ * Compiles a piece of HTML or DOM into a {@link angular.scope scope} object.
+   <pre>
+    var scope1 = angular.compile(window.document);
+    scope1.$init();
+
+    var scope2 = angular.compile('<div ng:click="clicked = true">click me</div>');
+    scope2.$init();
+   </pre>
+ *
+ * @param {string|DOMElement} element Element to compile.
+ * @param {Object=} parentScope Scope to become the parent scope of the newly compiled scope.
+ * @returns {Object} Compiled scope object.
+ */
+function compile(element, parentScope) {
   var compiler = new Compiler(angularTextMarkup, angularAttrMarkup, angularDirective, angularWidget),
       $element = jqLite(element);
-  return compiler.compile($element)($element, existingScope);
+  return compiler.compile($element)($element, parentScope);
 }
 /////////////////////////////////////////////////
 
@@ -873,7 +781,7 @@ function compile(element, existingScope) {
  */
 function parseKeyValue(/**string*/keyValue) {
   var obj = {}, key_value, key;
-  foreach((keyValue || "").split('&'), function(keyValue){
+  forEach((keyValue || "").split('&'), function(keyValue){
     if (keyValue) {
       key_value = keyValue.split('=');
       key = unescape(key_value[0]);
@@ -885,7 +793,7 @@ function parseKeyValue(/**string*/keyValue) {
 
 function toKeyValue(obj) {
   var parts = [];
-  foreach(obj, function(value, key) {
+  forEach(obj, function(value, key) {
     parts.push(escape(key) + (value === true ? '' : '=' + escape(value)));
   });
   return parts.length ? parts.join('&') : '';
@@ -1046,7 +954,7 @@ function angularInit(config){
   if (config.autobind) {
     // TODO default to the source of angular.js
     var scope = compile(window.document, _null, {'$config':config}),
-        $browser = scope.$inject('$browser');
+        $browser = scope.$service('$browser');
 
     if (config.css)
       $browser.addCss(config.base_url + config.css);

src/AngularPublic.js

@@ -10,17 +10,18 @@ var browserSingleton;
  */
 angularService('$browser', function($log){
   if (!browserSingleton) {
-    browserSingleton = new Browser(
-        window.location,
-        jqLite(window.document),
-        jqLite(window.document.getElementsByTagName('head')[0]),
-        XHR,
-        $log);
-    browserSingleton.startPoller(50, function(delay, fn){setTimeout(delay,fn);});
+    browserSingleton = new Browser(window, jqLite(window.document), jqLite(window.document.body),
+                                   XHR, $log);
+    var addPollFn = browserSingleton.addPollFn;
+    browserSingleton.addPollFn = function(){
+      browserSingleton.addPollFn = addPollFn;
+      browserSingleton.startPoller(100, function(delay, fn){setTimeout(delay,fn);});
+      return addPollFn.apply(browserSingleton, arguments);
+    };
     browserSingleton.bind();
   }
   return browserSingleton;
-}, {inject:['$log']});
+}, {$inject:['$log']});
 
 extend(angular, {
   'element': jqLite,
@@ -29,7 +30,7 @@ extend(angular, {
   'copy': copy,
   'extend': extend,
   'equals': equals,
-  'foreach': foreach,
+  'forEach': forEach,
   'injector': createInjector,
   'noop':noop,
   'bind':bind,

src/Browser.js

@@ -8,8 +8,29 @@ var XHR = window.XMLHttpRequest || function () {
   throw new Error("This browser does not support XMLHttpRequest.");
 };
 
-function Browser(location, document, head, XHR, $log) {
-  var self = this;
+/**
+ * @private
+ * @name Browser
+ *
+ * @description
+ * Constructor for the object exposed as $browser service.
+ *
+ * This object has two goals:
+ *
+ * - hide all the global state in the browser caused by the window object
+ * - abstract away all the browser specific features and inconsistencies
+ *
+ * @param {object} window The global window object.
+ * @param {object} document jQuery wrapped document.
+ * @param {object} body jQuery wrapped document.body.
+ * @param {function()} XHR XMLHttpRequest constructor.
+ * @param {object} $log console.log or an object with the same interface.
+ */
+function Browser(window, document, body, XHR, $log) {
+  var self = this,
+      location = window.location,
+      setTimeout = window.setTimeout;
+
   self.isMock = false;
 
   //////////////////////////////////////////////////////////////
@@ -19,6 +40,28 @@ function Browser(location, document, head, XHR, $log) {
   var outstandingRequestCount = 0;
   var outstandingRequestCallbacks = [];
 
+
+  /**
+   * Executes the `fn` function (supports currying) and decrements the `outstandingRequestCallbacks`
+   * counter. If the counter reaches 0, all the `outstandingRequestCallbacks` are executed.
+   */
+  function completeOutstandingRequest(fn) {
+    try {
+      fn.apply(null, slice.call(arguments, 1));
+    } finally {
+      outstandingRequestCount--;
+      if (outstandingRequestCount === 0) {
+        while(outstandingRequestCallbacks.length) {
+          try {
+            outstandingRequestCallbacks.pop()();
+          } catch (e) {
+            $log.error(e);
+          }
+        }
+      }
+    }
+  }
+
   /**
    * @workInProgress
    * @ngdoc method
@@ -48,7 +91,7 @@ function Browser(location, document, head, XHR, $log) {
         window[callbackId] = _undefined;
         callback(200, data);
       };
-      head.append(script);
+      body.append(script);
     } else {
       var xhr = new XHR();
       xhr.open(method, url, true);
@@ -58,19 +101,7 @@ function Browser(location, document, head, XHR, $log) {
       outstandingRequestCount ++;
       xhr.onreadystatechange = function() {
         if (xhr.readyState == 4) {
-          try {
-            callback(xhr.status || 200, xhr.responseText);
-          } finally {
-            outstandingRequestCount--;
-            if (outstandingRequestCount === 0) {
-              while(outstandingRequestCallbacks.length) {
-                try {
-                  outstandingRequestCallbacks.pop()();
-                } catch (e) {
-                }
-              }
-            }
-          }
+          completeOutstandingRequest(callback, xhr.status || 200, xhr.responseText);
         }
       };
       xhr.send(post || '');
@@ -105,7 +136,7 @@ function Browser(location, document, head, XHR, $log) {
    * @methodOf angular.service.$browser
    */
   self.poll = function() {
-    foreach(pollFns, function(pollFn){ pollFn(); });
+    forEach(pollFns, function(pollFn){ pollFn(); });
   };
 
   /**
@@ -183,6 +214,41 @@ function Browser(location, document, head, XHR, $log) {
     return location.href;
   };
 
+
+  /**
+   * @workInProgress
+   * @ngdoc method
+   * @name angular.service.$browser#onHashChange
+   * @methodOf angular.service.$browser
+   *
+   * @description
+   * Detects if browser support onhashchange events and register a listener otherwise registers
+   * $browser poller. The `listener` will then get called when the hash changes.
+   *
+   * The listener gets called with either HashChangeEvent object or simple object that also contains
+   * `oldURL` and `newURL` properties.
+   *
+   * NOTE: this is a api is intended for sole use by $location service. Please use
+   * {@link angular.service.$location $location service} to monitor hash changes in angular apps.
+   *
+   * @param {function(event)} listener Listener function to be called when url hash changes.
+   * @return {function()} Returns the registered listener fn - handy if the fn is anonymous.
+   */
+  self.onHashChange = function(listener) {
+    if ('onhashchange' in window) {
+      jqLite(window).bind('hashchange', listener);
+    } else {
+      var lastBrowserUrl = self.getUrl();
+
+      self.addPollFn(function() {
+        if (lastBrowserUrl != self.getUrl()) {
+          listener();
+        }
+      });
+    }
+    return listener;
+  }
+
   //////////////////////////////////////////////////////////////
   // Cookies API
   //////////////////////////////////////////////////////////////
@@ -250,6 +316,28 @@ function Browser(location, document, head, XHR, $log) {
     }
   };
 
+
+  /**
+   * @workInProgress
+   * @ngdoc method
+   * @name angular.service.$browser#defer
+   * @methodOf angular.service.$browser
+   * @param {function()} fn A function, who's execution should be defered.
+   * @param {int=} [delay=0] of milliseconds to defer the function execution.
+   *
+   * @description
+   * Executes a fn asynchroniously via `setTimeout(fn, delay)`.
+   *
+   * Unlike when calling `setTimeout` directly, in test this function is mocked and instead of using
+   * `setTimeout` in tests, the fns are queued in an array, which can be programaticaly flushed via
+   * `$browser.defer.flush()`.
+   *
+   */
+  self.defer = function(fn, delay) {
+    outstandingRequestCount++;
+    setTimeout(function() { completeOutstandingRequest(fn); }, delay || 0);
+  };
+
   //////////////////////////////////////////////////////////////
   // Misc API
   //////////////////////////////////////////////////////////////
@@ -305,7 +393,7 @@ function Browser(location, document, head, XHR, $log) {
     link.attr('rel', 'stylesheet');
     link.attr('type', 'text/css');
     link.attr('href', url);
-    head.append(link);
+    body.append(link);
   };
 
 
@@ -326,6 +414,6 @@ function Browser(location, document, head, XHR, $log) {
     script.attr('type', 'text/javascript');
     script.attr('src', url);
     if (dom_id) script.attr('id', dom_id);
-    head.append(script);
+    body.append(script);
   };
 }

src/Compiler.js

@@ -16,8 +16,8 @@ Template.prototype = {
   init: function(element, scope) {
     var inits = {};
     this.collectInits(element, inits, scope);
-    foreachSorted(inits, function(queue){
-      foreach(queue, function(fn) {fn();});
+    forEachSorted(inits, function(queue){
+      forEach(queue, function(fn) {fn();});
     });
   },
 
@@ -30,11 +30,12 @@ Template.prototype = {
     if (this.newScope) {
       childScope = createScope(scope);
       scope.$onEval(childScope.$eval);
+      element.data($$scope, childScope);
     }
-    foreach(this.inits, function(fn) {
+    forEach(this.inits, function(fn) {
       queue.push(function() {
         childScope.$tryEval(function(){
-          return childScope.$inject(fn, childScope, element);
+          return childScope.$service(fn, childScope, element);
         }, element);
       });
     });
@@ -68,6 +69,18 @@ Template.prototype = {
   }
 };
 
+/*
+ * Function walks up the element chain looking for the scope associated with the give element.
+ */
+function retrieveScope(element) {
+  var scope;
+  element = jqLite(element);
+  while (element && !(scope = element.data($$scope))) {
+    element = element.parent();
+  }
+  return scope;
+}
+
 ///////////////////////////////////
 //Compiler
 //////////////////////////////////
@@ -97,6 +110,7 @@ Compiler.prototype = {
       element = jqLite(element);
       var scope = parentScope && parentScope.$eval ?
           parentScope : createScope(parentScope);
+      element.data($$scope, scope);
       return extend(scope, {
         $element:element,
         $init: function() {
@@ -168,7 +182,7 @@ Compiler.prototype = {
         directiveFns = self.directives,
         descend = true,
         directives = true,
-        elementName = nodeName(element),
+        elementName = nodeName_(element),
         template,
         selfApi = {
           compile: bind(self, self.compile),
@@ -218,7 +232,7 @@ Compiler.prototype = {
       for(var i=0, child=element[0].childNodes;
           i<child.length; i++) {
         if (isTextNode(child[i])) {
-          foreach(self.markup, function(markup){
+          forEach(self.markup, function(markup){
             if (i<child.length) {
               var textNode = jqLite(child[i]);
               markup.call(selfApi, textNode.text(), textNode, element);
@@ -231,7 +245,7 @@ Compiler.prototype = {
     if (directives) {
       // Process attributes/directives
       eachAttribute(element, function(value, name){
-        foreach(self.attrMarkup, function(markup){
+        forEach(self.attrMarkup, function(markup){
           markup.call(selfApi, value, name, element);
         });
       });
@@ -273,6 +287,6 @@ function eachAttribute(element, fn){
     }
     attrValue[name] = value;
   }
-  foreachSorted(attrValue, fn);
+  forEachSorted(attrValue, fn);
 }
 

src/Injector.js

@@ -1,9 +1,20 @@
 /**
- * Create an inject method
- * @param providerScope provider's "this"
- * @param providers a function(name) which returns provider function
- * @param cache place where instances are saved for reuse
- * @returns {Function}
+ * @ngdoc function
+ * @name angular.injector
+ * @function
+ *
+ * @description
+ * Creates an inject function that can be used for dependency injection.
+ *
+ * @param {Object=} [providerScope={}] provider's `this`
+ * @param {Object.<string, function()>=} [providers=angular.service] Map of provider (factory)
+ *     function.
+ * @param {Object.<string, function()>=} [cache={}] Place where instances are saved for reuse. Can
+ *     also be used to override services speciafied by `providers` (useful in tests).
+ * @returns {function()} Injector function.
+ *
+ * @TODO These docs need a lot of work. Specifically the returned function should be described in
+ *     great detail + we need to provide some examples.
  */
 function createInjector(providerScope, providers, cache) {
   providers = providers || angularService;
@@ -26,7 +37,7 @@ function createInjector(providerScope, providers, cache) {
    *   none:   same as object but use providerScope as place to publish.
    */
   return function inject(value, scope, args){
-    var returnValue, provider, creation;
+    var returnValue, provider;
     if (isString(value)) {
       if (!cache.hasOwnProperty(value)) {
         provider = providers[value];
@@ -36,25 +47,32 @@ function createInjector(providerScope, providers, cache) {
       returnValue = cache[value];
     } else if (isArray(value)) {
       returnValue = [];
-      foreach(value, function(name) {
+      forEach(value, function(name) {
         returnValue.push(inject(name));
       });
     } else if (isFunction(value)) {
       returnValue = inject(value.$inject || []);
       returnValue = value.apply(scope, concat(returnValue, arguments, 2));
     } else if (isObject(value)) {
-      foreach(providers, function(provider, name){
-        creation = provider.$creation;
-        if (creation == 'eager') {
+      forEach(providers, function(provider, name){
+        if (provider.$eager)
           inject(name);
-        }
-        if (creation == 'eager-published') {
-          setter(value, name, inject(name));
-        }
+
+        if (provider.$creation)
+          throw new Error("Failed to register service '" + name +
+              "': $creation property is unsupported. Use $eager:true or see release notes.");
       });
     } else {
       returnValue = inject(providerScope);
     }
     return returnValue;
   };
-}
+}
+
+function injectService(services, fn) {
+  return extend(fn, {$inject:services});;
+}
+
+function injectUpdateView(fn) {
+  return injectService(['$updateView'], fn);
+}

src/JSON.js

@@ -29,19 +29,41 @@ function toJson(obj, pretty) {
  * Deserializes a string in the JSON format.
  *
  * @param {string} json JSON string to deserialize.
+ * @param {boolean} [useNative=false] Use native JSON parser if available
  * @returns {Object|Array|Date|string|number} Deserialized thingy.
  */
-function fromJson(json) {
+function fromJson(json, useNative) {
   if (!json) return json;
+
+  var obj, p, expression;
+
   try {
-    var p = parser(json, true);
-    var expression =  p.primary();
+    if (useNative && JSON && JSON.parse) {
+      obj = JSON.parse(json);
+      return transformDates(obj);
+    }
+
+    p = parser(json, true);
+    expression =  p.primary();
     p.assertAllConsumed();
     return expression();
+
   } catch (e) {
     error("fromJson error: ", json, e);
     throw e;
   }
+
+  // TODO make forEach optionally recursive and remove this function
+  function transformDates(obj) {
+    if (isString(obj) && obj.length === DATE_ISOSTRING_LN) {
+      return angularString.toDate(obj);
+    } else if (isArray(obj) || isObject(obj)) {
+      forEach(obj, function(val, name) {
+        obj[name] = transformDates(val);
+      });
+    }
+    return obj;
+  }
 }
 
 angular['toJson'] = toJson;

src/Resource.js

@@ -4,7 +4,7 @@ function Route(template, defaults) {
   this.template = template = template + '#';
   this.defaults = defaults || {};
   var urlParams = this.urlParams = {};
-  foreach(template.split(/\W/), function(param){
+  forEach(template.split(/\W/), function(param){
     if (param && template.match(new RegExp(":" + param + "\\W"))) {
       urlParams[param] = true;
     }
@@ -17,13 +17,13 @@ Route.prototype = {
     var self = this;
     var url = this.template;
     params = params || {};
-    foreach(this.urlParams, function(_, urlParam){
+    forEach(this.urlParams, function(_, urlParam){
       var value = params[urlParam] || self.defaults[urlParam] || "";
       url = url.replace(new RegExp(":" + urlParam + "(\\W)"), value + "$1");
     });
     url = url.replace(/\/?#$/, '');
     var query = [];
-    foreachSorted(params, function(value, key){
+    forEachSorted(params, function(value, key){
       if (!self.urlParams[key]) {
         query.push(encodeURI(key) + '=' + encodeURI(value));
       }
@@ -52,7 +52,7 @@ ResourceFactory.prototype = {
     actions = extend({}, ResourceFactory.DEFAULT_ACTIONS, actions);
     function extractParams(data){
       var ids = {};
-      foreach(paramDefaults || {}, function(value, key){
+      forEach(paramDefaults || {}, function(value, key){
         ids[key] = value.charAt && value.charAt(0) == '@' ? getter(data, value.substr(1)) : value;
       });
       return ids;
@@ -62,7 +62,7 @@ ResourceFactory.prototype = {
       copy(value || {}, this);
     }
 
-    foreach(actions, function(action, name){
+    forEach(actions, function(action, name){
       var isPostOrPut = action.method == 'POST' || action.method == 'PUT';
       Resource[name] = function (a1, a2, a3) {
         var params = {};
@@ -73,6 +73,7 @@ ResourceFactory.prototype = {
         case 2:
           if (isFunction(a2)) {
             callback = a2;
+            //fallthrough
           } else {
             params = a1;
             data = a2;
@@ -97,7 +98,7 @@ ResourceFactory.prototype = {
             if (status == 200) {
               if (action.isArray) {
                 value.length = 0;
-                foreach(response, function(item){
+                forEach(response, function(item){
                   value.push(new Resource(item));
                 });
               } else {

src/Scope.js

@@ -48,7 +48,7 @@ var scopeId = 0,
     getterFnCache = {},
     compileCache = {},
     JS_KEYWORDS = {};
-foreach(
+forEach(
     ("abstract,boolean,break,byte,case,catch,char,class,const,continue,debugger,default," +
     "delete,do,double,else,enum,export,extends,false,final,finally,float,for,function,goto," +
     "if,implements,import,ininstanceof,intinterface,long,native,new,null,package,private," +
@@ -61,12 +61,12 @@ function getterFn(path){
   if (fn) return fn;
 
   var code = 'var l, fn, t;\n';
-  foreach(path.split('.'), function(key) {
+  forEach(path.split('.'), function(key) {
     key = (JS_KEYWORDS[key]) ? '["' + key + '"]' : '.' + key;
     code += 'if(!s) return s;\n' +
             'l=s;\n' +
             's=s' + key + ';\n' +
-            'if(typeof s=="function") s = function(){ return l'+key+'.apply(l, arguments); };\n';
+            'if(typeof s=="function" && !(s instanceof RegExp)) s = function(){ return l'+key+'.apply(l, arguments); };\n';
     if (key.charAt(1) == '$') {
       // special code for super-imposed functions
       var name = key.substr(2);
@@ -191,7 +191,16 @@ function errorHandlerFor(element, error) {
  * Note: A widget that creates scopes (i.e. {@link angular.widget.@ng:repeat ng:repeat}) is
  * responsible for forwarding `$eval()` calls from the parent to those child scopes. That way,
  * calling $eval() on the root scope will update the whole page.
-
+ *
+ *
+ * @TODO THESE PARAMS AND RETURNS ARE NOT RENDERED IN THE TEMPLATE!! FIX THAT!
+ * @param {Object} parent The scope that should become the parent for the newly created scope.
+ * @param {Object.<string, function()>=} providers Map of service factory which need to be provided
+ *     for the current scope. Usually {@link angular.service}.
+ * @param {Object.<string, *>=} instanceCache Provides pre-instantiated services which should
+ *     append/override services provided by `providers`.
+ * @returns {Object} Newly created scope.
+ *
  *
  * @exampleDescription
  * This example demonstrates scope inheritance and property overriding.
@@ -234,7 +243,6 @@ function createScope(parent, providers, instanceCache) {
   parent = Parent.prototype = (parent || {});
   var instance = new Parent();
   var evalLists = {sorted:[]};
-  var postList = [], postHash = {}, postId = 0;
 
   extend(instance, {
     'this': instance,
@@ -261,7 +269,58 @@ function createScope(parent, providers, instanceCache) {
      * @param {function()} fn Function to be bound.
      */
     $bind: bind(instance, bind, instance),
+
+
+    /**
+     * @workInProgress
+     * @ngdoc function
+     * @name angular.scope.$get
+     * @function
+     *
+     * @description
+     * Returns the value for `property_chain` on the current scope. Unlike in JavaScript, if there
+     * are any `undefined` intermediary properties, `undefined` is returned instead of throwing an
+     * exception.
+     *
+       <pre>
+         var scope = angular.scope();
+         expect(scope.$get('person.name')).toEqual(undefined);
+         scope.person = {};
+         expect(scope.$get('person.name')).toEqual(undefined);
+         scope.person.name = 'misko';
+         expect(scope.$get('person.name')).toEqual('misko');
+       </pre>
+     *
+     * @param {string} property_chain String representing name of a scope property. Optionally
+     *     properties can be chained with `.` (dot), e.g. `'person.name.first'`
+     * @returns {*} Value for the (nested) property.
+     */
     $get: bind(instance, getter, instance),
+
+
+    /**
+     * @workInProgress
+     * @ngdoc function
+     * @name angular.scope.$set
+     * @function
+     *
+     * @description
+     * Assigns a value to a property of the current scope specified via `property_chain`. Unlike in
+     * JavaScript, if there are any `undefined` intermediary properties, empty objects are created
+     * and assigned in to them instead of throwing an exception.
+     *
+       <pre>
+         var scope = angular.scope();
+         expect(scope.person).toEqual(undefined);
+         scope.$set('person.name', 'misko');
+         expect(scope.person).toEqual({name:'misko'});
+         expect(scope.person.name).toEqual('misko');
+       </pre>
+     *
+     * @param {string} property_chain String representing name of a scope property. Optionally
+     *     properties can be chained with `.` (dot), e.g. `'person.name.first'`
+     * @param {*} value Value to assign to the scope property.
+     */
     $set: bind(instance, setter, instance),
 
 
@@ -311,11 +370,6 @@ function createScope(parent, providers, instanceCache) {
             instance.$tryEval(queue[j].fn, queue[j].handler);
           }
         }
-        while(postList.length) {
-          fn = postList.shift();
-          delete postHash[fn.$postEvalId];
-          instance.$tryEval(fn);
-        }
       } else if (type === $function) {
         return exp.call(instance);
       } else  if (type === 'string') {
@@ -489,27 +543,6 @@ function createScope(parent, providers, instanceCache) {
       });
     },
 
-    /**
-     * @workInProgress
-     * @ngdoc function
-     * @name angular.scope.$postEval
-     * @function
-     */
-    $postEval: function(expr) {
-      if (expr) {
-        var fn = expressionCompile(expr);
-        var id = fn.$postEvalId;
-        if (!id) {
-          id = '$' + instance.$id + "_" + (postId++);
-          fn.$postEvalId = id;
-        }
-        if (!postHash[id]) {
-          postList.push(postHash[id] = fn);
-        }
-      }
-    },
-
-
     /**
      * @workInProgress
      * @ngdoc function
@@ -542,10 +575,10 @@ function createScope(parent, providers, instanceCache) {
     $become: function(Class) {
       if (isFunction(Class)) {
         instance.constructor = Class;
-        foreach(Class.prototype, function(fn, name){
+        forEach(Class.prototype, function(fn, name){
           instance[name] = bind(instance, fn);
         });
-        instance.$inject.apply(instance, concat([Class, instance], arguments, 1));
+        instance.$service.apply(instance, concat([Class, instance], arguments, 1));
 
         //TODO: backwards compatibility hack, remove when we don't depend on init methods
         if (isFunction(Class.prototype.init)) {
@@ -582,7 +615,23 @@ function createScope(parent, providers, instanceCache) {
   if (!parent.$root) {
     instance.$root = instance;
     instance.$parent = instance;
-    (instance.$inject = createInjector(instance, providers, instanceCache))();
+
+    /**
+     * @workInProgress
+     * @ngdoc function
+     * @name angular.scope.$service
+     * @function
+     *
+     * @description
+     * Provides access to angular's dependency injector and
+     * {@link angular.service registered services}. In general the use of this api is discouraged,
+     * except for tests and components that currently don't support dependency injection (widgets,
+     * filters, etc).
+     *
+     * @param {string} serviceId String ID of the service to return.
+     * @returns {*} Value, object or function returned by the service factory function if any.
+     */
+    (instance.$service = createInjector(instance, providers, instanceCache))();
   }
 
   return instance;

src/angular-bootstrap.js

@@ -21,11 +21,14 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
-(function(previousOnLoad){
-  var filename = /^(.*)\/angular-bootstrap.js(#.*)?$/,
+(function(window) {
+
+  var filename = /^(.*\/)angular-bootstrap.js(#.*)?$/,
       scripts = document.getElementsByTagName("SCRIPT"),
       serverPath,
-      match;
+      match,
+      globalVars = {};
+
   for(var j = 0; j < scripts.length; j++) {
     match = (scripts[j].src || "").match(filename);
     if (match) {
@@ -33,50 +36,109 @@
     }
   }
 
-  function addScript(file){
-    document.write('<script type="text/javascript" src="' + serverPath + file +'"></script>');
+  function key(prop) {
+    return "ng-clobber_" + prop;
+  }
+
+  window.angularClobberTest = function(file) {
+    var varKey, prop,
+        clobbered = [];
+
+    for (prop in window) {
+      varKey = key(prop);
+
+      if (prop === 'event') { //skip special variables which keep on changing
+        continue;
+      }
+      else if (!globalVars.hasOwnProperty(varKey)) {
+        //console.log('new global variable found: ', prop);
+        globalVars[varKey] = window[prop];
+      } else if (globalVars[varKey] !== window[prop] && !isActuallyNaN(window[prop])) {
+        clobbered.push(prop);
+        console.error("Global variable clobbered by script " + file + "! Variable name: " + prop);
+        globalVars[varKey] = window[prop];
+      }
+    }
+
+    for (varKey in globalVars) {
+      prop = varKey.substr(11);
+      if (clobbered.indexOf(prop) == -1 &&
+          prop != 'event' &&
+          !isActuallyNaN(globalVars[varKey]) &&
+          globalVars[varKey] !== window[prop]) {
+
+        delete globalVars[varKey];
+        console.warn("Global variable unexpectedly deleted in script " + file + "! " +
+                     "Variable name: " + prop);
+      }
+    }
+
+    function isActuallyNaN(val) {
+      return isNaN(val) && (typeof val === 'number');
+    }
+  }
+
+  function addScripts(){
+    var prop, i;
+
+    // initialize the window property cache
+    for (prop in window) {
+      globalVars[key(prop)] = window[prop];
+    }
+
+    // load the js scripts
+    for (i in arguments) {
+      file = arguments[i];
+      document.write('<script type="text/javascript" src="' + serverPath + file + '" ' +
+                             'onload="angularClobberTest(\'' + file + '\')"></script>');
+    }
   }
 
   function addCss(file) {
     document.write('<link rel="stylesheet" type="text/css" href="' +
-                      serverPath + '/../css' + file  + '"/>');
+                      serverPath + '../css/' + file  + '"/>');
   }
 
-  addCss("/angular.css");
+  addCss('angular.css');
 
-  addScript("/Angular.js");
-  addScript("/JSON.js");
-  addScript("/Compiler.js");
-  addScript("/Scope.js");
-  addScript("/Injector.js");
-  addScript("/jqLite.js");
-  addScript("/parser.js");
-  addScript("/Resource.js");
-  addScript("/Browser.js");
-  addScript("/sanitizer.js");
-  addScript("/AngularPublic.js");
+  addScripts('Angular.js',
+             'JSON.js',
+             'Compiler.js',
+             'Scope.js',
+             'Injector.js',
+             'jqLite.js',
+             'parser.js',
+             'Resource.js',
+             'Browser.js',
+             'sanitizer.js',
+             'AngularPublic.js',
 
-  // Extension points
-  addScript("/services.js");
-  addScript("/apis.js");
-  addScript("/filters.js");
-  addScript("/formatters.js");
-  addScript("/validators.js");
-  addScript("/directives.js");
-  addScript("/markups.js");
-  addScript("/widgets.js");
+             // Extension points
+             'services.js',
+             'apis.js',
+             'filters.js',
+             'formatters.js',
+             'validators.js',
+             'directives.js',
+             'markups.js',
+             'widgets.js');
 
 
-  window.onload = function(){
-    try {
-      if (previousOnLoad) previousOnLoad();
-    } catch(e) {}
+  function onLoadListener(){
+    // empty the cache to prevent mem leaks
+    globalVars = {};
 
     //angular-ie-compat.js needs to be pregenerated for development with IE<8
     if (msie<8) addScript('../angular-ie-compat.js');
 
     angularInit(angularJsConfig(document));
-  };
+  }
 
-})(window.onload);
+  if (window.addEventListener){
+    window.addEventListener('load', onLoadListener, false);
+  } else if (window.attachEvent){
+    window.attachEvent('onload', onLoadListener);
+  }
+
+})(window);
 

src/angular.prefix

@@ -21,4 +21,4 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
-(function(window, document, previousOnLoad){
+(function(window, document){

src/angular.suffix

@@ -1,9 +1,6 @@
 
-  window.onload = function(){
-    try {
-      if (previousOnLoad) previousOnLoad();
-    } catch(e) {}
+  jqLite(document).ready(function(){
     angularInit(angularJsConfig(document));
-  };
+  });
 
-})(window, document, window.onload);
+})(window, document);

src/apis.js

@@ -11,6 +11,26 @@ var angularGlobal = {
   }
 };
 
+
+/**
+ * @workInProgress
+ * @ngdoc overview
+ * @name angular.Object
+ * @function
+ *
+ * @description
+ * Utility functions for manipulation with JavaScript objects.
+ *
+ * These functions are exposed in two ways:
+ *
+ * - **in angular expressions**: the functions are bound to all objects and augment the Object
+ *   type. The names of these methods are prefixed with `$` character to minimize naming collisions.
+ *   To call a method, invoke the function without the first argument, e.g, `myObject.$foo(param2)`.
+ *
+ * - **in JavaScript code**: the functions don't augment the Object type and must be invoked as
+ *   functions of `angular.Object` as `angular.Object.foo(myObject, param2)`.
+ *
+ */
 var angularCollection = {
   'copy': copy,
   'size': size,
@@ -19,8 +39,121 @@ var angularCollection = {
 var angularObject = {
   'extend': extend
 };
+
+/**
+ * @workInProgress
+ * @ngdoc overview
+ * @name angular.Array
+ *
+ * @description
+ * Utility functions for manipulation with JavaScript Array objects.
+ *
+ * These functions are exposed in two ways:
+ *
+ * - **in angular expressions**: the functions are bound to the Array objects and augment the Array
+ *   type as array methods. The names of these methods are prefixed with `$` character to minimize
+ *   naming collisions. To call a method, invoke `myArrayObject.$foo(params)`.
+ *
+ * - **in JavaScript code**: the functions don't augment the Array type and must be invoked as
+ *   functions of `angular.Array` as `angular.Array.foo(myArrayObject, params)`.
+ *
+ */
 var angularArray = {
+
+
+  /**
+   * @workInProgress
+   * @ngdoc function
+   * @name angular.Array.indexOf
+   * @function
+   *
+   * @description
+   * Determines the index of `value` in `array`.
+   *
+   * Note: this function is used to augment the Array type in angular expressions. See
+   * {@link angular.Array} for more info.
+   *
+   * @param {Array} array Array to search.
+   * @param {*} value Value to search for.
+   * @returns {number} The position of the element in `array`. The position is 0-based. `-1` is returned if the value can't be found.
+   *
+   * @example
+     <div ng:init="books = ['Moby Dick', 'Great Gatsby', 'Romeo and Juliet']"></div>
+     <input name='bookName' value='Romeo and Juliet'> <br>
+     Index of '{{bookName}}' in the list {{books}} is <em>{{books.$indexOf(bookName)}}</em>.
+
+     @scenario
+     it('should correctly calculate the initial index', function() {
+       expect(binding('books.$indexOf(bookName)')).toBe('2');
+     });
+
+     it('should recalculate', function() {
+       input('bookName').enter('foo');
+       expect(binding('books.$indexOf(bookName)')).toBe('-1');
+
+       input('bookName').enter('Moby Dick');
+       expect(binding('books.$indexOf(bookName)')).toBe('0');
+     });
+   */
   'indexOf': indexOf,
+
+
+  /**
+   * @workInProgress
+   * @ngdoc function
+   * @name angular.Array.sum
+   * @function
+   *
+   * @description
+   * This function calculates the sum of all numbers in `array`. If the `expressions` is supplied,
+   * it is evaluated once for each element in `array` and then the sum of these values is returned.
+   *
+   * Note: this function is used to augment the Array type in angular expressions. See
+   * {@link angular.Array} for more info.
+   *
+   * @param {Array} array The source array.
+   * @param {(string|function())=} expression Angular expression or a function to be evaluated for each
+   *     element in `array`. The array element becomes the `this` during the evaluation.
+   * @returns {number} Sum of items in the array.
+   *
+   * @example
+     <table ng:init="invoice= {items:[{qty:10, description:'gadget', cost:9.95}]}">
+       <tr><th>Qty</th><th>Description</th><th>Cost</th><th>Total</th><th></th></tr>
+       <tr ng:repeat="item in invoice.items">
+         <td><input name="item.qty" value="1" size="4" ng:required ng:validate="integer"></td>
+        <td><input name="item.description"></td>
+          <td><input name="item.cost" value="0.00" ng:required ng:validate="number" size="6"></td>
+         <td>{{item.qty * item.cost | currency}}</td>
+         <td>[<a href ng:click="invoice.items.$remove(item)">X</a>]</td>
+       </tr>
+       <tr>
+         <td><a href ng:click="invoice.items.$add()">add item</a></td>
+         <td></td>
+         <td>Total:</td>
+         <td>{{invoice.items.$sum('qty*cost') | currency}}</td>
+       </tr>
+     </table>
+
+     @scenario
+     //TODO: these specs are lame because I had to work around issues #164 and #167
+     it('should initialize and calculate the totals', function() {
+       expect(repeater('.doc-example-live table tr', 'item in invoice.items').count()).toBe(3);
+       expect(repeater('.doc-example-live table tr', 'item in invoice.items').row(1)).
+         toEqual(['$99.50']);
+       expect(binding("invoice.items.$sum('qty*cost')")).toBe('$99.50');
+       expect(binding("invoice.items.$sum('qty*cost')")).toBe('$99.50');
+     });
+
+     it('should add an entry and recalculate', function() {
+       element('.doc-example a:contains("add item")').click();
+       using('.doc-example-live tr:nth-child(3)').input('item.qty').enter('20');
+       using('.doc-example-live tr:nth-child(3)').input('item.cost').enter('100');
+
+       expect(repeater('.doc-example-live table tr', 'item in invoice.items').row(2)).
+         toEqual(['$2,000.00']);
+       expect(binding("invoice.items.$sum('qty*cost')")).toBe('$2,099.50');
+     });
+   */
   'sum':function(array, expression) {
     var fn = angular['Function']['compile'](expression);
     var sum = 0;
@@ -32,12 +165,140 @@ var angularArray = {
     }
     return sum;
   },
+
+
+  /**
+   * @workInProgress
+   * @ngdoc function
+   * @name angular.Array.remove
+   * @function
+   *
+   * @description
+   * Modifies `array` by removing an element from it. The element will be looked up using the
+   * {@link angular.Array.indexOf indexOf} function on the `array` and only the first instance of
+   * the element will be removed.
+   *
+   * Note: this function is used to augment the Array type in angular expressions. See
+   * {@link angular.Array} for more info.
+   *
+   * @param {Array} array Array from which an element should be removed.
+   * @param {*} value Element to be removed.
+   * @returns {*} The removed element.
+   *
+   * @example
+     <ul ng:init="tasks=['Learn Angular', 'Read Documentation',
+                         'Check out demos', 'Build cool applications']">
+       <li ng:repeat="task in tasks">
+         {{task}} [<a href="" ng:click="tasks.$remove(task)">X</a>]
+       </li>
+     </ul>
+     <hr/>
+     tasks = {{tasks}}
+
+     @scenario
+     it('should initialize the task list with for tasks', function() {
+       expect(repeater('.doc-example ul li', 'task in tasks').count()).toBe(4);
+       expect(repeater('.doc-example ul li', 'task in tasks').column('task')).
+         toEqual(['Learn Angular', 'Read Documentation', 'Check out demos',
+                  'Build cool applications']);
+     });
+
+     it('should initialize the task list with for tasks', function() {
+       element('.doc-example ul li a:contains("X"):first').click();
+       expect(repeater('.doc-example ul li', 'task in tasks').count()).toBe(3);
+
+       element('.doc-example ul li a:contains("X"):last').click();
+       expect(repeater('.doc-example ul li', 'task in tasks').count()).toBe(2);
+
+       expect(repeater('.doc-example ul li', 'task in tasks').column('task')).
+         toEqual(['Read Documentation', 'Check out demos']);
+     });
+   */
   'remove':function(array, value) {
     var index = indexOf(array, value);
     if (index >=0)
       array.splice(index, 1);
     return value;
   },
+
+
+  /**
+   * @workInProgress
+   * @ngdoc function
+   * @name angular.Array.filter
+   * @function
+   *
+   * @description
+   * Selects a subset of items from `array` and returns it as a new array.
+   *
+   * Note: this function is used to augment the Array type in angular expressions. See
+   * {@link angular.Array} for more info.
+   *
+   * @param {Array} array The source array.
+   * @param {string|Object|function()} expression The predicate to be used for selecting items from
+   *   `array`.
+   *
+   *   Can be one of:
+   *
+   *   - `string`: Predicate that results in a substring match using the value of `expression`
+   *     string. All strings or objects with string properties in `array` that contain this string
+   *     will be returned. The predicate can be negated by prefixing the string with `!`.
+   *
+   *   - `Object`: A pattern object can be used to filter specific properties on objects contained
+   *     by `array`. For example `{name:"M", phone:"1"}` predicate will return an array of items
+   *     which have property `name` containing "M" and property `phone` containing "1". A special
+   *     property name `$` can be used (as in `{$:"text"}`) to accept a match against any
+   *     property of the object. That's equivalent to the simple substring match with a `string`
+   *     as described above.
+   *
+   *   - `function`: A predicate function can be used to write arbitrary filters. The function is
+   *     called for each element of `array`. The final result is an array of those elements that
+   *     the predicate returned true for.
+   *
+   * @example
+     <div ng:init="friends = [{name:'John', phone:'555-1276'},
+                              {name:'Mary', phone:'800-BIG-MARY'},
+                              {name:'Mike', phone:'555-4321'},
+                              {name:'Adam', phone:'555-5678'},
+                              {name:'Julie', phone:'555-8765'}]"></div>
+
+     Search: <input name="searchText"/>
+     <table id="searchTextResults">
+       <tr><th>Name</th><th>Phone</th><tr>
+       <tr ng:repeat="friend in friends.$filter(searchText)">
+         <td>{{friend.name}}</td>
+         <td>{{friend.phone}}</td>
+       <tr>
+     </table>
+     <hr>
+     Any: <input name="search.$"/> <br>
+     Name only <input name="search.name"/><br>
+     Phone only <input name="search.phone"/><br>
+     <table id="searchObjResults">
+       <tr><th>Name</th><th>Phone</th><tr>
+       <tr ng:repeat="friend in friends.$filter(search)">
+         <td>{{friend.name}}</td>
+         <td>{{friend.phone}}</td>
+       <tr>
+     </table>
+
+     @scenario
+     it('should search across all fields when filtering with a string', function() {
+       input('searchText').enter('m');
+       expect(repeater('#searchTextResults tr', 'friend in friends').column('name')).
+         toEqual(['Mary', 'Mike', 'Adam']);
+
+       input('searchText').enter('76');
+       expect(repeater('#searchTextResults tr', 'friend in friends').column('name')).
+         toEqual(['John', 'Julie']);
+     });
+
+     it('should search in specific fields when filtering with a predicate object', function() {
+       input('search.$').enter('i');
+       expect(repeater('#searchObjResults tr', 'friend in friends').column('name')).
+         toEqual(['Mary', 'Mike', 'Julie']);
+     });
+   */
   'filter':function(array, expression) {
     var predicates = [];
     predicates.check = function(value) {
@@ -117,20 +378,214 @@ var angularArray = {
     }
     return filtered;
   },
+
+
+  /**
+   * @workInProgress
+   * @ngdoc function
+   * @name angular.Array.add
+   * @function
+   *
+   * @description
+   * `add` is a function similar to JavaScript's `Array#push` method, in that it appends a new
+   * element to an array, but it differs in that the value being added is optional and defaults to
+   * an emty object.
+   *
+   * Note: this function is used to augment the Array type in angular expressions. See
+   * {@link angular.Array} for more info.
+   *
+   * @param {Array} array The array expand.
+   * @param {*=} [value={}] The value to be added.
+   * @returns {Array} The expanded array.
+   *
+   * @exampleDescription
+   * This example shows how an initially empty array can be filled with objects created from user
+   * input via the `$add` method.
+   *
+   * @example
+     [<a href="" ng:click="people.$add()">add empty</a>]
+     [<a href="" ng:click="people.$add({name:'John', sex:'male'})">add 'John'</a>]
+     [<a href="" ng:click="people.$add({name:'Mary', sex:'female'})">add 'Mary'</a>]
+
+     <ul ng:init="people=[]">
+       <li ng:repeat="person in people">
+         <input name="person.name">
+         <select name="person.sex">
+           <option value="">--chose one--</option>
+           <option>male</option>
+           <option>female</option>
+         </select>
+         [<a href="" ng:click="people.$remove(person)">X</a>]
+       </li>
+     </ul>
+     <pre>people = {{people}}</pre>
+
+     @scenario
+     beforeEach(function() {
+        expect(binding('people')).toBe('people = []');
+     });
+
+     it('should create an empty record when "add empty" is clicked', function() {
+       element('.doc-example a:contains("add empty")').click();
+       expect(binding('people')).toBe('people = [{\n  "name":"",\n  "sex":null}]');
+     });
+
+     it('should create a "John" record when "add \'John\'" is clicked', function() {
+       element('.doc-example a:contains("add \'John\'")').click();
+       expect(binding('people')).toBe('people = [{\n  "name":"John",\n  "sex":"male"}]');
+     });
+
+     it('should create a "Mary" record when "add \'Mary\'" is clicked', function() {
+       element('.doc-example a:contains("add \'Mary\'")').click();
+       expect(binding('people')).toBe('people = [{\n  "name":"Mary",\n  "sex":"female"}]');
+     });
+
+     it('should delete a record when "X" is clicked', function() {
+        element('.doc-example a:contains("add empty")').click();
+        element('.doc-example li a:contains("X"):first').click();
+        expect(binding('people')).toBe('people = []');
+     });
+   */
   'add':function(array, value) {
     array.push(isUndefined(value)? {} : value);
     return array;
   },
+
+
+  /**
+   * @workInProgress
+   * @ngdoc function
+   * @name angular.Array.count
+   * @function
+   *
+   * @description
+   * Determines the number of elements in an array. Optionally it will count only those elements
+   * for which the `condition` evaluets to `true`.
+   *
+   * Note: this function is used to augment the Array type in angular expressions. See
+   * {@link angular.Array} for more info.
+   *
+   * @param {Array} array The array to count elements in.
+   * @param {(function()|string)=} condition A function to be evaluated or angular expression to be
+   *     compiled and evaluated. The element that is currently being iterated over, is exposed to
+   *     the `condition` as `this`.
+   * @returns {number} Number of elements in the array (for which the condition evaluates to true).
+   *
+   * @example
+     <pre ng:init="items = [{name:'knife', points:1},
+                            {name:'fork', points:3},
+                            {name:'spoon', points:1}]"></pre>
+     <ul>
+       <li ng:repeat="item in items">
+          {{item.name}}: points=
+          <input type="text" name="item.points"/> <!-- id="item{{$index}} -->
+       </li>
+     </ul>
+     <p>Number of items which have one point: <em>{{ items.$count('points==1') }}</em></p>
+     <p>Number of items which have more than one point: <em>{{items.$count('points&gt;1')}}</em></p>
+
+     @scenario
+     it('should calculate counts', function() {
+       expect(binding('items.$count(\'points==1\')')).toEqual(2);
+       expect(binding('items.$count(\'points>1\')')).toEqual(1);
+     });
+
+     it('should recalculate when updated', function() {
+       using('.doc-example li:first-child').input('item.points').enter('23');
+       expect(binding('items.$count(\'points==1\')')).toEqual(1);
+       expect(binding('items.$count(\'points>1\')')).toEqual(2);
+     });
+   */
   'count':function(array, condition) {
     if (!condition) return array.length;
     var fn = angular['Function']['compile'](condition), count = 0;
-    foreach(array, function(value){
+    forEach(array, function(value){
       if (fn(value)) {
         count ++;
       }
     });
     return count;
   },
+
+
+  /**
+   * @workInProgress
+   * @ngdoc function
+   * @name angular.Array.orderBy
+   * @function
+   *
+   * @description
+   * Orders `array` by the `expression` predicate.
+   *
+   * Note: this function is used to augment the Array type in angular expressions. See
+   * {@link angular.Array} for more info.
+   *
+   * @param {Array} array The array to sort.
+   * @param {function()|string|Array.<(function()|string)>} expression A predicate to be used by the
+   *    comparator to determine the order of elements.
+   *
+   *    Can be one of:
+   *
+   *    - `function`: JavaScript's Array#sort comparator function
+   *    - `string`: angular expression which evaluates to an object to order by, such as 'name' to
+   *      sort by a property called 'name'. Optionally prefixed with `+` or `-` to control ascending
+   *      or descending sort order (e.g. +name or -name).
+   *    - `Array`: array of function or string predicates, such that a first predicate in the array
+   *      is used for sorting, but when the items are equivalent next predicate is used.
+   *
+   * @param {boolean=} reverse Reverse the order the array.
+   * @returns {Array} Sorted copy of the source array.
+   *
+   * @example
+     <div ng:init="friends = [{name:'John', phone:'555-1212', age:10},
+                              {name:'Mary', phone:'555-9876', age:19},
+                              {name:'Mike', phone:'555-4321', age:21},
+                              {name:'Adam', phone:'555-5678', age:35},
+                              {name:'Julie', phone:'555-8765', age:29}]"></div>
+
+     <pre>Sorting predicate = {{predicate}}</pre>
+     <hr/>
+     <table ng:init="predicate='-age'">
+       <tr>
+         <th><a href="" ng:click="predicate = 'name'">Name</a>
+             (<a href ng:click="predicate = '-name'">^</a>)</th>
+         <th><a href="" ng:click="predicate = 'phone'">Phone</a>
+             (<a href ng:click="predicate = '-phone'">^</a>)</th>
+         <th><a href="" ng:click="predicate = 'age'">Age</a>
+             (<a href ng:click="predicate = '-age'">^</a>)</th>
+       <tr>
+       <tr ng:repeat="friend in friends.$orderBy(predicate)">
+         <td>{{friend.name}}</td>
+         <td>{{friend.phone}}</td>
+         <td>{{friend.age}}</td>
+       <tr>
+     </table>
+
+     @scenario
+     it('should be reverse ordered by aged', function() {
+       expect(binding('predicate')).toBe('Sorting predicate = -age');
+       expect(repeater('.doc-example table', 'friend in friends').column('friend.age')).
+         toEqual(['35', '29', '21', '19', '10']);
+       expect(repeater('.doc-example table', 'friend in friends').column('friend.name')).
+         toEqual(['Adam', 'Julie', 'Mike', 'Mary', 'John']);
+     });
+
+     it('should reorder the table when user selects different predicate', function() {
+       element('.doc-example a:contains("Name")').click();
+       expect(repeater('.doc-example table', 'friend in friends').column('friend.name')).
+         toEqual(['Adam', 'John', 'Julie', 'Mary', 'Mike']);
+       expect(repeater('.doc-example table', 'friend in friends').column('friend.age')).
+         toEqual(['35', '10', '29', '19', '21']);
+
+       element('.doc-example a:contains("Phone")+a:contains("^")').click();
+       expect(repeater('.doc-example table', 'friend in friends').column('friend.phone')).
+         toEqual(['555-9876', '555-8765', '555-5678', '555-4321', '555-1212']);
+       expect(repeater('.doc-example table', 'friend in friends').column('friend.name')).
+         toEqual(['Mary', 'Julie', 'Adam', 'Mike', 'John']);
+     });
+   */
+  //TODO: WTH is descend param for and how/when it should be used, how is it affected by +/- in
+  //      predicate? the code below is impossible to read and specs are not very good.
   'orderBy':function(array, expression, descend) {
     expression = isArray(expression) ? expression: [expression];
     expression = map(expression, function($){
@@ -173,11 +628,51 @@ var angularArray = {
         return t1 < t2 ? -1 : 1;
       }
     }
+  },
 
+
+  /**
+   * @workInProgress
+   * @ngdoc function
+   * @name angular.Array.limitTo
+   * @function
+   *
+   * @description
+   * Creates a new array containing only the first, or last `limit` number of elements of the
+   * source `array`.
+   *
+   * Note: this function is used to augment the Array type in angular expressions. See
+   * {@link angular.Array} for more info.
+   *
+   * @param {Array} array Source array to be limited.
+   * @param {string|Number} limit The length of the returned array. If the number is positive, the
+   *     first `limit` items from the source array will be copied, if the number is negative, the
+   *     last `limit` items will be copied.
+   * @returns {Array} New array of length `limit`.
+   *
+   */
+  limitTo: function(array, limit) {
+    limit = parseInt(limit, 10);
+    var out = [],
+        i, n;
+
+    if (limit > 0) {
+      i = 0;
+      n = limit;
+    } else {
+      i = array.length + limit;
+      n = array.length;
+    }
+
+    for (; i<n; i++) {
+      out.push(array[i]);
+    }
+
+    return out;
   }
 };
 
-var R_ISO8061_STR = /^(\d{4})-(\d\d)-(\d\d)(?:T(\d\d)(?:\:(\d\d)(?:\:(\d\d)(?:\.(\d{3}))?)?)?Z)?$/
+var R_ISO8061_STR = /^(\d{4})-(\d\d)-(\d\d)(?:T(\d\d)(?:\:(\d\d)(?:\:(\d\d)(?:\.(\d{3}))?)?)?Z)?$/;
 
 var angularString = {
   'quote':function(string) {
@@ -252,7 +747,7 @@ var angularFunction = {
 
 function defineApi(dst, chain){
   angular[dst] = angular[dst] || {};
-  foreach(chain, function(parent){
+  forEach(chain, function(parent){
     extend(angular[dst], parent);
   });
 }

src/directives.js

@@ -222,7 +222,7 @@ function compileBindTemplate(template){
   var fn = bindTemplateCache[template];
   if (!fn) {
     var bindings = [];
-    foreach(parseBindings(template), function(text){
+    forEach(parseBindings(template), function(text){
       var exp = binding(text);
       bindings.push(exp ? function(element){
         var error, value = this.$tryEval(exp, function(e){
@@ -304,7 +304,8 @@ angularDirective("ng:bind-template", function(expression, element){
 var REMOVE_ATTRIBUTES = {
   'disabled':'disabled',
   'readonly':'readOnly',
-  'checked':'checked'
+  'checked':'checked',
+  'selected':'selected'
 };
 /**
  * @workInProgress
@@ -359,27 +360,31 @@ var REMOVE_ATTRIBUTES = {
 angularDirective("ng:bind-attr", function(expression){
   return function(element){
     var lastValue = {};
-    var updateFn = element.parent().data('$update');
+    var updateFn = element.data($$update) || noop;
     this.$onEval(function(){
-      var values = this.$eval(expression);
+      var values = this.$eval(expression),
+          dirty = noop;
       for(var key in values) {
         var value = compileBindTemplate(values[key]).call(this, element),
             specialName = REMOVE_ATTRIBUTES[lowercase(key)];
         if (lastValue[key] !== value) {
           lastValue[key] = value;
           if (specialName) {
-            if (element[specialName] = toBoolean(value)) {
-              element.attr(specialName, value);
+            if (toBoolean(value)) {
+              element.attr(specialName, specialName);
+              element.attr('ng-' + specialName, value);
             } else {
-              element.removeAttr(key);
+              element.removeAttr(specialName);
+              element.removeAttr('ng-' + specialName);
             }
-            (element.data('$validate')||noop)();
+            (element.data($$validate)||noop)();
           } else {
             element.attr(key, value);
           }
-          this.$postEval(updateFn);
+          dirty = updateFn;
         }
       }
+      dirty();
     }, element);
   };
 });
@@ -418,14 +423,14 @@ angularDirective("ng:bind-attr", function(expression){
  * TODO: maybe we should consider allowing users to control event propagation in the future.
  */
 angularDirective("ng:click", function(expression, element){
-  return function(element){
+  return injectUpdateView(function($updateView, element){
     var self = this;
     element.bind('click', function(event){
       self.$tryEval(expression, element);
-      self.$root.$eval();
+      $updateView();
       event.stopPropagation();
     });
-  };
+  });
 });
 
 
@@ -466,14 +471,14 @@ angularDirective("ng:click", function(expression, element){
  * server and reloading the current page).
  */
 angularDirective("ng:submit", function(expression, element) {
-  return function(element) {
+  return injectUpdateView(function($updateView, element) {
     var self = this;
     element.bind('submit', function(event) {
       self.$tryEval(expression, element);
-      self.$root.$eval();
+      $updateView();
       event.preventDefault();
     });
-  };
+  });
 });
 
 

src/filters.js

@@ -217,12 +217,18 @@ angularFilter.date = function(date, format) {
   var text = date.toLocaleDateString(), fn;
   if (format && isString(format)) {
     text = '';
-    var parts = [];
+    var parts = [], match;
     while(format) {
-      parts = concat(parts, DATE_FORMATS_SPLIT.exec(format), 1);
-      format = parts.pop();
+      match = DATE_FORMATS_SPLIT.exec(format);
+      if (match) {
+        parts = concat(parts, match, 1);
+        format = parts.pop();
+      } else {
+        parts.push(format);
+        format = null;
+      }
     }
-    foreach(parts, function(value){
+    forEach(parts, function(value){
       fn = DATE_FORMATS[value];
       text += fn ? fn(date) : value;
     });

src/formatters.js

@@ -117,7 +117,7 @@ angularFormatter.list = formatter(
   function(obj) { return obj ? obj.join(", ") : obj; },
   function(value) {
     var list = [];
-    foreach((value || '').split(','), function(item){
+    forEach((value || '').split(','), function(item){
       item = trim(item);
       if (item) list.push(item);
     });

src/jqLite.js

@@ -5,12 +5,12 @@
 var jqCache = {},
     jqName = 'ng-' + new Date().getTime(),
     jqId = 1,
-    addEventListener = (window.document.attachEvent ?
-      function(element, type, fn) {element.attachEvent('on' + type, fn);} :
-      function(element, type, fn) {element.addEventListener(type, fn, false);}),
-    removeEventListener = (window.document.detachEvent ?
-      function(element, type, fn) {element.detachEvent('on' + type, fn); } :
-      function(element, type, fn) { element.removeEventListener(type, fn, false); });
+    addEventListenerFn = (window.document.addEventListener ?
+      function(element, type, fn) {element.addEventListener(type, fn, false);} :
+      function(element, type, fn) {element.attachEvent('on' + type, fn);}),
+    removeEventListenerFn = (window.document.removeEventListener ?
+      function(element, type, fn) {element.removeEventListener(type, fn, false); } :
+      function(element, type, fn) {element.detachEvent('on' + type, fn); });
 
 function jqNextId() { return (jqId++); }
 
@@ -18,8 +18,8 @@ function jqClearData(element) {
   var cacheId = element[jqName],
       cache = jqCache[cacheId];
   if (cache) {
-    foreach(cache.bind || {}, function(fn, type){
-      removeEventListener(element, type, fn);
+    forEach(cache.bind || {}, function(fn, type){
+      removeEventListenerFn(element, type, fn);
     });
     delete jqCache[cacheId];
     if (msie)
@@ -47,14 +47,14 @@ function getStyle(element) {
 }
 
 function JQLite(element) {
-  if (isElement(element)) {
-    this[0] = element;
-    this.length = 1;
-  } else if (isDefined(element.length) && element.item) {
+  if (!isElement(element) && isDefined(element.length) && element.item && !isWindow(element)) {
     for(var i=0; i < element.length; i++) {
       this[i] = element[i];
     }
     this.length = element.length;
+  } else {
+    this[0] = element;
+    this.length = 1;
   }
 }
 
@@ -81,19 +81,32 @@ JQLite.prototype = {
   dealoc: function(){
     (function dealoc(element){
       jqClearData(element);
-      for ( var i = 0, children = element.childNodes; i < children.length; i++) {
+      for ( var i = 0, children = element.childNodes || []; i < children.length; i++) {
         dealoc(children[i]);
       }
     })(this[0]);
   },
 
+  ready: function(fn) {
+    var fired = false;
+
+    function trigger() {
+      if (fired) return;
+      fired = true;
+      fn();
+    }
+
+    this.bind('DOMContentLoaded', trigger); // works for modern browsers and IE9
+    jqLite(window).bind('load', trigger); // fallback to window.onload for others
+  },
+
   bind: function(type, fn){
     var self = this,
         element = self[0],
         bind = self.data('bind'),
         eventHandler;
     if (!bind) this.data('bind', bind = {});
-    foreach(type.split(' '), function(type){
+    forEach(type.split(' '), function(type){
       eventHandler = bind[type];
       if (!eventHandler) {
         bind[type] = eventHandler = function(event) {
@@ -107,12 +120,12 @@ JQLite.prototype = {
               event.cancelBubble = true; //ie
             };
           }
-          foreach(eventHandler.fns, function(fn){
+          forEach(eventHandler.fns, function(fn){
             fn.call(self, event);
           });
         };
         eventHandler.fns = [];
-        addEventListener(element, type, eventHandler);
+        addEventListenerFn(element, type, eventHandler);
       }
       eventHandler.fns.push(fn);
     });
@@ -129,7 +142,7 @@ JQLite.prototype = {
   append: function(node) {
     var self = this[0];
     node = jqLite(node);
-    foreach(node, function(child){
+    forEach(node, function(child){
       self.appendChild(child);
     });
   },
@@ -187,7 +200,7 @@ JQLite.prototype = {
   attr: function(name, value){
     var e = this[0];
     if (isObject(name)) {
-      foreach(name, function(value, name){
+      forEach(name, function(value, name){
         e.setAttribute(name, value);
       });
     } else if (isDefined(value)) {

src/markups.js

@@ -35,7 +35,7 @@ angularTextMarkup('{{}}', function(text, textNode, parentElement) {
       parentElement.attr('ng:bind-template', text);
     } else {
       var cursor = textNode, newElement;
-      foreach(parseBindings(text), function(text){
+      forEach(parseBindings(text), function(text){
         var exp = binding(text);
         if (exp) {
           newElement = self.element('span');
@@ -59,7 +59,7 @@ angularTextMarkup('{{}}', function(text, textNode, parentElement) {
 
 // TODO: this should be widget not a markup
 angularTextMarkup('OPTION', function(text, textNode, parentElement){
-  if (nodeName(parentElement) == "OPTION") {
+  if (nodeName_(parentElement) == "OPTION") {
     var select = document.createElement('select');
     select.insertBefore(parentElement[0].cloneNode(true), _null);
     if (!select.innerHTML.match(/<option(\s.*\s|\s)value\s*=\s*.*>.*<\/\s*option\s*>/gi)) {

src/parser.js

@@ -9,7 +9,7 @@ var OPERATORS = {
     '/':function(self, a,b){return a/b;},
     '%':function(self, a,b){return a%b;},
     '^':function(self, a,b){return a^b;},
-    '=':function(self, a,b){return setter(self, a, b);},
+    '=':noop,
     '==':function(self, a,b){return a==b;},
     '!=':function(self, a,b){return a!=b;},
     '<':function(self, a,b){return a<b;},
@@ -26,7 +26,7 @@ var OPERATORS = {
 var ESCAPE = {"n":"\n", "f":"\f", "r":"\r", "t":"\t", "v":"\v", "'":"'", '"':'"'};
 
 function lex(text, parseStringsForObjects){
-  var dateParseLength = parseStringsForObjects ? 24 : -1,
+  var dateParseLength = parseStringsForObjects ? DATE_ISOSTRING_LN : -1,
       tokens = [],
       token,
       index = 0,
@@ -40,16 +40,19 @@ function lex(text, parseStringsForObjects){
       readString(ch);
     } else if (isNumber(ch) || is('.') && isNumber(peek())) {
       readNumber();
-    } else if ( was('({[:,;') && is('/') ) {
-      readRegexp();
     } else if (isIdent(ch)) {
       readIdent();
+      // identifiers can only be if the preceding char was a { or ,
       if (was('{,') && json[0]=='{' &&
          (token=tokens[tokens.length-1])) {
         token.json = token.text.indexOf('.') == -1;
       }
     } else if (is('(){}[].,;:')) {
-      tokens.push({index:index, text:ch, json:is('{}[]:,')});
+      tokens.push({
+        index:index, 
+        text:ch, 
+        json:(was(':[,') && is('{[')) || is('}]:,')
+      });
       if (is('{[')) json.unshift(ch);
       if (is('}]')) json.shift();
       index++;
@@ -142,6 +145,7 @@ function lex(text, parseStringsForObjects){
   function readIdent() {
     var ident = "";
     var start = index;
+    var fn;
     while (index < text.length) {
       var ch = text.charAt(index);
       if (ch == '.' || isIdent(ch) || isNumber(ch)) {
@@ -151,12 +155,17 @@ function lex(text, parseStringsForObjects){
       }
       index++;
     }
-    var fn = OPERATORS[ident];
-    if (!fn) {
-      fn = getterFn(ident);
-      fn.isAssignable = ident;
-    }
-    tokens.push({index:start, text:ident, fn:fn, json: OPERATORS[ident]});
+    fn = OPERATORS[ident];
+    tokens.push({
+      index:start, 
+      text:ident, 
+      json: fn,
+      fn:fn||extend(getterFn(ident), {
+        assign:function(self, value){
+          return setter(self, ident, value);
+        }
+      })
+    });
   }
   
   function readString(quote) {
@@ -201,44 +210,32 @@ function lex(text, parseStringsForObjects){
     }
     throwError("Unterminated quote", start);
   }
-  function readRegexp(quote) {
-    var start = index;
-    index++;
-    var regexp = "";
-    var escape = false;
-    while (index < text.length) {
-      var ch = text.charAt(index);
-      if (escape) {
-        regexp += ch;
-        escape = false;
-      } else if (ch === '\\') {
-        regexp += ch;
-        escape = true;
-      } else if (ch === '/') {
-        index++;
-        var flags = "";
-        if (isIdent(text.charAt(index))) {
-          readIdent();
-          flags = tokens.pop().text;
-        }
-        var compiledRegexp = new RegExp(regexp, flags);
-        tokens.push({index:start, text:regexp, flags:flags,
-          fn:function(){return compiledRegexp;}});
-        return;
-      } else {
-        regexp += ch;
-      }
-      index++;
-    }
-    throwError("Unterminated RegExp", start);
-  }
 }
 
 /////////////////////////////////////////
 
 function parser(text, json){
   var ZERO = valueFn(0),
-      tokens = lex(text, json);
+      tokens = lex(text, json),
+      assignment = _assignment, 
+      functionCall = _functionCall, 
+      fieldAccess = _fieldAccess, 
+      objectIndex = _objectIndex, 
+      filterChain = _filterChain, 
+      functionIdent = _functionIdent, 
+      pipeFunction = _pipeFunction;
+  if(json){
+    // The extra level of aliasing is here, just in case the lexer misses something, so that 
+    // we prevent any accidental execution in JSON.
+    assignment = logicalOR;
+    functionCall = 
+      fieldAccess = 
+      objectIndex = 
+      filterChain = 
+      functionIdent = 
+      pipeFunction = 
+        function (){ throwError("is not valid json", {text:text, index:0}); };
+  }
   return {
       assertAllConsumed: assertAllConsumed,
       primary: primary,
@@ -336,7 +333,7 @@ function parser(text, json){
     }
   }
 
-  function filterChain(){
+  function _filterChain(){
     var left = expression();
     var token;
     while(true) {
@@ -356,7 +353,7 @@ function parser(text, json){
     return pipeFunction(angularValidator);
   }
 
-  function pipeFunction(fnScope){
+  function _pipeFunction(fnScope){
     var fn = functionIdent(fnScope);
     var argsFn = [];
     var token;
@@ -382,16 +379,19 @@ function parser(text, json){
     return assignment();
   }
 
-  function assignment(){
+  function _assignment(){
     var left = logicalOR();
+    var right;
     var token;
     if (token = expect('=')) {
-      if (!left.isAssignable) {
+      if (!left.assign) {
         throwError("implies assignment but [" +
           text.substring(0, token.index) + "] can not be assigned to", token);
       }
-      var ident = function(){return left.isAssignable;};
-      return binaryFn(ident, token.fn, logicalOR());
+      right = logicalOR();
+      return function(self){
+        return left.assign(self, right(self));
+      };
     } else {
       return left;
     }
@@ -467,7 +467,7 @@ function parser(text, json){
     }
   }
 
-  function functionIdent(fnScope) {
+  function _functionIdent(fnScope) {
     var token = expect();
     var element = token.text.split('.');
     var instance = fnScope;
@@ -515,34 +515,34 @@ function parser(text, json){
     return primary;
   }
 
-  function fieldAccess(object) {
+  function _fieldAccess(object) {
     var field = expect().text;
     var getter = getterFn(field);
-    var fn = function (self){
+    return extend(function (self){
       return getter(object(self));
-    };
-    fn.isAssignable = field;
-    return fn;
+    }, {
+      assign:function(self, value){
+        return setter(object(self), field, value);
+      }
+    });
   }
 
-  function objectIndex(obj) {
+  function _objectIndex(obj) {
     var indexFn = expression();
     consume(']');
-    if (expect('=')) {
-      var rhs = expression();
-      return function (self){
-        return obj(self)[indexFn(self)] = rhs(self);
-      };
-    } else {
-      return function (self){
+    return extend(
+      function (self){
         var o = obj(self);
         var i = indexFn(self);
         return (o) ? o[i] : _undefined;
-      };
-    }
+      }, {
+        assign:function(self, value){
+          return obj(self)[indexFn(self)] = value;
+        }
+      });
   }
 
-  function functionCall(fn) {
+  function _functionCall(fn) {
     var argsFn = [];
     if (peekToken().text != ')') {
       do {

src/sanitizer.js

@@ -17,40 +17,42 @@
 // Regular Expressions for parsing tags and attributes
 var START_TAG_REGEXP = /^<\s*([\w:]+)((?:\s+\w+(?:\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|[^>\s]+))?)*)\s*(\/?)\s*>/,
   END_TAG_REGEXP = /^<\s*\/\s*([\w:]+)[^>]*>/,
-  ATTR_REGEXP = /(\w+)(?:\s*=\s*(?:(?:"((?:\\.|[^"])*)")|(?:'((?:\\.|[^'])*)')|([^>\s]+)))?/g,
+  ATTR_REGEXP = /(\w+)(?:\s*=\s*(?:(?:"((?:[^"])*)")|(?:'((?:[^'])*)')|([^>\s]+)))?/g,
   BEGIN_TAG_REGEXP = /^</,
   BEGING_END_TAGE_REGEXP = /^<\s*\//,
   COMMENT_REGEXP = /<!--(.*?)-->/g,
-  CDATA_REGEXP = /<!\[CDATA\[(.*?)]]>/g;
+  CDATA_REGEXP = /<!\[CDATA\[(.*?)]]>/g,
+  URI_REGEXP = /^((ftp|https?):\/\/|mailto:|#)/,
+  NON_ALPHANUMERIC_REGEXP = /([^\#-~| |!])/g; // Match everything outside of normal chars and " (quote character)
 
 // Empty Elements - HTML 4.01
-var emptyElements = makeMap("area,base,basefont,br,col,hr,img,input,isindex,link,param");
+var emptyElements = makeMap("area,br,col,hr,img");
 
 // Block Elements - HTML 4.01
-var blockElements = makeMap("address,blockquote,button,center,dd,del,dir,div,dl,dt,fieldset,"+
-    "form,hr,ins,isindex,li,map,menu,ol,p,pre,script,table,tbody,td,tfoot,th,thead,tr,ul");
+var blockElements = makeMap("address,blockquote,center,dd,del,dir,div,dl,dt,"+
+    "hr,ins,li,map,menu,ol,p,pre,script,table,tbody,td,tfoot,th,thead,tr,ul");
 
 // Inline Elements - HTML 4.01
-var inlineElements = makeMap("a,abbr,acronym,b,basefont,bdo,big,br,button,cite,code,del,dfn,em,font,i,img,"+
-    "input,ins,kbd,label,map,q,s,samp,select,small,span,strike,strong,sub,sup,textarea,tt,u,var");
-
+var inlineElements = makeMap("a,abbr,acronym,b,bdo,big,br,cite,code,del,dfn,em,font,i,img,"+
+    "ins,kbd,label,map,q,s,samp,small,span,strike,strong,sub,sup,tt,u,var");
 // Elements that you can, intentionally, leave open
 // (and which close themselves)
-var closeSelfElements = makeMap("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr");
-
-// Attributes that have their values filled in disabled="disabled"
-var fillAttrs = makeMap("checked,compact,declare,defer,disabled,ismap,multiple,nohref,noresize,noshade,nowrap,readonly,selected");
-
+var closeSelfElements = makeMap("colgroup,dd,dt,li,p,td,tfoot,th,thead,tr");
 // Special Elements (can contain anything)
 var specialElements = makeMap("script,style");
-
 var validElements = extend({}, emptyElements, blockElements, inlineElements, closeSelfElements);
-var validAttrs = extend({}, fillAttrs, makeMap(
-    'abbr,align,alink,alt,archive,axis,background,bgcolor,border,cellpadding,cellspacing,cite,class,classid,clear,code,codebase,'+
-    'codetype,color,cols,colspan,content,coords,data,dir,face,for,headers,height,href,hreflang,hspace,id,label,lang,language,'+
-    'link,longdesc,marginheight,marginwidth,maxlength,media,method,name,nowrap,profile,prompt,rel,rev,rows,rowspan,rules,scheme,'+
-    'scope,scrolling,shape,size,span,src,standby,start,summary,tabindex,target,text,title,type,usemap,valign,value,valuetype,'+
-    'vlink,vspace,width'));
+
+//see: http://www.w3.org/TR/html4/index/attributes.html
+//Attributes that have their values filled in disabled="disabled"
+var fillAttrs = makeMap("compact,ismap,nohref,nowrap");
+//Attributes that have href and hence need to be sanitized
+var uriAttrs = makeMap("background,href,longdesc,src,usemap");
+var validAttrs = extend({}, fillAttrs, uriAttrs, makeMap(
+    'abbr,align,alt,axis,bgcolor,border,cellpadding,cellspacing,class,clear,'+
+    'color,cols,colspan,coords,dir,face,headers,height,hreflang,hspace,'+
+    'lang,language,rel,rev,rows,rowspan,rules,'+
+    'scope,scrolling,shape,span,start,summary,target,title,type,'+
+    'valign,value,vspace,width'));
 
 /**
  * @example
@@ -64,7 +66,7 @@ var validAttrs = extend({}, fillAttrs, makeMap(
  * @param {string} html string
  * @param {object} handler
  */
-var htmlParser = function( html, handler ) {
+function htmlParser( html, handler ) {
   var index, chars, match, stack = [], last = html;
   stack.last = function(){ return stack[ stack.length - 1 ]; };
 
@@ -112,8 +114,7 @@ var htmlParser = function( html, handler ) {
         var text = index < 0 ? html : html.substring( 0, index );
         html = index < 0 ? "" : html.substring( index );
 
-        if ( handler.chars )
-          handler.chars( text );
+        handler.chars( decodeEntities(text) );
       }
 
     } else {
@@ -122,8 +123,7 @@ var htmlParser = function( html, handler ) {
           replace(COMMENT_REGEXP, "$1").
           replace(CDATA_REGEXP, "$1");
 
-        if ( handler.chars )
-          handler.chars( text );
+        handler.chars( decodeEntities(text) );
 
         return "";
       });
@@ -157,21 +157,18 @@ var htmlParser = function( html, handler ) {
     if ( !unary )
       stack.push( tagName );
 
-    if ( handler.start ) {
-      var attrs = {};
+    var attrs = {};
 
-      rest.replace(ATTR_REGEXP, function(match, name) {
-        var value = arguments[2] ? arguments[2] :
-          arguments[3] ? arguments[3] :
-          arguments[4] ? arguments[4] :
-          fillAttrs[name] ? name : "";
+    rest.replace(ATTR_REGEXP, function(match, name) {
+      var value = arguments[2] ? arguments[2] :
+        arguments[3] ? arguments[3] :
+        arguments[4] ? arguments[4] :
+        fillAttrs[name] ? name : "";
 
-        attrs[name] = value; //value.replace(/(^|[^\\])"/g, '$1\\\"') //"
-      });
+      attrs[name] = decodeEntities(value); //value.replace(/(^|[^\\])"/g, '$1\\\"') //"
+    });
 
-      if ( handler.start )
-        handler.start( tagName, attrs, unary );
-    }
+    handler.start( tagName, attrs, unary );
   }
 
   function parseEndTag( tag, tagName ) {
@@ -186,14 +183,13 @@ var htmlParser = function( html, handler ) {
     if ( pos >= 0 ) {
       // Close all the open elements, up the stack
       for ( i = stack.length - 1; i >= pos; i-- )
-        if ( handler.end )
-          handler.end( stack[ i ] );
+        handler.end( stack[ i ] );
 
       // Remove the open elements from the stack
       stack.length = pos;
     }
   }
-};
+}
 
 /**
  * @param str 'key1,key2,...'
@@ -206,28 +202,32 @@ function makeMap(str){
   return obj;
 }
 
-/*
- * For attack vectors see: http://ha.ckers.org/xss.html
- */
-var JAVASCRIPT_URL = /^javascript:/i,
-    NBSP_REGEXP = /&nbsp;/gim,
-    HEX_ENTITY_REGEXP = /&#x([\da-f]*);?/igm,
-    DEC_ENTITY_REGEXP = /&#(\d+);?/igm,
-    CHAR_REGEXP = /[\w:]/gm,
-    HEX_DECODE = function(match, code){return fromCharCode(parseInt(code,16));},
-    DEC_DECODE = function(match, code){return fromCharCode(code);};
 /**
- * @param {string} url
- * @returns true if url decodes to something which starts with 'javascript:' hence unsafe
+ * decodes all entities into regular string
+ * @param value
+ * @returns {string} A string with decoded entities.
  */
-function isJavaScriptUrl(url) {
-  var chars = [];
-  url.replace(NBSP_REGEXP, '').
-      replace(HEX_ENTITY_REGEXP, HEX_DECODE).
-      replace(DEC_ENTITY_REGEXP, DEC_DECODE).
-      // Remove all non \w: characters, unfurtunetly value.replace(/[\w:]/,'') can be defeated using \u0000
-      replace(CHAR_REGEXP, function(ch){chars.push(ch);});
-  return JAVASCRIPT_URL.test(lowercase(chars.join('')));
+var hiddenPre=document.createElement("pre");
+function decodeEntities(value) {
+  hiddenPre.innerHTML=value.replace(/</g,"&lt;");
+  return hiddenPre.innerText || hiddenPre.textContent;
+}
+
+/**
+ * Escapes all potentially dangerous characters, so that the 
+ * resulting string can be safely inserted into attribute or
+ * element text.
+ * @param value
+ * @returns escaped text
+ */
+function encodeEntities(value) {
+  return value.
+    replace(/&/g, '&amp;').
+    replace(NON_ALPHANUMERIC_REGEXP, function(value){
+      return '&#' + value.charCodeAt(0) + ';';
+    }).
+    replace(/</g, '&lt;').
+    replace(/>/g, '&gt;');
 }
 
 /**
@@ -249,18 +249,16 @@ function htmlSanitizeWriter(buf){
       if (!ignore && specialElements[tag]) {
         ignore = tag;
       }
-      if (!ignore && validElements[tag]) {
+      if (!ignore && validElements[tag] == true) {
         out('<');
         out(tag);
-        foreach(attrs, function(value, key){
-          if (validAttrs[lowercase(key)] && !isJavaScriptUrl(value)) {
+        forEach(attrs, function(value, key){
+          var lkey=lowercase(key);
+          if (validAttrs[lkey]==true && (uriAttrs[lkey]!==true || value.match(URI_REGEXP))) {
             out(' ');
             out(key);
             out('="');
-            out(value.
-                replace(/</g, '&lt;').
-                replace(/>/g, '&gt;').
-                replace(/\"/g,'&quot;'));
+            out(encodeEntities(value));
             out('"');
           }
         });
@@ -269,7 +267,7 @@ function htmlSanitizeWriter(buf){
     },
     end: function(tag){
         tag = lowercase(tag);
-        if (!ignore && validElements[tag]) {
+        if (!ignore && validElements[tag] == true) {
           out('</');
           out(tag);
           out('>');
@@ -280,10 +278,7 @@ function htmlSanitizeWriter(buf){
       },
     chars: function(chars){
         if (!ignore) {
-          out(chars.
-              replace(/&(\w+[&;\W])?/g, function(match, entity){return entity?match:'&amp;';}).
-              replace(/</g, '&lt;').
-              replace(/>/g, '&gt;'));
+          out(encodeEntities(chars));
         }
       }
   };

src/scenario/Describe.js

@@ -21,7 +21,7 @@ angular.scenario.Describe = function(descName, parent) {
   var beforeEachFns = this.beforeEachFns;
   this.setupBefore = function() {
     if (parent) parent.setupBefore.call(this);
-    angular.foreach(beforeEachFns, function(fn) { fn.call(this); }, this);
+    angular.forEach(beforeEachFns, function(fn) { fn.call(this); }, this);
   };
 
   /**
@@ -29,7 +29,7 @@ angular.scenario.Describe = function(descName, parent) {
    */
   var afterEachFns = this.afterEachFns;
   this.setupAfter  = function() {
-    angular.foreach(afterEachFns, function(fn) { fn.call(this); }, this);
+    angular.forEach(afterEachFns, function(fn) { fn.call(this); }, this);
     if (parent) parent.setupAfter.call(this);
   };
 };
@@ -133,14 +133,14 @@ angular.scenario.Describe.prototype.xit = angular.noop;
  */
 angular.scenario.Describe.prototype.getSpecs = function() {
   var specs = arguments[0] || [];
-  angular.foreach(this.children, function(child) {
+  angular.forEach(this.children, function(child) {
     child.getSpecs(specs);
   });
-  angular.foreach(this.its, function(it) {
+  angular.forEach(this.its, function(it) {
     specs.push(it);
   });
   var only = [];
-  angular.foreach(specs, function(it) {
+  angular.forEach(specs, function(it) {
     if (it.only) {
       only.push(it);
     }

src/scenario/ObjectModel.js

@@ -19,7 +19,7 @@ angular.scenario.ObjectModel = function(runner) {
 
   runner.on('SpecBegin', function(spec) {
     var block = self.value;
-    angular.foreach(self.getDefinitionPath(spec), function(def) {
+    angular.forEach(self.getDefinitionPath(spec), function(def) {
       if (!block.children[def.name]) {
         block.children[def.name] = {
           id: def.id,

src/scenario/Runner.js

@@ -16,7 +16,7 @@ angular.scenario.Runner = function($window) {
     beforeEach: this.beforeEach,
     afterEach: this.afterEach
   };
-  angular.foreach(this.api, angular.bind(this, function(fn, key) {
+  angular.forEach(this.api, angular.bind(this, function(fn, key) {
     this.$window[key] = angular.bind(this, fn);
   }));
 };
@@ -33,7 +33,7 @@ angular.scenario.Runner.prototype.emit = function(eventName) {
   eventName = eventName.toLowerCase();
   if (!this.listeners[eventName])
     return;
-  angular.foreach(this.listeners[eventName], function(listener) {
+  angular.forEach(this.listeners[eventName], function(listener) {
     listener.apply(self, args);
   });
 };
@@ -164,17 +164,17 @@ angular.scenario.Runner.prototype.run = function(application) {
   asyncForEach(this.rootDescribe.getSpecs(), function(spec, specDone) {
     var dslCache = {};
     var runner = self.createSpecRunner_($root);
-    angular.foreach(angular.scenario.dsl, function(fn, key) {
+    angular.forEach(angular.scenario.dsl, function(fn, key) {
       dslCache[key] = fn.call($root);
     });
-    angular.foreach(angular.scenario.dsl, function(fn, key) {
+    angular.forEach(angular.scenario.dsl, function(fn, key) {
       self.$window[key] = function() {
         var line = callerFile(3);
         var scope = angular.scope(runner);
 
         // Make the dsl accessible on the current chain
         scope.dsl = {};
-        angular.foreach(dslCache, function(fn, key) {
+        angular.forEach(dslCache, function(fn, key) {
           scope.dsl[key] = function() {
             return dslCache[key].apply(scope, arguments);
           };

src/scenario/Scenario.js

@@ -38,7 +38,7 @@ angular.scenario.dsl = angular.scenario.dsl || function(name, fn) {
         return result;
       var self = this;
       var chain = angular.extend({}, result);
-      angular.foreach(chain, function(value, name) {
+      angular.forEach(chain, function(value, name) {
         if (angular.isFunction(value)) {
           chain[name] = function() {
             return executeStatement.call(self, value, arguments);
@@ -101,7 +101,7 @@ function angularScenarioInit($scenario, config) {
     output = config.scenario_output.split(',');
   }
 
-  angular.foreach(angular.scenario.output, function(fn, name) {
+  angular.forEach(angular.scenario.output, function(fn, name) {
     if (!output.length || indexOf(output,name) != -1) {
       var context = body.append('<div></div>').find('div:last');
       context.attr('id', name);
@@ -244,7 +244,7 @@ function browserTrigger(element, type) {
         'select-multiple': 'change'
     }[element.type] || 'click';
   }
-  if (lowercase(nodeName(element)) == 'option') {
+  if (lowercase(nodeName_(element)) == 'option') {
     element.parentNode.value = element.value;
     element = element.parentNode;
     type = 'change';
@@ -285,7 +285,7 @@ function browserTrigger(element, type) {
 (function(fn){
   var parentTrigger = fn.trigger;
   fn.trigger = function(type) {
-    if (/(click|change|keyup)/.test(type)) {
+    if (/(click|change|keydown)/.test(type)) {
       return this.each(function(index, node) {
         browserTrigger(node, type);
       });

src/scenario/SpecRunner.js

@@ -112,7 +112,7 @@ angular.scenario.SpecRunner.prototype.addFutureAction = function(name, behavior,
         var args = Array.prototype.slice.call(arguments, 1);
         selector = (self.selector || '') + ' ' + (selector || '');
         selector = _jQuery.trim(selector) || '*';
-        angular.foreach(args, function(value, index) {
+        angular.forEach(args, function(value, index) {
           selector = selector.replace('$' + (index + 1), value);
         });
         var result = $document.find(selector);

src/scenario/angular.prefix

@@ -21,5 +21,5 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
-(function(window, document, previousOnLoad){
+(function(window, document){
   var _jQuery = window.jQuery.noConflict(true);

src/scenario/angular.suffix

@@ -1,10 +1,7 @@
   var $scenario = new angular.scenario.Runner(window);
 
-  window.onload = function() {
-    try {
-      if (previousOnLoad) previousOnLoad();
-    } catch(e) {}
+  jqLite(document).ready(function() {
     angularScenarioInit($scenario, angularJsConfig(document));
-  };
+  });
 
-})(window, document, window.onload);
+})(window, document);

src/scenario/dsl.js

@@ -331,7 +331,7 @@ angular.scenario.dsl('element', function() {
     });
   };
 
-  angular.foreach(KEY_VALUE_METHODS, function(methodName) {
+  angular.forEach(KEY_VALUE_METHODS, function(methodName) {
     chain[methodName] = function(name, value) {
       var futureName = "element '" + this.label + "' get " + methodName + " '" + name + "'";
       if (angular.isDefined(value)) {
@@ -344,7 +344,7 @@ angular.scenario.dsl('element', function() {
     };
   });
 
-  angular.foreach(VALUE_METHODS, function(methodName) {
+  angular.forEach(VALUE_METHODS, function(methodName) {
     chain[methodName] = function(value) {
       var futureName = "element '" + this.label + "' " + methodName;
       if (angular.isDefined(value)) {

src/scenario/output/Html.js

@@ -121,7 +121,7 @@ angular.scenario.output('html', function(context, runner) {
    */
   function findContext(spec) {
     var currentContext = context.find('#specs');
-    angular.foreach(model.getDefinitionPath(spec), function(defn) {
+    angular.forEach(model.getDefinitionPath(spec), function(defn) {
       var id = 'describe-' + defn.id;
       if (!context.find('#' + id).length) {
         currentContext.find('> .test-children').append(

src/scenario/output/Xml.js

@@ -17,7 +17,7 @@ angular.scenario.output('xml', function(context, runner) {
    * @param {Object} tree node to serialize
    */
   function serializeXml(context, tree) {
-     angular.foreach(tree.children, function(child) {
+     angular.forEach(tree.children, function(child) {
        var describeContext = $('<describe></describe>');
        describeContext.attr('id', child.id);
        describeContext.attr('name', child.name);
@@ -26,14 +26,14 @@ angular.scenario.output('xml', function(context, runner) {
      });
      var its = $('<its></its>');
      context.append(its);
-     angular.foreach(tree.specs, function(spec) {
+     angular.forEach(tree.specs, function(spec) {
        var it = $('<it></it>');
        it.attr('id', spec.id);
        it.attr('name', spec.name);
        it.attr('duration', spec.duration);
        it.attr('status', spec.status);
        its.append(it);
-       angular.foreach(spec.steps, function(step) {
+       angular.forEach(spec.steps, function(step) {
          var stepContext = $('<step></step>');
          stepContext.attr('name', step.name);
          stepContext.attr('duration', step.duration);

src/services.js

@@ -1,11 +1,10 @@
 var URL_MATCH = /^(file|ftp|http|https):\/\/(\w+:{0,1}\w*@)?([\w\.-]*)(:([0-9]+))?(\/[^\?#]*)?(\?([^#]*))?(#(.*))?$/,
     HASH_MATCH = /^([^\?]*)?(\?([^\?]*))?$/,
     DEFAULT_PORTS = {'http': 80, 'https': 443, 'ftp':21},
-    EAGER = 'eager',
-    EAGER_PUBLISHED = EAGER + '-published';
+    EAGER = true;
 
 function angularServiceInject(name, fn, inject, eager) {
-  angularService(name, fn, {$inject:inject, $creation:eager});
+  angularService(name, fn, {$inject:inject, $eager:eager});
 }
 
 /**
@@ -26,7 +25,7 @@ function angularServiceInject(name, fn, inject, eager) {
    <input ng:init="greeting='Hello World!'" type="text" name="greeting" />
    <button ng:click="$window.alert(greeting)">ALERT</button>
  */
-angularServiceInject("$window", bind(window, identity, window), [], EAGER_PUBLISHED);
+angularServiceInject("$window", bind(window, identity, window), [], EAGER);
 
 /**
  * @workInProgress
@@ -39,7 +38,7 @@ angularServiceInject("$window", bind(window, identity, window), [], EAGER_PUBLIS
  */
 angularServiceInject("$document", function(window){
   return jqLite(window.document);
-}, ['$window'], EAGER_PUBLISHED);
+}, ['$window'], EAGER);
 
 /**
  * @workInProgress
@@ -69,27 +68,20 @@ angularServiceInject("$document", function(window){
    <input type='text' name="$location.hash"/>
    <pre>$location = {{$location}}</pre>
  */
-angularServiceInject("$location", function(browser) {
+angularServiceInject("$location", function($browser) {
   var scope = this,
-      location = {toString:toString, update:update, updateHash: updateHash},
-      lastBrowserUrl = browser.getUrl(),
-      lastLocationHref,
-      lastLocationHash;
+      location = {update:update, updateHash: updateHash},
+      lastLocation = {};
 
-  browser.addPollFn(function() {
-    if (lastBrowserUrl != browser.getUrl()) {
-      update(lastBrowserUrl = browser.getUrl());
-      updateLastLocation();
-      scope.$eval();
-    }
-  });
+  $browser.onHashChange(function() { //register
+    update($browser.getUrl());
+    copy(location, lastLocation);
+    scope.$eval();
+  })(); //initialize
 
-  this.$onEval(PRIORITY_FIRST, updateBrowser);
+  this.$onEval(PRIORITY_FIRST, sync);
   this.$onEval(PRIORITY_LAST, updateBrowser);
 
-  update(lastBrowserUrl);
-  updateLastLocation();
-
   return location;
 
   // PUBLIC METHODS
@@ -110,7 +102,7 @@ angularServiceInject("$location", function(browser) {
    * scope.$location.update({host: 'www.google.com', protocol: 'https'});
    * scope.$location.update({hashPath: '/path', hashSearch: {a: 'b', x: true}});
    *
-   * @param {(string|Object)} href Full href as a string or hash object with properties
+   * @param {(string|Object)} href Full href as a string or object with properties
    */
   function update(href) {
     if (isString(href)) {
@@ -166,62 +158,55 @@ angularServiceInject("$location", function(browser) {
     update(hash);
   }
 
-  /**
-   * @workInProgress
-   * @ngdoc method
-   * @name angular.service.$location#toString
-   * @methodOf angular.service.$location
-   * 
-   * @description
-   * Returns string representation - href
-   */
-  function toString() {
-    updateLocation();
-    return location.href;
-  }
 
   // INNER METHODS
 
   /**
-   * Update location object
+   * Synchronizes all location object properties.
    *
    * User is allowed to change properties, so after property change,
    * location object is not in consistent state.
    *
+   * Properties are synced with the following precedence order:
+   *
+   * - `$location.href`
+   * - `$location.hash`
+   * - everything else
+   *
    * @example
    * scope.$location.href = 'http://www.angularjs.org/path#a/b'
    * immediately after this call, other properties are still the old ones...
    *
    * This method checks the changes and update location to the consistent state
    */
-  function updateLocation() {
-    if (location.href == lastLocationHref) {
-      if (location.hash == lastLocationHash) {
-        location.hash = composeHash(location);
+  function sync() {
+    if (!equals(location, lastLocation)) {
+      if (location.href != lastLocation.href) {
+        update(location.href);
+        return;
       }
-      location.href = composeHref(location);
+      if (location.hash != lastLocation.hash) {
+        var hash = parseHash(location.hash);
+        updateHash(hash.path, hash.search);
+      } else {
+        location.hash = composeHash(location);
+        location.href = composeHref(location);
+      }
+      update(location.href);
     }
-    update(location.href);
   }
 
-  /**
-   * Update information about last location
-   */
-  function updateLastLocation() {
-    lastLocationHref = location.href;
-    lastLocationHash = location.hash;
-  }
 
   /**
    * If location has changed, update the browser
    * This method is called at the end of $eval() phase
    */
   function updateBrowser() {
-    updateLocation();
+    sync();
 
-    if (location.href != lastLocationHref) {    	
-      browser.setUrl(lastBrowserUrl = location.href);
-      updateLastLocation();
+    if ($browser.getUrl() != location.href) {
+      $browser.setUrl(location.href);
+      copy(location, lastLocation);
     }
   }
 
@@ -295,7 +280,7 @@ angularServiceInject("$location", function(browser) {
 
     return h;
   }
-}, ['$browser'], EAGER_PUBLISHED);
+}, ['$browser']);
 
 
 /**
@@ -372,7 +357,7 @@ angularServiceInject("$log", function($window){
     if (logFn.apply) {
       return function(){
         var args = [];
-        foreach(arguments, function(arg){
+        forEach(arguments, function(arg){
           args.push(formatError(arg));
         });
         return logFn.apply(console, args);
@@ -382,7 +367,7 @@ angularServiceInject("$log", function($window){
       return logFn;
     }
   }
-}, ['$window'], EAGER_PUBLISHED);
+}, ['$window'], EAGER);
 
 /**
  * @workInProgress
@@ -406,7 +391,67 @@ angularServiceInject('$exceptionHandler', function($log){
   return function(e) {
     $log.error(e);
   };
-}, ['$log'], EAGER_PUBLISHED);
+}, ['$log'], EAGER);
+
+/**
+ * @workInProgress
+ * @ngdoc service
+ * @name angular.service.$updateView
+ * @requires $browser
+ *
+ * @description
+ * Calling `$updateView` enqueues the eventual update of the view. (Update the DOM to reflect the
+ * model). The update is eventual, since there are often multiple updates to the model which may
+ * be deferred. The default update delayed is 25 ms. This means that the view lags the model by
+ * that time. (25ms is small enough that it is perceived as instantaneous by the user). The delay
+ * can be adjusted by setting the delay property of the service.
+ *
+ * <pre>angular.service('$updateView').delay = 10</pre>
+ *
+ * The delay is there so that multiple updates to the model which occur sufficiently close
+ * together can be merged into a single update.
+ *
+ * You don't usually call '$updateView' directly since angular does it for you in most cases,
+ * but there are some cases when you need to call it.
+ *
+ *  - `$updateView()` called automatically by angular:
+ *    - Your Application Controllers: Your controller code is called by angular and hence
+ *      angular is aware that you may have changed the model.
+ *    - Your Services: Your service is usually called by your controller code, hence same rules
+ *      apply.
+ *  - May need to call `$updateView()` manually:
+ *    - Widgets / Directives: If you listen to any DOM events or events on any third party
+ *      libraries, then angular is not aware that you may have changed state state of the
+ *      model, and hence you need to call '$updateView()' manually.
+ *    - 'setTimeout'/'XHR':  If you call 'setTimeout' (instead of {@link angular.service.$defer})
+ *      or 'XHR' (instead of {@link angular.service.$xhr}) then you may be changing the model
+ *      without angular knowledge and you may need to call '$updateView()' directly.
+ *
+ * NOTE: if you wish to update the view immediately (without delay), you can do so by calling
+ * {@link scope.$eval} at any time from your code:
+ * <pre>scope.$root.$eval()</pre>
+ *
+ * In unit-test mode the update is instantaneous and synchronous to simplify writing tests.
+ *
+ */
+
+function serviceUpdateViewFactory($browser){
+  var rootScope = this;
+  var scheduled;
+  function update(){
+    scheduled = false;
+    rootScope.$eval();
+  }
+  return $browser.isMock ? update : function(){
+    if (!scheduled) {
+      scheduled = true;
+      $browser.defer(update, serviceUpdateViewFactory.delay);
+    }
+  };
+}
+serviceUpdateViewFactory.delay = 25;
+
+angularServiceInject('$updateView', serviceUpdateViewFactory, ['$browser']);
 
 /**
  * @workInProgress
@@ -499,7 +544,7 @@ angularServiceInject("$invalidWidgets", function(){
   /** Return count of all invalid widgets that are currently visible */
   invalidWidgets.visible = function() {
     var count = 0;
-    foreach(invalidWidgets, function(widget){
+    forEach(invalidWidgets, function(widget){
       count = count + (isVisible(widget) ? 1 : 0);
     });
     return count;
@@ -531,7 +576,7 @@ angularServiceInject("$invalidWidgets", function(){
   }
 
   return invalidWidgets;
-}, [], EAGER_PUBLISHED);
+}, [], EAGER);
 
 
 
@@ -539,7 +584,7 @@ function switchRouteMatcher(on, when, dstName) {
   var regex = '^' + when.replace(/[\.\\\(\)\^\$]/g, "\$1") + '$',
       params = [],
       dst = {};
-  foreach(when.split(/\W/), function(param){
+  forEach(when.split(/\W/), function(param){
     if (param) {
       var paramRegExp = new RegExp(":" + param + "([\\W])");
       if (regex.match(paramRegExp)) {
@@ -550,7 +595,7 @@ function switchRouteMatcher(on, when, dstName) {
   });
   var match = on.match(new RegExp(regex));
   if (match) {
-    foreach(params, function(name, index){
+    forEach(params, function(name, index){
       dst[name] = match[index + 1];
     });
     if (dstName) this.$set(dstName, dst);
@@ -659,7 +704,7 @@ angularServiceInject('$route', function(location) {
   function updateRoute(){
     var childScope;
     $route.current = _null;
-    angular.foreach(routes, function(routeParams, route) {
+    angular.forEach(routes, function(routeParams, route) {
       if (!childScope) {
         var pathParams = matcher(location.hashPath, route);
         if (pathParams) {
@@ -671,21 +716,21 @@ angularServiceInject('$route', function(location) {
         }
       }
     });
-    angular.foreach(onChange, parentScope.$tryEval);
+    angular.forEach(onChange, parentScope.$tryEval);
     if (childScope) {
       childScope.$become($route.current.controller);
     }
   }
   this.$watch(function(){return dirty + location.hash;}, updateRoute);
   return $route;
-}, ['$location'], EAGER_PUBLISHED);
+}, ['$location']);
 
 /**
  * @workInProgress
  * @ngdoc service
  * @name angular.service.$xhr
  * @requires $browser
- * @requires $error
+ * @requires $xhr.error
  * @requires $log
  * 
  * @description
@@ -705,7 +750,7 @@ angularServiceInject('$xhr', function($browser, $error, $log){
     $browser.xhr(method, url, post, function(code, response){
       try {
         if (isString(response) && /^\s*[\[\{]/.exec(response) && /[\}\]]\s*$/.exec(response)) {
-          response = fromJson(response);
+          response = fromJson(response, true);
         }
         if (code == 200) {
           callback(code, response);
@@ -760,7 +805,7 @@ angularServiceInject('$xhr.bulk', function($xhr, $error, $log){
       post = _null;
     }
     var currentQueue;
-    foreach(bulkXHR.urls, function(queue){
+    forEach(bulkXHR.urls, function(queue){
       if (isFunction(queue.match) ? queue.match(url) : queue.match.exec(url)) {
         currentQueue = queue;
       }
@@ -774,13 +819,13 @@ angularServiceInject('$xhr.bulk', function($xhr, $error, $log){
   }
   bulkXHR.urls = {};
   bulkXHR.flush = function(callback){
-    foreach(bulkXHR.urls, function(queue, url){
+    forEach(bulkXHR.urls, function(queue, url){
       var currentRequests = queue.requests;
       if (currentRequests && currentRequests.length) {
         queue.requests = [];
         queue.callbacks = [];
         $xhr('POST', url, {requests:currentRequests}, function(code, response){
-          foreach(response, function(response, i){
+          forEach(response, function(response, i){
             try {
               if (response.status == 200) {
                 (currentRequests[i].callback || noop)(response.status, response.response);
@@ -801,6 +846,40 @@ angularServiceInject('$xhr.bulk', function($xhr, $error, $log){
   return bulkXHR;
 }, ['$xhr', '$xhr.error', '$log']);
 
+
+/**
+ * @workInProgress
+ * @ngdoc service
+ * @name angular.service.$defer
+ * @requires $browser
+ * @requires $log
+ *
+ * @description
+ * Delegates to {@link angular.service.$browser.defer $browser.defer}, but wraps the `fn` function
+ * into a try/catch block and delegates any exceptions to
+ * {@link angular.services.$exceptionHandler $exceptionHandler} service.
+ *
+ * In tests you can use `$browser.defer.flush()` to flush the queue of deferred functions.
+ *
+ * @param {function()} fn A function, who's execution should be deferred.
+ */
+angularServiceInject('$defer', function($browser, $exceptionHandler, $updateView) {
+  var scope = this;
+
+  return function(fn) {
+    $browser.defer(function() {
+      try {
+        fn();
+      } catch(e) {
+        $exceptionHandler(e);
+      } finally {
+        $updateView();
+      }
+    });
+  };
+}, ['$browser', '$exceptionHandler', '$updateView']);
+
+
 /**
  * @workInProgress
  * @ngdoc service
@@ -811,7 +890,7 @@ angularServiceInject('$xhr.bulk', function($xhr, $error, $log){
  * 
  * @example
  */
-angularServiceInject('$xhr.cache', function($xhr){
+angularServiceInject('$xhr.cache', function($xhr, $defer, $log){
   var inflight = {}, self = this;
   function cache(method, url, post, callback, verifyCache){
     if (isFunction(post)) {
@@ -819,9 +898,9 @@ angularServiceInject('$xhr.cache', function($xhr){
       post = _null;
     }
     if (method == 'GET') {
-      var data;
-      if (data = cache.data[url]) {
-        callback(200, copy(data.value));
+      var data, dataCached;
+      if (dataCached = cache.data[url]) {
+        $defer(function() { callback(200, copy(dataCached.value)); });
         if (!verifyCache)
           return;
       }
@@ -835,11 +914,11 @@ angularServiceInject('$xhr.cache', function($xhr){
             cache.data[url] = { value: response };
           var callbacks = inflight[url].callbacks;
           delete inflight[url];
-          foreach(callbacks, function(callback){
+          forEach(callbacks, function(callback){
             try {
               (callback||noop)(status, copy(response));
             } catch(e) {
-              self.$log.error(e);
+              $log.error(e);
             }
           });
         });
@@ -853,21 +932,116 @@ angularServiceInject('$xhr.cache', function($xhr){
   cache.data = {};
   cache.delegate = $xhr;
   return cache;
-}, ['$xhr.bulk']);
+}, ['$xhr.bulk', '$defer', '$log']);
+
 
 /**
  * @workInProgress
- * @ngdoc service
+ * @ngdoc function
  * @name angular.service.$resource
  * @requires $xhr
- * 
+ *
  * @description
  * Is a factory which creates a resource object which lets you interact with 
  * <a href="http://en.wikipedia.org/wiki/Representational_State_Transfer" target="_blank">RESTful</a>
  * server-side data sources.
  * Resource object has action methods which provide high-level behaviors without
- * the need to interact with the low level $xhr or XMLHttpRequest(). 
- * 
+ * the need to interact with the low level $xhr or XMLHttpRequest().
+ *
+ * <pre>
+     // Define CreditCard class
+     var CreditCard = $resource('/user/:userId/card/:cardId',
+      {userId:123, cardId:'@id'}, {
+       charge: {method:'POST', params:{charge:true}}
+      });
+
+     // We can retrieve a collection from the server
+     var cards = CreditCard.query();
+     // GET: /user/123/card
+     // server returns: [ {id:456, number:'1234', name:'Smith'} ];
+
+     var card = cards[0];
+     // each item is an instance of CreditCard
+     expect(card instanceof CreditCard).toEqual(true);
+     card.name = "J. Smith";
+     // non GET methods are mapped onto the instances
+     card.$save();
+     // POST: /user/123/card/456 {id:456, number:'1234', name:'J. Smith'}
+     // server returns: {id:456, number:'1234', name: 'J. Smith'};
+
+     // our custom method is mapped as well.
+     card.$charge({amount:9.99});
+     // POST: /user/123/card/456?amount=9.99&charge=true {id:456, number:'1234', name:'J. Smith'}
+     // server returns: {id:456, number:'1234', name: 'J. Smith'};
+
+     // we can create an instance as well
+     var newCard = new CreditCard({number:'0123'});
+     newCard.name = "Mike Smith";
+     newCard.$save();
+     // POST: /user/123/card {number:'0123', name:'Mike Smith'}
+     // server returns: {id:789, number:'01234', name: 'Mike Smith'};
+     expect(newCard.id).toEqual(789);
+ * </pre>
+ *
+ * The object returned from this function execution is a resource "class" which has "static" method
+ * for each action in the definition.
+ *
+ * Calling these methods invoke `$xhr` on the `url` template with the given `method` and `params`.
+ * When the data is returned from the server then the object is an instance of the resource type and
+ * all of the non-GET methods are available with `$` prefix. This allows you to easily support CRUD
+ * operations (create, read, update, delete) on server-side data.
+
+   <pre>
+     var User = $resource('/user/:userId', {userId:'@id'});
+     var user = User.get({userId:123}, function(){
+       user.abc = true;
+       user.$save();
+     });
+   </pre>
+ *
+ *     It's worth noting that the callback for `get`, `query` and other method gets passed in the
+ *     response that came from the server, so one could rewrite the above example as:
+ *
+   <pre>
+     var User = $resource('/user/:userId', {userId:'@id'});
+     User.get({userId:123}, function(u){
+       u.abc = true;
+       u.$save();
+     });
+   </pre>
+ *
+ *
+ * @param {string} url A parameterized URL template with parameters prefixed by `:` as in
+ *     `/user/:username`.
+ * @param {Object=} paramDefaults Default values for `url` parameters. These can be overridden in
+ *     `actions` methods.
+ * @param {Object.<Object>=} actions Map of actions available for the resource.
+ *
+ *     Each resource comes preconfigured with `get`, `save`, `query`, `remove`, and `delete` to
+ *     mimic the RESTful philosophy.
+ *
+ *     To create your own actions, pass in a map keyed on action names (e.g. `'charge'`) with
+ *     elements consisting of these properties:
+ *
+ *     - `{string} method`:  Request method type. Valid methods are: `GET`, `POST`, `PUT`, `DELETE`,
+ *        and [`JSON`](http://en.wikipedia.org/wiki/JSON#JSONP) (also known as JSONP).
+ *     - `{Object=} params`: Set of pre-bound parameters for the action.
+ *     - `{boolean=} isArray`: If true then the returned object for this action is an array, see the
+ *       pre-binding section.
+ *     - `{boolean=} verifyCache`: If true then items returned from cache, are double checked by
+ *       running the query again and updating the resource asynchroniously.
+ *
+ *     Each service comes preconfigured with the following overridable actions:
+ *     <pre>
+ *       { 'get':    {method:'GET'},
+           'save':   {method:'POST'},
+           'query':  {method:'GET', isArray:true},
+           'remove': {method:'DELETE'},
+           'delete': {method:'DELETE'} };
+ *     </pre>
+ *
+ * @returns {Object} A resource "class".
+ *
  * @example
    <script>
      function BuzzController($resource) {
@@ -897,7 +1071,7 @@ angularServiceInject('$xhr.cache', function($xhr){
        <h1 style="font-size: 15px;">
 	       <img src="{{item.actor.thumbnailUrl}}" style="max-height:30px;max-width:30px;"/>
 	       <a href="{{item.actor.profileUrl}}">{{item.actor.name}}</a>
-	       <a href="#" ng:click="expandReplies(item)" style="float: right;">Expand replies: {{item.links.replies[0].count}}</a>
+	       <a href ng:click="expandReplies(item)" style="float: right;">Expand replies: {{item.links.replies[0].count}}</a>
        </h1>
        {{item.object.content | html}}
        <div ng:repeat="reply in item.replies.data.items" style="margin-left: 20px;">
@@ -995,7 +1169,7 @@ angularServiceInject('$cookies', function($browser) {
       }
     }
   }
-}, ['$browser'], EAGER_PUBLISHED);
+}, ['$browser']);
 
 /**
  * @workInProgress