feat($parse): allow for assignments in ternary operator branches

Closes #8512
Closes #8484
CLoses #5434

Conflicts:
	test/ng/parseSpec.js

.bowerrc

@@ -0,0 +1,4 @@
+{
+  "directory": "bower_components",
+  "json": "bower.json"
+}

.editorconfig

@@ -0,0 +1,21 @@
+# http://editorconfig.org
+
+root = true
+
+[*]
+charset = utf-8
+indent_style = space
+indent_size = 2
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[src/ngLocale/**]
+insert_final_newline = false
+
+[dropdown-toggle.js]
+trim_trailing_whitespace = false
+insert_final_newline = false
+
+[htmlparser.js]
+insert_final_newline = false

.gitignore

@@ -1,6 +1,4 @@
-build/
-angularjs.netrc
-jstd.log
+/build/
 .DS_Store
 gen_docs.disable
 test.disable
@@ -8,7 +6,15 @@ regression/temp*.html
 performance/temp*.html
 .idea/workspace.xml
 *~
+*.swp
 angular.js.tmproj
-node_modules
+/node_modules/
+/components/
+/bower_components/
 angular.xcodeproj
 .idea
+.agignore
+libpeerconnection.log
+npm-debug.log
+/tmp/
+/scripts/bower/bower-*

.jscs.json

@@ -0,0 +1,6 @@
+{
+  "disallowKeywords": ["with"],
+  "disallowTrailingWhitespace": true,
+  "requireRightStickedOperators": ["!"],
+  "requireLeftStickedOperators": [","]
+}

.jscs.json.todo

@@ -0,0 +1,19 @@
+// This is an incomplete TODO list of checks we want to start enforcing
+//
+// The goal is to enable these checks one by one by moving them to .jscs.json along with commits
+// that correct the existing code base issues and make the new check pass.
+
+{
+  "requireCurlyBraces": ["if", "else", "for", "while", "do", "try", "catch"],
+  "requireSpaceAfterKeywords": ["if", "else", "for", "while", "do", "switch", "return", "try", "catch"],
+  "disallowLeftStickedOperators": ["?", "+", "-", "/", "*", "=", "==", "===", "!=", "!==", ">", ">=", "<", "<="],
+  "disallowRightStickedOperators": ["?", "+", "/", "*", ":", "=", "==", "===", "!=", "!==", ">", ">=", "<", "<="],
+  "disallowImplicitTypeConversion": ["string"],
+  "disallowMultipleLineBreaks": true,
+  "disallowKeywordsOnNewLine": ["else"],
+  "requireLineFeedAtFileEnd": true,
+  "validateJSDoc": {
+    "checkParamNames": true,
+    "requireParamTypes": true
+  }
+}

.jshintignore

@@ -0,0 +1,2 @@
+node_modules/**
+lib/htmlparser/**

.jshintrc

@@ -0,0 +1,5 @@
+{
+  "extends": ".jshintrc-base",
+  "node": true,
+  "globals": {}
+}

.jshintrc-base

@@ -0,0 +1,19 @@
+{
+  "bitwise": true,
+  "immed": true,
+  "newcap": true,
+  "noarg": true,
+  "noempty": true,
+  "nonew": true,
+  "trailing": true,
+  "maxlen": 200,
+  "boss": true,
+  "eqnull": true,
+  "expr": true,
+  "globalstrict": true,
+  "laxbreak": true,
+  "loopfunc": true,
+  "sub": true,
+  "undef": true,
+  "indent": 2
+}

.travis.yml

@@ -1,13 +1,49 @@
 language: node_js
 node_js:
-  - 0.8
+  - '0.10'
+
+branches:
+  except:
+    - /^g3_.*$/
+
+env:
+  matrix:
+    - JOB=unit
+    - JOB=e2e TEST_TARGET=jqlite
+    - JOB=e2e TEST_TARGET=jquery
+    - JOB=e2e TEST_TARGET=doce2e
+  global:
+    - SAUCE_USERNAME=angular-ci
+    - SAUCE_ACCESS_KEY=9b988f434ff8-fbca-8aa4-4ae3-35442987
+    - LOGS_DIR=/tmp/angular-build/logs
+    - BROWSER_PROVIDER_READY_FILE=/tmp/sauce-connect-ready
+
+install:
+  # - npm config set registry http://23.251.144.68
+  # Disable the spinner, it looks bad on Travis
+  - npm config set spin false
+  # Log HTTP requests
+  - npm config set loglevel http
+  - time ./scripts/travis/npm-bundle-deps.sh
+  - time npm install
 
 before_script:
-  - export DISPLAY=:99.0
-  - sh -e /etc/init.d/xvfb start
+  - mkdir -p $LOGS_DIR
+  - ./lib/sauce/sauce_connect_setup.sh
   - npm install -g grunt-cli
   - grunt package
-  - grunt webserver > /dev/null &
+  - ./scripts/travis/wait_for_browser_provider.sh
 
 script:
-  - grunt test --browsers Firefox --reporters=dots
+  - ./scripts/travis/build.sh
+
+after_script:
+  - ./scripts/travis/print_logs.sh
+
+notifications:
+  webhooks:
+    urls:
+      - https://webhooks.gitter.im/e/d2120f3f2bb39a4531b2
+    on_success: change  # options: [always|never|change] default: always
+    on_failure: always  # options: [always|never|change] default: always
+    on_start: false     # default: false

CONTRIBUTING.md

@@ -1,32 +1,274 @@
-## Submitting issues
+#Contributing to AngularJS
 
-If you have questions about how to use AngularJS, please direct these to the
-[Google Group][groups] discussion list or [StackOverflow][stackoverflow]. We are
-also available on [IRC][irc].
+We'd love for you to contribute to our source code and to make AngularJS even better than it is
+today! Here are the guidelines we'd like you to follow:
 
-### Guidelines
+ - [Code of Conduct](#coc)
+ - [Question or Problem?](#question)
+ - [Issues and Bugs](#issue)
+ - [Feature Requests](#feature)
+ - [Submission Guidelines](#submit)
+ - [Coding Rules](#rules)
+ - [Commit Message Guidelines](#commit)
+ - [Signing the CLA](#cla)
+ - [Further Info](#info)
 
-* Search the archive first, it's likely that your question was already answered.
-* A live example demonstrating your problem or question, will get an answer faster.
-* Create one using this [template][template]
-* If you get help, help others. Good karma rulez!
+## <a name="coc"></a> Code of Conduct
+Help us keep Angular open and inclusive. Please read and follow our [Code of Conduct][coc].
+
+## <a name="question"></a> Got a Question or Problem?
+
+If you have questions about how to use AngularJS, please direct these to the [Google Group][groups]
+discussion list or [StackOverflow][stackoverflow]. We are also available on [IRC][irc].
+
+## <a name="issue"></a> Found an Issue?
+If you find a bug in the source code or a mistake in the documentation, you can help us by
+submitting an issue to our [GitHub Repository][github]. Even better you can submit a Pull Request
+with a fix.
+
+***Localization Issue:*** *Angular.js uses the [Google Closure I18N library], to generate its own I18N files. This means that
+any changes to these files would be lost the next time that we import the library. The recommended
+approach is to submit a patch to the I18N project directly, instead of submitting it here.*
+
+**Please see the Submission Guidelines below**.
+
+## <a name="feature"></a> Want a Feature?
+You can request a new feature by submitting an issue to our [GitHub Repository][github].  If you
+would like to implement a new feature then consider what kind of change it is:
+
+* **Major Changes** that you wish to contribute to the project should be discussed first on our
+[dev mailing list][angular-dev] or [IRC][irc] so that we can better coordinate our efforts, prevent
+duplication of work, and help you to craft the change so that it is successfully accepted into the
+project.
+* **Small Changes** can be crafted and submitted to [GitHub Repository][github] as a Pull Request.
+
+
+## <a name="docs"></a> Want a Doc Fix?
+If you want to help improve the docs, it's a good idea to let others know what you're working on to 
+minimize duplication of effort. Before starting, check out the issue queue for [Milestone:Docs Only](https://github.com/angular/angular.js/issues?milestone=24&state=open). 
+Comment on an issue to let others know what you're working on, or create a new issue if your work
+doesn't fit within the scope of any of the existing doc fix projects.
+
+For large fixes, please build and test the documentation before submitting the PR to be sure you haven't
+accidentally introduced any layout or formatting issues. You should also make sure that your commit message
+is labeled "docs:" and follows the **Git Commit Guidelines** outlined below.
+
+If you're just making a small change, don't worry about filing an issue first. Use the friendly blue "Improve this doc" button at the top right of the doc page to fork the repository in-place and make a quick change on the fly.
+
+## <a name="submit"></a> Submission Guidelines
+
+### Submitting an Issue
+Before you submit your issue search the archive, maybe your question was already answered.
 
 If your issue appears to be a bug, and hasn't been reported, open a new issue.
 Help us to maximize the effort we can spend fixing issues and adding new
-features, by not reporting duplicate issues.
+features, by not reporting duplicate issues.  Providing the following information will increase the
+chances of your issue being dealt with quickly:
 
-[stackoverflow]: http://stackoverflow.com/questions/tagged/angularjs
-[groups]: https://groups.google.com/forum/?fromgroups#!forum/angular
-[irc]: http://webchat.freenode.net/?channels=angularjs&uio=d4
-[template]: http://plnkr.co/edit/gist:3510140
+* **Overview of the issue** - if an error is being thrown a non-minified stack trace helps
+* **Motivation for or Use Case** - explain why this is a bug for you
+* **Angular Version(s)** - is it a regression?
+* **Browsers and Operating System** - is this a problem with all browsers or only IE8?
+* **Reproduce the error** - provide a live example (using [Plunker][plunker] or
+  [JSFiddle][jsfiddle]) or a unambiguous set of steps.
+* **Related issues** - has a similar issue been reported before?
+* **Suggest a Fix** - if you can't fix the bug yourself, perhaps you can point to what might be
+  causing the problem (line of code or commit)
 
-## Contributing to Source Code
+Here is a great example of a well defined issue: https://github.com/angular/angular.js/issues/5069
 
-We'd love for you to contribute to our source code and to make AngularJS even
-better than it is today!
+**If you get help, help others. Good karma rulez!**
 
- Please read the [contribution guidelines][contribute] to learn about how to submit code as well as
- other useful info like how to build and test AngularJS code.
+### Submitting a Pull Request
+Before you submit your pull request consider the following guidelines:
 
-[list]: https://groups.google.com/forum/?fromgroups#!forum/angular
+* Search [GitHub](https://github.com/angular/angular.js/pulls) for an open or closed Pull Request
+  that relates to your submission. You don't want to duplicate effort.
+* Please sign our [Contributor License Agreement (CLA)](#signing-the-cla) before sending pull
+  requests. We cannot accept code without this.
+* Make your changes in a new git branch
+
+     ```shell
+     git checkout -b my-fix-branch master
+     ```
+
+* Create your patch, **including appropriate test cases**.
+* Follow our [Coding Rules](#coding-rules).
+* Run the full Angular test suite, as described in the [developer documentation][dev-doc],
+  and ensure that all tests pass.
+* Commit your changes using a descriptive commit message that follows our
+  [commit message conventions](#commit-message-format) and passes our commit message presubmit hook
+  `validate-commit-msg.js`. Adherence to the [commit message conventions](#commit-message-format)
+  is required because release notes are automatically generated from these messages.
+
+     ```shell
+     git commit -a
+     ```
+  Note: the optional commit `-a` command line option will automatically "add" and "rm" edited files.
+
+* Build your changes locally to ensure all the tests pass
+
+    ```shell
+    grunt test
+    ```
+
+* Push your branch to GitHub:
+
+    ```shell
+    git push origin my-fix-branch
+    ```
+
+* In GitHub, send a pull request to `angular:master`.
+* If we suggest changes then
+  * Make the required updates.
+  * Re-run the Angular test suite to ensure tests are still passing.
+  * Rebase your branch and force push to your GitHub repository (this will update your Pull Request):
+
+    ```shell
+    git rebase master -i
+    git push -f
+    ```
+
+That's it! Thank you for your contribution!
+
+#### After your pull request is merged
+
+After your pull request is merged, you can safely delete your branch and pull the changes
+from the main (upstream) repository:
+
+* Delete the remote branch on GitHub either through the GitHub web UI or your local shell as follows:
+
+    ```shell
+    git push origin --delete my-fix-branch
+    ```
+
+* Check out the master branch:
+
+    ```shell
+    git checkout master -f
+    ```
+
+* Delete the local branch:
+
+    ```shell
+    git branch -D my-fix-branch
+    ```
+
+* Update your master with the latest upstream version:
+
+    ```shell
+    git pull --ff upstream master
+    ```
+
+## <a name="rules"></a> Coding Rules
+To ensure consistency throughout the source code, keep these rules in mind as you are working:
+
+* All features or bug fixes **must be tested** by one or more [specs][unit-testing].
+* All public API methods **must be documented** with ngdoc, an extended version of jsdoc (we added
+  support for markdown and templating via @ngdoc tag). To see how we document our APIs, please check
+  out the existing ngdocs and see [this wiki page][ngDocs].
+* With the exceptions listed below, we follow the rules contained in
+  [Google's JavaScript Style Guide][js-style-guide]:
+    * **Do not use namespaces**: Instead,  wrap the entire angular code base in an anonymous closure and
+      export our API explicitly rather than implicitly.
+    * Wrap all code at **100 characters**.
+    * Instead of complex inheritance hierarchies, we **prefer simple objects**. We use prototypical
+      inheritance only when absolutely necessary.
+    * We **love functions and closures** and, whenever possible, prefer them over objects.
+    * To write concise code that can be better minified, we **use aliases internally** that map to the
+      external API. See our existing code to see what we mean.
+    * We **don't go crazy with type annotations** for private internal APIs unless it's an internal API
+      that is used throughout AngularJS. The best guidance is to do what makes the most sense.
+
+## <a name="commit"></a> Git Commit Guidelines
+
+We have very precise rules over how our git commit messages can be formatted.  This leads to **more
+readable messages** that are easy to follow when looking through the **project history**.  But also,
+we use the git commit messages to **generate the AngularJS change log**.
+
+### Commit Message Format
+Each commit message consists of a **header**, a **body** and a **footer**.  The header has a special
+format that includes a **type**, a **scope** and a **subject**:
+
+```
+<type>(<scope>): <subject>
+<BLANK LINE>
+<body>
+<BLANK LINE>
+<footer>
+```
+
+Any line of the commit message cannot be longer 100 characters! This allows the message to be easier
+to read on github as well as in various git tools.
+
+### Type
+Must be one of the following:
+
+* **feat**: A new feature
+* **fix**: A bug fix
+* **docs**: Documentation only changes
+* **style**: Changes that do not affect the meaning of the code (white-space, formatting, missing
+  semi-colons, etc)
+* **refactor**: A code change that neither fixes a bug or adds a feature
+* **perf**: A code change that improves performance
+* **test**: Adding missing tests
+* **chore**: Changes to the build process or auxiliary tools and libraries such as documentation
+  generation
+
+### Scope
+The scope could be anything specifying place of the commit change. For example `$location`,
+`$browser`, `$compile`, `$rootScope`, `ngHref`, `ngClick`, `ngView`, etc...
+
+### Subject
+The subject contains succinct description of the change:
+
+* use the imperative, present tense: "change" not "changed" nor "changes"
+* don't capitalize first letter
+* no dot (.) at the end
+
+###Body
+Just as in the **subject**, use the imperative, present tense: "change" not "changed" nor "changes"
+The body should include the motivation for the change and contrast this with previous behavior.
+
+###Footer
+The footer should contain any information about **Breaking Changes** and is also the place to
+reference GitHub issues that this commit **Closes**.
+
+
+A detailed explanation can be found in this [document][commit-message-format].
+
+## <a name="cla"></a> Signing the CLA
+
+Please sign our Contributor License Agreement (CLA) before sending pull requests. For any code
+changes to be accepted, the CLA must be signed. It's a quick process, we promise!
+
+* For individuals we have a [simple click-through form][individual-cla].
+* For corporations we'll need you to
+  [print, sign and one of scan+email, fax or mail the form][corporate-cla].
+
+## <a name="info"></a> Further Information
+You can find out more detailed information about contributing in the
+[AngularJS documentation][contributing].
+
+
+
+[Google Closure I18N library]: https://github.com/google/closure-library/tree/master/closure/goog/i18n
+[angular-dev]: https://groups.google.com/forum/?fromgroups#!forum/angular-dev
+[coc]: https://github.com/angular/code-of-conduct/blob/master/CODE_OF_CONDUCT.md
+[commit-message-format]: https://docs.google.com/document/d/1QrDFcIiPjSLDn3EL15IJygNPiHORgU1_OOAqWjiDU5Y/edit#
 [contribute]: http://docs.angularjs.org/misc/contribute
+[contributing]: http://docs.angularjs.org/misc/contribute
+[corporate-cla]: http://code.google.com/legal/corporate-cla-v1.0.html
+[github]: https://github.com/angular/angular.js
+[groups]: https://groups.google.com/forum/?fromgroups#!forum/angular
+[individual-cla]: http://code.google.com/legal/individual-cla-v1.0.html
+[irc]: http://webchat.freenode.net/?channels=angularjs&uio=d4
+[js-style-guide]: http://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml
+[jsfiddle]: http://jsfiddle.net/
+[list]: https://groups.google.com/forum/?fromgroups#!forum/angular
+[ngDocs]: https://github.com/angular/angular.js/wiki/Writing-AngularJS-Documentation
+[plunker]: http://plnkr.co/edit
+[stackoverflow]: http://stackoverflow.com/questions/tagged/angularjs
+[unit-testing]: https://docs.angularjs.org/guide/unit-testing
+
+[![Analytics](https://ga-beacon.appspot.com/UA-8594346-11/angular.js/CONTRIBUTING.md?pixel)](https://github.com/igrigorik/ga-beacon)

Gruntfile.js

@@ -1,18 +1,20 @@
+'use strict';
+
 var files = require('./angularFiles').files;
 var util = require('./lib/grunt/utils.js');
+var versionInfo = require('./lib/versions/version-info');
+var path = require('path');
 
 module.exports = function(grunt) {
   //grunt plugins
-  grunt.loadNpmTasks('grunt-contrib-clean');
-  grunt.loadNpmTasks('grunt-contrib-copy');
-  grunt.loadNpmTasks('grunt-contrib-connect');
-  grunt.loadNpmTasks('grunt-contrib-compress');
+  require('load-grunt-tasks')(grunt);
+
   grunt.loadTasks('lib/grunt');
 
-  var NG_VERSION = util.getVersion();
+  var NG_VERSION = versionInfo.currentVersion;
+  NG_VERSION.cdn = versionInfo.cdnVersion;
   var dist = 'angular-'+ NG_VERSION.full;
 
-
   //global beforeEach
   util.init();
 
@@ -21,6 +23,15 @@ module.exports = function(grunt) {
   grunt.initConfig({
     NG_VERSION: NG_VERSION,
 
+    parallel: {
+      travis: {
+        tasks: [
+          util.parallelTask(['test:unit', 'test:promises-aplus', 'tests:docs'], {stream: true}),
+          util.parallelTask(['test:e2e'])
+        ]
+      }
+    },
+
     connect: {
       devserver: {
         options: {
@@ -40,33 +51,114 @@ module.exports = function(grunt) {
           }
         }
       },
-      testserver: {}
+      testserver: {
+        options: {
+          // We use end2end task (which does not start the webserver)
+          // and start the webserver as a separate process (in travis_build.sh)
+          // to avoid https://github.com/joyent/libuv/issues/826
+          port: 8000,
+          hostname: '0.0.0.0',
+          middleware: function(connect, options){
+            return [
+              function(req, resp, next) {
+                // cache get requests to speed up tests on travis
+                if (req.method === 'GET') {
+                  resp.setHeader('Cache-control', 'public, max-age=3600');
+                }
+
+                next();
+              },
+              connect.favicon('images/favicon.ico'),
+              connect.static(options.base)
+            ];
+          }
+        }
+      }
     },
 
 
-    test: {
+    tests: {
       jqlite: 'karma-jqlite.conf.js',
       jquery: 'karma-jquery.conf.js',
-      modules: 'karma-modules.conf.js',
-      //NOTE run grunt test:e2e instead and it will start a webserver for you
-      end2end: 'karma-e2e.conf.js'
+      docs: 'karma-docs.conf.js',
+      modules: 'karma-modules.conf.js'
     },
 
 
     autotest: {
       jqlite: 'karma-jqlite.conf.js',
-      jquery: 'karma-jquery.conf.js'
+      jquery: 'karma-jquery.conf.js',
+      modules: 'karma-modules.conf.js',
+      docs: 'karma-docs.conf.js'
     },
 
 
-    clean: {build: ['build']},
+    protractor: {
+      normal: 'protractor-conf.js',
+      travis: 'protractor-travis-conf.js',
+      jenkins: 'protractor-jenkins-conf.js'
+    },
 
 
+    clean: {
+      build: ['build'],
+      tmp: ['tmp']
+    },
+
+    jshint: {
+      options: {
+        jshintrc: true,
+      },
+      node: {
+        files: { src: ['*.js', 'lib/**/*.js'] },
+      },
+      tests: {
+        files: { src: 'test/**/*.js' },
+      },
+      ng: {
+        files: { src: files['angularSrc'] },
+      },
+      ngAnimate: {
+        files: { src: 'src/ngAnimate/**/*.js' },
+      },
+      ngCookies: {
+        files: { src: 'src/ngCookies/**/*.js' },
+      },
+      ngLocale: {
+        files: { src: 'src/ngLocale/**/*.js' },
+      },
+      ngMock: {
+        files: { src: 'src/ngMock/**/*.js' },
+      },
+      ngResource: {
+        files: { src: 'src/ngResource/**/*.js' },
+      },
+      ngRoute: {
+        files: { src: 'src/ngRoute/**/*.js' },
+      },
+      ngSanitize: {
+        files: { src: 'src/ngSanitize/**/*.js' },
+      },
+      ngScenario: {
+        files: { src: 'src/ngScenario/**/*.js' },
+      },
+      ngTouch: {
+        files: { src: 'src/ngTouch/**/*.js' },
+      }
+    },
+
+    jscs: {
+      src: ['src/**/*.js', 'test/**/*.js'],
+      options: {
+        config: ".jscs.json"
+      }
+    },
+
     build: {
       scenario: {
         dest: 'build/angular-scenario.js',
         src: [
-          'lib/jquery/jquery.js',
+          'bower_components/jquery/jquery.js',
           util.wrap([files['angularSrc'], files['angularScenario']], 'ngScenario/angular')
         ],
         styles: {
@@ -78,73 +170,80 @@ module.exports = function(grunt) {
         src: util.wrap([files['angularSrc']], 'angular'),
         styles: {
           css: ['css/angular.css'],
+          generateCspCssFile: true,
           minify: true
         }
       },
       loader: {
         dest: 'build/angular-loader.js',
-        src: util.wrap(['src/loader.js'], 'loader')
+        src: util.wrap(files['angularLoader'], 'loader')
       },
-      mobile: {
-        dest: 'build/angular-mobile.js',
-        src: util.wrap([
-          'src/ngMobile/mobile.js',
-          'src/ngMobile/directive/ngClick.js',
-          'src/ngMobile/directive/ngSwipe.js'
-            ], 'module')
+      touch: {
+        dest: 'build/angular-touch.js',
+        src: util.wrap(files['angularModules']['ngTouch'], 'module')
       },
       mocks: {
         dest: 'build/angular-mocks.js',
-        src: ['src/ngMock/angular-mocks.js'],
+        src: util.wrap(files['angularModules']['ngMock'], 'module'),
         strict: false
       },
       sanitize: {
         dest: 'build/angular-sanitize.js',
-        src: util.wrap([
-          'src/ngSanitize/sanitize.js',
-          'src/ngSanitize/directive/ngBindHtml.js',
-          'src/ngSanitize/filter/linky.js',
-        ], 'module')
+        src: util.wrap(files['angularModules']['ngSanitize'], 'module')
       },
       resource: {
         dest: 'build/angular-resource.js',
-        src: util.wrap(['src/ngResource/resource.js'], 'module')
+        src: util.wrap(files['angularModules']['ngResource'], 'module')
+      },
+      animate: {
+        dest: 'build/angular-animate.js',
+        src: util.wrap(files['angularModules']['ngAnimate'], 'module')
+      },
+      route: {
+        dest: 'build/angular-route.js',
+        src: util.wrap(files['angularModules']['ngRoute'], 'module')
       },
       cookies: {
         dest: 'build/angular-cookies.js',
-        src: util.wrap(['src/ngCookies/cookies.js'], 'module')
+        src: util.wrap(files['angularModules']['ngCookies'], 'module')
       },
-      bootstrap: {
-        dest: 'build/docs/components/angular-bootstrap.js',
-        src: util.wrap(['docs/components/bootstrap/bootstrap.js'], 'module')
-      },
-      bootstrapPrettify: {
-        dest: 'build/docs/components/angular-bootstrap-prettify.js',
-        src: util.wrap(['docs/components/bootstrap/bootstrap-prettify.js', 'docs/components/bootstrap/google-prettify/prettify.js'], 'module'),
-        styles: {
-          css: ['docs/components/bootstrap/google-prettify/prettify.css'],
-          minify: true
-        }
+      "promises-aplus-adapter": {
+        dest:'tmp/promises-aplus-adapter++.js',
+        src:['src/ng/q.js','lib/promises-aplus/promises-aplus-test-adapter.js']
       }
     },
 
 
     min: {
       angular: 'build/angular.js',
+      animate: 'build/angular-animate.js',
       cookies: 'build/angular-cookies.js',
       loader: 'build/angular-loader.js',
-      mobile: 'build/angular-mobile.js',
+      touch: 'build/angular-touch.js',
       resource: 'build/angular-resource.js',
-      sanitize: 'build/angular-sanitize.js',
-      bootstrap: 'build/docs/components/angular-bootstrap.js',
-      bootstrapPrettify: 'build/docs/components/angular-bootstrap-prettify.js',
+      route: 'build/angular-route.js',
+      sanitize: 'build/angular-sanitize.js'
     },
 
 
-    docs: {
-      process: ['build/docs/*.html', 'build/docs/.htaccess']
+    "ddescribe-iit": {
+      files: [
+        'src/**/*.js',
+        'test/**/*.js',
+        '!test/ngScenario/DescribeSpec.js',
+        '!src/ng/directive/booleanAttrs.js', // legitimate xit here
+        '!src/ngScenario/**/*.js'
+      ]
     },
 
+    "merge-conflict": {
+      files: [
+        'src/**/*',
+        'test/**/*',
+        'docs/**/*',
+        'css/**/*'
+      ]
+    },
 
     copy: {
       i18n: {
@@ -157,8 +256,23 @@ module.exports = function(grunt) {
 
     compress: {
       build: {
-        options: {archive: 'build/' + dist +'.zip'},
-        src: ['**'], cwd: 'build', expand: true, dot: true, dest: dist + '/'
+        options: {archive: 'build/' + dist +'.zip', mode: 'zip'},
+        src: ['**'],
+        cwd: 'build',
+        expand: true,
+        dot: true,
+        dest: dist + '/'
+      }
+    },
+
+    shell:{
+      "promises-aplus-tests":{
+        options:{
+          //stdout:true,
+          stderr:true,
+          failOnError:true
+        },
+        command:path.normalize('./node_modules/.bin/promises-aplus-tests tmp/promises-aplus-adapter++.js')
       }
     },
 
@@ -166,15 +280,35 @@ module.exports = function(grunt) {
     write: {
       versionTXT: {file: 'build/version.txt', val: NG_VERSION.full},
       versionJSON: {file: 'build/version.json', val: JSON.stringify(NG_VERSION)}
+    },
+
+    bump: {
+      options: {
+        files: ['package.json'],
+        commit: false,
+        createTag: false,
+        push: false
+      }
     }
   });
 
 
   //alias tasks
-  grunt.registerTask('test:unit', ['test:jqlite', 'test:jquery', 'test:modules']);
-  grunt.registerTask('minify', ['clean', 'build', 'minall']);
-  grunt.registerTask('test:e2e', ['connect:testserver', 'test:end2end']);
+  grunt.registerTask('test', 'Run unit, docs and e2e tests with Karma', ['jshint', 'jscs', 'package','test:unit','test:promises-aplus', 'tests:docs', 'test:protractor']);
+  grunt.registerTask('test:jqlite', 'Run the unit tests with Karma' , ['tests:jqlite']);
+  grunt.registerTask('test:jquery', 'Run the jQuery unit tests with Karma', ['tests:jquery']);
+  grunt.registerTask('test:modules', 'Run the Karma module tests with Karma', ['tests:modules']);
+  grunt.registerTask('test:docs', 'Run the doc-page tests with Karma', ['package', 'tests:docs']);
+  grunt.registerTask('test:unit', 'Run unit, jQuery and Karma module tests with Karma', ['tests:jqlite', 'tests:jquery', 'tests:modules']);
+  grunt.registerTask('test:protractor', 'Run the end to end tests with Protractor and keep a test server running in the background', ['webdriver', 'connect:testserver', 'protractor:normal']);
+  grunt.registerTask('test:travis-protractor', 'Run the end to end tests with Protractor for Travis CI builds', ['connect:testserver', 'protractor:travis']);
+  grunt.registerTask('test:ci-protractor', 'Run the end to end tests with Protractor for Jenkins CI builds', ['webdriver', 'connect:testserver', 'protractor:jenkins']);
+  grunt.registerTask('test:e2e', 'Alias for test:protractor', ['test:protractor']);
+  grunt.registerTask('test:promises-aplus',['build:promises-aplus-adapter','shell:promises-aplus-tests']);
+
+  grunt.registerTask('minify', ['bower','clean', 'build', 'minall']);
   grunt.registerTask('webserver', ['connect:devserver']);
-  grunt.registerTask('package', ['clean', 'buildall', 'minall', 'docs', 'copy', 'write', 'compress']);
+  grunt.registerTask('package', ['bower','clean', 'buildall', 'minall', 'collect-errors', 'docs', 'copy', 'write', 'compress']);
+  grunt.registerTask('ci-checks', ['ddescribe-iit', 'merge-conflict', 'jshint', 'jscs']);
   grunt.registerTask('default', ['package']);
 };

LICENSE

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2010-2012 Google, Inc. http://angularjs.org
+Copyright (c) 2010-2014 Google, Inc. http://angularjs.org
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.closure.md

@@ -0,0 +1,23 @@
+Using AngularJS with the Closure Compiler
+=========================================
+
+The Closure Compiler project contains externs definitions for AngularJS
+JavaScript in its `contrib/externs` directory.
+
+The definitions contain externs for use with the Closure compiler (aka
+JSCompiler). Passing these files to the --externs parameter of a compiler
+pass allows using type annotations for AngularJS objects. For example,
+Angular's $scope objects can be annotated as:
+```js
+/** @type {angular.Scope} */
+var scope = $scope;
+```
+
+This allows JSCompiler to type check accesses to scope, give warnings about
+missing methods or incorrect arguments, and also prevents renaming of property
+accesses with advanced compilation.
+
+The externs are incomplete and maintained on an as-needed basis, but strive to
+be correct. Externs for individual modules should be added in separate files.
+
+See https://developers.google.com/closure/compiler/

README.md

@@ -1,4 +1,4 @@
-AngularJS
+AngularJS [![Build Status](https://travis-ci.org/angular/angular.js.svg?branch=master)](https://travis-ci.org/angular/angular.js)
 =========
 
 AngularJS lets you write client-side web applications as if you had a smarter browser.  It lets you
@@ -7,7 +7,7 @@ syntax to express your application’s components clearly and succinctly.  It au
 synchronizes data from your UI (view) with your JavaScript objects (model) through 2-way data
 binding. To help you structure your application better and make it easy to test, AngularJS teaches
 the browser how to do dependency injection and inversion of control. Oh yeah and it also helps with
-server-side communication, taming async callbacks with promises and deferreds; and make client-side
+server-side communication, taming async callbacks with promises and deferreds; and makes client-side
 navigation and deeplinking with hashbang urls or HTML5 pushState a piece of cake. The best of all:
 it makes development fun!
 
@@ -16,6 +16,7 @@ it makes development fun!
 * API Docs: http://docs.angularjs.org/api
 * Developer Guide: http://docs.angularjs.org/guide
 * Contribution guidelines: http://docs.angularjs.org/misc/contribute
+* Dashboard: http://dashboard.angularjs.org
 
 Building AngularJS
 ---------
@@ -37,3 +38,7 @@ To execute end-to-end (e2e) tests, use:
 
 To learn more about the grunt tasks, run `grunt --help` and also read our
 [contribution guidelines](http://docs.angularjs.org/misc/contribute).
+
+
+[![Analytics](https://ga-beacon.appspot.com/UA-8594346-11/angular.js/README.md?pixel)](https://github.com/igrigorik/ga-beacon)
+

TRIAGING.md

@@ -0,0 +1,134 @@
+# Triage new issues/PRs on github
+
+This document shows the steps the Angular team is using to triage issues.
+The labels are used later on for [planning releases](#assigning-work).
+
+
+## Automatic processing
+
+We have tools (e.g. [Mary Poppins]) that automatically add comments and labels to issues and PRs.
+The following is done automatically so you don't have to worry about it:
+
+* Label `cla: yes` or `cla: no` for pull requests
+* Label `GH: *`
+    * `PR` - issue is a PR
+    * `issue` - otherwise
+
+
+## Triaging Process
+
+This process based on the idea of minimizing user pain
+[from this blog post](http://www.lostgarden.com/2008/05/improving-bug-triage-with-user-pain.html).
+
+1. Open the list of [non triaged issues](https://github.com/angular/angular.js/issues?direction=desc&milestone=none&page=1&sort=created&state=open)
+    * Sort by submit date, with the newest issues first
+    * You don't have to do issues in order; feel free to pick and choose issues as you please.
+    * You can triage older issues as well
+    * Triage to your heart's content
+1. Assign yourself: Pick an issue that is not assigned to anyone and assign it to you
+
+1. Understandable? - verify if the description of the request is clear.
+    * If not, [close it][] according to the instructions below and go to the last step.
+1. Duplicate?
+    * If you've seen this issue before [close it][], and go to the last step.
+    * Check if there are comments that link to a dupe. If so verify that this is indeed a dupe, [close it][], and go to the last step.
+1. Bugs:
+    * Label `Type: Bug`
+    * Reproducible? - Steps to reproduce the bug are clear. If they are not, ask for a clarification. If there's no reply after a week, [close it][].
+    * Reproducible on master? - <http://code.angularjs.org/snapshot/>
+
+1. Non bugs:
+    * Label `Type: Feature`, `Type: Chore`, or `Type: Perf`
+    * Belongs in core? – Often new features should be implemented as a third-party module rather than an addition to the core.
+      If this doesn't belong, [close it][], and go to the last step.
+    * Label `needs: breaking change` - if needed
+    * Label `needs: public api` - if the issue requires introduction of a new public API
+1. Label `browser: *` - if the issue **only** affects a certain browser
+1. Label `frequency: *` – How often does this issue come up? How many developers does this affect? Chose just one of the following:
+    * low - obscure issue affecting a handful of developers
+    * moderate - impacts a common usage pattern
+    * high - impacts most or all Angular apps
+1. Label `severity: *` - How bad is the issue? Chose just one of the following:
+    * security issue
+    * regression
+    * memory leak
+    * broken expected use - it's hard or impossible for a developer using Angular to accomplish something that Angular should be able to do
+    * confusing - unexpected or inconsistent behavior; hard-to-debug
+    * inconvenience - causes ugly/boilerplate code in apps
+1. Label `component: *`
+    * In rare cases, it's ok to have multiple components.
+1. Label `PRs plz!` - These issues are good targets for PRs from the open source community. Apply to issues where the problem and solution are well defined in the comments, and it's not too complex.
+1. Label `origin: google` for issues from Google
+
+1. Assign a milestone:
+   * Backlog - triaged fixes and features, should be the default choice
+   * Current 1.x.y milestone (e.g. 1.3.0-beta-2) - regressions and urgent bugs only
+
+
+1. Unassign yourself from the issue
+
+
+## Tips
+
+* Label `resolution: *`
+    * these tags can be used for labeling a closed issue/PR with a reason why it was closed.
+    * Right now there are only a few rejection reasons, but we can add more as needed. Feel free to suggest one to a core team member. We don't use this label for issues that were fixed or PRs that were merged.
+
+
+## Closing an Issue or PR
+
+We're grateful to anyone who takes the time to submit an issue, even if we ultimately decide not to act on it.
+Be kind and respectful as you close issues. Be sure to follow the [code of conduct][].
+
+1. Always thank the person who submitted it.
+1. If it's a duplicate, link to the older or more descriptive issue that supersedes the one you are closing.
+1. Let them know if there's some way for them to follow-up.
+    * When the issue is unclear or reproducible, note that you'll reopen it if they can clarify or provide a better example. Mention [plunker] or [fiddle] for examples. Watch your notifications and follow-up if they do provide clarification. :)
+    * If appropriate, suggest implementing a feature as a third-party module.
+
+If in doubt, ask a core team member what to do.
+[Brian](https://github.com/btford) is probably the person to ask.
+You can mention him in the relevant thread like this: `@btford`.
+
+**Example:**
+
+> Thanks for submitting this issue!
+> Unfortunately, we don't think this functionality belongs in core.
+> The good news is that you could easily implement this as a third-party module and publish it on Bower and/or npm.
+
+
+## Assigning Work
+
+These criteria are then used to calculate a "user pain" score.
+Work is assigned weekly to core team members starting with the highest pain, descending down to the lowest.
+
+```
+pain = severity × frequency
+```
+
+**severity:**
+
+- security issue (6)
+- regression (5)
+- memory leak (4)
+- broken expected use (3)
+- confusing (2)
+- inconvenience (1)
+
+**frequency:**
+
+- low (1)
+- moderate (2)
+- high (3)
+
+**Note:** Security issues, regressions, and memory leaks should almost always be set to `frequency: high`.
+
+
+[![Analytics](https://ga-beacon.appspot.com/UA-8594346-11/angular.js/TRIAGING.md?pixel)](https://github.com/igrigorik/ga-beacon)
+
+
+[close it]: #closing-an-issue-or-pr
+[code of conduct]: https://github.com/angular/code-of-conduct/blob/master/CODE_OF_CONDUCT.md
+[Mary Poppins]: https://github.com/btford/mary-poppins
+[plunker]: http://plnkr.co/
+[fiddle]: http://jsfiddle.net/

angularFiles.js

@@ -1,5 +1,8 @@
-angularFiles = {
+'use strict';
+
+var angularFiles = {
   'angularSrc': [
+    'src/minErr.js',
     'src/Angular.js',
     'src/loader.js',
     'src/AngularPublic.js',
@@ -9,28 +12,31 @@ angularFiles = {
     'src/auto/injector.js',
 
     'src/ng/anchorScroll.js',
-    'src/ng/animation.js',
-    'src/ng/animator.js',
+    'src/ng/animate.js',
+    'src/ng/asyncCallback.js',
     'src/ng/browser.js',
     'src/ng/cacheFactory.js',
     'src/ng/compile.js',
     'src/ng/controller.js',
     'src/ng/document.js',
     'src/ng/exceptionHandler.js',
+    'src/ng/http.js',
+    'src/ng/httpBackend.js',
     'src/ng/interpolate.js',
+    'src/ng/interval.js',
+    'src/ng/locale.js',
     'src/ng/location.js',
     'src/ng/log.js',
     'src/ng/parse.js',
     'src/ng/q.js',
-    'src/ng/route.js',
-    'src/ng/routeParams.js',
+    'src/ng/raf.js',
     'src/ng/rootScope.js',
+    'src/ng/sanitizeUri.js',
+    'src/ng/sce.js',
     'src/ng/sniffer.js',
-    'src/ng/window.js',
-    'src/ng/http.js',
-    'src/ng/httpBackend.js',
-    'src/ng/locale.js',
     'src/ng/timeout.js',
+    'src/ng/urlUtils.js',
+    'src/ng/window.js',
 
     'src/ng/filter.js',
     'src/ng/filter/filter.js',
@@ -59,26 +65,46 @@ angularFiles = {
     'src/ng/directive/ngStyle.js',
     'src/ng/directive/ngSwitch.js',
     'src/ng/directive/ngTransclude.js',
-    'src/ng/directive/ngView.js',
     'src/ng/directive/script.js',
     'src/ng/directive/select.js',
     'src/ng/directive/style.js'
   ],
 
-  'angularSrcModules': [
-    'src/ngCookies/cookies.js',
-    'src/ngResource/resource.js',
-    'src/ngSanitize/sanitize.js',
-    'src/ngSanitize/directive/ngBindHtml.js',
-    'src/ngSanitize/filter/linky.js',
-    'src/ngMock/angular-mocks.js',
-    'src/ngMobile/mobile.js',
-    'src/ngMobile/directive/ngClick.js',
-    'src/ngMobile/directive/ngSwipe.js',
-
-    'docs/components/bootstrap/bootstrap.js'
+  'angularLoader': [
+    'src/minErr.js',
+    'src/loader.js'
   ],
 
+  'angularModules': {
+    'ngAnimate': [
+      'src/ngAnimate/animate.js'
+    ],
+    'ngCookies': [
+      'src/ngCookies/cookies.js'
+    ],
+    'ngResource': [
+      'src/ngResource/resource.js'
+    ],
+    'ngRoute': [
+      'src/ngRoute/route.js',
+      'src/ngRoute/routeParams.js',
+      'src/ngRoute/directive/ngView.js'
+    ],
+    'ngSanitize': [
+      'src/ngSanitize/sanitize.js',
+      'src/ngSanitize/filter/linky.js'
+    ],
+    'ngMock': [
+      'src/ngMock/angular-mocks.js'
+    ],
+    'ngTouch': [
+      'src/ngTouch/touch.js',
+      'src/ngTouch/swipe.js',
+      'src/ngTouch/directive/ngClick.js',
+      'src/ngTouch/directive/ngSwipe.js'
+    ],
+  },
+
   'angularScenario': [
     'src/ngScenario/Scenario.js',
     'src/ngScenario/browserTrigger.js',
@@ -97,143 +123,99 @@ angularFiles = {
   ],
 
   'angularTest': [
-    'test/testabilityPatch.js',
-    'test/matchers.js',
+    'test/helpers/*.js',
     'test/ngScenario/*.js',
     'test/ngScenario/output/*.js',
-    'test/ngScenario/jstd-scenario-adapter/*.js',
     'test/*.js',
     'test/auto/*.js',
-    'test/ng/*.js',
-    'test/ng/directive/*.js',
-    'test/ng/filter/*.js',
+    'test/ng/**/*.js',
+    'test/ngAnimate/*.js',
     'test/ngCookies/*.js',
     'test/ngResource/*.js',
-    'test/ngSanitize/*.js',
-    'test/ngSanitize/directive/*.js',
-    'test/ngSanitize/filter/*.js',
+    'test/ngRoute/**/*.js',
+    'test/ngSanitize/**/*.js',
     'test/ngMock/*.js',
-    'test/ngMobile/directive/*.js',
-    'docs/component-spec/bootstrap/*.js',
-    'docs/component-spec/*.js'
+    'test/ngTouch/**/*.js'
   ],
 
-  'jstd': [
-    'lib/jasmine/jasmine.js',
-    'lib/jasmine-jstd-adapter/JasmineAdapter.js',
-    'lib/jquery/jquery.js',
+  'karma': [
+    'bower_components/jquery/jquery.js',
     'test/jquery_remove.js',
     '@angularSrc',
     'src/publishExternalApis.js',
     '@angularSrcModules',
     '@angularScenario',
-    'src/ngScenario/jstd-scenario-adapter/Adapter.js',
     '@angularTest',
-    'example/personalLog/*.js',
-    'example/personalLog/test/*.js'
   ],
 
-  'jstdExclude': [
+  'karmaExclude': [
     'test/jquery_alias.js',
     'src/angular-bootstrap.js',
     'src/ngScenario/angular-bootstrap.js'
   ],
 
-  'jstdScenario': [
+  'karmaScenario': [
     'build/angular-scenario.js',
-    'build/jstd-scenario-adapter-config.js',
-    'build/jstd-scenario-adapter.js',
     'build/docs/docs-scenario.js'
   ],
 
-  "jstdModules": [
-    'lib/jasmine/jasmine.js',
-    'lib/jasmine-jstd-adapter/JasmineAdapter.js',
+  "karmaModules": [
     'build/angular.js',
-    'src/ngMock/angular-mocks.js',
-    'src/ngCookies/cookies.js',
-    'src/ngResource/resource.js',
-    'src/ngMobile/mobile.js',
-    'src/ngMobile/directive/ngClick.js',
-    'src/ngMobile/directive/ngSwipe.js',
-    'src/ngSanitize/sanitize.js',
-    'src/ngSanitize/directive/ngBindHtml.js',
-    'src/ngSanitize/filter/linky.js',
+    '@angularSrcModules',
     'src/ngScenario/browserTrigger.js',
-    'test/matchers.js',
-    'test/testabilityPatch.js',
+    'test/helpers/*.js',
     'test/ngMock/*.js',
     'test/ngCookies/*.js',
+    'test/ngRoute/**/*.js',
     'test/ngResource/*.js',
-    'test/ngSanitize/*.js',
-    'test/ngSanitize/directive/*.js',
-    'test/ngSanitize/filter/*.js',
-    'test/ngMobile/directive/*.js'
+    'test/ngSanitize/**/*.js',
+    'test/ngTouch/**/*.js'
   ],
 
-  'jstdPerf': [
-   'lib/jasmine/jasmine.js',
-   'lib/jasmine-jstd-adapter/JasmineAdapter.js',
-   '@angularSrc',
-   '@angularSrcModules',
-   'src/ngMock/angular-mocks.js',
-   'perf/data/*.js',
-   'perf/testUtils.js',
-   'perf/*.js'
-  ],
-
-  'jstdPerfExclude': [
-    'src/ng/angular-bootstrap.js',
-    'src/ngScenario/angular-bootstrap.js'
-  ],
-
-  'jstdJquery': [
-    'lib/jasmine/jasmine.js',
-    'lib/jasmine-jstd-adapter/JasmineAdapter.js',
-    'lib/jquery/jquery.js',
+  'karmaJquery': [
+    'bower_components/jquery/jquery.js',
     'test/jquery_alias.js',
     '@angularSrc',
     'src/publishExternalApis.js',
     '@angularSrcModules',
     '@angularScenario',
-    'src/ngScenario/jstd-scenario-adapter/Adapter.js',
     '@angularTest',
-    'example/personalLog/*.js',
-
-    'example/personalLog/test/*.js'
   ],
 
-  'jstdJqueryExclude': [
+  'karmaJqueryExclude': [
     'src/angular-bootstrap.js',
     'src/ngScenario/angular-bootstrap.js',
     'test/jquery_remove.js'
   ]
 };
 
+angularFiles['angularSrcModules'] = [].concat(
+  angularFiles['angularModules']['ngAnimate'],
+  angularFiles['angularModules']['ngCookies'],
+  angularFiles['angularModules']['ngResource'],
+  angularFiles['angularModules']['ngRoute'],
+  angularFiles['angularModules']['ngSanitize'],
+  angularFiles['angularModules']['ngMock'],
+  angularFiles['angularModules']['ngTouch']
+);
+
 if (exports) {
-  exports.files = angularFiles
-  exports.mergeFiles = function mergeFiles() {
+  exports.files = angularFiles;
+  exports.mergeFilesFor = function() {
     var files = [];
 
-    [].splice.call(arguments, 0).forEach(function(file) {
-      if (file.match(/karma/)) {
-        files.push(file);
-      } else {
-        angularFiles[file].forEach(function(f) {
-          // replace @ref
-          var match = f.match(/^\@(.*)/);
-          if (match) {
-            var deps = angularFiles[match[1]];
-            files = files.concat(deps);
-          } else {
-            if (!/jstd|jasmine/.test(f)) { //TODO(i): remove once we don't have jstd/jasmine in repo
-              files.push(f);
-            }
-          }
-        });
-      }
+    Array.prototype.slice.call(arguments, 0).forEach(function(filegroup) {
+      angularFiles[filegroup].forEach(function(file) {
+        // replace @ref
+        var match = file.match(/^\@(.*)/);
+        if (match) {
+          files = files.concat(angularFiles[match[1]]);
+        } else {
+          files.push(file);
+        }
+      });
     });
 
     return files;
-  }
+  };
 }

bower.json

@@ -0,0 +1,12 @@
+{
+  "name": "AngularJS",
+  "devDependencies": {
+    "jquery": "1.10.2",
+    "lunr.js": "0.4.3",
+    "open-sans-fontface": "1.0.4",
+    "google-code-prettify": "1.0.1",
+    "closure-compiler": "https://closure-compiler.googlecode.com/files/compiler-20130603.zip",
+    "ng-closure-runner": "https://raw.github.com/angular/ng-closure-runner/v0.2.3/assets/ng-closure-runner.zip",
+    "bootstrap": "3.1.1"
+  }
+}

changelog.js

@@ -3,6 +3,8 @@
 // TODO(vojta): pre-commit hook for validating messages
 // TODO(vojta): report errors, currently Q silence everything which really sucks
 
+'use strict';
+
 var child = require('child_process');
 var fs = require('fs');
 var util = require('util');
@@ -16,7 +18,6 @@ var LINK_ISSUE = '[#%s](https://github.com/angular/angular.js/issues/%s)';
 var LINK_COMMIT = '[%s](https://github.com/angular/angular.js/commit/%s)';
 
 var EMPTY_COMPONENT = '$$';
-var MAX_SUBJECT_LENGTH = 80;
 
 
 var warn = function() {
@@ -54,11 +55,6 @@ var parseRawCommit = function(raw) {
     return null;
   }
 
-  if (match[3].length > MAX_SUBJECT_LENGTH) {
-    warn('Too long subject: %s %s', msg.hash, msg.subject);
-    match[3] = match[3].substr(0, MAX_SUBJECT_LENGTH);
-  }
-
   msg.type = match[1];
   msg.component = match[2];
   msg.subject = match[3];
@@ -148,6 +144,7 @@ var writeChangelog = function(stream, commits, version) {
   var sections = {
     fix: {},
     feat: {},
+    perf: {},
     breaks: {}
   };
 
@@ -169,14 +166,15 @@ var writeChangelog = function(stream, commits, version) {
         hash: commit.hash,
         closes: []
       });
-    };
+    }
   });
 
   stream.write(util.format(HEADER_TPL, version, version, currentDate()));
   printSection(stream, 'Bug Fixes', sections.fix);
   printSection(stream, 'Features', sections.feat);
+  printSection(stream, 'Performance Improvements', sections.perf);
   printSection(stream, 'Breaking Changes', sections.breaks, false);
-}
+};
 
 
 var getPreviousTag = function() {
@@ -192,7 +190,7 @@ var getPreviousTag = function() {
 var generate = function(version, file) {
   getPreviousTag().then(function(tag) {
     console.log('Reading git log since', tag);
-    readGitLog('^fix|^feat|Breaks', tag).then(function(commits) {
+    readGitLog('^fix|^feat|^perf|BREAKING', tag).then(function(commits) {
       console.log('Parsed', commits.length, 'commits');
       console.log('Generating changelog to', file || 'stdout', '(', version, ')');
       writeChangelog(file ? fs.createWriteStream(file) : process.stdout, commits, version);

changelog.spec.js

@@ -1,3 +1,7 @@
+/* global describe: false, it: false, expect: false */
+
+'use strict';
+
 describe('changelog.js', function() {
   var ch = require('./changelog');
 
@@ -13,7 +17,7 @@ describe('changelog.js', function() {
       expect(msg.hash).toBe('9b1aff905b638aa274a5fc8f88662df446d374bd');
       expect(msg.subject).toBe('broadcast $destroy event on scope destruction');
       expect(msg.body).toBe('perf testing shows that in chrome this change adds 5-15% overhead\n' +
-          'when destroying 10k nested scopes where each scope has a $destroy listener\n')
+          'when destroying 10k nested scopes where each scope has a $destroy listener\n');
       expect(msg.component).toBe('scope');
     });
 

changelog.tmp.md

@@ -1,80 +0,0 @@
-<a name="v1.0.0rc3"></a>
-# v1.0.0rc3 (2012-03-27)
-
-
-## Bug Fixes
-
-- **$compile:**
-  - create new (isolate) scopes for directives on root elements ([5390fb37](https://github.com/angular/angular.js/commit/5390fb37d2c01937922613fc57df4986af521787), closes [#817](https://github.com/angular/angular.js/issues/817))
-  - don't touch static element attributes ([9cb2195e](https://github.com/angular/angular.js/commit/9cb2195e61a78e99020ec19d687a221ca88b5900))
-  - Merge interpolated css class when replacing an element ([f49eaf8b](https://github.com/angular/angular.js/commit/f49eaf8bf2df5f4e0e82d6c89e849a4f82c8d414))
-- **$http:**
-  - don't send Content-Type header when no data ([1a5bebd9](https://github.com/angular/angular.js/commit/1a5bebd927ecd22f9c34617642fdf58fe3f62efb), closes [#749](https://github.com/angular/angular.js/issues/749))
-- **$log:**
-  - avoid console.log.apply calls in IE ([15213ec2](https://github.com/angular/angular.js/commit/15213ec212769837cb2b7e781ffc5bfd598d27ca), closes [#805](https://github.com/angular/angular.js/issues/805))
-- **$resource:**
-  - support escaping of ':' in resource url ([6d6f8753](https://github.com/angular/angular.js/commit/6d6f875345e01f2c6c63ef95164f6f39e923da15))
-- **compiler:**
-  - allow transclusion of root elements ([9918b748](https://github.com/angular/angular.js/commit/9918b748be01266eb10db39d51b4d3098d54ab66))
-- **e2e runner:**
-  - fix typo that caused errors on IE8 ([ee5a5352](https://github.com/angular/angular.js/commit/ee5a5352fd4b94cedee6ef20d4bf2d43ce77e00b), closes [#806](https://github.com/angular/angular.js/issues/806))
-- **forEach:**
-  - should ignore prototypically inherited properties ([8d7e6948](https://github.com/angular/angular.js/commit/8d7e6948496ff26ef1da8854ba02fcb8eebfed61), closes [#813](https://github.com/angular/angular.js/issues/813))
-- **forms:**
-  - Remove double registering of form ([1faafa31](https://github.com/angular/angular.js/commit/1faafa31582c4e9413f48dc7d12f5b681f9fe9fd))
-  - Set ng-valid/ng-invalid correctly ([08bfea18](https://github.com/angular/angular.js/commit/08bfea183a850b29da270eac47f80b598cbe600f))
-- **init:**
-  - use jQuery#ready for init if available ([cb2ad9ab](https://github.com/angular/angular.js/commit/cb2ad9abf24e6f855cc749efe3155bd7987ece9d), closes [#818](https://github.com/angular/angular.js/issues/818))
-- **json:**
-  - added support for iso8061 timezone ([5ac14f63](https://github.com/angular/angular.js/commit/5ac14f633a69f49973b5512780c6ec7752405967))
-- **matchers.toHaveClass:**
-  - Correct reference to angular.mock.dump ([f701ce08](https://github.com/angular/angular.js/commit/f701ce08f9d63be05fc3b92f57ad473e1e749b2d))
-- **ng-switch:**
-  - properly destroy child scopes ([2315d9b3](https://github.com/angular/angular.js/commit/2315d9b3610994b36c44e4a97fb1427d59471ce8))
-- **ngDocSpec:**
-  - fix broken tests ([53b6f522](https://github.com/angular/angular.js/commit/53b6f522a56eea314cbd084816e08f24b2c7879f))
-- **ngForm:**
-  - alias name||ngForm ([823adb23](https://github.com/angular/angular.js/commit/823adb231995e917bc060bfa49453e2a96bac2b6))
-- **ngRepeat:**
-  - correct variable reference in error message ([935c1018](https://github.com/angular/angular.js/commit/935c1018da05dbf3124b2dd33619c4a3c82d7a2a))
-- **ngView:**
-  - controller not published ([21e74c2d](https://github.com/angular/angular.js/commit/21e74c2d2e8e985b23711785287feb59965cbd90))
-- **q:**
-  - resolve all of nothing to nothing ([ac75079e](https://github.com/angular/angular.js/commit/ac75079e2113949d5d64adbcf23d56f3cf295d41))
-- **select:**
-  - multiselect failes to update view on selection insert ([6ecac8e7](https://github.com/angular/angular.js/commit/6ecac8e71a84792a434d21db2c245b3648c55f18))
-
-
-## Features
-
-- **$compile:**
-  - do not interpolate boolean attributes, rather evaluate them ([a08cbc02](https://github.com/angular/angular.js/commit/a08cbc02e78e789a66e9af771c410e8ad1646e25))
-- **$controller:**
-  - support controller registration via $controllerProvider ([d54dfecb](https://github.com/angular/angular.js/commit/d54dfecb00fba41455536c5ddd55310592fdaf84))
-- **$route:**
-  - when matching consider trailing slash as optional ([a4fe51da](https://github.com/angular/angular.js/commit/a4fe51da3ba0dc297ecd389e230d6664f250c9a6), closes [#784](https://github.com/angular/angular.js/issues/784))
-- **assertArgFn:**
-  - should support array annotated fns ([4b8d9260](https://github.com/angular/angular.js/commit/4b8d926062eb4d4483555bdbdec4656f585ab40b))
-- **http:**
-  - added params parameter ([73c85930](https://github.com/angular/angular.js/commit/73c8593077155a9f2e8ef42efd4c497eba0bef4f))
-- **injector:**
-  - infer _foo_ as foo ([f13dd339](https://github.com/angular/angular.js/commit/f13dd3393dfb7a33565c9360342c193bc0bddcb6))
-- **input.radio:**
-  - Allow value attribute to be interpolated ([ade6c452](https://github.com/angular/angular.js/commit/ade6c452753145c84884d17027a7865bf4b34b0c))
-- **jqLite:**
-  - make injector() and scope() work with the document object ([5fdab52d](https://github.com/angular/angular.js/commit/5fdab52dd7c269f99839f4fa6b5854d9548269fa))
-  - add .controller() method ([6c5a05ad](https://github.com/angular/angular.js/commit/6c5a05ad49a1e083570c3dfe331403398f899dbe))
-- **ngValue:**
-  - allow radio inputs to have non string values ([09e175f0](https://github.com/angular/angular.js/commit/09e175f02cca0f4a295fd0c9b980cd8f432e722b), closes [#816](https://github.com/angular/angular.js/issues/816))
-- **scope:**
-  - broadcast $destroy event on scope destruction ([9b1aff90](https://github.com/angular/angular.js/commit/9b1aff905b638aa274a5fc8f88662df446d374bd))
-- **scope.$eval:**
-  - Allow passing locals to the expression ([192ff61f](https://github.com/angular/angular.js/commit/192ff61f5d61899e667c6dbce4d3e6e399429d8b))
-
-
-## Breaking Changes
-
-- boolean attrs are evaluated rather than interpolated ([a08cbc02](https://github.com/angular/angular.js/commit/a08cbc02e78e789a66e9af771c410e8ad1646e25))
-- ng-bind-attr directive removed ([55027132](https://github.com/angular/angular.js/commit/55027132f3d57e5dcf94683e6e6bd7b0aae0087d))
-- any app that depends on this service and its fallback to Modernizr, please ([aaedefb9](https://github.com/angular/angular.js/commit/aaedefb92e6bec6626e173e5155072c91471596a))
-

compare-master-to-stable.js

@@ -0,0 +1,165 @@
+#!/usr/local/bin/node
+
+'use strict';
+
+var util = require('util');
+var cp = require('child_process');
+
+var Q = require('q');
+var _ = require('lodash');
+var semver = require('semver');
+
+var exec = function (cmd) {
+  return function () {
+    var args = Array.prototype.slice.call(arguments, 0);
+    args.unshift(cmd);
+    var fullCmd = util.format.apply(util, args);
+    return Q.nfcall(cp.exec, fullCmd).then(function (out) {
+      return out[0].split('\n');
+    });
+  };
+};
+
+var andThen = function (fn, after) {
+  return function () {
+    return fn.apply(this, arguments).then(after);
+  };
+};
+
+var oneArg = function (fn) {
+  return function (arg) {
+    return fn(arg);
+  };
+};
+
+var oneLine = function (lines) {
+  return lines[0].trim();
+};
+
+var noArgs = function (fn) {
+  return function () {
+    return fn();
+  };
+};
+
+var identity = function (i) { return i; };
+
+// like Q.all, but runs the comands in series
+// useful for ensuring env state (like which branch is checked out)
+var allInSeries = function (fn) {
+  return function (args) {
+    var results = [];
+    var def;
+    while (args.length > 0) {
+      (function (arg) {
+        if (def) {
+          def = def.then(function () {
+            return fn(arg);
+          });
+        } else {
+          def = fn(arg);
+        }
+        def = def.then(function (res) {
+          results.push(res);
+        });
+      }(args.pop()));
+    }
+    return def.then(function () {
+      return results;
+    });
+  };
+};
+
+var compareBranches = function (left, right) {
+  console.log('# These commits are in ' + left.name + ' but not in ' + right.name + '\n');
+  console.log(_(left.log).
+    difference(right.log).
+    map(function (line) {
+      return left.full[left.log.indexOf(line)]; // lol O(n^2)
+    }).
+    value().
+    join('\n'));
+};
+
+var checkout = oneArg(exec('git checkout %s'));
+
+var getCurrentBranch = andThen(noArgs(exec('git rev-parse --abbrev-ref HEAD')), oneLine);
+var getTags = noArgs(exec('git tag'));
+var getShaOfTag = oneArg(exec('git rev-list %s | head -n 1'));
+var getTheLog = oneArg(exec('git log --pretty=oneline %s..HEAD | cat'));
+
+// remember this so we can restore state
+var currentBranch;
+
+getCurrentBranch().
+then(function (branch) {
+  currentBranch = branch;
+}).
+then(getTags).
+then(function (tags) {
+  return tags.
+    filter(semver.valid).
+    map(semver.clean).
+    sort(semver.rcompare);
+}).
+then(function (tags) {
+  var major = tags[0].split('.')[0] + '.x';
+  return tags.
+    filter(function (ver) {
+      return semver.satisfies(ver, major);
+    });
+}).
+then(function (tags) {
+  return _(tags).
+    groupBy(function (tag) {
+      return tag.split('.')[1];
+    }).
+    map(function (group) {
+      return _.first(group);
+    }).
+    map(function (tag) {
+      return 'v' + tag;
+    }).
+    value();
+}).
+then(function (tags) {
+  return [
+    { name: 'v1.0.x', tag: tags[0] },
+    { name: 'master', tag: tags[1] }
+  ];
+}).
+then(allInSeries(function (branch) {
+  return checkout(branch.name).
+    then(function () {
+      return getTheLog(branch.tag);
+    }).
+    then(function (log) {
+      return log.
+        filter(identity);
+    }).
+    then(function (log) {
+      branch.full = log.map(function (line) {
+        line = line.split(' ');
+        var sha = line.shift();
+        var msg = line.join(' ');
+        return sha + (msg.toLowerCase().indexOf('fix') === -1 ? '   ' : ' * ') + msg;
+      });
+      branch.log = log.map(function (line) {
+        return line.substr(41);
+      });
+      return branch;
+    });
+})).
+then(function (pairs) {
+  compareBranches(pairs[0], pairs[1]);
+  console.log('\n');
+  compareBranches(pairs[1], pairs[0]);
+  return pairs;
+}).
+then(function () {
+  return checkout(currentBranch);
+}).
+catch(function (e) {
+  console.log(e.stack);
+});
+

css/angular.css

@@ -1,10 +1,22 @@
 @charset "UTF-8";
 
 [ng\:cloak], [ng-cloak], [data-ng-cloak], [x-ng-cloak],
-.ng-cloak, .x-ng-cloak {
-  display: none;
+.ng-cloak, .x-ng-cloak,
+.ng-hide {
+  display: none !important;
 }
 
 ng\:form {
   display: block;
 }
+
+.ng-animate-block-transitions {
+  transition:0s all!important;
+  -webkit-transition:0s all!important;
+}
+
+/* show the element during a show/hide animation when the
+ * animation is ongoing, but the .ng-hide class is active */
+.ng-hide-add-active, .ng-hide-remove {
+  display: block!important;
+}

docs/app/assets/Error404.html

@@ -0,0 +1,11 @@
+<h1>Oops!</h1>
+
+<p>The page you requested does not exist. Perhaps you were looking for something else...</p>
+
+<div ng-controller="Error404SearchCtrl">
+
+  <dl ng-repeat="(key, value) in results" ng-show="value.length" style="float: left; margin-right:20px">
+    <dt>{{ key }}</dt>
+    <dd ng-repeat="item in value"><a ng-href="{{ item.path }}">{{ item.name }}</a></dd>
+  </dl>
+</div>

docs/app/assets/css/doc_widgets.css

@@ -15,7 +15,7 @@ ul.doc-example > li {
 
 ul.doc-example > li.doc-example-heading {
   border: none;
-  border-radius: none;
+  border-radius: 0;
   margin-bottom: -10px;
 }
 

docs/app/assets/css/docs.css

@@ -0,0 +1,690 @@
+html, body {
+  position:relative;
+  height:100%;
+}
+
+#wrapper {
+  min-height:100%;
+  position:relative;
+  padding-bottom:120px;
+}
+
+.footer {
+  border-top:20px solid white;
+  position:absolute;
+  bottom:0;
+  left:0;
+  right:0;
+  z-index:100;
+  padding-top: 2em;
+  background-color: #333;
+  color: white;
+  padding-bottom: 2em;
+}
+
+.header-fixed {
+  position:fixed;
+  z-index:1000;
+  top:0;
+  left:0;
+  right:0;
+}
+
+.header-branding {
+  min-height:41px!important;
+}
+
+.docs-navbar-primary {
+  border-radius:0!important;
+  margin-bottom:0!important;
+}
+
+/* Logo */
+/*.dropdown-menu {
+  display:none;
+}
+*/
+h1,h2,h3,h4,h5,h6 {
+  font-family: "Open Sans";
+}
+
+.subnav-body {
+  margin:70px 0 20px;
+}
+
+.header .brand {
+  padding-top: 6px;
+  padding-bottom: 0px;
+}
+
+.header .brand img {
+  margin-top:5px;
+  height: 30px;
+}
+
+.docs-search {
+  margin:10px 0;
+  padding:4px 0 4px 20px;
+  background:white;
+  border-radius:20px;
+  vertical-align:middle;
+}
+
+.docs-search > .search-query {
+  font-size:14px;
+  border:0;
+  width:80%;
+  color:#555;
+}
+
+.docs-search > .search-icon {
+  font-size:15px;
+  margin-right:10px;
+}
+
+.docs-search > .search-query:focus {
+  outline:0;
+}
+
+/* end: Logo */
+
+
+.spacer {
+  height: 1em;
+}
+
+
+.icon-cog {
+  line-height: 13px;
+}
+
+.naked-list,
+.naked-list ul,
+.naked-list li {
+  list-style:none;
+  margin:0;
+  padding:0;
+}
+
+.nav-index-section a {
+  font-weight:bold;
+  font-family: "Open Sans";
+  color:black!important;
+  margin-top:10px;
+  display:block;
+}
+
+.nav-index-group {
+  margin-bottom:20px!important;
+}
+
+.nav-index-group-heading {
+  color:#6F0101;
+  font-weight:bold;
+  font-size:1.2em;
+  padding:0;
+  margin:0;
+  border-bottom:1px soild #aaa;
+  margin-bottom:5px;
+}
+
+.nav-breadcrumb {
+  margin:4px 0;
+  padding:0;
+}
+
+.nav-breadcrumb-entry {
+  font-family: "Open Sans";
+  padding:0;
+  margin:0;
+  font-size:18px;
+  display:inline-block;
+  vertical-align:middle;
+}
+
+.nav-breadcrumb-entry > .divider {
+  color:#555;
+  display:inline-block;
+  padding-left:8px;
+}
+
+.nav-breadcrumb-entry > span,
+.nav-breadcrumb-entry > a {
+  color:#6F0101;
+}
+
+.step-list > li:nth-child(1) {
+  padding-left:20px;
+}
+
+.step-list > li:nth-child(2) {
+  padding-left:40px;
+}
+
+.step-list > li:nth-child(3) {
+  padding-left:60px;
+}
+
+.api-profile-header-heading {
+  margin:0;
+  padding:0;
+}
+
+.api-profile-header-structure,
+.api-profile-header-structure a {
+  font-family: "Open Sans";
+  font-weight:bold;
+  color:#999;
+}
+
+.api-profile-section {
+  margin-top:30px;
+  padding-top:30px;
+  border-top:1px solid #aaa;
+}
+
+pre {
+  white-space: pre-wrap;
+  word-break: normal;
+}
+
+.aside-nav a,
+.aside-nav a:link,
+.aside-nav a:visited,
+.aside-nav a:active {
+  color:#999;
+}
+.aside-nav a:hover {
+  color:black;
+}
+
+.api-profile-description > p:first-child {
+  margin:15px 0;
+  font-size:18px;
+}
+
+p > code,
+code.highlighted {
+  background:#f4f4f4;
+  border-radius:5px;
+  padding:2px 5px;
+  color:maroon;
+}
+
+ul + p {
+  margin-top: 10px;
+}
+
+.docs-version-jump {
+  min-width:100%;
+  max-width:100%;
+}
+
+.picker {
+  position: relative;
+  width: auto;
+  display: inline-block;
+  margin: 0 0 2px 1.2%;
+  overflow: hidden;
+  border: 1px solid #e5e5e5;
+  -webkit-border-radius: 4px;
+  -moz-border-radius: 4px;
+  -ms-border-radius: 4px;
+  -o-border-radius: 4px;
+  border-radius: 4px;
+  font-family: "Open Sans";
+  font-weight: 600;
+  height: auto;
+  background-image: -webkit-gradient(linear, 50% 0%, 50% 100%, color-stop(0%, #ffffff), color-stop(100%, #f2f2f2));
+  background-image: -webkit-linear-gradient(#ffffff, #f2f2f2);
+  background-image: -moz-linear-gradient(#ffffff, #f2f2f2);
+  background-image: -o-linear-gradient(#ffffff, #f2f2f2);
+  background-image: linear-gradient(#ffffff, #f2f2f2);
+}
+
+.picker select {
+  position: relative;
+  display: block;
+  min-width: 100%;
+  width: 120%;
+  height: 34px;
+  padding: 6px 30px 6px 15px;
+  color: #555555;
+  border: none;
+  background: transparent;
+  outline: none;
+  -webkit-appearance: none;
+  z-index: 99;
+  cursor: pointer;
+  font-size: 16px;
+  -moz-appearance: none;
+  text-indent: 0.01px;
+  text-overflow: '';
+}
+
+.picker:after {
+  content:"";
+  position: absolute;
+  right: 8%;
+  top: 50%;
+  z-index: 0;
+  color: #999;
+  width: 0;
+  margin-top:-2px;
+  height: 0;
+  border-top: 6px solid;
+  border-right: 6px solid transparent;
+  border-left: 6px solid transparent;
+}
+
+iframe.example {
+  width: 100%;
+  border: 1px solid black;
+}
+
+.search-results-frame {
+  clear:both;
+  display:table;
+  width:100%;
+}
+
+.search-results.ng-hide {
+  display:none;
+}
+
+.search-results-container {
+  padding-bottom:1em;
+  border-top:1px solid #111;
+  background:#181818;
+  box-shadow:inset 0 0 10px #111;
+}
+
+.search-results-container .search-results-group {
+  vertical-align:top;
+  padding:10px 10px;
+  display:inline-block;
+}
+
+.search-results-group-heading {
+  font-family: "Open Sans";
+  padding-left:10px;
+  color:white;
+}
+
+.search-results-frame > .search-results-group:first-child > .search-results {
+  border-right:1px solid #050505;
+}
+
+.search-results-group.col-group-api { width:30%; }
+.search-results-group.col-group-guide { width:30%; }
+.search-results-group.col-group-tutorial { width:25%; }
+.search-results-group.col-group-misc,
+.search-results-group.col-group-error { float:right; clear:both; width:15% }
+
+
+.search-results-group.col-group-api .search-result {
+  width:48%;
+  display:inline-block;
+}
+
+.search-close {
+  position: absolute;
+  bottom: 0;
+  left: 50%;
+  margin-left: -100px;
+  color: white;
+  text-align: center;
+  padding: 5px;
+  background: #333;
+  border-top-right-radius: 5px;
+  border-top-left-radius: 5px;
+  width: 200px;
+  box-shadow:0 0 10px #111;
+}
+
+.variables-matrix {
+  border:1px solid #ddd;
+  width:100%;
+  margin:10px 0;
+}
+
+.variables-matrix td,
+.variables-matrix th {
+  padding:10px;
+}
+
+.variables-matrix td {
+  border-top:1px solid #eee;
+}
+
+.variables-matrix td + td,
+.variables-matrix th + th {
+  border-left:1px solid #eee;
+}
+
+.variables-matrix tr:nth-child(even) td {
+  background:#f5f5f5;
+}
+
+.variables-matrix th {
+  background:#f1f1f1;
+}
+
+.sup-header {
+  padding-top:10px;
+  padding-bottom:5px;
+  background:rgba(245,245,245,0.88);
+  box-shadow:0 0 2px #999;
+}
+
+.main-body-grid {
+  margin-top:120px;
+  position:relative;
+}
+
+.main-body-grid > .grid-left,
+.main-body-grid > .grid-right {
+  padding:20px 0;
+}
+
+.main-body-grid > .grid-left {
+  position:fixed;
+  top:120px;
+  bottom:0;
+  padding-bottom:120px;
+  overflow:auto;
+}
+
+.main-header-grid > .grid-left,
+.main-body-grid > .grid-left {
+  width:260px;
+}
+
+.main-header-grid > .grid-right,
+.main-body-grid > .grid-right {
+  margin-left:270px;
+  position:relative;
+}
+
+.main-header-grid > .grid-left {
+  float:left;
+}
+
+.main-body-grid .side-navigation {
+  position:relative;
+}
+
+.main-body-grid .side-navigation.ng-hide {
+  display:block!important;
+}
+
+.variables-matrix td {
+  vertical-align:top;
+  padding:5px;
+}
+
+.type-hint {
+  display:inline-block;
+  background: gray;
+}
+
+.variables-matrix .type-hint {
+  text-align:center;
+  min-width:60px;
+  margin:1px 5px;
+}
+
+.type-hint + .type-hint {
+  margin-top:5px;
+}
+
+.type-hint-expression {
+  background:purple;
+}
+
+.type-hint-date {
+  background:pink;
+}
+
+.type-hint-string {
+  background:#3a87ad;
+}
+
+.type-hint-function {
+  background:green;
+}
+
+.type-hint-object {
+  background:#999;
+}
+
+.type-hint-array {
+  background:#F90;;
+}
+
+.type-hint-boolean {
+  background:rgb(18, 131, 39);
+}
+
+.type-hint-number {
+  background:rgb(189, 63, 66);
+}
+
+.type-hint-regexp {
+  background: rgb(90, 84, 189);
+}
+
+.type-hint-domelement {
+  background: rgb(95, 158, 160);
+}
+
+.runnable-example-frame {
+  width:100%;
+  height:300px;
+  border: 1px solid #ddd;
+  border-radius:5px;
+}
+
+.runnable-example-tabs {
+  margin-top:10px;
+  margin-bottom:20px;
+}
+
+.tutorial-nav {
+  display:block;
+}
+
+h1 + ul, h1 + ul > li,
+h2 + ul, h2 + ul > li,
+ul.tutorial-nav, ul.tutorial-nav > li,
+.usage > ul, .usage > ul > li,
+ul.methods, ul.methods > li,
+ul.events, ul.events > li {
+  list-style:none;
+  padding:0;
+}
+
+h2 {
+  border-top:1px solid #eee;
+  margin-top:30px;
+  padding-top:30px;
+}
+
+h4 {
+  margin-top:20px;
+  padding-top:20px;
+}
+
+.btn {
+  color:#428bca;
+  position: relative;
+  width: auto;
+  display: inline-block;
+  margin: 0 0 2px;
+  overflow: hidden;
+  border: 1px solid #e5e5e5;
+  -webkit-border-radius: 4px;
+  -moz-border-radius: 4px;
+  -ms-border-radius: 4px;
+  -o-border-radius: 4px;
+  border-radius: 4px;
+  font-family: "Open Sans";
+  font-weight: 600;
+  height: auto;
+  background-image: -webkit-gradient(linear, 50% 0%, 50% 100%, color-stop(0%, #ffffff), color-stop(100%, #f2f2f2));
+  background-image: -webkit-linear-gradient(#ffffff, #f2f2f2);
+  background-image: -moz-linear-gradient(#ffffff, #f2f2f2);
+  background-image: -o-linear-gradient(#ffffff, #f2f2f2);
+  background-image: linear-gradient(#ffffff, #f2f2f2);
+}
+
+.btn + .btn {
+  margin-left:10px;
+}
+
+.btn:hover {
+  color:black!important;
+  border: 1px solid #ddd!important;
+  background:white!important;
+}
+
+.view-source, .improve-docs {
+  position:relative;
+  z-index:100;
+}
+
+.view-source {
+  margin-right:10px;
+}
+
+.improve-docs {
+  float:right;
+}
+
+.return-arguments,
+.return-arguments th,
+.return-arguments th + th,
+.return-arguments td,
+.return-arguments td + td {
+  border-radius:0;
+  border:0;
+}
+
+.return-arguments td:first-child {
+  width:100px;
+}
+
+ul.methods > li,
+ul.events > li {
+  margin-bottom:40px;
+}
+
+@media only screen and (min-width: 769px) and (max-width: 991px) {
+  .main-body-grid {
+    margin-top: 160px;
+  }
+  .main-body-grid > .grid-left {
+    top: 160px;
+  }
+}
+
+@media only screen and (max-width : 768px) {
+  .picker, .picker select {
+    width:auto;
+    display:block;
+    margin-bottom:10px;
+  }
+  .docs-navbar-primary {
+    text-align:center;
+  }
+  .main-body-grid {
+    margin-top:0;
+  }
+  .main-header-grid > .grid-left,
+  .main-body-grid > .grid-left,
+  .main-header-grid > .grid-right,
+  .main-body-grid > .grid-right {
+    display:block;
+    float:none;
+    width:auto!important;
+    margin-left:0;
+  }
+  .main-body-grid > .grid-left,
+  .header-fixed, .footer {
+    position:static!important;
+  }
+  .main-body-grid > .grid-left {
+    background:#efefef;
+    margin-left:-1em;
+    margin-right:-1em;
+    padding:1em;
+    width:auto!important;
+    overflow:visible;
+  }
+  .main-header-grid > .grid-right,
+  .main-body-grid > .grid-right {
+    margin-left:0;
+  }
+  .main-body-grid .side-navigation {
+    display:block!important;
+  }
+  .main-body-grid .side-navigation.ng-hide {
+    display:none!important;
+  }
+  .nav-index-group .nav-index-listing {
+    display:inline-block;
+    padding:3px 0;
+  }
+  .nav-index-group .nav-index-listing:not(.nav-index-section) + .nav-index-listing:not(.nav-index-section):after {
+      padding-right:5px;
+      content:",  ";
+  }
+  .nav-index-group .nav-index-listing:last-child {
+    content:"";
+  }
+  .nav-index-group .nav-index-section {
+    display:block;
+  }
+  .toc-toggle {
+    margin-bottom:20px;
+  }
+  .toc-close {
+    position: absolute;
+    bottom: -50px;
+    left: 50%;
+    margin-left: -50%;
+    text-align: center;
+    padding: 5px;
+    background: #eee;
+    border-radius: 5px;
+    width: 90%;
+    border:1px solid #ddd;
+    box-shadow:0 0 10px #bbb;
+  }
+  .navbar-brand {
+    float:none;
+    text-align:center;
+  }
+  .search-results-container {
+    padding-bottom:60px;
+    text-align:left;
+  }
+  .search-results-group {
+    float:none!important;
+    display:block!important;
+    width:auto!important;
+    border:0!important;
+    padding:0!important;
+  }
+  .search-results-group .search-result {
+    display:inline-block!important;
+    padding:0 5px;
+    width:auto!important;
+  }
+  .search-results-group .search-result:after {
+    content:", ";
+  }
+  #wrapper {
+    padding-bottom:0px;
+  }
+}

docs/app/assets/css/prettify-theme.css

@@ -0,0 +1,138 @@
+/* GitHub Theme */
+.prettyprint {
+  background: white;
+  font-family: Menlo, 'Bitstream Vera Sans Mono', 'DejaVu Sans Mono', Monaco, Consolas, monospace;
+  font-size: 12px;
+  line-height: 1.5;
+}
+
+.pln {
+  color: #333333;
+}
+
+@media screen {
+  .str {
+    color: #dd1144;
+  }
+
+  .kwd {
+    color: #333333;
+  }
+
+  .com {
+    color: #999988;
+  }
+
+  .typ {
+    color: #445588;
+  }
+
+  .lit {
+    color: #445588;
+  }
+
+  .pun {
+    color: #333333;
+  }
+
+  .opn {
+    color: #333333;
+  }
+
+  .clo {
+    color: #333333;
+  }
+
+  .tag {
+    color: navy;
+  }
+
+  .atn {
+    color: teal;
+  }
+
+  .atv {
+    color: #dd1144;
+  }
+
+  .dec {
+    color: #333333;
+  }
+
+  .var {
+    color: teal;
+  }
+
+  .fun {
+    color: #990000;
+  }
+}
+@media print, projection {
+  .str {
+    color: #006600;
+  }
+
+  .kwd {
+    color: #006;
+    font-weight: bold;
+  }
+
+  .com {
+    color: #600;
+    font-style: italic;
+  }
+
+  .typ {
+    color: #404;
+    font-weight: bold;
+  }
+
+  .lit {
+    color: #004444;
+  }
+
+  .pun, .opn, .clo {
+    color: #444400;
+  }
+
+  .tag {
+    color: #006;
+    font-weight: bold;
+  }
+
+  .atn {
+    color: #440044;
+  }
+
+  .atv {
+    color: #006600;
+  }
+}
+/* Specify class=linenums on a pre to get line numbering */
+ol.linenums {
+  margin-top: 0;
+  margin-bottom: 0;
+}
+
+/* IE indents via margin-left */
+li.L0,
+li.L1,
+li.L2,
+li.L3,
+li.L4,
+li.L5,
+li.L6,
+li.L7,
+li.L8,
+li.L9 {
+  /* */
+}
+
+/* Alternate shading for lines */
+li.L1,
+li.L3,
+li.L5,
+li.L7,
+li.L9 {
+  /* */
+}

docs/app/assets/css/prettify.css

@@ -0,0 +1,51 @@
+.pln { color: #000 }  /* plain text */
+
+@media screen {
+  .str { color: #080 }  /* string content */
+  .kwd { color: #008 }  /* a keyword */
+  .com { color: #800 }  /* a comment */
+  .typ { color: #606 }  /* a type name */
+  .lit { color: #066 }  /* a literal value */
+  /* punctuation, lisp open bracket, lisp close bracket */
+  .pun, .opn, .clo { color: #660 }
+  .tag { color: #008 }  /* a markup tag name */
+  .atn { color: #606 }  /* a markup attribute name */
+  .atv { color: #080 }  /* a markup attribute value */
+  .dec, .var { color: #606 }  /* a declaration; a variable name */
+  .fun { color: red }  /* a function name */
+}
+
+/* Use higher contrast and text-weight for printable form. */
+@media print, projection {
+  .str { color: #060 }
+  .kwd { color: #006; font-weight: bold }
+  .com { color: #600; font-style: italic }
+  .typ { color: #404; font-weight: bold }
+  .lit { color: #044 }
+  .pun, .opn, .clo { color: #440 }
+  .tag { color: #006; font-weight: bold }
+  .atn { color: #404 }
+  .atv { color: #060 }
+}
+
+pre.prettyprint {
+  padding: 8px;
+  background-color: #f7f7f9;
+  border: 1px solid #e1e1e8;
+}
+pre.prettyprint.linenums {
+  -webkit-box-shadow: inset 40px 0 0 #fbfbfc, inset 41px 0 0 #ececf0;
+     -moz-box-shadow: inset 40px 0 0 #fbfbfc, inset 41px 0 0 #ececf0;
+          box-shadow: inset 40px 0 0 #fbfbfc, inset 41px 0 0 #ececf0;
+}
+ol.linenums {
+  margin: 0 0 0 33px; /* IE indents via margin-left */
+}
+ol.linenums li {
+  padding-left: 12px;
+  font-size:12px;
+  color: #bebec5;
+  line-height: 18px;
+  text-shadow: 0 1px 0 #fff;
+  list-style-type:decimal!important;
+}

docs/app/assets/img/angularjs-for-header-only.svg

@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 15.0.0, SVG Export Plug-In  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" [
+	<!ENTITY ns_flows "http://ns.adobe.com/Flows/1.0/">
+]>
+<svg version="1.1"
+	 xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:a="http://ns.adobe.com/AdobeSVGViewerExtensions/3.0/"
+	 x="0px" y="0px" width="687px" height="176px" viewBox="0 0 687 176" overflow="visible" enable-background="new 0 0 687 176"
+	 xml:space="preserve">
+<defs>
+</defs>
+<path fill="#FFFFFF" d="M179.011,125.328V54.527h9.158l43.322,57.035V54.527h8.666v70.801h-9.158l-43.326-57.536v57.536H179.011z
+	 M179.011,125.328"/>
+<path fill="#FFFFFF" d="M310.46,122.554c-5.708,2.182-11.864,3.269-18.467,3.269c-25.644,0-38.469-12.294-38.469-36.887
+	c0-23.27,12.378-34.908,37.134-34.908c7.096,0,13.7,0.994,19.802,2.976v7.921c-6.103-2.311-12.378-3.468-18.813-3.468
+	c-19.306,0-28.96,9.162-28.96,27.479c0,19.639,9.504,29.463,28.517,29.463c3.034,0,6.404-0.396,10.103-1.193V93.145h9.154V122.554z
+	 M310.46,122.554"/>
+<path fill="#FFFFFF" d="M325.067,97.996V54.523h9.154v43.473c0,13.598,6.768,20.4,20.303,20.4c13.531,0,20.301-6.803,20.301-20.4
+	V54.523h9.158v43.473c0,18.556-9.82,27.825-29.459,27.825C334.886,125.821,325.067,116.552,325.067,97.996L325.067,97.996z
+	 M325.067,97.996"/>
+<path fill="#FFFFFF" d="M409.48,54.523v63.376h37.037v7.425h-46.191V54.523H409.48z M409.48,54.523"/>
+<path fill="#FFFFFF" d="M459.736,125.327h-9.504l35.201-80.146l35.199,80.146h-10.15l-9.158-22.282h-23.418l2.527-7.424h17.82
+	l-13.217-32.088L459.736,125.327z M459.736,125.327"/>
+<path fill="#FFFFFF" d="M530.289,125.328V54.527h30.203c13.469,0,20.197,5.659,20.197,16.982c0,9.207-6.578,16.028-19.75,20.445
+	l24.309,33.374h-12.086l-22.521-31.835v-5.992c13.531-2.151,20.301-7.344,20.301-15.598c0-6.533-3.766-9.801-11.293-9.801h-20.201
+	v63.226H530.289z M530.289,125.328"/>
+<path fill="#B52E31" d="M619.561,54.523v50.405c0,13.603-8.006,20.396-24.016,20.396V117.9c9.902,0,14.857-4.329,14.857-12.973
+	V54.523H619.561z M619.561,54.523"/>
+<path fill="#B52E31" d="M635.896,122.849v-8.418c7.428,2.639,15.447,3.965,24.064,3.965c12.178,0,18.271-4.457,18.271-13.372
+	c0-7.584-4.492-11.385-13.469-11.385h-9.113c-14.818,0-22.234-6.435-22.234-19.31c0-13.531,9.492-20.303,28.479-20.303
+	c8.25,0,15.922,0.998,23.021,2.976v8.418c-7.1-2.644-14.771-3.965-23.021-3.965c-12.875,0-19.311,4.293-19.311,12.875
+	c0,7.588,4.352,11.385,13.066,11.385h9.113c15.08,0,22.627,6.439,22.627,19.31c0,13.864-9.141,20.796-27.43,20.796
+	C651.344,125.819,643.324,124.826,635.896,122.849L635.896,122.849z M635.896,122.849"/>
+<path fill="#B2B2B2" d="M82.688,0L0,29.1l13.066,108.335l69.71,38.314l70.069-38.834l13.062-108.331L82.688,0z M82.688,0"/>
+<path fill="#B52E31" d="M157.66,34.846L82.496,9.214v157.381l62.991-34.861L157.66,34.846z M157.66,34.846"/>
+<path fill="#E23237" d="M9.279,35.308l11.196,96.889l62.019,34.398V9.211L9.279,35.308z M9.279,35.308"/>
+<path fill="#F2F2F2" d="M99.918,87.493L82.632,51.396L67.415,87.493H99.918z M106.508,102.672h-45.82l-10.251,25.64l-19.067,0.352
+	L82.496,14.929l52.908,113.734h-17.673L106.508,102.672z M106.508,102.672"/>
+<path fill="#B2B2B2" d="M82.496,14.929l0.136,36.467l17.268,36.125H82.534l-0.039,15.127l24.012,0.023l11.223,25.996l18.245,0.339
+	L82.496,14.929z M82.496,14.929"/>
+</svg>

docs/app/assets/js/angular-bootstrap/bootstrap-prettify.js

@@ -6,6 +6,8 @@ var service = { value: {} };
 var DEPENDENCIES = {
   'angular.js': 'http://code.angularjs.org/' + angular.version.full + '/angular.min.js',
   'angular-resource.js': 'http://code.angularjs.org/' + angular.version.full + '/angular-resource.min.js',
+  'angular-route.js': 'http://code.angularjs.org/' + angular.version.full + '/angular-route.min.js',
+  'angular-animate.js': 'http://code.angularjs.org/' + angular.version.full + '/angular-animate.min.js',
   'angular-sanitize.js': 'http://code.angularjs.org/' + angular.version.full + '/angular-sanitize.min.js',
   'angular-cookies.js': 'http://code.angularjs.org/' + angular.version.full + '/angular-cookies.min.js'
 };
@@ -26,7 +28,7 @@ function escape(text) {
 function setHtmlIe8SafeWay(element, html) {
   var newElement = angular.element('<pre>' + html + '</pre>');
 
-  element.html('');
+  element.empty();
   element.append(newElement.contents());
   return element;
 }
@@ -87,21 +89,6 @@ directive.jsFiddle = function(getEmbeddedTemplate, escape, script) {
 };
 
 
-directive.code = function() {
-  return {restrict: 'E', terminal: true};
-};
-
-
-directive.prettyprint = ['reindentCode', function(reindentCode) {
-  return {
-    restrict: 'C',
-    terminal: true,
-    compile: function(element) {
-      element.html(window.prettyPrintOne(reindentCode(element.html()), undefined, true));
-    }
-  };
-}];
-
 
 directive.ngSetText = ['getEmbeddedTemplate', function(getEmbeddedTemplate) {
   return {
@@ -159,38 +146,43 @@ directive.ngSetHtml = ['getEmbeddedTemplate', function(getEmbeddedTemplate) {
 directive.ngEvalJavascript = ['getEmbeddedTemplate', function(getEmbeddedTemplate) {
   return {
     compile: function (element, attr) {
-      var script = getEmbeddedTemplate(attr.ngEvalJavascript);
-
-      try {
-        if (window.execScript) { // IE
-          window.execScript(script || '""'); // IE complains when evaling empty string
-        } else {
-          window.eval(script);
+      var fileNames = attr.ngEvalJavascript.split(' ');
+      angular.forEach(fileNames, function(fileName) {
+        var script = getEmbeddedTemplate(fileName);
+        try {
+          if (window.execScript) { // IE
+            window.execScript(script || '""'); // IE complains when evaling empty string
+          } else {
+            window.eval(script + '//@ sourceURL=' + fileName);
+          }
+        } catch (e) {
+          if (window.console) {
+            window.console.log(script, '\n', e);
+          } else {
+            window.alert(e);
+          }
         }
-      } catch (e) {
-        if (window.console) {
-          window.console.log(script, '\n', e);
-        } else {
-          window.alert(e);
-        }
-      }
+      });
     }
   };
 }];
 
 
-directive.ngEmbedApp = ['$templateCache', '$browser', '$rootScope', '$location', '$sniffer',
-                function($templateCache,   $browser,  docsRootScope, $location,   $sniffer) {
+directive.ngEmbedApp = ['$templateCache', '$browser', '$rootScope', '$location', '$sniffer', '$animate',
+                function($templateCache,   $browser,  docsRootScope, $location,   $sniffer,   $animate) {
   return {
     terminal: true,
     link: function(scope, element, attrs) {
-      var modules = [];
+      var modules = ['ngAnimate'],
+          embedRootScope,
+          deregisterEmbedRootScope;
 
       modules.push(['$provide', function($provide) {
         $provide.value('$templateCache', $templateCache);
         $provide.value('$anchorScroll', angular.noop);
         $provide.value('$browser', $browser);
         $provide.value('$sniffer', $sniffer);
+        $provide.value('$animate', $animate);
         $provide.provider('$location', function() {
           this.$get = ['$rootScope', function($rootScope) {
             docsRootScope.$on('$locationChangeSuccess', function(event, oldUrl, newUrl) {
@@ -200,32 +192,35 @@ directive.ngEmbedApp = ['$templateCache', '$browser', '$rootScope', '$location',
           }];
           this.html5Mode = angular.noop;
         });
-        $provide.decorator('$timeout', ['$rootScope', '$delegate', function($rootScope, $delegate) {
-          return angular.extend(function(fn, delay) {
-            if (delay && delay > 50) {
-              return setTimeout(function() {
-                $rootScope.$apply(fn);
-              }, delay);
-            } else {
-              return $delegate.apply(this, arguments);
-            }
-          }, $delegate);
-        }]);
-        $provide.decorator('$rootScope', ['$delegate', function(embedRootScope) {
-          docsRootScope.$watch(function embedRootScopeDigestWatch() {
+
+        $provide.decorator('$rootScope', ['$delegate', function($delegate) {
+          embedRootScope = $delegate;
+
+          // Since we are teleporting the $animate service, which relies on the $$postDigestQueue
+          // we need the embedded scope to use the same $$postDigestQueue as the outer scope
+          embedRootScope.$$postDigestQueue = docsRootScope.$$postDigestQueue;
+
+          deregisterEmbedRootScope = docsRootScope.$watch(function embedRootScopeDigestWatch() {
             embedRootScope.$digest();
           });
+
           return embedRootScope;
         }]);
       }]);
       if (attrs.ngEmbedApp)  modules.push(attrs.ngEmbedApp);
 
-      element.bind('click', function(event) {
+      element.on('click', function(event) {
         if (event.target.attributes.getNamedItem('ng-click')) {
           event.preventDefault();
         }
       });
 
+      element.bind('$destroy', function() {
+        deregisterEmbedRootScope();
+        embedRootScope.$destroy();
+      });
+
+      element.data('$injector', null);
       angular.bootstrap(element, modules);
     }
   };

docs/app/assets/js/angular-bootstrap/bootstrap.js

@@ -0,0 +1,442 @@
+'use strict';
+
+var directive = {};
+
+directive.runnableExample = ['$templateCache', '$document', function($templateCache, $document) {
+  var exampleClassNameSelector = '.runnable-example-file';
+  var doc = $document[0];
+  var tpl =
+    '<nav class="runnable-example-tabs" ng-if="tabs">' +
+    '  <a ng-class="{active:$index==activeTabIndex}"' +
+         'ng-repeat="tab in tabs track by $index" ' +
+         'href="" ' +
+         'class="btn"' +
+         'ng-click="setTab($index)">' +
+    '    {{ tab }}' +
+    '  </a>' +
+    '</nav>';
+
+  return {
+    restrict: 'C',
+    scope : true,
+    controller : ['$scope', function($scope) {
+      $scope.setTab = function(index) {
+        var tab = $scope.tabs[index];
+        $scope.activeTabIndex = index;
+        $scope.$broadcast('tabChange', index, tab);
+      };
+    }],
+    compile : function(element) {
+      element.html(tpl + element.html());
+      return function(scope, element) {
+        var node = element[0];
+        var examples = node.querySelectorAll(exampleClassNameSelector);
+        var tabs = [], now = Date.now();
+        angular.forEach(examples, function(child, index) {
+          tabs.push(child.getAttribute('name'));
+        });
+
+        if(tabs.length > 0) {
+          scope.tabs = tabs;
+          scope.$on('tabChange', function(e, index, title) {
+            angular.forEach(examples, function(child) {
+              child.style.display = 'none';
+            });
+            var selected = examples[index];
+            selected.style.display = 'block';
+          });
+          scope.setTab(0);
+        }
+      }
+    }
+  };
+}];
+
+directive.dropdownToggle =
+          ['$document', '$location', '$window',
+  function ($document,   $location,   $window) {
+    var openElement = null, close;
+    return {
+      restrict: 'C',
+      link: function(scope, element, attrs) {
+        scope.$watch(function dropdownTogglePathWatch(){return $location.path();}, function dropdownTogglePathWatchAction() {
+          close && close();
+        });
+
+        element.parent().on('click', function(event) {
+          close && close();
+        });
+
+        element.on('click', function(event) {
+          event.preventDefault();
+          event.stopPropagation();
+
+          var iWasOpen = false;
+
+          if (openElement) {
+            iWasOpen = openElement === element;
+            close();
+          }
+
+          if (!iWasOpen){
+            element.parent().addClass('open');
+            openElement = element;
+
+            close = function (event) {
+              event && event.preventDefault();
+              event && event.stopPropagation();
+              $document.off('click', close);
+              element.parent().removeClass('open');
+              close = null;
+              openElement = null;
+            }
+
+            $document.on('click', close);
+          }
+        });
+      }
+    };
+  }];
+
+directive.syntax = function() {
+  return {
+    restrict: 'A',
+    link: function(scope, element, attrs) {
+      function makeLink(type, text, link, icon) {
+        return '<a href="' + link + '" class="btn syntax-' + type + '" target="_blank" rel="nofollow">' +
+                '<span class="' + icon + '"></span> ' + text +
+               '</a>';
+      };
+
+      var html = '';
+      var types = {
+        'github' : {
+          text : 'View on Github',
+          key : 'syntaxGithub',
+          icon : 'icon-github'
+        },
+        'plunkr' : {
+          text : 'View on Plunkr',
+          key : 'syntaxPlunkr',
+          icon : 'icon-arrow-down'
+        },
+        'jsfiddle' : {
+          text : 'View on JSFiddle',
+          key : 'syntaxFiddle',
+          icon : 'icon-cloud'
+        }
+      };
+      for(var type in types) {
+        var data = types[type];
+        var link = attrs[data.key];
+        if(link) {
+          html += makeLink(type, data.text, link, data.icon);
+        }
+      };
+
+      var nav = document.createElement('nav');
+      nav.className = 'syntax-links';
+      nav.innerHTML = html;
+
+      var node = element[0];
+      var par = node.parentNode;
+      par.insertBefore(nav, node);
+    }
+  }
+}
+
+directive.tabbable = function() {
+  return {
+    restrict: 'C',
+    compile: function(element) {
+      var navTabs = angular.element('<ul class="nav nav-tabs"></ul>'),
+          tabContent = angular.element('<div class="tab-content"></div>');
+
+      tabContent.append(element.contents());
+      element.append(navTabs).append(tabContent);
+    },
+    controller: ['$scope', '$element', function($scope, $element) {
+      var navTabs = $element.contents().eq(0),
+          ngModel = $element.controller('ngModel') || {},
+          tabs = [],
+          selectedTab;
+
+      ngModel.$render = function() {
+        var $viewValue = this.$viewValue;
+
+        if (selectedTab ? (selectedTab.value != $viewValue) : $viewValue) {
+          if(selectedTab) {
+            selectedTab.paneElement.removeClass('active');
+            selectedTab.tabElement.removeClass('active');
+            selectedTab = null;
+          }
+          if($viewValue) {
+            for(var i = 0, ii = tabs.length; i < ii; i++) {
+              if ($viewValue == tabs[i].value) {
+                selectedTab = tabs[i];
+                break;
+              }
+            }
+            if (selectedTab) {
+              selectedTab.paneElement.addClass('active');
+              selectedTab.tabElement.addClass('active');
+            }
+          }
+
+        }
+      };
+
+      this.addPane = function(element, attr) {
+        var li = angular.element('<li><a href></a></li>'),
+            a = li.find('a'),
+            tab = {
+              paneElement: element,
+              paneAttrs: attr,
+              tabElement: li
+            };
+
+        tabs.push(tab);
+
+        attr.$observe('value', update)();
+        attr.$observe('title', function(){ update(); a.text(tab.title); })();
+
+        function update() {
+          tab.title = attr.title;
+          tab.value = attr.value || attr.title;
+          if (!ngModel.$setViewValue && (!ngModel.$viewValue || tab == selectedTab)) {
+            // we are not part of angular
+            ngModel.$viewValue = tab.value;
+          }
+          ngModel.$render();
+        }
+
+        navTabs.append(li);
+        li.on('click', function(event) {
+          event.preventDefault();
+          event.stopPropagation();
+          if (ngModel.$setViewValue) {
+            $scope.$apply(function() {
+              ngModel.$setViewValue(tab.value);
+              ngModel.$render();
+            });
+          } else {
+            // we are not part of angular
+            ngModel.$viewValue = tab.value;
+            ngModel.$render();
+          }
+        });
+
+        return function() {
+          tab.tabElement.remove();
+          for(var i = 0, ii = tabs.length; i < ii; i++ ) {
+            if (tab == tabs[i]) {
+              tabs.splice(i, 1);
+            }
+          }
+        };
+      }
+    }]
+  };
+};
+
+directive.table = function() {
+  return {
+    restrict: 'E',
+    link: function(scope, element, attrs) {
+      if (!attrs['class']) {
+        element.addClass('table table-bordered table-striped code-table');
+      }
+    }
+  };
+};
+
+var popoverElement = function() {
+  var object = {
+    init : function() {
+      this.element = angular.element(
+        '<div class="popover popover-incode top">' +
+          '<div class="arrow"></div>' +
+          '<div class="popover-inner">' +
+            '<div class="popover-title"><code></code></div>' +
+            '<div class="popover-content"></div>' +
+          '</div>' +
+        '</div>'
+      );
+      this.node = this.element[0];
+      this.element.css({
+        'display':'block',
+        'position':'absolute'
+      });
+      angular.element(document.body).append(this.element);
+
+      var inner = this.element.children()[1];
+      this.titleElement   = angular.element(inner.childNodes[0].firstChild);
+      this.contentElement = angular.element(inner.childNodes[1]);
+
+      //stop the click on the tooltip
+      this.element.bind('click', function(event) {
+        event.preventDefault();
+        event.stopPropagation();
+      });
+
+      var self = this;
+      angular.element(document.body).bind('click',function(event) {
+        if(self.visible()) self.hide();
+      });
+    },
+
+    show : function(x,y) {
+      this.element.addClass('visible');
+      this.position(x || 0, y || 0);
+    },
+
+    hide : function() {
+      this.element.removeClass('visible');
+      this.position(-9999,-9999);
+    },
+
+    visible : function() {
+      return this.position().y >= 0;
+    },
+
+    isSituatedAt : function(element) {
+      return this.besideElement ? element[0] == this.besideElement[0] : false;
+    },
+
+    title : function(value) {
+      return this.titleElement.html(value);
+    },
+
+    content : function(value) {
+      if(value && value.length > 0) {
+        value = marked(value);
+      }
+      return this.contentElement.html(value);
+    },
+
+    positionArrow : function(position) {
+      this.node.className = 'popover ' + position;
+    },
+
+    positionAway : function() {
+      this.besideElement = null;
+      this.hide();
+    },
+
+    positionBeside : function(element) {
+      this.besideElement = element;
+
+      var elm = element[0];
+      var x = elm.offsetLeft;
+      var y = elm.offsetTop;
+      x -= 30;
+      y -= this.node.offsetHeight + 10;
+      this.show(x,y);
+    },
+
+    position : function(x,y) {
+      if(x != null && y != null) {
+        this.element.css('left',x + 'px');
+        this.element.css('top', y + 'px');
+      }
+      else {
+        return {
+          x : this.node.offsetLeft,
+          y : this.node.offsetTop
+        };
+      }
+    }
+  };
+
+  object.init();
+  object.hide();
+
+  return object;
+};
+
+directive.popover = ['popoverElement', function(popover) {
+  return {
+    restrict: 'A',
+    priority : 500,
+    link: function(scope, element, attrs) {
+      element.bind('click',function(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        if(popover.isSituatedAt(element) && popover.visible()) {
+          popover.title('');
+          popover.content('');
+          popover.positionAway();
+        }
+        else {
+          popover.title(attrs.title);
+          popover.content(attrs.content);
+          popover.positionBeside(element);
+        }
+      });
+    }
+  }
+}];
+
+directive.tabPane = function() {
+  return {
+    require: '^tabbable',
+    restrict: 'C',
+    link: function(scope, element, attrs, tabsCtrl) {
+      element.on('$remove', tabsCtrl.addPane(element, attrs));
+    }
+  };
+};
+
+directive.foldout = ['$http', '$animate','$window', function($http, $animate, $window) {
+  return {
+    restrict: 'A',
+    priority : 500,
+    link: function(scope, element, attrs) {
+      var container, loading, url = attrs.url;
+      if(/\/build\//.test($window.location.href)) {
+        url = '/build/docs' + url;
+      }
+      element.bind('click',function() {
+        scope.$apply(function() {
+          if(!container) {
+            if(loading) return;
+
+            loading = true;
+            var par = element.parent();
+            container = angular.element('<div class="foldout">loading...</div>');
+            $animate.enter(container, null, par);
+
+            $http.get(url, { cache : true }).success(function(html) {
+              loading = false;
+
+              html = '<div class="foldout-inner">' +
+                      '<div calss="foldout-arrow"></div>' +
+                      html +
+                     '</div>';
+              container.html(html);
+
+              //avoid showing the element if the user has already closed it
+              if(container.css('display') == 'block') {
+                container.css('display','none');
+                $animate.addClass(container, 'ng-hide');
+              }
+            });
+          }
+          else {
+            container.hasClass('ng-hide') ? $animate.removeClass(container, 'ng-hide') : $animate.addClass(container, 'ng-hide');
+          }
+        });
+      });
+    }
+  }
+}];
+
+angular.module('bootstrap', [])
+  .directive(directive)
+  .factory('popoverElement', popoverElement)
+  .run(function() {
+    marked.setOptions({
+      gfm: true,
+      tables: true
+    });
+  });

docs/app/assets/js/angular-bootstrap/dropdown-toggle.js

@@ -0,0 +1,145 @@
+/* This code is taken from the AngularUI - Bootstrap Project (https://github.com/angular-ui/bootstrap)
+ *
+ * The MIT License
+ * 
+ * Copyright (c) 2012-2014 the AngularUI Team, https://github.com/organizations/angular-ui/teams/291112
+ * 
+ * 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.
+ *
+ */
+
+angular.module('ui.bootstrap.dropdown', [])
+
+.constant('dropdownConfig', {
+  openClass: 'open'
+})
+
+.service('dropdownService', ['$document', function($document) {
+  var self = this, openScope = null;
+
+  this.open = function( dropdownScope ) {
+    if ( !openScope ) {
+      $document.bind('click', closeDropdown);
+      $document.bind('keydown', escapeKeyBind);
+    }
+
+    if ( openScope && openScope !== dropdownScope ) {
+        openScope.isOpen = false;
+    }
+
+    openScope = dropdownScope;
+  };
+
+  this.close = function( dropdownScope ) {
+    if ( openScope === dropdownScope ) {
+      openScope = null;
+      $document.unbind('click', closeDropdown);
+      $document.unbind('keydown', escapeKeyBind);
+    }
+  };
+
+  var closeDropdown = function() {
+    openScope.$apply(function() {
+      openScope.isOpen = false;
+    });
+  };
+
+  var escapeKeyBind = function( evt ) {
+    if ( evt.which === 27 ) {
+      closeDropdown();
+    }
+  };
+}])
+
+.controller('DropdownController', ['$scope', '$attrs', 'dropdownConfig', 'dropdownService', '$animate', function($scope, $attrs, dropdownConfig, dropdownService, $animate) {
+  var self = this, openClass = dropdownConfig.openClass;
+
+  this.init = function( element ) {
+    self.$element = element;
+    $scope.isOpen = angular.isDefined($attrs.isOpen) ? $scope.$parent.$eval($attrs.isOpen) : false;
+  };
+
+  this.toggle = function( open ) {
+    return $scope.isOpen = arguments.length ? !!open : !$scope.isOpen;
+  };
+
+  // Allow other directives to watch status
+  this.isOpen = function() {
+    return $scope.isOpen;
+  };
+
+  $scope.$watch('isOpen', function( value ) {
+    $animate[value ? 'addClass' : 'removeClass'](self.$element, openClass);
+
+    if ( value ) {
+      dropdownService.open( $scope );
+    } else {
+      dropdownService.close( $scope );
+    }
+
+    $scope.onToggle({ open: !!value });
+  });
+
+  $scope.$on('$locationChangeSuccess', function() {
+    $scope.isOpen = false;
+  });
+}])
+
+.directive('dropdown', function() {
+  return {
+    restrict: 'CA',
+    controller: 'DropdownController',
+    scope: {
+      isOpen: '=?',
+      onToggle: '&'
+    },
+    link: function(scope, element, attrs, dropdownCtrl) {
+      dropdownCtrl.init( element );
+    }
+  };
+})
+
+.directive('dropdownToggle', function() {
+  return {
+    restrict: 'CA',
+    require: '?^dropdown',
+    link: function(scope, element, attrs, dropdownCtrl) {
+      if ( !dropdownCtrl ) {
+        return;
+      }
+
+      element.bind('click', function(event) {
+        event.preventDefault();
+        event.stopPropagation();
+
+        if ( !element.hasClass('disabled') && !element.prop('disabled') ) {
+          scope.$apply(function() {
+            dropdownCtrl.toggle();
+          });
+        }
+      });
+
+      // WAI-ARIA
+      element.attr({ 'aria-haspopup': true, 'aria-expanded': false });
+      scope.$watch(dropdownCtrl.isOpen, function( isOpen ) {
+        element.attr('aria-expanded', !!isOpen);
+      });
+    }
+  };
+});

docs/app/src/app.js

@@ -0,0 +1,23 @@
+angular.module('docsApp', [
+  'ngRoute',
+  'ngCookies',
+  'ngSanitize',
+  'ngAnimate',
+  'DocsController',
+  'versionsData',
+  'pagesData',
+  'directives',
+  'errors',
+  'examples',
+  'search',
+  'tutorials',
+  'versions',
+  'bootstrap',
+  'bootstrapPrettify',
+  'ui.bootstrap.dropdown'
+])
+
+
+.config(function($locationProvider) {
+  $locationProvider.html5Mode(true).hashPrefix('!');
+});

docs/app/src/directives.js

@@ -0,0 +1,32 @@
+angular.module('directives', [])
+
+/**
+ * backToTop Directive
+ * @param  {Function} $anchorScroll
+ *
+ * @description Ensure that the browser scrolls when the anchor is clicked
+ */
+.directive('backToTop', ['$anchorScroll', '$location', function($anchorScroll, $location) {
+  return function link(scope, element) {
+    element.on('click', function(event) {
+      $location.hash('');
+      scope.$apply($anchorScroll);
+    });
+  };
+}])
+
+
+.directive('code', function() {
+  return {
+    restrict: 'E',
+    terminal: true,
+    compile: function(element) {
+      var linenums = element.hasClass('linenum');// || element.parent()[0].nodeName === 'PRE';
+      var match = /lang-(\S)+/.exec(element.className);
+      var lang = match && match[1];
+      var html = element.html();
+      element.html(window.prettyPrintOne(html, lang, linenums));
+    }
+  };
+});
+

docs/app/src/docs.js

@@ -0,0 +1,130 @@
+angular.module('DocsController', [])
+
+.controller('DocsController', [
+          '$scope', '$rootScope', '$location', '$window', '$cookies', 'openPlunkr',
+              'NG_PAGES', 'NG_NAVIGATION', 'NG_VERSION',
+  function($scope, $rootScope, $location, $window, $cookies, openPlunkr,
+              NG_PAGES, NG_NAVIGATION, NG_VERSION) {
+
+
+  $scope.openPlunkr = openPlunkr;
+
+  $scope.docsVersion = NG_VERSION.isSnapshot ? 'snapshot' : NG_VERSION.version;
+
+  $scope.fold = function(url) {
+    if(url) {
+      $scope.docs_fold = '/notes/' + url;
+      if(/\/build/.test($window.location.href)) {
+        $scope.docs_fold = '/build/docs' + $scope.docs_fold;
+      }
+      window.scrollTo(0,0);
+    }
+    else {
+      $scope.docs_fold = null;
+    }
+  };
+  var OFFLINE_COOKIE_NAME = 'ng-offline',
+      INDEX_PATH = /^(\/|\/index[^\.]*.html)$/;
+
+
+  /**********************************
+   Publish methods
+   ***********************************/
+
+  $scope.navClass = function(navItem) {
+    return {
+      active: navItem.href && this.currentPage.path,
+      'nav-index-section': navItem.type === 'section'
+    };
+  };
+
+  $scope.afterPartialLoaded = function() {
+    var pagePath = $scope.currentPage ? $scope.currentPage.path : $location.path();
+    $window._gaq.push(['_trackPageview', pagePath]);
+  };
+
+  /** stores a cookie that is used by apache to decide which manifest ot send */
+  $scope.enableOffline = function() {
+    //The cookie will be good for one year!
+    var date = new Date();
+    date.setTime(date.getTime()+(365*24*60*60*1000));
+    var expires = "; expires="+date.toGMTString();
+    var value = angular.version.full;
+    document.cookie = OFFLINE_COOKIE_NAME + "="+value+expires+"; path=" + $location.path;
+
+    //force the page to reload so server can serve new manifest file
+    window.location.reload(true);
+  };
+
+
+
+  /**********************************
+   Watches
+   ***********************************/
+
+
+  $scope.$watch(function docsPathWatch() {return $location.path(); }, function docsPathWatchAction(path) {
+
+    var currentPage = $scope.currentPage = NG_PAGES[path];
+    if ( !currentPage && path.charAt(0)==='/' ) {
+      // Strip off leading slash
+      path = path.substr(1);
+    }
+
+    currentPage = $scope.currentPage = NG_PAGES[path];
+    if ( !currentPage && path.charAt(path.length-1) === '/' && path.length > 1 ) {
+      // Strip off trailing slash
+      path = path.substr(0, path.length-1);
+    }
+
+    currentPage = $scope.currentPage = NG_PAGES[path];
+    if ( !currentPage && /\/index$/.test(path) ) {
+      // Strip off index from the end
+      path = path.substr(0, path.length - 6);
+    }
+
+    currentPage = $scope.currentPage = NG_PAGES[path];
+
+    if ( currentPage ) {
+      $scope.currentArea = currentPage && NG_NAVIGATION[currentPage.area];
+      var pathParts = currentPage.path.split('/');
+      var breadcrumb = $scope.breadcrumb = [];
+      var breadcrumbPath = '';
+      angular.forEach(pathParts, function(part) {
+        breadcrumbPath += part;
+        breadcrumb.push({ name: (NG_PAGES[breadcrumbPath]&&NG_PAGES[breadcrumbPath].name) || part, url: breadcrumbPath });
+        breadcrumbPath += '/';
+      });
+    } else {
+      $scope.currentArea = NG_NAVIGATION['api'];
+      $scope.breadcrumb = [];
+    }
+  });
+
+  /**********************************
+   Initialize
+   ***********************************/
+
+  $scope.versionNumber = angular.version.full;
+  $scope.version = angular.version.full + "  " + angular.version.codeName;
+  $scope.subpage = false;
+  $scope.offlineEnabled = ($cookies[OFFLINE_COOKIE_NAME] == angular.version.full);
+  $scope.futurePartialTitle = null;
+  $scope.loading = 0;
+  $scope.$cookies = $cookies;
+
+  $cookies.platformPreference = $cookies.platformPreference || 'gitUnix';
+
+  if (!$location.path() || INDEX_PATH.test($location.path())) {
+    $location.path('/api').replace();
+  }
+
+  // bind escape to hash reset callback
+  angular.element(window).on('keydown', function(e) {
+    if (e.keyCode === 27) {
+      $scope.$apply(function() {
+        $scope.subpage = false;
+      });
+    }
+  });
+}]);

docs/app/src/errors.js

@@ -0,0 +1,62 @@
+angular.module('errors', ['ngSanitize'])
+
+.filter('errorLink', ['$sanitize', function ($sanitize) {
+  var LINKY_URL_REGEXP = /((ftp|https?):\/\/|(mailto:)?[A-Za-z0-9._%+-]+@)\S*[^\s\.\;\,\(\)\{\}<>]/g,
+      MAILTO_REGEXP = /^mailto:/,
+      STACK_TRACE_REGEXP = /:\d+:\d+$/;
+
+  var truncate = function (text, nchars) {
+    if (text.length > nchars) {
+      return text.substr(0, nchars - 3) + '...';
+    }
+    return text;
+  };
+
+  return function (text, target) {
+    var targetHtml = target ? ' target="' + target + '"' : '';
+
+    if (!text) return text;
+
+    return $sanitize(text.replace(LINKY_URL_REGEXP, function (url) {
+      if (STACK_TRACE_REGEXP.test(url)) {
+        return url;
+      }
+
+      // if we did not match ftp/http/mailto then assume mailto
+      if (!/^((ftp|https?):\/\/|mailto:)/.test(url)) url = 'mailto:' + url;
+
+      return '<a' + targetHtml + ' href="' + url +'">' +
+                truncate(url.replace(MAILTO_REGEXP, ''), 60) +
+              '</a>';
+    }));
+  };
+}])
+
+
+.directive('errorDisplay', ['$location', 'errorLinkFilter', function ($location, errorLinkFilter) {
+  var interpolate = function (formatString) {
+    var formatArgs = arguments;
+    return formatString.replace(/\{\d+\}/g, function (match) {
+      // Drop the braces and use the unary plus to convert to an integer.
+      // The index will be off by one because of the formatString.
+      var index = +match.slice(1, -1);
+      if (index + 1 >= formatArgs.length) {
+        return match;
+      }
+      return formatArgs[index+1];
+    });
+  };
+
+  return {
+    link: function (scope, element, attrs) {
+      var search = $location.search(),
+        formatArgs = [attrs.errorDisplay],
+        i;
+
+      for (i = 0; angular.isDefined(search['p'+i]); i++) {
+        formatArgs.push(search['p'+i]);
+      }
+      element.html(errorLinkFilter(interpolate.apply(null, formatArgs), '_blank'));
+    }
+  };
+}]);

docs/app/src/examples.js

@@ -0,0 +1,77 @@
+angular.module('examples', [])
+
+.factory('formPostData', ['$document', function($document) {
+  return function(url, fields) {
+    /**
+     * Form previously posted to target="_blank", but pop-up blockers were causing this to not work.
+     * If a user chose to bypass pop-up blocker one time and click the link, they would arrive at
+     * a new default plnkr, not a plnkr with the desired template.
+     */
+    var form = angular.element('<form style="display: none;" method="post" action="' + url + '"></form>');
+    angular.forEach(fields, function(value, name) {
+      var input = angular.element('<input type="hidden" name="' +  name + '">');
+      input.attr('value', value);
+      form.append(input);
+    });
+    $document.find('body').append(form);
+    form[0].submit();
+    form.remove();
+  };
+}])
+
+
+.factory('openPlunkr', ['formPostData', '$http', '$q', function(formPostData, $http, $q) {
+  return function(exampleFolder) {
+
+    var exampleName = 'AngularJS Example';
+
+    // Load the manifest for the example
+    $http.get(exampleFolder + '/manifest.json')
+      .then(function(response) {
+        return response.data;
+      })
+      .then(function(manifest) {
+        var filePromises = [];
+
+        // Build a pretty title for the Plunkr
+        var exampleNameParts = manifest.name.split('-');
+        exampleNameParts.unshift('AngularJS');
+        angular.forEach(exampleNameParts, function(part, index) {
+          exampleNameParts[index] = part.charAt(0).toUpperCase() + part.substr(1);
+        });
+        exampleName = exampleNameParts.join(' - ');
+
+        angular.forEach(manifest.files, function(filename) {
+          filePromises.push($http.get(exampleFolder + '/' + filename, { transformResponse: [] })
+            .then(function(response) {
+
+              // The manifests provide the production index file but Plunkr wants
+              // a straight index.html
+              if (filename === "index-production.html") {
+                filename = "index.html"
+              }
+
+              return {
+                name: filename,
+                content: response.data
+              };
+            }));
+        });
+        return $q.all(filePromises);
+      })
+      .then(function(files) {
+        var postData = {};
+
+        angular.forEach(files, function(file) {
+          postData['files[' + file.name + ']'] = file.content;
+        });
+
+        postData['tags[0]'] = "angularjs";
+        postData['tags[1]'] = "example";
+        postData.private = true;
+        postData.description = exampleName;
+
+        formPostData('http://plnkr.co/edit/?p=preview', postData);
+      });
+  };
+}]);

docs/app/src/navigationService.js

@@ -0,0 +1,24 @@
+angular.module('docsApp.navigationService', [])
+
+.factory('navigationService', function($window) {
+  var service = {
+    currentPage: null,
+    currentVersion: null,
+    changePage: function(newPage) {
+
+    },
+    changeVersion: function(newVersion) {
+
+      //TODO =========
+    //   var currentPagePath = '';
+
+    // // preserve URL path when switching between doc versions
+    // if (angular.isObject($rootScope.currentPage) && $rootScope.currentPage.section && $rootScope.currentPage.id) {
+    //   currentPagePath = '/' + $rootScope.currentPage.section + '/' + $rootScope.currentPage.id;
+    // }
+
+    // $window.location = version.url + currentPagePath;
+
+    }
+  };
+});

docs/app/src/search.js

@@ -0,0 +1,153 @@
+angular.module('search', [])
+
+.controller('DocsSearchCtrl', ['$scope', '$location', 'docsSearch', function($scope, $location, docsSearch) {
+  function clearResults() {
+    $scope.results = [];
+    $scope.colClassName = null;
+    $scope.hasResults = false;
+  }
+
+  $scope.search = function(q) {
+    var MIN_SEARCH_LENGTH = 2;
+    if(q.length >= MIN_SEARCH_LENGTH) {
+      var results = docsSearch(q);
+      var totalAreas = 0;
+      for(var i in results) {
+        ++totalAreas;
+      }
+      if(totalAreas > 0) {
+        $scope.colClassName = 'cols-' + totalAreas;
+      }
+      $scope.hasResults = totalAreas > 0;
+      $scope.results = results;
+    }
+    else {
+      clearResults();
+    }
+    if(!$scope.$$phase) $scope.$apply();
+  };
+  $scope.submit = function() {
+    var result;
+    for(var i in $scope.results) {
+      result = $scope.results[i][0];
+      if(result) {
+        break;
+      }
+    }
+    if(result) {
+      $location.path(result.path);
+      $scope.hideResults();
+    }
+  };
+  $scope.hideResults = function() {
+    clearResults();
+    $scope.q = '';
+  };
+}])
+
+.controller('Error404SearchCtrl', ['$scope', '$location', 'docsSearch', function($scope, $location, docsSearch) {
+  $scope.results = docsSearch($location.path().split(/[\/\.:]/).pop());
+}])
+
+.factory('lunrSearch', function() {
+  return function(properties) {
+    if (window.RUNNING_IN_NG_TEST_RUNNER) return null;
+
+    var engine = lunr(properties);
+    return {
+      store : function(values) {
+        engine.add(values);
+      },
+      search : function(q) {
+        return engine.search(q);
+      }
+    };
+  };
+})
+
+.factory('docsSearch', ['$rootScope','lunrSearch', 'NG_PAGES',
+    function($rootScope, lunrSearch, NG_PAGES) {
+  if (window.RUNNING_IN_NG_TEST_RUNNER) {
+    return null;
+  }
+
+  var index = lunrSearch(function() {
+    this.ref('id');
+    this.field('title', {boost: 50});
+    this.field('keywords', { boost : 20 });
+  });
+
+  angular.forEach(NG_PAGES, function(page, key) {
+    if(page.searchTerms) {
+      index.store({
+        id : key,
+        title : page.searchTerms.titleWords,
+        keywords : page.searchTerms.keywords
+      });
+    };
+  });
+
+  return function(q) {
+    var results = {
+      api : [],
+      tutorial : [],
+      guide : [],
+      error : [],
+      misc : []
+    };
+    angular.forEach(index.search(q), function(result) {
+      var key = result.ref;
+      var item = NG_PAGES[key];
+      var area = item.area;
+      item.path = key;
+
+      var limit = area == 'api' ? 40 : 14;
+      if(results[area].length < limit) {
+        results[area].push(item);
+      }
+    });
+    return results;
+  };
+}])
+
+.directive('focused', function($timeout) {
+  return function(scope, element, attrs) {
+    element[0].focus();
+    element.on('focus', function() {
+      scope.$apply(attrs.focused + '=true');
+    });
+    element.on('blur', function() {
+      // have to use $timeout, so that we close the drop-down after the user clicks,
+      // otherwise when the user clicks we process the closing before we process the click.
+      $timeout(function() {
+        scope.$eval(attrs.focused + '=false');
+      });
+    });
+    scope.$eval(attrs.focused + '=true');
+  };
+})
+
+.directive('docsSearchInput', ['$document',function($document) {
+  return function(scope, element, attrs) {
+    var ESCAPE_KEY_KEYCODE = 27,
+        FORWARD_SLASH_KEYCODE = 191;
+    angular.element($document[0].body).bind('keydown', function(event) {
+      var input = element[0];
+      if(event.keyCode == FORWARD_SLASH_KEYCODE && document.activeElement != input) {
+        event.stopPropagation();
+        event.preventDefault();
+        input.focus();
+      }
+    });
+
+    element.bind('keydown', function(event) {
+      if(event.keyCode == ESCAPE_KEY_KEYCODE) {
+        event.stopPropagation();
+        event.preventDefault();
+        scope.$apply(function() {
+          scope.hideResults();
+        });
+      }
+    });
+  };
+}]);

docs/app/src/tutorials.js

@@ -0,0 +1,50 @@
+angular.module('tutorials', [])
+
+.directive('docTutorialNav', function(templateMerge) {
+  var pages = [
+    '',
+    'step_00', 'step_01', 'step_02', 'step_03', 'step_04',
+    'step_05', 'step_06', 'step_07', 'step_08', 'step_09',
+    'step_10', 'step_11', 'step_12', 'the_end'
+  ];
+  return {
+    compile: function(element, attrs) {
+      var seq = 1 * attrs.docTutorialNav,
+          props = {
+            seq: seq,
+            prev: pages[seq],
+            next: pages[2 + seq],
+            diffLo: seq ? (seq - 1): '0~1',
+            diffHi: seq
+          };
+
+      element.addClass('btn-group');
+      element.addClass('tutorial-nav');
+      element.append(templateMerge(
+        '<a href="tutorial/{{prev}}"><li class="btn btn-primary"><i class="glyphicon glyphicon-step-backward"></i> Previous</li></a>\n' +
+        '<a href="http://angular.github.io/angular-phonecat/step-{{seq}}/app"><li class="btn btn-primary"><i class="glyphicon glyphicon-play"></i> Live Demo</li></a>\n' +
+        '<a href="https://github.com/angular/angular-phonecat/compare/step-{{diffLo}}...step-{{diffHi}}"><li class="btn btn-primary"><i class="glyphicon glyphicon-search"></i> Code Diff</li></a>\n' +
+        '<a href="tutorial/{{next}}"><li class="btn btn-primary">Next <i class="glyphicon glyphicon-step-forward"></i></li></a>', props));
+    }
+  };
+})
+
+
+.directive('docTutorialReset', function() {
+  return {
+    scope: {
+      'step': '@docTutorialReset'
+    },
+    template:
+      '<p><a href="" ng-click="show=!show;$event.stopPropagation()">Workspace Reset Instructions  ➤</a></p>\n' +
+      '<div class="alert alert-info" ng-show="show">\n' +
+      '  <p>Reset the workspace to step {{step}}.</p>' +
+      '  <p><pre>git checkout -f step-{{step}}</pre></p>\n' +
+      '  <p>Refresh your browser or check out this step online: '+
+          '<a href="http://angular.github.io/angular-phonecat/step-{{step}}/app">Step {{step}} Live Demo</a>.</p>\n' +
+      '</div>\n' +
+      '<p>The most important changes are listed below. You can see the full diff on ' +
+        '<a ng-href="https://github.com/angular/angular-phonecat/compare/step-{{step ? (step - 1): \'0~1\'}}...step-{{step}}">GitHub</a>\n' +
+      '</p>'
+  };
+});

docs/app/src/versions.js

@@ -0,0 +1,31 @@
+"use strict";
+
+angular.module('versions', [])
+
+.controller('DocsVersionsCtrl', ['$scope', '$location', '$window', 'NG_VERSIONS', function($scope, $location, $window, NG_VERSIONS) {
+  $scope.docs_version  = NG_VERSIONS[0];
+
+  for(var i=0, minor = NaN; i < NG_VERSIONS.length; i++) {
+    var version = NG_VERSIONS[i];
+    // NaN will give false here
+    if (minor <= version.minor) {
+      continue;
+    }
+    version.isLatest = true;
+    minor = version.minor;
+  }
+
+  $scope.docs_versions = NG_VERSIONS;
+  $scope.getGroupName = function(v) {
+    return v.isLatest ? 'Latest' : (v.isStable ? 'Stable' : 'Unstable');
+  };
+
+  $scope.jumpToDocsVersion = function(version) {
+    var currentPagePath = $location.path();
+
+    // TODO: We need to do some munging of the path for different versions of the API...
+
+
+    $window.location = version.docsUrl + currentPagePath;
+  };
+}]);

docs/app/test/docsSpec.js

@@ -0,0 +1,34 @@
+describe("DocsController", function() {
+  var $scope;
+
+  angular.module('fake', [])
+    .value('$cookies', {})
+    .value('openPlunkr', function() {})
+    .value('NG_PAGES', {})
+    .value('NG_NAVIGATION', {})
+    .value('NG_VERSION', {});
+
+  beforeEach(module('fake', 'DocsController'));
+  beforeEach(inject(function($rootScope, $controller) {
+    $scope = $rootScope;
+    $controller('DocsController', { $scope: $scope });
+  }));
+
+
+  describe('afterPartialLoaded', function() {
+    it("should update the Google Analytics with currentPage path if currentPage exists", inject(function($window) {
+      $window._gaq = [];
+      $scope.currentPage = { path: 'a/b/c' };
+      $scope.afterPartialLoaded();
+      expect($window._gaq.pop()).toEqual(['_trackPageview', 'a/b/c']);
+    }));
+
+
+    it("should update the Google Analytics with $location.path if currentPage is missing", inject(function($window, $location) {
+      $window._gaq = [];
+      spyOn($location, 'path').andReturn('x/y/z');
+      $scope.afterPartialLoaded();
+      expect($window._gaq.pop()).toEqual(['_trackPageview', 'x/y/z']);
+    }));
+  });
+});

docs/component-spec/bootstrap/bootstrapSpec.js

@@ -1,157 +0,0 @@
-'use strict';
-
-describe('bootstrap', function() {
-  var $compile, $rootScope, element;
-
-  function clickTab(element, index) {
-    browserTrigger(element.children().eq(0).children().eq(index));
-  }
-
-  beforeEach(module('bootstrap'));
-  beforeEach(inject(function(_$compile_, _$rootScope_) {
-    $compile = _$compile_;
-    $rootScope = _$rootScope_;
-  }));
-  beforeEach(function(){
-    function findTab(element, index) {
-      return _jQuery(element[0]).find('> .nav-tabs > li').eq(index);
-    }
-    function findTabPane(element, index) {
-      return _jQuery(element[0]).find('> .tab-content > .tab-pane').eq(index);
-    }
-
-    this.addMatchers({
-      toHaveTab: function(index, title) {
-        var tab = findTab(element, index);
-
-        this.message = function() {
-          if (tab.length) {
-            return 'Expect tab index ' + index + ' to be ' + toJson(title) + ' but was ' + toJson(tab.text());
-          } else {
-            return 'Expect tab index ' + index + ' to be ' + toJson(title) + ' but there are only ' +
-              element.children().length + ' tabs.';
-          }
-        };
-
-        return tab.length && tab.text() == title;
-      },
-
-      toHaveTabPane: function(index, title) {
-        var tabPane = findTabPane(element, index);
-
-        this.message = function() {
-          if (tabPane.length) {
-            return 'Expect tab pane index ' + index + ' to be ' + toJson(title) + ' but was ' + toJson(tabPane.text());
-          } else {
-            return 'Expect tab pane index ' + index + ' to be ' + toJson(title) + ' but there are only ' +
-              element.children().length + 'tab panes.';
-          }
-        };
-
-        return tabPane.length && tabPane.text() == title;
-      },
-
-      toHaveSelected: function(index) {
-        var tab = findTab(element, index);
-        var tabPane = findTabPane(element, index);
-
-        this.message = function() {
-          return 'Expect tab  index ' + index + ' to be selected\n' +
-            '     TAB: ' + angular.mock.dump(tab) + '\n' +
-            'TAB-PANE: ' + angular.mock.dump(tabPane);
-        };
-
-        return tabPane.hasClass('active') && tab.hasClass('active');
-      }
-    });
-  });
-
-  afterEach(function() {
-    dealoc(element);
-  });
-
-  describe('tabbable', function() {
-
-    it('should create the right structure', function() {
-      element = $compile(
-        '<div class="tabbable">' +
-          '<div class="tab-pane" title="first">tab1</div>' +
-          '<div class="tab-pane" title="second">tab2</div>' +
-        '</div>')($rootScope);
-
-      $rootScope.$apply();
-
-      expect(element).toHaveTab(0, 'first');
-      expect(element).toHaveTab(1, 'second');
-
-      expect(element).toHaveTabPane(0, 'tab1');
-      expect(element).toHaveTabPane(1, 'tab2');
-
-      expect(element).toHaveSelected(0);
-    });
-
-
-    it('should respond to tab click', function(){
-      element = $compile(
-        '<div class="tabbable">' +
-          '<div class="tab-pane" title="first">tab1</div>' +
-          '<div class="tab-pane" title="second">tab2</div>' +
-          '</div>')($rootScope);
-
-      expect(element).toHaveSelected(0);
-      clickTab(element, 1);
-      expect(element).toHaveSelected(1);
-    });
-
-
-    it('should select the first tab in repeater', function() {
-      element = $compile(
-        '<div class="tabbable">' +
-          '<div class="tab-pane" ng-repeat="id in [1,2,3]" title="Tab {{id}}" value="tab-{{id}}">' +
-          'Tab content {{id}}!' +
-          '</div>' +
-        '</div>')($rootScope);
-      $rootScope.$apply();
-
-      expect(element).toHaveSelected(0);
-    });
-
-
-    describe('ngModel', function() {
-      it('should bind to model', function() {
-        $rootScope.tab = 'B';
-
-        element = $compile(
-          '<div class="tabbable" ng-model="tab">' +
-            '<div class="tab-pane" title="first" value="A">tab1</div>' +
-            '<div class="tab-pane" title="second" value="B">tab2</div>' +
-          '</div>')($rootScope);
-
-        $rootScope.$apply();
-        expect(element).toHaveSelected(1);
-
-        $rootScope.tab = 'A';
-        $rootScope.$apply();
-        expect(element).toHaveSelected(0);
-
-        clickTab(element, 1);
-        expect($rootScope.tab).toEqual('B');
-        expect(element).toHaveSelected(1);
-      });
-
-
-      it('should not overwrite the model', function() {
-        $rootScope.tab = 'tab-2';
-        element = $compile(
-        '<div class="tabbable" ng-model="tab">' +
-            '<div class="tab-pane" ng-repeat="id in [1,2,3]" title="Tab {{id}}" value="tab-{{id}}">' +
-            'Tab content {{id}}!' +
-            '</div>' +
-            '</div>')($rootScope);
-        $rootScope.$apply();
-
-        expect(element).toHaveSelected(1);
-      });
-    });
-  });
-});

docs/component-spec/bootstrap/code.html

@@ -1,91 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <script src="../../src/angular-bootstrap.js"></script>
-    <script type="text/javascript">
-      $script('src/bootstrap/google-prettify/prettify', 'prettify');
-      $script.ready('angular', function() {
-        $script(['src/bootstrap/bootstrap-prettify', 'src/bootstrap/bootstrap'], 'myCode');
-        angular.module('myApp', []).run(function($rootScope){ $rootScope.text = 'WORKS!' });
-      });
-      $script.ready(['myCode', 'prettify'], function() {
-        angular.bootstrap(document, ['bootstrapPrettify', 'bootstrap']);
-      });
-    </script>
-    <link rel="stylesheet" href="../../src/bootstrap/google-prettify/prettify.css" type="text/css">
-    <link rel="stylesheet" href="../../src/bootstrap/css/bootstrap.css" type="text/css">
-  </head>
-  <body>
-    <div class="container">
-      <div class="row">
-        <div class="span12">
-          <h1>AngularJS is {{'working'}}</h1>
-
-          <h2>Directive: <code>prettify</code></h2>
-          <pre class="prettyprint linenums">
-            &lt;p&gt;Sample text here...&lt;/p&gt;
-          </pre>
-
-
-          <h2>Directive: <code>ng-set-text</code></h2>
-          <pre class="prettyprint linenums" ng-set-text="hello.html"></pre>
-          <script type="text/html" id="hello.html">
-            <h1>Hello World!</h1>
-          </script>
-
-          <h2>Directive: <code>ng-html-wrap</code></h2>
-          <pre class="prettyprint linenums" ng-set-text="hello.html" ng-html-wrap="angular.js angular-resource.js myApp abc.js abc.css"></pre>
-
-          <h2>Directive <code>ng-embed-app</code></h2>
-          <div ng-embed-app="myApp">{{text}}</div>
-
-          <h1>Bootstrap</h1>
-
-          <h2>Directive <code>drop-down-toggle</code></h2>
-          <div class="btn btn-primary dropdown">
-            <a href="#ABC" class="dropdown-toggle">
-              Account
-              <b class="caret"></b>
-            </a>
-            <ul class="dropdown-menu">
-              <li>One</li>
-              <li>Two</li>
-            </ul>
-          </div>
-
-          <h2 ng-init="state = 'tab-2' ">Directive <code>tabbable</code></h2>
-          state = {{state}}
-
-          <div class="tabbable" ng-model="state">
-            <div class="tab-pane" ng-repeat="id in [1,2,3]" title="Tab {{id}}" value='tab-{{id}}'>
-              Tab content {{id}}!
-            </div>
-          </div>
-
-          <hr/>
-
-          <div class="tabbable" ng-model="state">
-            <div class="tab-pane" ng-repeat="id in [1,2,3]" title="Tab {{id}}" value='tab-{{id}}'>
-              Tab content {{id}}!
-            </div>
-          </div>
-
-          <hr/>
-
-          <div class="tabbable">
-            <div class="tab-pane" ng-repeat="id in [1,2,3]" title="Tab {{id}}" value='tab-{{id}}'>
-              Tab content {{id}}!
-            </div>
-          </div>
-
-        </div>
-      </div>
-    </div>
-    <br/>
-    <br/>
-    <br/>
-    <br/>
-    <br/>
-    <br/>
-  </body>
-</html>

docs/component-spec/syntaxSpec.js

@@ -1,50 +0,0 @@
-describe('Docs Syntax', function() {
-
-  beforeEach(module('bootstrap'));
-
-  describe('syntax', function() {
-
-    var id, element, document;
-
-    beforeEach(inject(function($compile, $rootScope, $document) {
-      document = $document[0];
-      //create the HTML elements missing in IE8 for this directive
-      document.createElement('nav');
-
-      element = angular.element(
-        '<div>' +
-          '<pre syntax ' +
-            'syntax-github="gh-url" ' +
-            'syntax-plunkr="pl-url" ' +
-            'syntax-fiddle="jf-url">' +
-          '</pre>' +
-        '</div>'
-      );
-      $compile(element)($rootScope);
-      $rootScope.$digest();
-
-      element = element[0];
-      document.body.appendChild(element);
-    }));
-
-    it("should properly prepare a github link in the page", function() {
-      var github = element.querySelector('.syntax-github');
-      expect(github.innerHTML).toMatch(/View on Github/i);
-      expect(github.getAttribute('href')).toBe('gh-url');
-    });
-
-    it("should properly prepare a plunkr link in the page", function() {
-      var plunkr = element.querySelector('.syntax-plunkr');
-      expect(plunkr.innerHTML).toMatch(/View on Plunkr/i);
-      expect(plunkr.getAttribute('href')).toBe('pl-url');
-    });
-
-    it("should properly prepare a jsfiddle link in the page", function() {
-      var jsfiddle = element.querySelector('.syntax-jsfiddle');
-      expect(jsfiddle.innerHTML).toMatch(/View on JSFiddle/i);
-      expect(jsfiddle.getAttribute('href')).toBe('jf-url');
-    });
-
-  });
-
-});

docs/components/angular-bootstrap.js

@@ -1,227 +0,0 @@
-
-/*!
- * $script.js Async loader & dependency manager
- * https://github.com/ded/script.js
- * (c) Dustin Diaz, Jacob Thornton 2011
- * License: MIT
- */
-(function (name, definition, context) {
-  if (typeof context['module'] != 'undefined' && context['module']['exports']) context['module']['exports'] = definition()
-  else if (typeof context['define'] != 'undefined' && context['define'] == 'function' && context['define']['amd']) define(name, definition)
-  else context[name] = definition()
-})('$script', function () {
-  var doc = document
-    , head = doc.getElementsByTagName('head')[0]
-    , validBase = /^https?:\/\//
-    , list = {}, ids = {}, delay = {}, scriptpath
-    , scripts = {}, s = 'string', f = false
-    , push = 'push', domContentLoaded = 'DOMContentLoaded', readyState = 'readyState'
-    , addEventListener = 'addEventListener', onreadystatechange = 'onreadystatechange'
-
-  function every(ar, fn) {
-    for (var i = 0, j = ar.length; i < j; ++i) if (!fn(ar[i])) return f
-    return 1
-  }
-  function each(ar, fn) {
-    every(ar, function(el) {
-      return !fn(el)
-    })
-  }
-
-  if (!doc[readyState] && doc[addEventListener]) {
-    doc[addEventListener](domContentLoaded, function fn() {
-      doc.removeEventListener(domContentLoaded, fn, f)
-      doc[readyState] = 'complete'
-    }, f)
-    doc[readyState] = 'loading'
-  }
-
-  function $script(paths, idOrDone, optDone) {
-    paths = paths[push] ? paths : [paths]
-    var idOrDoneIsDone = idOrDone && idOrDone.call
-      , done = idOrDoneIsDone ? idOrDone : optDone
-      , id = idOrDoneIsDone ? paths.join('') : idOrDone
-      , queue = paths.length
-    function loopFn(item) {
-      return item.call ? item() : list[item]
-    }
-    function callback() {
-      if (!--queue) {
-        list[id] = 1
-        done && done()
-        for (var dset in delay) {
-          every(dset.split('|'), loopFn) && !each(delay[dset], loopFn) && (delay[dset] = [])
-        }
-      }
-    }
-    setTimeout(function () {
-      each(paths, function (path) {
-        if (scripts[path]) {
-          id && (ids[id] = 1)
-          return scripts[path] == 2 && callback()
-        }
-        scripts[path] = 1
-        id && (ids[id] = 1)
-        create(!validBase.test(path) && scriptpath ? scriptpath + path + '.js' : path, callback)
-      })
-    }, 0)
-    return $script
-  }
-
-  function create(path, fn) {
-    var el = doc.createElement('script')
-      , loaded = f
-    el.onload = el.onerror = el[onreadystatechange] = function () {
-      if ((el[readyState] && !(/^c|loade/.test(el[readyState]))) || loaded) return;
-      el.onload = el[onreadystatechange] = null
-      loaded = 1
-      scripts[path] = 2
-      fn()
-    }
-    el.async = 1
-    el.src = path
-    head.insertBefore(el, head.firstChild)
-  }
-
-  $script.get = create
-
-  $script.order = function (scripts, id, done) {
-    (function callback(s) {
-      s = scripts.shift()
-      if (!scripts.length) $script(s, id, done)
-      else $script(s, callback)
-    }())
-  }
-
-  $script.path = function (p) {
-    scriptpath = p
-  }
-  $script.ready = function (deps, ready, req) {
-    deps = deps[push] ? deps : [deps]
-    var missing = [];
-    !each(deps, function (dep) {
-      list[dep] || missing[push](dep);
-    }) && every(deps, function (dep) {return list[dep]}) ?
-      ready() : !function (key) {
-      delay[key] = delay[key] || []
-      delay[key][push](ready)
-      req && req(missing)
-    }(deps.join('|'))
-    return $script
-  }
-  return $script
-}, this);
-
-
-/**
- * @license AngularJS
- * (c) 2010-2012 Google, Inc. http://angularjs.org
- * License: MIT
- */
-(function(window, document) {
-
-  var filename = /^(.*\/)angular-bootstrap.js(#.*)?$/,
-      scripts = document.getElementsByTagName("SCRIPT"),
-      serverPath,
-      match,
-      globalVars = {},
-      IGNORE = {
-        innerHeight: true, innerWidth: true,
-        onkeyup: true, onkeydown: true, onresize: true,
-        event: true, frames: true, external: true,
-        sessionStorage: true, clipboardData: true, localStorage: true};
-
-  for(var j = 0; j < scripts.length; j++) {
-    match = (scripts[j].src || "").match(filename);
-    if (match) {
-      serverPath = match[1];
-    }
-  }
-
-  document.write('<link rel="stylesheet" type="text/css" href="' + serverPath + '../css/angular.css"/>');
-
-  $script.path(serverPath+'../');
-  $script('angularFiles', function() {
-    var index = 0,
-        scripts = angularFiles.angularSrc;
-
-    try { delete window.angularFiles; } catch(e) { window.angularFiles = undefined; }
-    // initialize the window property cache
-    for (var prop in window) {
-      if (IGNORE[prop] || prop.match(/^moz[A-Z]/)) { //skip special variables which keep on changing
-        continue;
-      }
-      try {
-        globalVars[key(prop)] = window[prop];
-      } catch(e) {} //ignore properties that throw exception when accessed (common in FF)
-    }
-
-    (function next() {
-      if (index < scripts.length) {
-        var file = scripts[index++],
-            last = index == scripts.length,
-            name = last ? 'angular' : file;
-
-        $script(file.replace(/\.js$/, ''), name, function() {
-          angularClobberTest(file);
-          next();
-        });
-      } else {
-        // empty the cache to prevent mem leaks
-        globalVars = {};
-
-        bindJQuery();
-        publishExternalAPI(window.angular);
-
-        angularInit(document, angular.bootstrap);
-      }
-    })();
-  });
-
-  function key(prop) {
-    return "ng-clobber_" + prop;
-  }
-
-  function angularClobberTest(file) {
-    var varKey, prop,
-        clobbered = {};
-
-    for (prop in window) {
-      varKey = key(prop);
-
-      if (IGNORE[prop] || prop.match(/^moz[A-Z]/)) { //skip special variables which keep on changing
-        continue;
-      } else if (!globalVars.hasOwnProperty(varKey)) {
-        //console.log('new global variable found: ', prop);
-        try {
-          globalVars[varKey] = window[prop];
-        } catch(e) {} //ignore properties that throw exception when accessed (common in FF)
-      } else if (globalVars[varKey] !== window[prop] && !isActuallyNaN(window[prop]) && prop != 'jqLite') {
-        clobbered[prop] = true;
-        console.error("Global variable clobbered by script " + file + "! Variable name: " + prop);
-        globalVars[varKey] = window[prop];
-      }
-    }
-    for (varKey in globalVars) {
-      prop = varKey.substr(11);
-      if (prop === 'event' || prop.match(/^moz[A-Z]/)) { //skip special variables which keep on changing
-        continue;
-      }
-      if (!clobbered[prop] &&
-          prop != 'event' &&
-          prop != 'jqLite' &&
-          !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 (typeof val === 'number') && isNaN(val);
-    }
-  }
-})(window, document);
-

docs/components/bootstrap/bootstrap.js

@@ -1,212 +0,0 @@
-'use strict';
-
-var directive = {};
-
-directive.dropdownToggle =
-          ['$document', '$location', '$window',
-  function ($document,   $location,   $window) {
-    var openElement = null, close;
-    return {
-      restrict: 'C',
-      link: function(scope, element, attrs) {
-        scope.$watch(function dropdownTogglePathWatch(){return $location.path();}, function dropdownTogglePathWatchAction() {
-          close && close();
-        });
-
-        element.parent().bind('click', function(event) {
-          close && close();
-        });
-
-        element.bind('click', function(event) {
-          event.preventDefault();
-          event.stopPropagation();
-
-          var iWasOpen = false;
-
-          if (openElement) {
-            iWasOpen = openElement === element;
-            close();
-          }
-
-          if (!iWasOpen){
-            element.parent().addClass('open');
-            openElement = element;
-
-            close = function (event) {
-              event && event.preventDefault();
-              event && event.stopPropagation();
-              $document.unbind('click', close);
-              element.parent().removeClass('open');
-              close = null;
-              openElement = null;
-            }
-
-            $document.bind('click', close);
-          }
-        });
-      }
-    };
-  }];
-
-directive.syntax = function() {
-  return {
-    restrict: 'A',
-    link: function(scope, element, attrs) {
-      function makeLink(type, text, link, icon) {
-        return '<a href="' + link + '" class="btn syntax-' + type + '" target="_blank" rel="nofollow">' + 
-                '<span class="' + icon + '"></span> ' + text +
-               '</a>';
-      };
-
-      var html = '';
-      var types = {
-        'github' : {
-          text : 'View on Github',
-          key : 'syntaxGithub',
-          icon : 'icon-github'
-        },
-        'plunkr' : {
-          text : 'View on Plunkr',
-          key : 'syntaxPlunkr',
-          icon : 'icon-arrow-down'
-        },
-        'jsfiddle' : {
-          text : 'View on JSFiddle',
-          key : 'syntaxFiddle',
-          icon : 'icon-cloud'
-        }
-      };
-      for(var type in types) {
-        var data = types[type];
-        var link = attrs[data.key];
-        if(link) {
-          html += makeLink(type, data.text, link, data.icon);
-        }
-      };
-
-      var nav = document.createElement('nav');
-      nav.className = 'syntax-links';
-      nav.innerHTML = html;
-
-      var node = element[0];
-      var par = node.parentNode;
-      par.insertBefore(nav, node);
-    }
-  }
-}
-
-directive.tabbable = function() {
-  return {
-    restrict: 'C',
-    compile: function(element) {
-      var navTabs = angular.element('<ul class="nav nav-tabs"></ul>'),
-          tabContent = angular.element('<div class="tab-content"></div>');
-
-      tabContent.append(element.contents());
-      element.append(navTabs).append(tabContent);
-    },
-    controller: ['$scope', '$element', function($scope, $element) {
-      var navTabs = $element.contents().eq(0),
-          ngModel = $element.controller('ngModel') || {},
-          tabs = [],
-          selectedTab;
-
-      ngModel.$render = function() {
-        var $viewValue = this.$viewValue;
-
-        if (selectedTab ? (selectedTab.value != $viewValue) : $viewValue) {
-          if(selectedTab) {
-            selectedTab.paneElement.removeClass('active');
-            selectedTab.tabElement.removeClass('active');
-            selectedTab = null;
-          }
-          if($viewValue) {
-            for(var i = 0, ii = tabs.length; i < ii; i++) {
-              if ($viewValue == tabs[i].value) {
-                selectedTab = tabs[i];
-                break;
-              }
-            }
-            if (selectedTab) {
-              selectedTab.paneElement.addClass('active');
-              selectedTab.tabElement.addClass('active');
-            }
-          }
-
-        }
-      };
-
-      this.addPane = function(element, attr) {
-        var li = angular.element('<li><a href></a></li>'),
-            a = li.find('a'),
-            tab = {
-              paneElement: element,
-              paneAttrs: attr,
-              tabElement: li
-            };
-
-        tabs.push(tab);
-
-        attr.$observe('value', update)();
-        attr.$observe('title', function(){ update(); a.text(tab.title); })();
-
-        function update() {
-          tab.title = attr.title;
-          tab.value = attr.value || attr.title;
-          if (!ngModel.$setViewValue && (!ngModel.$viewValue || tab == selectedTab)) {
-            // we are not part of angular
-            ngModel.$viewValue = tab.value;
-          }
-          ngModel.$render();
-        }
-
-        navTabs.append(li);
-        li.bind('click', function(event) {
-          event.preventDefault();
-          event.stopPropagation();
-          if (ngModel.$setViewValue) {
-            $scope.$apply(function() {
-              ngModel.$setViewValue(tab.value);
-              ngModel.$render();
-            });
-          } else {
-            // we are not part of angular
-            ngModel.$viewValue = tab.value;
-            ngModel.$render();
-          }
-        });
-
-        return function() {
-          tab.tabElement.remove();
-          for(var i = 0, ii = tabs.length; i < ii; i++ ) {
-            if (tab == tabs[i]) {
-              tabs.splice(i, 1);
-            }
-          }
-        };
-      }
-    }]
-  };
-};
-
-directive.table = function() {
-  return {
-    restrict: 'E',
-    link: function(scope, element, attrs) {
-      element[0].className = 'table table-bordered table-striped code-table';
-    }
-  };
-};
-
-directive.tabPane = function() {
-  return {
-    require: '^tabbable',
-    restrict: 'C',
-    link: function(scope, element, attrs, tabsCtrl) {
-      element.bind('$remove', tabsCtrl.addPane(element, attrs));
-    }
-  };
-};
-
-
-angular.module('bootstrap', []).directive(directive);

docs/components/bootstrap/google-prettify/prettify.css

@@ -1,30 +0,0 @@
-.com { color: #93a1a1; }
-.lit { color: #195f91; }
-.pun, .opn, .clo { color: #93a1a1; }
-.fun { color: #dc322f; }
-.str, .atv { color: #D14; }
-.kwd, .linenums .tag { color: #1e347b; }
-.typ, .atn, .dec, .var { color: teal; }
-.pln { color: #48484c; }
-
-.prettyprint {
-  padding: 8px;
-  background-color: #f7f7f9;
-  border: 1px solid #e1e1e8;
-}
-.prettyprint.linenums {
-  -webkit-box-shadow: inset 40px 0 0 #fbfbfc, inset 41px 0 0 #ececf0;
-     -moz-box-shadow: inset 40px 0 0 #fbfbfc, inset 41px 0 0 #ececf0;
-          box-shadow: inset 40px 0 0 #fbfbfc, inset 41px 0 0 #ececf0;
-}
-
-/* Specify class=linenums on a pre to get line numbering */
-ol.linenums {
-  margin: 0 0 0 33px; /* IE indents via margin-left */
-} 
-ol.linenums li {
-  padding-left: 12px;
-  color: #bebec5;
-  line-height: 18px;
-  text-shadow: 0 1px 0 #fff;
-}

docs/config/index.js

@@ -0,0 +1,43 @@
+var _ = require('lodash');
+var path = require('canonical-path');
+var packagePath = __dirname;
+
+var basePackage = require('dgeni-packages/ngdoc');
+var examplesPackage = require('dgeni-packages/examples');
+
+module.exports = function(config) {
+
+  config = basePackage(config);
+  config = examplesPackage(config);
+
+  config.append('processing.processors', [
+    require('./processors/git-data'),
+    require('./processors/error-docs'),
+    require('./processors/keywords'),
+    require('./processors/versions-data'),
+    require('./processors/pages-data'),
+    require('./processors/protractor-generate'),
+    require('./processors/index-page'),
+    require('./processors/debug-dump')
+  ]);
+
+  config.append('processing.tagDefinitions', [
+    require('./tag-defs/tutorial-step')
+  ]);
+
+  config.append('processing.defaultTagTransforms', [
+    require('dgeni-packages/jsdoc/tag-defs/transforms/trim-whitespace')
+  ]);
+
+  config.append('processing.inlineTagDefinitions', [
+    require('./inline-tag-defs/type')
+  ]);
+
+  config.set('processing.search.ignoreWordsFile', path.resolve(packagePath, 'ignore.words'));
+
+  config.prepend('rendering.templateFolders', [
+    path.resolve(packagePath, 'templates')
+  ]);
+
+  return config;
+};

docs/config/inline-tag-defs/type.js

@@ -0,0 +1,12 @@
+var typeClassFilter = require('dgeni-packages/ngdoc/rendering/filters/type-class');
+var encoder = new require('node-html-encoder').Encoder();
+
+module.exports = {
+  name: 'type',
+  description: 'Replace with markup that displays a nice type',
+  handlerFactory: function() {
+    return function(doc, tagName, tagDescription) {
+      return '<a href="" class="' + typeClassFilter.process(tagDescription) + '">'+encoder.htmlEncode(tagDescription) + '</a>';
+    };
+  }
+};

docs/config/processors/debug-dump.js

@@ -0,0 +1,33 @@
+var fs = require('q-io/fs');
+var log = require('winston');
+var util = require("util");
+
+module.exports = {
+  name: 'debug-dump',
+  runBefore: ['write-files'],
+  description: 'This processor dumps docs that match a filter to a file',
+  process: function(docs, config) {
+
+    var filter, outputPath, depth;
+
+    filter = config.get('processing.debug-dump.filter');
+    outputPath = config.get('processing.debug-dump.outputPath');
+    depth = config.get('processing.debug-dump.depth', 2);
+
+
+    if ( filter && outputPath ) {
+      log.info('Dumping docs:', filter, outputPath);
+      var filteredDocs = filter(docs);
+      var dumpedDocs = util.inspect(filteredDocs, depth);
+      return writeFile(outputPath, dumpedDocs).then(function() {
+        return docs;
+      });
+    }
+  }
+};
+
+function writeFile(file, content) {
+  return fs.makeTree(fs.directory(file)).then(function() {
+    return fs.write(file, content, 'wb');
+  });
+}

docs/config/processors/error-docs.js

@@ -0,0 +1,59 @@
+var _ = require('lodash');
+var log = require('winston');
+var path = require('canonical-path');
+
+module.exports = {
+  name: 'error-docs',
+  description: 'Compute the various fields for docs in the Error area',
+  runAfter: ['tags-extracted', 'compute-path'],
+  runBefore: ['extra-docs-added'],
+  exports: {
+    errorNamespaces: ['factory', function() { return {}; }],
+    minerrInfo: ['factory', function(config) {
+      var minerrInfoPath = config.get('processing.errors.minerrInfoPath');
+      if ( !minerrInfoPath ) {
+        throw new Error('Error in configuration: Please provide a path to the minerr info file (errors.json) ' +
+          'in the `config.processing.errors.minerrInfoPath` property');
+      }
+      return require(minerrInfoPath);
+    }]
+  },
+  process: function(docs, partialNames, errorNamespaces, minerrInfo) {
+
+    // Create error namespace docs and attach error docs to each
+    _.forEach(docs, function(doc) {
+      if ( doc.docType === 'error' ) {
+
+        // Parse out the error info from the id
+        parts = doc.name.split(':');
+        doc.namespace = parts[0];
+        doc.name = parts[1];
+
+
+        var namespaceDoc = errorNamespaces[doc.namespace];
+        if ( !namespaceDoc ) {
+          // First time we came across this namespace, so create a new one
+          namespaceDoc = errorNamespaces[doc.namespace] = {
+            area: doc.area,
+            name: doc.namespace,
+            errors: [],
+            path: path.dirname(doc.path),
+            outputPath: path.dirname(doc.outputPath) + '.html',
+            docType: 'errorNamespace'
+          };
+        }
+
+        // Add this error to the namespace
+        namespaceDoc.errors.push(doc);
+        doc.namespace = namespaceDoc;
+
+        doc.formattedErrorMessage = minerrInfo.errors[doc.namespace.name][doc.name];
+
+      }
+
+    });
+
+
+    return docs.concat(_.values(errorNamespaces));
+  }
+};

docs/config/processors/git-data.js

@@ -0,0 +1,20 @@
+var gruntUtils = require('../../../lib/grunt/utils');
+var versionInfo = require('../../../lib/versions/version-info');
+
+module.exports = {
+  name: 'git-data',
+  runBefore: ['reading-files'],
+  description: 'This processor adds information from the local git repository to the extraData injectable',
+  exports: {
+    gitData: ['factory', function() {
+      return {
+        version: versionInfo.currentVersion,
+        versions: versionInfo.previousVersions,
+        info: versionInfo.gitRepoInfo
+      };
+    }]
+  },
+  process: function(extraData, gitData) {
+    extraData.git = gitData;
+  }
+};

docs/config/processors/index-page.js

@@ -0,0 +1,40 @@
+var _ = require('lodash');
+var log = require('winston');
+var path = require('canonical-path');
+
+module.exports = {
+  name: 'index-page',
+  runAfter: ['adding-extra-docs'],
+  runBefore: ['extra-docs-added'],
+  description: 'This processor creates docs that will be rendered as the index page for the app',
+  process: function(docs, config) {
+
+    var deployment = config.deployment;
+    if ( !deployment || !deployment.environments ) {
+      throw new Error('No deployment environments found in the config.');
+    }
+
+    // Collect up all the areas in the docs
+    var areas = {};
+    _.forEach(docs, function(doc) {
+      if ( doc.area ) {
+        areas[doc.area] = doc.area;
+      }
+    });
+    areas = _.keys(areas);
+
+    _.forEach(deployment.environments, function(environment) {
+
+      var indexDoc = _.defaults({
+        docType: 'indexPage',
+        areas: areas
+      }, environment);
+
+      indexDoc.id = 'index' + (environment.name === 'default' ? '' : '-' + environment.name);
+      // Use .. to put it at the root of the build
+      indexDoc.outputPath = indexDoc.id + '.html';
+
+      docs.push(indexDoc);
+    });
+  }
+};

docs/config/processors/keywords.js

@@ -0,0 +1,88 @@
+var _ = require('lodash');
+var log = require('winston');
+var fs = require('fs');
+var path = require('canonical-path');
+
+module.exports = {
+  name: 'keywords',
+  runAfter: ['docs-processed'],
+  runBefore: ['adding-extra-docs'],
+  description: 'This processor extracts all the keywords from the document',
+  process: function(docs, config) {
+
+    // Keywords to ignore
+    var wordsToIgnore = [];
+    var propertiesToIgnore;
+    var areasToSearch;
+
+    // Keywords start with "ng:" or one of $, _ or a letter
+    var KEYWORD_REGEX = /^((ng:|[\$_a-z])[\w\-_]+)/;
+
+    // Load up the keywords to ignore, if specified in the config
+    if ( config.processing.search && config.processing.search.ignoreWordsFile ) {
+
+      var ignoreWordsPath = path.resolve(config.basePath, config.processing.search.ignoreWordsFile);
+      wordsToIgnore = fs.readFileSync(ignoreWordsPath, 'utf8').toString().split(/[,\s\n\r]+/gm);
+
+      log.debug('Loaded ignore words from "' + ignoreWordsPath + '"');
+      log.silly(wordsToIgnore);
+
+    }
+
+    areasToSearch = _.indexBy(config.get('processing.search.areasToSearch', ['api', 'guide', 'misc', 'error', 'tutorial']));
+
+    propertiesToIgnore = _.indexBy(config.get('processing.search.propertiesToIgnore', []));
+    log.debug('Properties to ignore', propertiesToIgnore);
+
+    var ignoreWordsMap = _.indexBy(wordsToIgnore);
+
+    // If the title contains a name starting with ng, e.g. "ngController", then add the module name
+    // without the ng to the title text, e.g. "controller".
+    function extractTitleWords(title) {
+      var match = /ng([A-Z]\w*)/.exec(title);
+      if ( match ) {
+        title = title + ' ' + match[1].toLowerCase();
+      }
+      return title;
+    }
+
+    function extractWords(text, words, keywordMap) {
+
+      var tokens = text.toLowerCase().split(/[\.\s,`'"#]+/mg);
+      _.forEach(tokens, function(token){
+        var match = token.match(KEYWORD_REGEX);
+        if (match){
+          key = match[1];
+          if ( !keywordMap[key]) {
+            keywordMap[key] = true;
+            words.push(key);
+          }
+        }
+      });
+    }
+
+
+    // We are only interested in docs that live in the right area
+    docs = _.filter(docs, function(doc) { return areasToSearch[doc.area]; });
+
+    _.forEach(docs, function(doc) {
+
+      var words = [];
+      var keywordMap = _.clone(ignoreWordsMap);
+
+      // Search each top level property of the document for search terms
+      _.forEach(doc, function(value, key) {
+        if ( _.isString(value) && !propertiesToIgnore[key] ) {
+          extractWords(value, words, keywordMap);
+        }
+      });
+
+      doc.searchTerms = {
+        titleWords: extractTitleWords(doc.name),
+        keywords: _.sortBy(words).join(' ')
+      };
+
+    });
+
+  }
+};

docs/config/processors/pages-data.js

@@ -0,0 +1,214 @@
+var _ = require('lodash');
+var path = require('canonical-path');
+var log = require('winston');
+
+var AREA_NAMES = {
+  api: 'API',
+  guide: 'Developer Guide',
+  misc: 'Miscellaneous',
+  tutorial: 'Tutorial',
+  error: 'Error Reference'
+};
+
+function getNavGroup(pages, area, pageSorter, pageMapper) {
+
+  var navItems = _(pages)
+    // We don't want the child to include the index page as this is already catered for
+    .omit(function(page) { return page.id === 'index'; })
+
+    // Apply the supplied sorting function
+    .sortBy(pageSorter)
+
+    // Apply the supplied mapping function
+    .map(pageMapper)
+
+    .value();
+
+  return {
+    name: area.name,
+    type: 'group',
+    href: area.id,
+    navItems: navItems
+  };
+}
+
+
+var navGroupMappers = {
+  api: function(areaPages, area) {
+    var navGroups = _(areaPages)
+      .filter('module') // We are not interested in docs that are not in a module
+
+      .groupBy('module')
+
+      .map(function(modulePages, moduleName) {
+        log.debug('moduleName: ' + moduleName);
+        var navItems = [];
+        var modulePage;
+
+        _(modulePages)
+
+          .groupBy('docType')
+
+          .tap(function(docTypes) {
+            log.debug(_.keys(docTypes));
+            // Extract the module page from the collection
+            modulePage = docTypes.module[0];
+            delete docTypes.module;
+          })
+
+          .tap(function(docTypes) {
+            if ( docTypes.input ) {
+              docTypes.directive = docTypes.directive || [];
+              // Combine input docTypes into directive docTypes
+              docTypes.directive = docTypes.directive.concat(docTypes.input);
+              delete docTypes.input;
+            }
+          })
+
+          .forEach(function(sectionPages, sectionName) {
+
+            sectionPages = _.sortBy(sectionPages, 'name');
+
+            if ( sectionPages.length > 0 ) {
+              // Push a navItem for this section
+              navItems.push({
+                name: sectionName,
+                type: 'section',
+                href: path.dirname(sectionPages[0].path)
+              });
+
+              // Push the rest of the sectionPages for this section
+              _.forEach(sectionPages, function(sectionPage) {
+
+                navItems.push({
+                  name: sectionPage.name,
+                  href: sectionPage.path,
+                  type: sectionPage.docType
+                });
+
+              });
+            }
+          });
+        return {
+          name: moduleName,
+          href: modulePage.path,
+          type: 'group',
+          navItems: navItems
+        };
+      })
+      .value();
+    return navGroups;
+  },
+  tutorial: function(pages, area) {
+    return [getNavGroup(pages, area, 'step', function(page) {
+      return {
+        name: page.name,
+        step: page.step,
+        href: page.path,
+        type: 'tutorial'
+      };
+    })];
+  },
+  error: function(pages, area) {
+    return [getNavGroup(pages, area, 'path', function(page) {
+      return {
+        name: page.name,
+        href: page.path,
+        type: page.docType === 'errorNamespace' ? 'section' : 'error'
+      };
+    })];
+  },
+  pages: function(pages, area) {
+    return [getNavGroup(pages, area, 'path', function(page) {
+      return {
+        name: page.name,
+        href: page.path,
+        type: 'page'
+      };
+    })];
+  }
+};
+
+module.exports = {
+  name: 'pages-data',
+  description: 'This plugin will create a new doc that will be rendered as an angularjs module ' +
+               'which will contain meta information about the pages and navigation',
+  runAfter: ['adding-extra-docs', 'component-groups-generate', 'compute-path'],
+  runBefore: ['extra-docs-added'],
+  process: function(docs, config) {
+
+    var outputFolder = config.rendering.outputFolder;
+
+    _(docs)
+    .filter(function(doc) { return doc.area === 'api'; })
+    .filter(function(doc) { return doc.docType === 'module'; })
+    .forEach(function(doc) { if ( !doc.path ) {
+      log.warn('Missing path property for ', doc.id);
+    }})
+    .map(function(doc) { return _.pick(doc, ['id', 'module', 'docType', 'area']); })
+    .tap(function(docs) {
+      log.debug(docs);
+    });
+
+
+    // We are only interested in docs that are in a area and not landing pages
+    var navPages = _.filter(docs, function(page) {
+      return page.area &&
+        page.docType != 'componentGroup';
+    });
+
+    // Generate an object collection of pages that is grouped by area e.g.
+    // - area "api"
+    //  - group "ng"
+    //    - section "directive"
+    //    - ngApp
+    //    - ngBind
+    //    - section "global"
+    //    - angular.element
+    //    - angular.bootstrap
+    //    - section "service"
+    //    - $compile
+    //  - group "ngRoute"
+    //    - section "directive"
+    //    - ngView
+    //    - section "service"
+    //    - $route
+    //
+    var areas = {};
+    _(navPages)
+      .groupBy('area')
+      .forEach(function(pages, areaId) {
+        var area = {
+          id: areaId,
+          name: AREA_NAMES[areaId]
+        };
+        areas[areaId] = area;
+
+        var navGroupMapper = navGroupMappers[area.id] || navGroupMappers['pages'];
+        area.navGroups = navGroupMapper(pages, area);
+      });
+
+    // Extract a list of basic page information for mapping paths to partials and for client side searching
+    var pages = _(docs)
+      .map(function(doc) {
+        var page = _.pick(doc, [
+          'docType', 'id', 'name', 'area', 'outputPath', 'path', 'searchTerms'
+        ]);
+        return page;
+      })
+      .indexBy('path')
+      .value();
+
+
+    var docData = {
+      docType: 'pages-data',
+      id: 'pages-data',
+      template: 'pages-data.template.js',
+      outputPath: 'js/pages-data.js',
+
+      areas: areas,
+      pages: pages
+    };
+    docs.push(docData);
+  }
+};

docs/config/processors/protractor-generate.js

@@ -0,0 +1,49 @@
+var _ = require('lodash');
+var path = require('canonical-path');
+
+module.exports = {
+  name: 'protractor-generate',
+  description: 'Generate a protractor test file from the e2e tests in the examples',
+  runAfter: ['adding-extra-docs'],
+  runBefore: ['extra-docs-added'],
+  process: function(docs, examples, config) {
+    var protractorFolder = config.get('rendering.protractor.outputFolder', 'ptore2e');
+
+    _.forEach(examples, function(example) {
+
+      _.forEach(example.files, function(file) {
+
+        // Check if it's a Protractor test.
+        if (file.type !== 'protractor') {
+          return;
+        }
+
+        // Create new files for the tests.
+        docs.push(createProtractorDoc(example, file, 'jquery'));
+        docs.push(createProtractorDoc(example, file, 'jqlite'));
+      });
+    });
+
+    function createProtractorDoc(example, file, env) {
+      var protractorDoc = {
+        docType: 'e2e-test',
+        id: 'protractorTest' + '-' + example.id,
+        template: 'protractorTests.template.js',
+        outputPath: path.join(protractorFolder, example.id, env + '_test.js'),
+        innerTest: file.fileContents,
+        pathPrefix: '.', // Hold for if we test with full jQuery
+        exampleId: example.id,
+        description: example.doc.id
+      };
+
+      if (env === 'jquery') {
+        protractorDoc.examplePath = example.outputFolder + '/index-jquery.html';
+      } else {
+        protractorDoc.examplePath = example.outputFolder + '/index.html';
+      }
+      return protractorDoc;
+    }
+
+
+  }
+};

docs/config/processors/versions-data.js

@@ -0,0 +1,38 @@
+var _ = require('lodash');
+
+module.exports = {
+  name: 'versions-data',
+  description: 'This plugin will create a new doc that will be rendered as an angularjs module ' +
+               'which will contain meta information about the versions of angular',
+  runAfter: ['adding-extra-docs', 'pages-data'],
+  runBefore: ['extra-docs-added'],
+  process: function(docs, gitData) {
+
+    var version = gitData.version;
+    var versions = gitData.versions;
+
+    if ( !version ) {
+      throw new Error('Invalid configuration.  Please provide a valid `source.currentVersion` property');
+    }
+    if ( !versions ) {
+      throw new Error('Invalid configuration.  Please provide a valid `source.previousVersions` property');
+    }
+
+    var versionDoc = {
+      docType: 'versions-data',
+      id: 'versions-data',
+      template: 'versions-data.template.js',
+      outputPath: 'js/versions-data.js',
+    };
+
+    versionDoc.currentVersion = version;
+
+    versionDoc.versions = _(versions)
+      .filter(function(version) { return version.major > 0; })
+      .push(version)
+      .reverse()
+      .value();
+
+    docs.push(versionDoc);
+  }
+};

docs/config/tag-defs/tutorial-step.js

@@ -0,0 +1,9 @@
+module.exports = {
+  name: 'step',
+  transforms: function(doc, tag, value) {
+    if ( doc.docType !== 'tutorial' ) {
+      throw new Error('Invalid tag, step.  You should only use this tag on tutorial docs');
+    }
+    return parseInt(value,10);
+  }
+};

docs/config/templates/error.template.html

@@ -0,0 +1,17 @@
+{% extends "base.template.html" %}
+
+{% block content %}
+<h1>Error: {$ doc.id $}
+  <div><span class='hint'>{$ doc.fullName $}</span></div>
+</h1>
+
+<div>
+    <pre class="minerr-errmsg" error-display="{$ doc.formattedErrorMessage $}">{$ doc.formattedErrorMessage $}</pre>
+</div>
+
+<h2>Description</h2>
+<div class="description">
+  {$ doc.description | marked $}
+</div>
+
+{% endblock %}

docs/config/templates/errorNamespace.template.html

@@ -0,0 +1,28 @@
+{% extends 'base.template.html' %}
+
+{% block content %}
+<h1>{$ doc.name $}</h1>
+
+<div class="description">
+  Here are the list of errors in the {$ doc.name $} namespace.
+
+</div>
+
+<div class="component-breakdown">
+  <div>
+    <table class="definition-table">
+      <tr>
+        <th>Name</th>
+        <th>Description</th>
+      </tr>
+      {% for errorDoc in doc.errors -%}
+      <tr>
+        <td><a href="{$ errorDoc.path $}">{$ errorDoc.name $}</td>
+        <td>{$ errorDoc.fullName $}</td>
+      </tr>
+      {% endfor %}
+    </table>
+  </div>
+</div>
+
+{% endblock %}