docs(CHANGELOG): add v1.3.4 changes

Fixes #10078
Closes #10172

.editorconfig

@@ -10,9 +10,6 @@ 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

.gitignore

@@ -13,6 +13,7 @@ angular.js.tmproj
 bower_components/
 angular.xcodeproj
 .idea
+*.iml
 .agignore
 .lvimrc
 libpeerconnection.log

.jscs.json

@@ -1,6 +1,41 @@
 {
+  "excludeFiles": ["src/ngLocale/**"],
   "disallowKeywords": ["with"],
+  "disallowMixedSpacesAndTabs": true,
+  "disallowMultipleLineStrings": true,
+  "disallowNewlineBeforeBlockStatements": true,
+  "disallowSpaceAfterObjectKeys": true,
+  "disallowSpaceAfterPrefixUnaryOperators": ["++", "--", "+", "-", "~", "!"],
+  "disallowSpaceBeforeBinaryOperators": [","],
+  "disallowSpaceBeforePostfixUnaryOperators": ["++", "--"],
+  "disallowSpacesInAnonymousFunctionExpression": {
+    "beforeOpeningRoundBrace": true
+  },
+  "disallowSpacesInFunctionDeclaration": {
+    "beforeOpeningRoundBrace": true
+  },
+  "disallowSpacesInNamedFunctionExpression": {
+    "beforeOpeningRoundBrace": true
+  },
+  "disallowSpacesInsideArrayBrackets": true,
+  "disallowSpacesInsideParentheses": true,
+  "disallowTrailingComma": true,
   "disallowTrailingWhitespace": true,
-  "requireRightStickedOperators": ["!"],
-  "requireLeftStickedOperators": [","]
+  "requireCommaBeforeLineBreak": true,
+  "requireLineFeedAtFileEnd": true,
+  "requireSpaceAfterBinaryOperators": ["?", ":", "+", "-", "/", "*", "%", "==", "===", "!=", "!==", ">", ">=", "<", "<=", "&&", "||"],
+  "requireSpaceBeforeBinaryOperators": ["?", ":", "+", "-", "/", "*", "%", "==", "===", "!=", "!==", ">", ">=", "<", "<=", "&&", "||"],
+  "requireSpaceAfterKeywords": ["if", "else", "for", "while", "do", "switch", "return", "try", "catch"],
+  "requireSpaceBeforeBlockStatements": true,
+  "requireSpacesInConditionalExpression": {
+    "afterTest": true,
+    "beforeConsequent": true,
+    "afterConsequent": true,
+    "beforeAlternate": true
+  },
+  "requireSpacesInFunction": {
+    "beforeOpeningCurlyBrace": true
+  },
+  "validateLineBreaks": "LF",
+  "validateParameterSeparator": ", "
 }

.jscs.json.todo

@@ -5,13 +5,9 @@
 
 {
   "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

CHANGELOG.md

@@ -1,3 +1,294 @@
+<a name="1.3.4"></a>
+# 1.3.4 highfalutin-petroglyph (2014-11-24)
+
+## Bug Fixes
+
+- **$browser:** allow chaining url() calls in setter mode
+  ([764fa869](https://github.com/angular/angular.js/commit/764fa869dd8809d494924c23f30ddaa4cac84249),
+   [#10157](https://github.com/angular/angular.js/issues/10157))
+- **$http:** return empty headers, ignore properties in Object prototype
+  ([637c020f](https://github.com/angular/angular.js/commit/637c020f828a7ceeaacf83bb1a54ed3092e6c273),
+   [#7779](https://github.com/angular/angular.js/issues/7779), [#10113](https://github.com/angular/angular.js/issues/10113), [#10091](https://github.com/angular/angular.js/issues/10091))
+- **$locale:** Allow currency filter to fall back to maxFrac from locale
+  ([6dbd606a](https://github.com/angular/angular.js/commit/6dbd606ad7b708d5886c0e7ffee20ae8f8719711),
+   [#10179](https://github.com/angular/angular.js/issues/10179))
+- **$location:** allow empty string URLs to reset path, search, and hash
+  ([7812dfce](https://github.com/angular/angular.js/commit/7812dfcee8ab98cbf38261f9948d9541656bf554),
+   [#10063](https://github.com/angular/angular.js/issues/10063), [#10064](https://github.com/angular/angular.js/issues/10064))
+- **$route:** fix redirection with optional/eager params
+  ([891acf4c](https://github.com/angular/angular.js/commit/891acf4c201823fd2c925ee321c70d06737d5944),
+   [#9819](https://github.com/angular/angular.js/issues/9819), [#9827](https://github.com/angular/angular.js/issues/9827))
+- **Angular:** properly get node name for svg element wrapper
+  ([09a98323](https://github.com/angular/angular.js/commit/09a9832358960c98392c9df1a9fd9592f59bc844),
+   [#10078](https://github.com/angular/angular.js/issues/10078), [#10172](https://github.com/angular/angular.js/issues/10172))
+- **NgModelController:** typo $rawModelValue -> $$rawModelValue
+  ([4f4ff5f3](https://github.com/angular/angular.js/commit/4f4ff5f31b82c6f7be409ea4edbad4c2913ac1f1))
+- **input:**
+  - set ngTrueValue on required checkbox
+  ([8692f87a](https://github.com/angular/angular.js/commit/8692f87a4689fa0dd3640f4dcab5c6b6f960489b),
+   [#5164](https://github.com/angular/angular.js/issues/5164))
+  - call $setTouched in blur asynchronously if necessary
+  ([eab27187](https://github.com/angular/angular.js/commit/eab271876cb87c1f5f6c6f29e814fb8fecad87ff),
+   [#8762](https://github.com/angular/angular.js/issues/8762), [#9808](https://github.com/angular/angular.js/issues/9808), [#10014](https://github.com/angular/angular.js/issues/10014))
+- **input[date]:** do not use `$isEmpty` to check the model validity
+  ([40406e2f](https://github.com/angular/angular.js/commit/40406e2f22713efbd37ef3eff408339727cb62d9))
+- **linky:** encode double quotes when serializing email addresses
+  ([8ee8ffeb](https://github.com/angular/angular.js/commit/8ee8ffeba0a5a133fa792745c1019d294ecfcef3),
+   [#8945](https://github.com/angular/angular.js/issues/8945), [#8964](https://github.com/angular/angular.js/issues/8964), [#5946](https://github.com/angular/angular.js/issues/5946), [#10090](https://github.com/angular/angular.js/issues/10090), [#9256](https://github.com/angular/angular.js/issues/9256))
+- **ngMaxlength:** ignore maxlength when not set to a non-negative integer
+  ([92f87b11](https://github.com/angular/angular.js/commit/92f87b114242b01876e1dc5c6fddd061352ecb2c),
+   [#9874](https://github.com/angular/angular.js/issues/9874))
+- **ngModel:** don't run parsers when executing $validate
+  ([e3764e30](https://github.com/angular/angular.js/commit/e3764e30a301ec6136c8e6b5493d39feb3cd1ecc))
+- **ngModelOptions:** preserve context of getter/setters
+  ([bb4d3b73](https://github.com/angular/angular.js/commit/bb4d3b73a1ccf3dee55b0c25baf031bae5cbb676),
+   [#9394](https://github.com/angular/angular.js/issues/9394), [#9865](https://github.com/angular/angular.js/issues/9865))
+
+
+## Features
+
+- **ngMaxlength:** add support for disabling max length limit
+  ([5c1fdff6](https://github.com/angular/angular.js/commit/5c1fdff691b9367d73f72f6a0298cb6a6e259f35),
+   [#9995](https://github.com/angular/angular.js/issues/9995))
+- **ngModelController:** add $setDirty method
+  ([e8941c0f](https://github.com/angular/angular.js/commit/e8941c0fe5217d2e705bad8253dc0162aff4c709),
+   [#10038](https://github.com/angular/angular.js/issues/10038), [#10049](https://github.com/angular/angular.js/issues/10049))
+- **ngPluralize:** add support for `count` to be a one-time expression
+  ([2b41a586](https://github.com/angular/angular.js/commit/2b41a5868aee79e3872ad92db66e30959207d98e),
+   [#10004](https://github.com/angular/angular.js/issues/10004))
+
+
+## Performance Improvements
+
+- ***:** use Object.create instead of creating temporary constructors
+  ([bf6a79c3](https://github.com/angular/angular.js/commit/bf6a79c3484f474c300b5442ae73483030ef5782),
+   [#10058](https://github.com/angular/angular.js/issues/10058))
+
+
+## Breaking Changes
+
+- **ngModelOptions:** due to [bb4d3b73](https://github.com/angular/angular.js/commit/bb4d3b73a1ccf3dee55b0c25baf031bae5cbb676),
+  previously, ngModel invoked getter/setters in the global context.
+
+For example:
+
+```js
+<input ng-model="model.value" ng-model-options="{ getterSetter: true }">
+```
+
+would previously invoke `model.value()` in the global context.
+
+Now, ngModel invokes `value` with `model` as the context.
+
+It's unlikely that real apps relied on this behavior. If they did they can use `.bind` to explicilty
+bind a getter/getter to the global context, or just reference globals normally without `this`.
+
+
+<a name="1.2.27"></a>
+# 1.2.27 prime-factorization (2014-11-20)
+
+
+## Bug Fixes
+
+- **$animate:** clear the GCS cache even when no animation is detected
+  ([f619d032](https://github.com/angular/angular.js/commit/f619d032c932752313c646b5295bad8a68ef3871),
+   [#8813](https://github.com/angular/angular.js/issues/8813))
+- **$browser:**
+  - Cache `location.href` only during page reload phase
+  ([434d7a09](https://github.com/angular/angular.js/commit/434d7a09039151c1e627ac156213905d06b7df10),
+   [#9235](https://github.com/angular/angular.js/issues/9235), [#9470](https://github.com/angular/angular.js/issues/9470))
+  - don’t use history api when only the hash changes
+  ([a6e6438d](https://github.com/angular/angular.js/commit/a6e6438dae1ed92b29608d0b8830b0a7fbb624ef),
+   [#9423](https://github.com/angular/angular.js/issues/9423), [#9424](https://github.com/angular/angular.js/issues/9424))
+  - handle async href on url change in <=IE9
+  ([fe7d9ded](https://github.com/angular/angular.js/commit/fe7d9dedaa5ec3b3f56d9eb9c513cf99e40121ce),
+   [#9235](https://github.com/angular/angular.js/issues/9235))
+- **$http:** add missing shortcut methods and missing docs
+  ([ec4fe1bc](https://github.com/angular/angular.js/commit/ec4fe1bcab6f981103a10f860a3a00122aa78607),
+   [#9180](https://github.com/angular/angular.js/issues/9180), [#9321](https://github.com/angular/angular.js/issues/9321))
+- **$location:**
+  - revert erroneous logic and backport refactorings from master
+  ([1ee9b4ef](https://github.com/angular/angular.js/commit/1ee9b4ef5e4a795061d3aa19adefdeb7e0209eeb),
+   [#8492](https://github.com/angular/angular.js/issues/8492))
+  - allow 0 in path() and hash()
+  ([f807d7ab](https://github.com/angular/angular.js/commit/f807d7ab4ebd18899154528ea9ed50d5bc25c57a))
+- **$parse:** add quick check for Function constructor in fast path
+  ([756640f5](https://github.com/angular/angular.js/commit/756640f5aa8f3fd0084bff50534e23976a6fff00))
+- **$parse, events:** prevent accidental misuse of properties on $event
+  ([4d0614fd](https://github.com/angular/angular.js/commit/4d0614fd0da12c5783dfb4956c330edac87e62fe),
+   [#9969](https://github.com/angular/angular.js/issues/9969))
+- **ngMock:** $httpBackend should match data containing Date objects correctly
+  ([1426b029](https://github.com/angular/angular.js/commit/1426b02980badfd322eb960d71bfb1a14d657847),
+   [#5127](https://github.com/angular/angular.js/issues/5127))
+- **orderBy:** sort by identity if no predicate is given
+  ([45b896a1](https://github.com/angular/angular.js/commit/45b896a16abbcbfcdfb9a95c2d10c76a805b57cc),
+   [#5847](https://github.com/angular/angular.js/issues/5847), [#4579](https://github.com/angular/angular.js/issues/4579), [#9403](https://github.com/angular/angular.js/issues/9403))
+- **select:** ensure the label attribute is updated in Internet Explorer
+  ([16833d0f](https://github.com/angular/angular.js/commit/16833d0fb6585117e9978d1accc3ade83e22e797),
+   [#9621](https://github.com/angular/angular.js/issues/9621), [#10042](https://github.com/angular/angular.js/issues/10042))
+
+
+## Performance Improvements
+
+- **orderBy:** copy array with slice instead of for loop
+  ([409bcb38](https://github.com/angular/angular.js/commit/409bcb3810a1622178268f7ff7f4130887a1a3dc),
+   [#9942](https://github.com/angular/angular.js/issues/9942))
+
+
+<a name="1.3.3"></a>
+# 1.3.3 undersea-arithmetic (2014-11-17)
+
+
+## Bug Fixes
+
+- **$http:** don't parse single space responses as JSON
+  ([6f19a6fd](https://github.com/angular/angular.js/commit/6f19a6fd33ab72d3908e3418fba47ee8e1598fa6),
+   [#9907](https://github.com/angular/angular.js/issues/9907))
+- **minErr:** stringify non-JSON compatible objects in error messages
+  ([cf43ccdf](https://github.com/angular/angular.js/commit/cf43ccdf9b8665a2fd5d6aa52f80cb2d7c9bb7e2),
+   [#10085](https://github.com/angular/angular.js/issues/10085))
+- **$rootScope:** handle cyclic references in scopes when creating error messages
+  ([e80053d9](https://github.com/angular/angular.js/commit/e80053d91fd7c722e092a23d326384de2e552eb6),
+   [#10085](https://github.com/angular/angular.js/issues/10085))
+- **ngRepeat:** support cyclic object references in error messages
+  ([fa12c3c8](https://github.com/angular/angular.js/commit/fa12c3c86af7965d1b9d9a5dd3434755e9e04635),
+   [#9838](https://github.com/angular/angular.js/issues/9838), [#10065](https://github.com/angular/angular.js/issues/10065), [#10085](https://github.com/angular/angular.js/issues/10085))
+- **ngMock:** call $interval callbacks even when invokeApply is false
+  ([d81ff888](https://github.com/angular/angular.js/commit/d81ff8885b77f70c6417d7be3124d86d07447375),
+   [#10032](https://github.com/angular/angular.js/issues/10032))
+- **ngPattern:** match behaviour of native HTML pattern attribute
+  ([85eb9660](https://github.com/angular/angular.js/commit/85eb9660ef67c24d5104a6a1921bedad0bd1b57e),
+   [#9881](https://github.com/angular/angular.js/issues/9881), [#9888](https://github.com/angular/angular.js/issues/9888))
+- **select:** ensure the label attribute is updated in Internet Explorer
+  ([6604c236](https://github.com/angular/angular.js/commit/6604c2361427fba8c43a39dc2e92197390dfbdbe),
+   [#9621](https://github.com/angular/angular.js/issues/9621), [#10042](https://github.com/angular/angular.js/issues/10042))
+
+
+## Features
+
+- **$location:** allow to location to be changed during $locationChangeStart
+  ([a9352c19](https://github.com/angular/angular.js/commit/a9352c19ce33f0393d6581547c7ea8dfc2a8b78f),
+   [#9607](https://github.com/angular/angular.js/issues/9607), [#9678](https://github.com/angular/angular.js/issues/9678))
+- **$routeProvider:** allow setting caseInsensitiveMatch on the provider
+  ([0db573b7](https://github.com/angular/angular.js/commit/0db573b7493f76abd94ff65ce660017d617e865b),
+   [#6477](https://github.com/angular/angular.js/issues/6477), [#9873](https://github.com/angular/angular.js/issues/9873))
+
+
+## Performance Improvements
+
+- **orderBy:** copy array with slice instead of for loop
+  ([8eabc546](https://github.com/angular/angular.js/commit/8eabc5463c795d87f37e5a9eacbbb14435024061),
+   [#9942](https://github.com/angular/angular.js/issues/9942))
+
+## Breaking Changes
+
+- **$parse:** due to [fbad2805](https://github.com/angular/angular.js/commit/fbad2805703569058a4a860747b0e2d8aee36bdf),
+    you can't use characters that have special meaning in AngularJS expressions (ex.: `.` or `-`)
+    as part of filter's name. Before this commit custom filters could contain special characters
+    (like a dot) in their name but this wasn't intentional.
+
+<a name="1.3.2"></a>
+# 1.3.2 cardiovasculatory-magnification (2014-11-07)
+
+
+## Bug Fixes
+
+- **$compile:** do not rebind parent bound transclude functions
+  ([841c0907](https://github.com/angular/angular.js/commit/841c0907556f525dbc4223609d808319fe0dd7e2),
+   [#9413](https://github.com/angular/angular.js/issues/9413))
+- **$parse:**
+  - stateful interceptors override an `undefined` expression
+  ([ed99821e](https://github.com/angular/angular.js/commit/ed99821e4dc621864f7e2d9a6b5305fca27fb7fa),
+   [#9821](https://github.com/angular/angular.js/issues/9821), [#9825](https://github.com/angular/angular.js/issues/9825))
+  - add quick check for Function constructor in fast path
+  ([e676d642](https://github.com/angular/angular.js/commit/e676d642f5feb8d3ba88944634afb479ba525c36))
+- **$parse, events:** prevent accidental misuse of properties on $event
+  ([e057a9aa](https://github.com/angular/angular.js/commit/e057a9aa398ead209bd6bbf76e22d2d5562904fb))
+- **ngRoute:** allow proto inherited properties in route params object
+  ([b4770582](https://github.com/angular/angular.js/commit/b4770582f84f26c8ff7f2320a36a6b0ceff6e6cc),
+   [#8181](https://github.com/angular/angular.js/issues/8181), [#9731](https://github.com/angular/angular.js/issues/9731))
+- **select:** use strict comparison for isSelected with selectAs
+  ([9e305948](https://github.com/angular/angular.js/commit/9e305948e4965fb86b0c79985dc6e8c59a9c66af),
+   [#9639](https://github.com/angular/angular.js/issues/9639), [#9949](https://github.com/angular/angular.js/issues/9949))
+
+
+## Features
+
+- **ngAria:** announce ngMessages with aria-live
+  ([187e4318](https://github.com/angular/angular.js/commit/187e43185dfb1bce6a318d95958c73cfb789d33c),
+   [#9834](https://github.com/angular/angular.js/issues/9834))
+- **ngMock:** decorator that adds Scope#$countChildScopes and Scope#$countWatchers
+  ([74981c9f](https://github.com/angular/angular.js/commit/74981c9f208b3617cbf00beafd61138d25c5d546),
+   [#9926](https://github.com/angular/angular.js/issues/9926), [#9871](https://github.com/angular/angular.js/issues/9871))
+
+
+##  Security Note
+
+This release also contains security fixes for expression sandbox bypasses.
+
+These issues affect only applications with known server-side XSS holes that are also using [CSP](https://developer.mozilla.org/en-US/docs/Web/Security/CSP) to secure their client-side code. If your application falls into this rare category, we recommend updating your version of Angular.
+
+We'd like to thank security researches [Sebastian Lekies](https://twitter.com/sebastianlekies), [Jann Horn](http://thejh.net/), and [Gábor Molnár](https://twitter.com/molnar_g) for reporting these issues to us.
+
+We also added a documentation page focused on security, which contains some of the best practices, DOs and DON'Ts. Please check out [https://docs.angularjs.org/guide/security](https://docs.angularjs.org/guide/security).
+
+
+
+<a name="1.3.1"></a>
+# 1.3.1 spectral-lobster (2014-10-31)
+
+
+## Bug Fixes
+
+- **$compile:** returning null when an optional controller is not found
+  ([2cd5b4ec](https://github.com/angular/angular.js/commit/2cd5b4ec4409a818ccd33a6fbdeb99a3443a1809),
+   [#9404](https://github.com/angular/angular.js/issues/9404), [#9392](https://github.com/angular/angular.js/issues/9392))
+- **$observe:** check if the attribute is undefined
+  ([531a8de7](https://github.com/angular/angular.js/commit/531a8de72c439d8ddd064874bf364c00cedabb11),
+   [#9707](https://github.com/angular/angular.js/issues/9707), [#9720](https://github.com/angular/angular.js/issues/9720))
+- **$parse:** support dirty-checking objects with null prototype
+  ([28661d1a](https://github.com/angular/angular.js/commit/28661d1a8cc3a8454bad7ae531e027b1256476c9),
+   [#9568](https://github.com/angular/angular.js/issues/9568))
+- **$sce:** use msie instead of $document[0].documentMode
+  ([45252c3a](https://github.com/angular/angular.js/commit/45252c3a545336a0bac93be6ee28cde6afaa3cb4),
+   [#9661](https://github.com/angular/angular.js/issues/9661))
+- **$templateRequest:** ignore JSON Content-Type header and content
+  ([1bd473eb](https://github.com/angular/angular.js/commit/1bd473eb4587900086e0b6b308dcf1dcfe9760d9),
+   [#5756](https://github.com/angular/angular.js/issues/5756), [#9619](https://github.com/angular/angular.js/issues/9619))
+- **i18n:** rename datetimeSymbols to be camelCase
+  ([94f5a285](https://github.com/angular/angular.js/commit/94f5a285bfcf04d800afc462a7a37a3469d77f1a))
+- **loader:** fix double spaces
+  ([8b2f1a47](https://github.com/angular/angular.js/commit/8b2f1a47b584ceb98689f48538a2af73cd65dfd8),
+   [#9630](https://github.com/angular/angular.js/issues/9630))
+- **ngMock:** $httpBackend should match data containing Date objects correctly
+  ([1025f6eb](https://github.com/angular/angular.js/commit/1025f6ebf4e5933a12920889be00cd8ac8a106fa),
+   [#5127](https://github.com/angular/angular.js/issues/5127))
+- **ngSanitize:** attribute name: xmlns:href -> xlink:href
+  ([4cccf0f2](https://github.com/angular/angular.js/commit/4cccf0f2a89b002d63cb443e1e7b15f76dcef425),
+   [#9769](https://github.com/angular/angular.js/issues/9769))
+- **select:** assign result of track exp to element value
+  ([4b4098bf](https://github.com/angular/angular.js/commit/4b4098bfcae64f69c70a22393de1f3d9a0d3dc46),
+   [#9718](https://github.com/angular/angular.js/issues/9718), [#9592](https://github.com/angular/angular.js/issues/9592))
+- **templateRequest:** allow empty html template
+  ([52ceec22](https://github.com/angular/angular.js/commit/52ceec2229dc132b76da4e022c91474344f2d906),
+   [#9581](https://github.com/angular/angular.js/issues/9581))
+- **testability:** escape regex chars in `findBindings` if using `exactMatch`
+  ([02aa4f4b](https://github.com/angular/angular.js/commit/02aa4f4b85ee15922a1f2de8ba78f562c18518d0),
+   [#9595](https://github.com/angular/angular.js/issues/9595), [#9600](https://github.com/angular/angular.js/issues/9600))
+
+
+## Features
+
+- **$compile:** allow $watchCollection to be used in bi-directional bindings
+  ([40bbc981](https://github.com/angular/angular.js/commit/40bbc9817845bf75581daee5d0ec30980affb0f5),
+   [#9725](https://github.com/angular/angular.js/issues/9725))
+- **ngSanitize:** accept SVG elements and attributes
+  ([a54b25d7](https://github.com/angular/angular.js/commit/a54b25d77999a85701dfc5396fef78e586a99667),
+   [#9578](https://github.com/angular/angular.js/issues/9578), [#9751](https://github.com/angular/angular.js/issues/9751))
+
+
+
+
 <a name="1.3.0"></a>
 # 1.3.0 superluminal-nudge (2014-10-13)
 
@@ -54,7 +345,7 @@
 - **currencyFilter:** add fractionSize as optional parameter
   ([20685ffe](https://github.com/angular/angular.js/commit/20685ffe11036d4d604d13f0d792ca46497af4a1),
    [#3642](https://github.com/angular/angular.js/issues/3642), [#3461](https://github.com/angular/angular.js/issues/3461), [#3642](https://github.com/angular/angular.js/issues/3642), [#7922](https://github.com/angular/angular.js/issues/7922))
-- **jqLite:** add private jqDocumentComplete function
+- **jqLite:** add private jqLiteDocumentLoaded function
   ([0dd316ef](https://github.com/angular/angular.js/commit/0dd316efea209e5e5de3e456b4e6562f011a1294))
 
 
@@ -1452,6 +1743,8 @@ Closes #8230
 
 - **jQuery:** due to [9e7cb3c3](https://github.com/angular/angular.js/commit/9e7cb3c37543008e6236bb5a2c4536df2e1e43a9),
   Angular no longer supports jQuery versions below 2.1.1.
+- **$q:** due to [23bc92b1](https://github.com/angular/angular.js/commit/23bc92b17df882a907fb326320f0622717fefe7b),
+  Promises methods are no longer enumerated when using for-loops with `hasOwnProperty` check. E.g. `angular.extends`
 
 
 <a name="1.2.22"></a>

CONTRIBUTING.md

@@ -173,7 +173,7 @@ To ensure consistency throughout the source code, keep these rules in mind as yo
     * **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
+    * Instead of complex inheritance hierarchies, we **prefer simple objects**. We use prototypal
       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

Gruntfile.js

@@ -4,6 +4,7 @@ var files = require('./angularFiles').files;
 var util = require('./lib/grunt/utils.js');
 var versionInfo = require('./lib/versions/version-info');
 var path = require('path');
+var e2e = require('./test/e2e/tools');
 
 module.exports = function(grunt) {
   //grunt plugins
@@ -46,12 +47,14 @@ module.exports = function(grunt) {
           base: '.',
           keepalive: true,
           middleware: function(connect, options){
+            var base = Array.isArray(options.base) ? options.base[options.base.length - 1] : options.base;
             return [
               util.conditionalCsp(),
               util.rewrite(),
+              e2e.middleware(),
               connect.favicon('images/favicon.ico'),
-              connect.static(options.base),
-              connect.directory(options.base)
+              connect.static(base),
+              connect.directory(base)
             ];
           }
         }
@@ -64,6 +67,7 @@ module.exports = function(grunt) {
           port: 8000,
           hostname: '0.0.0.0',
           middleware: function(connect, options){
+            var base = Array.isArray(options.base) ? options.base[options.base.length - 1] : options.base;
             return [
               function(req, resp, next) {
                 // cache get requests to speed up tests on travis
@@ -74,8 +78,9 @@ module.exports = function(grunt) {
                 next();
               },
               util.conditionalCsp(),
+              e2e.middleware(),
               connect.favicon('images/favicon.ico'),
-              connect.static(options.base)
+              connect.static(base)
             ];
           }
         }
@@ -287,14 +292,14 @@ module.exports = function(grunt) {
       }
     },
 
-    shell:{
-      "promises-aplus-tests":{
-        options:{
-          //stdout:true,
-          stderr:true,
-          failOnError:true
+    shell: {
+      "promises-aplus-tests": {
+        options: {
+          stdout: false,
+          stderr: true,
+          failOnError: true
         },
-        command:path.normalize('./node_modules/.bin/promises-aplus-tests tmp/promises-aplus-adapter++.js')
+        command: path.normalize('./node_modules/.bin/promises-aplus-tests tmp/promises-aplus-adapter++.js')
       }
     },
 

angularFiles.js

@@ -5,6 +5,7 @@ var angularFiles = {
     'src/minErr.js',
     'src/Angular.js',
     'src/loader.js',
+    'src/stringify.js',
     'src/AngularPublic.js',
     'src/jqLite.js',
     'src/apis.js',
@@ -73,6 +74,7 @@ var angularFiles = {
   ],
 
   'angularLoader': [
+    'stringify.js',
     'src/minErr.js',
     'src/loader.js'
   ],

benchmarks/README.md

@@ -3,4 +3,4 @@ found at: https://github.com/angular/benchpress/blob/master/README.md.
 
 In this project, there is a configured grunt task for building the benchmarks,
 `grunt bp_build`, which places the runnable benchmarks in "/build/benchmarks/".
-The existing `grunt webserver` task can be used to serve the built benchmarks at `localhost:8000/build/benchmarks/<benchmark-name>`
+The existing `grunt webserver` task can be used to serve the built benchmarks at `localhost:8000/build/benchmarks/<benchmark-name>`

benchmarks/parsed-expressions-bp/app.js

@@ -71,7 +71,8 @@ app.controller('DataController', function($scope, $rootScope) {
       date2: new Date(Math.random()*Date.now()),
       func: function(){ return star; },
       obj: data[i-1],
-      keys: data[i-1] && (data[i-1].keys || Object.keys(data[i-1]))
+      keys: data[i-1] && (data[i-1].keys || Object.keys(data[i-1])),
+      constructor: data[i-1]
     });
   }
 

benchmarks/parsed-expressions-bp/main.html

@@ -16,6 +16,12 @@
           <label for="complexPath">Complex Paths</label>
         </li>
 
+        <li>
+          <input type="radio" ng-model="expressionType" value="constructorPath" id="constructorPath">
+          <label for="constructorPath">Constructor Paths</label>
+          ($parse special cases "constructor" for security)
+        </li>
+
         <li>
           <input type="radio" ng-model="expressionType" value="fieldAccess" id="fieldAccess">
           <label for="fieldAccess">Field Accessors</label>
@@ -77,6 +83,17 @@
           <span bm-pe-watch="row.keys"></span>
         </li>
 
+        <li ng-switch-when="constructorPath" ng-repeat="(rowIdx, row) in ::data">
+          <span bm-pe-watch="row.index"></span>
+          <span bm-pe-watch="row.constructor.index"></span>
+          <span bm-pe-watch="row.constructor.index"></span>
+          <span bm-pe-watch="row.constructor.index"></span>
+          <span bm-pe-watch="row.constructor.constructor.index"></span>
+          <span bm-pe-watch="row.constructor.constructor.index"></span>
+          <span bm-pe-watch="row.constructor.constructor.constructor.index"></span>
+          <span bm-pe-watch="row.constructor.constructor.constructor.index"></span>
+        </li>
+
         <li ng-switch-when="complexPath" ng-repeat="(rowIdx, row) in ::data">
           <span bm-pe-watch="row.index"></span>
           <span bm-pe-watch="row.num0"></span>

docs/app/assets/css/docs.css

@@ -128,6 +128,10 @@ h1,h2,h3,h4,h5,h6 {
   margin-bottom:5px;
 }
 
+.nav-index-group .nav-index-listing.current a {
+  color: #B52E31;
+}
+
 .nav-breadcrumb {
   margin:4px 0;
   padding:0;

docs/app/e2e/api-docs/api-pages.scenario.js

@@ -5,15 +5,15 @@ describe("doc.angularjs.org", function() {
   describe("API pages", function() {
 
     it("should display links to code on GitHub", function() {
-      browser.get('index-debug.html#!/api/ng/service/$http');
+      browser.get('build/docs/index.html#!/api/ng/service/$http');
       expect(element(by.css('.improve-docs')).getAttribute('href')).toMatch(/https?:\/\/github\.com\/angular\/angular\.js\/edit\/.+\/src\/ng\/http\.js/);
 
-      browser.get('index-debug.html#!/api/ng/service/$http');
+      browser.get('build/docs/index.html#!/api/ng/service/$http');
       expect(element(by.css('.view-source')).getAttribute('href')).toMatch(/https?:\/\/github\.com\/angular\/angular\.js\/tree\/.+\/src\/ng\/http\.js#L\d+/);
     });
 
     it('should change the page content when clicking a link to a service', function () {
-      browser.get('');
+      browser.get('build/docs/index.html');
 
       var ngBindLink = element(by.css('.definition-table td a[href="api/ng/directive/ngClick"]'));
       ngBindLink.click();
@@ -24,7 +24,7 @@ describe("doc.angularjs.org", function() {
 
 
     it('should show the functioning input directive example', function () {
-      browser.get('index-debug.html#!/api/ng/directive/input');
+      browser.get('build/docs/index.html#!/api/ng/directive/input');
 
       // Ensure that the page is loaded before trying to switch frames.
       browser.waitForAngular();
@@ -39,7 +39,7 @@ describe("doc.angularjs.org", function() {
     });
 
     it("should trim indentation from code blocks", function() {
-      browser.get('index-debug.html#!/api/ng/type/$rootScope.Scope');
+      browser.get('build/docs/index.html#!/api/ng/type/$rootScope.Scope');
 
       var codeBlocks = element.all(by.css('pre > code.lang-js'));
       codeBlocks.each(function(codeBlock) {

docs/app/e2e/api-docs/provider-pages.scenario.js

@@ -3,7 +3,7 @@
 describe("provider pages", function() {
 
   it("should show the related service", function() {
-    browser.get('index-debug.html#!/api/ng/provider/$compileProvider');
+    browser.get('build/docs/index.html#!/api/ng/provider/$compileProvider');
     var serviceLink = element.all(by.css('ol.api-profile-header-structure li a')).first();
     expect(serviceLink.getText()).toEqual('- $compile');
     expect(serviceLink.getAttribute('href')).toMatch(/api\/ng\/service\/\$compile/);

docs/app/e2e/api-docs/service-pages.scenario.js

@@ -3,19 +3,19 @@
 describe("service pages", function() {
 
   it("should show the related provider if there is one", function() {
-    browser.get('index-debug.html#!/api/ng/service/$compile');
+    browser.get('build/docs/index.html#!/api/ng/service/$compile');
     var providerLink = element.all(by.css('ol.api-profile-header-structure li a')).first();
     expect(providerLink.getText()).toEqual('- $compileProvider');
     expect(providerLink.getAttribute('href')).toMatch(/api\/ng\/provider\/\$compileProvider/);
 
-    browser.get('index-debug.html#!/api/ng/service/$q');
+    browser.get('build/docs/index.html#!/api/ng/service/$q');
     providerLink = element.all(by.css('ol.api-profile-header-structure li a')).first();
     expect(providerLink.getText()).not.toEqual('- $qProvider');
     expect(providerLink.getAttribute('href')).not.toMatch(/api\/ng\/provider\/\$compileProvider/);
   });
 
   it("should show parameter defaults", function() {
-    browser.get('index-debug.html#!/api/ng/service/$timeout');
+    browser.get('build/docs/index.html#!/api/ng/service/$timeout');
     expect(element.all(by.css('.input-arguments p em')).first().getText()).toContain('(default: 0)');
   });
 

docs/app/e2e/app.scenario.js

@@ -39,7 +39,7 @@ describe('docs.angularjs.org', function () {
 
 
     it('should change the page content when clicking a link to a service', function () {
-      browser.get('');
+      browser.get('build/docs/index.html');
 
       var ngBindLink = element(by.css('.definition-table td a[href="api/ng/directive/ngClick"]'));
       ngBindLink.click();
@@ -51,33 +51,33 @@ describe('docs.angularjs.org', function () {
 
 
     it('should be resilient to trailing slashes', function() {
-      browser.get('index-debug.html#!/api/ng/function/angular.noop/');
+      browser.get('build/docs/index.html#!/api/ng/function/angular.noop/');
       var pageBody = element(by.css('h1'));
       expect(pageBody.getText()).toEqual('angular.noop');
     });
 
 
     it('should be resilient to trailing "index"', function() {
-      browser.get('index-debug.html#!/api/ng/function/angular.noop/index');
+      browser.get('build/docs/index.html#!/api/ng/function/angular.noop/index');
       var pageBody = element(by.css('h1'));
       expect(pageBody.getText()).toEqual('angular.noop');
     });
 
 
     it('should be resilient to trailing "index/"', function() {
-      browser.get('index-debug.html#!/api/ng/function/angular.noop/index/');
+      browser.get('build/docs/index.html#!/api/ng/function/angular.noop/index/');
       var pageBody = element(by.css('h1'));
       expect(pageBody.getText()).toEqual('angular.noop');
     });
 
 
     it('should display formatted error messages on error doc pages', function() {
-      browser.get('index-debug.html#!error/ng/areq?p0=Missing&p1=not%20a%20function,%20got%20undefined');
+      browser.get('build/docs/index.html#!error/ng/areq?p0=Missing&p1=not%20a%20function,%20got%20undefined');
       expect(element(by.css('.minerr-errmsg')).getText()).toEqual("Argument 'Missing' is not a function, got undefined");
     });
 
     it("should display an error if the page does not exist", function() {
-      browser.get('index-debug.html#!/api/does/not/exist');
+      browser.get('build/docs/index.html#!/api/does/not/exist');
       expect(element(by.css('h1')).getText()).toBe('Oops!');
     });
 

docs/app/src/docs.js

@@ -13,6 +13,7 @@ angular.module('DocsController', [])
   $scope.navClass = function(navItem) {
     return {
       active: navItem.href && this.currentPage && this.currentPage.path,
+      current: this.currentPage && this.currentPage.path === navItem.href,
       'nav-index-section': navItem.type === 'section'
     };
   };

docs/app/src/search.js

@@ -41,10 +41,14 @@ angular.module('search', [])
 
   $scope.submit = function() {
     var result;
-    for(var i in $scope.results) {
-      result = $scope.results[i][0];
-      if(result) {
-        break;
+    if ($scope.results.api) {
+      result = $scope.results.api[0];
+    } else {
+      for(var i in $scope.results) {
+        result = $scope.results[i][0];
+        if(result) {
+          break;
+        }
       }
     }
     if(result) {

docs/app/src/versions.js

@@ -1,7 +1,10 @@
+"use strict";
+
 angular.module('versions', [])
 
 .controller('DocsVersionsCtrl', ['$scope', '$location', '$window', 'NG_VERSIONS', function($scope, $location, $window, NG_VERSIONS) {
   $scope.docs_version  = NG_VERSIONS[0];
+  $scope.docs_versions = NG_VERSIONS;
 
   for(var i=0, minor = NaN; i < NG_VERSIONS.length; i++) {
     var version = NG_VERSIONS[i];
@@ -13,9 +16,8 @@ angular.module('versions', [])
     minor = version.minor;
   }
 
-  $scope.docs_versions = NG_VERSIONS;
   $scope.getGroupName = function(v) {
-    return v.isLatest ? 'Latest' : (v.isStable ? 'Stable' : 'Unstable');
+    return v.isLatest ? 'Latest' : ('v' + v.major + '.' + v.minor + '.x');
   };
 
   $scope.jumpToDocsVersion = function(version) {

docs/config/index.js

@@ -5,8 +5,8 @@ var packagePath = __dirname;
 
 var Package = require('dgeni').Package;
 
-// Create and export a new Dgeni package called dgeni-example. This package depends upon
-// the jsdoc and nunjucks packages defined in the dgeni-packages npm module.
+// Create and export a new Dgeni package called angularjs. This package depends upon
+// the ngdoc,nunjucks and examples packages defined in the dgeni-packages npm module.
 module.exports = new Package('angularjs', [
   require('dgeni-packages/ngdoc'),
   require('dgeni-packages/nunjucks'),
@@ -157,6 +157,8 @@ module.exports = new Package('angularjs', [
     jqueryDeployment
   ];
 
+  generateProtractorTestsProcessor.basePath = 'build/docs/';
+
   generateExamplesProcessor.deployments = [
     debugDeployment,
     defaultDeployment,

docs/content/api/index.ngdoc

@@ -161,6 +161,27 @@ or JavaScript callbacks.
   </tr>
 </table>
 
+## {@link ngAria ngAria}
+
+Use ngAria to inject common accessibility attributes into directives and improve the experience for users with disabilities.
+
+<div class="alert alert-info">Include the **angular-aria.js** file and set ngAria as a dependency for this to work in your application.</div>
+
+<table class="definition-table spaced">
+  <tr>
+    <td>
+      {@link ngAria#service Services}
+    </td>
+    <td>
+      <p>
+          The {@link ngAria.$aria $aria} service contains helper methods for applying ARIA attributes to HTML.
+      <p>
+      <p>
+          {@link ngAria.$ariaProvider $ariaProvider} is used for configuring ARIA attributes.
+      </p>
+    </td>
+  </tr>
+</table>
 
 ## {@link ngResource ngResource}
 

docs/content/error/$http/badreq.ngdoc

@@ -0,0 +1,10 @@
+@ngdoc error
+@name $http:badreq
+@fullName Bad Request Configuration
+@description
+
+This error occurs when the request configuration parameter passed to the {@link ng.$http `$http`} service is not an object.  `$http` expects a single parameter, the request configuration object, but received a parameter that was not an object.  The error message should provide additional context such as the actual value of the parameter that was received.  If you passed a string parameter, perhaps you meant to call one of the shorthand methods on `$http` such as `$http.get(…)`, etc.
+
+To resolve this error, make sure you pass a valid request configuration object to `$http`.
+
+For more information, see the {@link ng.$http `$http`} service API documentation.

docs/content/error/$injector/modulerr.ngdoc

@@ -6,6 +6,22 @@
 This error occurs when a module fails to load due to some exception. The error
 message above should provide additional context.
 
+### Using `ngRoute`
+
 In AngularJS `1.2.0` and later, `ngRoute` has been moved to its own module.
 If you are getting this error after upgrading to `1.2.x` or later, be sure that you've
 installed {@link ngRoute `ngRoute`}.
+
+### Monkey-patching Angular's `ng` module
+
+This error can also occur if you have tried to add your own components to the `ng` module.
+This has never been supported and from `1.3.0` it will actually trigger this error.
+For instance the following code could trigger this error.
+
+```js
+angular.module('ng').filter('tel', function (){});
+```
+
+Instead create your own module and add it as a dependency to your application's top-level module.
+See [#9692](https://github.com/angular/angular.js/issues/9692) and
+[#7709](https://github.com/angular/angular.js/issues/7709) for more information

docs/content/error/$injector/unpr.ngdoc

@@ -61,7 +61,7 @@ Attempting to inject one controller into another will also throw an `Unknown pro
 
 ```
 angular.module('myModule', [])
-  .controller('MyFirstController', function() { /* ... */ });
+  .controller('MyFirstController', function() { /* ... */ })
   .controller('MySecondController', ['MyFirstController', function(MyFirstController) {
     // This controller throws an unknown provider error because
     // MyFirstController cannot be injected.

docs/content/error/$location/ihshprfx.ngdoc

@@ -8,10 +8,10 @@ This error occurs when {@link ng.$location $location} service is configured to u
 For example if you configure `$location` service with prefix `'!'`:
 ```
 myApp.config(function($locationProvider) {
-  $locationProvider.prefix('!');
+  $locationProvider.hashPrefix('!');
 });
 ```
 
-If you enter the app at url `http:/myapp.com/#/myView` this error will be throw.
+If you enter the app at url `http://myapp.com/#/myView` this error will be thrown.
 
-The correct url for this configuration is `http:/myapp.com/#!/myView` (note the `'!'` after `'#'` symbol).
+The correct url for this configuration is `http://myapp.com/#!/myView` (note the `'!'` after `'#'` symbol).

docs/content/error/ngRepeat/dupes.ngdoc

@@ -15,7 +15,7 @@ For example the issue can be triggered by this *invalid* code:
 
 To resolve this error either ensure that the items in the collection have unique identity or use the `track by` syntax to specify how to track the association between models and DOM.
 
-To resolve the example above can be resolved by using `track by $index`, which will cause the items to be keyed by their position in the array instead of their value:
+The example above can be resolved by using `track by $index`, which will cause the items to be keyed by their position in the array instead of their value:
 
 ```
 <div ng-repeat="value in [4, 4] track by $index"></div>

docs/content/guide/$location.ngdoc

@@ -332,7 +332,7 @@ reload to the original link.
 Be sure to check all relative links, images, scripts etc. Angular requires you to specify the url
 base in the head of your main html file (`<base href="/my-base">`) unless `html5Mode.requireBase` is
 set to `false` in the html5Mode definition object passed to `$locationProvider.html5Mode()`. With
-that, relative urls will always be resolved to this base url, event if the initial url of the
+that, relative urls will always be resolved to this base url, even if the initial url of the
 document was different.
 
 There is one exception: Links that only contain a hash fragment (e.g. `<a href="#target">`)

docs/content/guide/accessibility.ngdoc

@@ -6,56 +6,360 @@
 
 # Accessibility with ngAria
 
-You can use the `ngAria` module to have common ARIA attributes automatically applied when you
-use certain directives. To enable `ngAria`, just require the module into your application and 
-the code will hook into your ng-show/ng-hide, input, textarea, button, select and 
-ng-required directives and add the appropriate ARIA states and properties.
+The goal of ngAria is to improve Angular's default accessibility by enabling common
+[ARIA](http://www.w3.org/TR/wai-aria/) attributes that convey state or semantic information for
+assistive technologies used by persons with disabilities.
 
-Currently, the following attributes are implemented:
- * aria-hidden
- * aria-checked
- * aria-disabled
- * aria-required
- * aria-invalid
- * aria-multiline
- * aria-valuenow
- * aria-valuemin
- * aria-valuemax
- * tabindex
+##Including ngAria
 
-You can disable individual attributes by using the `{@link ngAria.$ariaProvider#config config}` method.
-
-###Example
+Using {@link ngAria ngAria} is as simple as requiring the ngAria module in your application. ngAria hooks into
+standard AngularJS directives and quietly injects accessibility support into your application
+at runtime.
 
 ```js
 angular.module('myApp', ['ngAria'])...
 ```
 
-Elements using `ng-model` with `required` or `ngRequired` directives will automatically have
-`aria-required` attributes with the proper corresponding values.
+###Using ngAria
+Most of what ngAria does is only visible "under the hood". To see the module in action, once you've
+added it as a dependency, you can test a few things:
+ * Using your favorite element inspector, look for ngAria attributes in your own code.
+ * Test using your keyboard to ensure `tabindex` is used correctly.
+ * Fire up a screen reader such as VoiceOver to listen for ARIA support.
+[Helpful screen reader tips.](http://webaim.org/articles/screenreader_testing/)
+
+##Supported directives
+Currently, ngAria interfaces with the following directives:
+
+ * <a href="#ngmodel">ngModel</a>
+ * <a href="#ngdisabled">ngDisabled</a>
+ * <a href="#ngshow">ngShow</a>
+ * <a href="#nghide">ngHide</a>
+ * <a href="#ngclick-and-ngdblclick">ngClick</a>
+ * <a href="#ngclick-and-ngdblclick">ngDblClick</a>
+
+<h2 id="ngmodel">ngModel</h2>
+
+Most of ngAria's heavy lifting happens in the {@link ngModel ngModel}
+directive.  For elements using ngModel, special attention is paid by ngAria if that element also
+has a a role or type of `checkbox`, `radio`, `range` or `textbox`.
+
+For those elements using ngModel, ngAria will dynamically bind and update the following ARIA
+attributes (if they have not been explicitly specified by the developer):
+
+ * aria-checked
+ * aria-valuemin
+ * aria-valuemax
+ * aria-valuenow
+ * aria-invalid
+ * aria-required
+
+###Example
+
+<example module="ngAria_ngModelExample" deps="angular-aria.js">
+ <file name="index.html">
+  <style>
+    [role=checkbox] {
+      cursor: pointer;
+      display: inline-block;
+    }
+    [role=checkbox] .icon:before {
+      content: '\2610';
+      display: inline-block;
+      font-size: 2em;
+      line-height: 1;
+      vertical-align: middle;
+      speak: none;
+    }
+    [role=checkbox].active .icon:before {
+      content: '\2611';
+    }
+    pre {
+      white-space: pre-wrap;
+    }
+  </style>
+ <div>
+ <form ng-controller="formsController">
+  <some-checkbox role="checkbox" ng-model="checked" ng-class="{active: checked}"
+    ng-disabled="isDisabled" ng-click="toggleCheckbox()"
+    aria-label="Custom Checkbox" show-attrs>
+    <span class="icon" aria-hidden="true"></span>
+    Custom Checkbox
+  </some-checkbox>
+ </form>
+ </div>
+ <script>
+  var app = angular.module('ngAria_ngModelExample', ['ngAria'])
+  .controller('formsController', function($scope){
+    $scope.checked = false;
+    $scope.toggleCheckbox = function(){
+      $scope.checked = !$scope.checked;
+    }
+  })
+  .directive('someCheckbox', function(){
+    return {
+      restrict: 'E',
+      link: function($scope, $el, $attrs) {
+        $el.on('keypress', function(event){
+          event.preventDefault();
+          if(event.keyCode === 32 || event.keyCode === 13){
+            $scope.toggleCheckbox();
+            $scope.$apply();
+          }
+        });
+      }
+    }
+  })
+  .directive('showAttrs', function() {
+    return function($scope, $el, $attrs) {
+      var pre = document.createElement('pre');
+      $el.after(pre);
+      $scope.$watch(function() {
+        var $attrs = {};
+        Array.prototype.slice.call($el[0].attributes, 0).forEach(function(item) {
+          if (item.name !== 'show-$attrs') {
+            $attrs[item.name] = item.value;
+          }
+        });
+        return $attrs;
+      }, function(newAttrs, oldAttrs) {
+        pre.textContent = JSON.stringify(newAttrs, null, 2);
+      }, true);
+    }
+  });
+ </script>
+ </file>
+</example>
+
+ngAria will also add `tabIndex`, ensuring custom elements with these roles will be reachable from
+the keyboard. It is still up to **you** as a developer to **ensure custom controls will be
+operable** from the keybard. Think of `ng-click` on a `<div>` or `<md-checkbox>`: you still need
+to bind `ng-keypress` to make it fully operable from the keyboard. As a rule, any time you create
+a widget involving user interaction, be sure to test it with your keyboard and at least one mobile
+and desktop screen reader (preferably more).
+
+<h2 id="ngdisabled">ngDisabled</h2>
+
+The `disabled` attribute is only valid for certain elements such as `button`, `input` and
+`textarea`. To properly disable custom element directives such as `<md-checkbox>` or `<taco-tab>`,
+using ngAria with [ngDisabled](https://docs.angularjs.org/api/ng/directive/ngDisabled) will also
+add `aria-disabled`. This tells assistive technologies when a non-native input is disabled, helping
+custom controls to be more accessible.
+
+###Example
 
 ```html
-<material-input ng-model="val" required>
+<md-checkbox ng-disabled="disabled">
 ```
 
 Becomes:
 
 ```html
-<material-input ng-model="val" required aria-required="true">
+<md-checkbox disabled aria-disabled="true">
 ```
 
-ngAria is just a starting point. You'll have to manually choose how to implement some
-accessibility features.
+>You can check whether a control is legitimately disabled for a screen reader by visiting
+[chrome://accessibility](chrome://accessibility).
 
-For instance, you may want to add `ng-keypress` bindings alongside `ng-click` to make keyboard
-navigation easier.
+<h2 id="ngshow">ngShow</h2>
 
+>The [ngShow](https://docs.angularjs.org/api/ng/directive/ngShow) directive shows or hides the
+given HTML element based on the expression provided to the `ngShow` attribute. The element is
+shown or hidden by removing or adding the `.ng-hide` CSS class onto the element.
 
-## Additional Resources
+In its default setup, ngAria for `ngShow` is actually redundant. It toggles `aria-hidden` on the
+directive when it is hidden or shown. However, the default CSS of `display: none !important`,
+already hides child elements from a screen reader. It becomes more useful when the default
+CSS is overridden with properties that don’t affect assistive technologies, such as `opacity`
+or `transform`. By toggling `aria-hidden` dynamically with ngAria, we can ensure content visually
+hidden with this technique will not be read aloud in a screen reader.
+
+One caveat with this combination of CSS and `aria-hidden`: you must also remove links and other
+interactive child elements from the tab order using `tabIndex=“-1”` on each control. This ensures
+screen reader users won't accidentally focus on "mystery elements". Managing tab index on every
+child control can be complex and affect performance, so it’s best to just stick with the default
+`display: none` CSS. See the [fourth rule of ARIA use](http://www.w3.org/TR/aria-in-html/#fourth-rule-of-aria-use).
+
+###Example
+```css
+.ng-hide {
+  display: block;
+  opacity: 0;
+}
+```
+```html
+<div ng-show="false" class="ng-hide" aria-hidden="true"></div>
+```
+
+Becomes:
+
+```html
+<div ng-show="true" aria-hidden="false"></div>
+```
+*Note: Child links, buttons or other interactive controls must also be removed from the tab order.*
+
+<h2 id="nghide">ngHide</h2>
+
+>The [ngHide](https://docs.angularjs.org/api/ng/directive/ngHide) directive shows or hides the
+given HTML element based on the expression provided to the `ngHide` attribute. The element is
+shown or hidden by removing or adding the `.ng-hide` CSS class onto the element.
+
+The default CSS for `ngHide`, the inverse method to `ngShow`, makes ngAria redundant. It toggles
+`aria-hidden` on the directive when it is hidden or shown, but the content is already hidden with
+`display: none`. See explanation for <a href="#ngshow">ngShow</a> when overriding the default CSS.
+
+<h2 id="ngclick-and-ngdblclick">ngClick and ngDblclick</h2>
+If `ng-click` or `ng-dblclick` is encountered, ngAria will add `tabindex` if it isn't there already.
+Even with this, you must currently still add `ng-keypress` to non-interactive elements such as `div`
+or `taco-button` to enable keyboard access. Conversation is currently ongoing about whether ngAria
+should also bind `ng-keypress`.
+
+<h3>Example</h3>
+```html
+<div ng-click="toggleMenu()"></div>
+```
+
+Becomes:
+```html
+<div ng-click="toggleMenu()" tabindex="0"></div>
+```
+*Note: ngAria still requires `ng-keypress` to be added manually to non-native controls like divs.*
+
+<h2 id="ngmessages">ngMessages</h2>
+
+The new ngMessages module makes it easy to display form validation or other messages with priority
+sequencing and animation. To expose these visual messages to screen readers,
+ngAria injects `aria-live="polite"`, causing them to be read aloud any time a message is shown,
+regardless of the user's focus location.
+###Example
+
+```html
+<div ng-messages="myForm.myName.$error">
+  <div ng-message="required">You did not enter a field</div>
+  <div ng-message="maxlength">Your field is too long</div>
+</div>
+```
+
+Becomes:
+
+```html
+<div ng-messages="myForm.myName.$error" aria-live="polite">
+  <div ng-message="required">You did not enter a field</div>
+  <div ng-message="maxlength">Your field is too long</div>
+</div>
+```
+
+##Disabling attributes
+The attribute magic of ngAria may not work for every scenario. To disable individual attributes,
+you can use the {@link ngAria.$ariaProvider#config config} method. Just keep in mind this will
+tell ngAria to ignore the attribute globally.
+
+<example module="ngAria_ngDisabledExample" deps="angular-aria.js">
+ <file name="index.html">
+  <style>
+    [role=checkbox] {
+      cursor: pointer;
+      display: inline-block;
+    }
+    [role=checkbox] .icon:before {
+      content: '\2610';
+      display: inline-block;
+      font-size: 2em;
+      line-height: 1;
+      vertical-align: middle;
+      speak: none;
+    }
+    [role=checkbox].active .icon:before {
+      content: '\2611';
+    }
+  </style>
+ <form ng-controller="formsController">
+  <div ng-model="someModel" show-attrs>
+    Div with ngModel and aria-invalid disabled
+  </div>
+  <div role="checkbox" ng-model="checked" ng-class="{active: checked}"
+    aria-label="Custom Checkbox" ng-click="toggleCheckbox()" some-checkbox show-attrs>
+    <span class="icon" aria-hidden="true"></span>
+    Custom Checkbox for comparison
+  </div>
+ </form>
+ <script>
+  angular.module('ngAria_ngDisabledExample', ['ngAria'], function config($ariaProvider) {
+    $ariaProvider.config({
+      ariaInvalid: false,
+      tabindex: true
+    });
+  })
+  .controller('formsController', function($scope){
+    $scope.checked = false;
+    $scope.toggleCheckbox = function(){
+      $scope.checked = !$scope.checked;
+    }
+  })
+  .directive('someCheckbox', function(){
+    return {
+      restrict: 'A',
+      link: function($scope, $el, $attrs) {
+        $el.on('keypress', function(event){
+          event.preventDefault();
+          if(event.keyCode === 32 || event.keyCode === 13){
+            $scope.toggleCheckbox();
+            $scope.$apply();
+          }
+        });
+      }
+    }
+  })
+  .directive('showAttrs', function() {
+    return function(scope, el, attrs) {
+      var pre = document.createElement('pre');
+      el.after(pre);
+      scope.$watch(function() {
+        var attrs = {};
+        Array.prototype.slice.call(el[0].attributes, 0).forEach(function(item) {
+          if (item.name !== 'show-attrs') {
+            attrs[item.name] = item.value;
+          }
+        });
+        return attrs;
+      }, function(newAttrs, oldAttrs) {
+        pre.textContent = JSON.stringify(newAttrs, null, 2);
+      }, true);
+    }
+  });
+ </script>
+ </file>
+</example>
+
+##Common Accessibility Patterns
 
 Accessibility best practices that apply to web apps in general also apply to Angular.
 
-* [A11Y Project](http://a11yproject.com/)
-* [WebAim](http://webaim.org/)
-* [Using WAI-ARIA in HTML](http://www.w3.org/TR/2014/WD-aria-in-html-20140626/)
-* [Apps For All: Coding Accessible Web Applications](https://shop.smashingmagazine.com/apps-for-all-coding-accessible-web-applications.html)
+ * **Text alternatives**: Add alternate text content to make visual information accessible using
+ [these W3C guidelines](http://www.w3.org/TR/html-alt-techniques/). The appropriate technique
+ depends on the specific markup but can be accomplished using offscreen spans, `aria-label` or
+ label elements, image `alt` attributes, `figure`/`figcaption` elements and more.
+ * **HTML Semantics**: If you're creating custom element directives, Web Components or HTML in
+ general, use native elements wherever possible to utilize built-in events and properties.
+ Alternatively, use ARIA to communicate semantic meaning. See [notes on ARIA use](http://www.w3.org/TR/aria-in-html/#notes-on-aria-use-in-html).
+ * **Focus management**: Guide the user around the app as views are appended/removed.
+ Focus should *never* be lost, as this causes unexpected behavior and much confusion (referred to
+ as "freak-out mode").
+ * **Announcing changes**: When filtering or other UI messaging happens away from the user's focus,
+ notify with [ARIA Live Regions](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/ARIA_Live_Regions).
+ * **Color contrast and scale**: Make sure content is legible and interactive controls are usable
+ at all screen sizes. Consider configurable UI themes for people with color blindness, low vision
+ or other visual impairments.
+ * **Progressive enhancement**: Some users do not browse with JavaScript enabled or do not have
+ the latest browser. An accessible message about site requirements can inform users and improve
+ the experience.
+
+## Additional Resources
+
+ * [Using ARIA in HTML](http://www.w3.org/TR/aria-in-html/)
+ * [AngularJS Accessibility at ngEurope](https://www.youtube.com/watch?v=dmYDggEgU-s&list=UUEGUP3TJJfMsEM_1y8iviSQ)
+ * [Testing with Screen Readers](http://webaim.org/articles/screenreader_testing/)
+ * [Chrome Accessibility Developer Tools](https://chrome.google.com/webstore/detail/accessibility-developer-t/fpkknkljclfencbdbgkenhalefipecmb?hl=en)
+ * [W3C Accessibility Testing](http://www.w3.org/wiki/Accessibility_testing)
+ * [WebAIM](http://webaim.org)
+ * [A11y Project](http://a11yproject.com)

docs/content/guide/bootstrap.ngdoc

@@ -20,7 +20,7 @@ initialization.
 <html xmlns:ng="http://angularjs.org" ng-app>
   <body>
     ...
-    <script src="angular.js">
+    <script src="angular.js"></script>
   </body>
 </html>
 ```
@@ -73,6 +73,23 @@ If the {@link ng.directive:ngApp `ng-app`} directive is found then Angular will:
 </html>
 ```
 
+As a best practice, consider adding an `ng-strict-di` directive on the same element as
+`ng-app`:
+
+
+```html
+<!doctype html>
+<html ng-app="optionalModuleName" ng-strict-di>
+  <body>
+    I can add: {{ 1+2 }}.
+    <script src="angular.js"></script>
+  </body>
+</html>
+```
+
+This will ensure that all services in your application are properly annotated.
+See the {@link guide/di#using-strict-dependency-injection dependancy injection strict mode} docs
+for more.
 
 
 ## Manual Initialization
@@ -128,8 +145,8 @@ This is the sequence that your code should follow:
 
 ## Deferred Bootstrap
 
-This feature enables tools like Batarang and test runners to
-hook into angular's bootstrap process and sneak in more modules
+This feature enables tools like [Batarang](https://github.com/angular/angularjs-batarang) and test runners
+to hook into angular's bootstrap process and sneak in more modules
 into the DI registry which can replace or augment DI services for
 the purpose of instrumentation or mocking out heavy dependencies.
 

docs/content/guide/compiler.ngdoc

@@ -332,7 +332,7 @@ The first issue we have to solve is that the dialog box template expects `title`
 But we would like the template's scope property `title` to be the result of interpolating the
 `<dialog>` element's `title` attribute (i.e. `"Hello {{username}}"`). Furthermore, the buttons expect
 the `onOk` and `onCancel` functions to be present in the scope. This limits the usefulness of the
-widget. To solve the mapping issue we use the `locals` to create local variables which the template
+widget. To solve the mapping issue we use the `scope` to create local variables which the template
 expects as follows:
 
 ```js

docs/content/guide/concepts.ngdoc

@@ -56,10 +56,10 @@ Try out the Live Preview above, and then let's walk through the example and desc
 
 This looks like normal HTML, with some new markup. In Angular, a file like this is called a
 <a name="template">"{@link templates template}"</a>. When Angular starts your application, it parses and
-processes this new markup from the template using the so called <a name="compiler">"{@link compiler compiler}"</a>.
+processes this new markup from the template using the so-called <a name="compiler">"{@link compiler compiler}"</a>.
 The loaded, transformed and rendered DOM is then called the <a name="view">"view"</a>.
 
-The first kind of new markup are the so called <a name="directive">"{@link directive directives}"</a>.
+The first kind of new markup are the so-called <a name="directive">"{@link directive directives}"</a>.
 They apply special behavior to attributes or elements in the HTML. In the example above we use the
 {@link ng.directive:ngApp `ng-app`} attribute, which is linked to a directive that automatically
 initializes our application. Angular also defines a directive for the {@link ng.directive:input `input`}
@@ -89,7 +89,7 @@ A filter formats the value of an expression for display to the user.
 In the example above, the filter {@link ng.filter:currency `currency`} formats a number
 into an output that looks like money.
 
-The important thing in the example is that angular provides _live_ bindings:
+The important thing in the example is that Angular provides _live_ bindings:
 Whenever the input values change, the value of the expressions are automatically
 recalculated and the DOM is updated with their values.
 The concept behind this is <a name="databinding">"{@link databinding two-way data binding}"</a>.
@@ -150,13 +150,13 @@ different currencies and also pay the invoice.
 
 What changed?
 
-First, there is a new JavaScript file that contains a so called <a name="controller">"{@link controller controller}"</a>.
+First, there is a new JavaScript file that contains a so-called <a name="controller">"{@link controller controller}"</a>.
 More exactly, the file contains a constructor function that creates the actual controller instance.
 The purpose of controllers is to expose variables and functionality to expressions and directives.
 
-Besides the new file that contains the controller code we also added a
+Besides the new file that contains the controller code we also added an
 {@link ng.directive:ngController `ng-controller`} directive to the HTML.
-This directive tells angular that the new `InvoiceController` is responsible for the element with the directive
+This directive tells Angular that the new `InvoiceController` is responsible for the element with the directive
 and all of the element's children.
 The syntax `InvoiceController as invoice` tells Angular to instantiate the controller
 and save it in the variable `invoice` in the current scope.
@@ -263,7 +263,7 @@ services, ...) is created and wired using dependency injection. Within Angular,
 the DI container is called the <a name="injector">"{@link di injector}"</a>.
 
 To use DI, there needs to be a place where all the things that should work together are registered.
-In Angular, this is the purpose of the so called <a name="module">"{@link module modules}"</a>.
+In Angular, this is the purpose of the so-called <a name="module">"{@link module modules}"</a>.
 When Angular starts, it will use the configuration of the module with the name defined by the `ng-app` directive,
 including the configuration of all modules that this module depends on.
 

docs/content/guide/di.ngdoc

@@ -11,13 +11,227 @@ their dependencies.
 The Angular injector subsystem is in charge of creating components, resolving their dependencies,
 and providing them to other components as requested.
 
+
+## Using Dependency Injection
+
+DI is pervasive throughout Angular. You can use it when defining components or when providing `run`
+and `config` blocks for a module.
+
+- Components such as services, directives, filters, and animations are defined by an injectable
+factory method or constructor function. These components can be injected with "service" and "value"
+components as dependencies.
+
+- Controllers are defined by a constructor function, which can be injected with any of the "service"
+and "value" components as dependencies, but they can also be provided with special dependencies. See
+{@link di#controllers Controllers} below for a list of these special dependencies.
+
+- The `run` method accepts a function, which can be injected with "service", "value" and "constant"
+components as dependencies. Note that you cannot inject "providers" into `run` blocks.
+
+- The `config` method accepts a function, which can be injected with "provider" and "constant"
+components as dependencies. Note that you cannot inject "service" or "value" components into
+configuration.
+
+See {@link module#module-loading-dependencies Modules} for more details about `run` and `config`
+blocks.
+
+
+### Factory Methods
+
+The way you define a directive, service, or filter is with a factory function.
+The factory methods are registered with modules. The recommended way of declaring factories is:
+
+```js
+angular.module('myModule', [])
+  .factory('serviceId', ['depService', function(depService) {
+    // ...
+  }])
+  .directive('directiveName', ['depService', function(depService) {
+    // ...
+  }])
+  .filter('filterName', ['depService', function(depService) {
+    // ...
+  }]);
+```
+
+### Module Methods
+
+We can specify functions to run at configuration and run time for a module by calling the `config`
+and `run` methods. These functions are injectable with dependencies just like the factory functions
+above.
+
+```js
+angular.module('myModule', [])
+  .config(['depProvider', function(depProvider) {
+    // ...
+  }])
+  .run(['depService', function(depService) {
+    // ...
+  }]);
+```
+
+### Controllers
+
+Controllers are "classes" or "constructor functions" that are responsible for providing the
+application behavior that supports the declarative markup in the template. The recommended way of
+declaring Controllers is using the array notation:
+
+```js
+someModule.controller('MyController', ['$scope', 'dep1', 'dep2', function($scope, dep1, dep2) {
+  ...
+  $scope.aMethod = function() {
+    ...
+  }
+  ...
+}]);
+```
+
+Unlike services, there can be many instances of the same type of controller in an application.
+
+Moreover, additional dependencies are made available to Controllers:
+
+* {@link scope `$scope`}: Controllers are associated with an element in the DOM and so are
+  provided with access to the {@link scope scope}. Other components (like services) only have
+  access to the {@link $rootScope `$rootScope`} service.
+* {@link ngRoute.$routeProvider#when resolves}: If a controller is instantiated as part of a route,
+  then any values that are resolved as part of the route are made available for injection into the
+  controller.
+
+
+## Dependency Annotation
+
+Angular invokes certain functions (like service factories and controllers) via the injector.
+You need to annotate these functions so that the injector knows what services to inject into
+the function. There are three ways of annotating your code with service name information:
+
+- Using the inline array annotation (preferred)
+- Using the `$inject` property annotation
+- Implicitly from the function parameter names (has caveats)
+
+### Inline Array Annotation
+
+This is the preferred way to annotate application components. This is how the examples in the
+documentation are written.
+
+For example:
+
+```js
+someModule.controller('MyController', ['$scope', 'greeter', function($scope, greeter) {
+  // ...
+}]);
+```
+
+Here we pass an array whose elements consist of a list of strings (the names of the dependencies)
+followed by the function itself.
+
+When using this type of annotation, take care to keep the annotation array in sync with the
+parameters in the function declaration.
+
+### `$inject` Property Annotation
+
+To allow the minifiers to rename the function parameters and still be able to inject the right services,
+the function needs to be annotated with the `$inject` property. The `$inject` property is an array
+of service names to inject.
+
+```js
+var MyController = function($scope, greeter) {
+  // ...
+}
+MyController.$inject = ['$scope', 'greeter'];
+someModule.controller('MyController', MyController);
+```
+
+In this scenario the ordering of the values in the `$inject` array must match the ordering of the
+parameters in `MyController`.
+
+Just like with the array annotation, you'll need to take care to keep the `$inject` in sync with
+the parameters in the function declaration.
+
+### Implicit Annotation
+
+<div class="alert alert-danger">
+**Careful:** If you plan to [minify](http://en.wikipedia.org/wiki/Minification_(programming&#41;)
+your code, your service names will get renamed and break your app.
+</div>
+
+The simplest way to get hold of the dependencies is to assume that the function parameter names
+are the names of the dependencies.
+
+```js
+someModule.controller('MyController', function($scope, greeter) {
+  // ...
+});
+```
+
+Given a function the injector can infer the names of the services to inject by examining the
+function declaration and extracting the parameter names. In the above example `$scope`, and
+`greeter` are two services which need to be injected into the function.
+
+One advantage of this approach is that there's no array of names to keep in sync with the
+function parameters. You can also freely reorder dependencies.
+
+However this method will not work with JavaScript minifiers/obfuscators because of how they
+rename parameters.
+
+Tools like [ng-annotate](https://github.com/olov/ng-annotate) let you use implicit dependency
+annotations in your app and automatically add inline array annotations prior to minifying.
+If you decide to take this approach, you probably want to use `ng-strict-di`.
+
+Because of these caveats, we recommend avoiding this style of annotation.
+
+
+## Using Strict Dependency Injection
+
+You can add an `ng-strict-di` directive on the same element as `ng-app` to opt into strict DI mode:
+
+```html
+<!doctype html>
+<html ng-app="myApp" ng-strict-di>
+<body>
+  I can add: {{ 1 + 2 }}.
+  <script src="angular.js"></script>
+</body>
+</html>
+```
+
+Strict mode throws an error whenever a service tries to use implicit annotations.
+
+Consider this module, which includes a `willBreak` service that uses implicit DI:
+
+```js
+angular.module('myApp', [])
+  .factory('willBreak', function($rootScope) {
+    // $rootScope is implicitly injected
+  })
+  .run(['willBreak', function(willBreak) {
+    // Angular will throw when this runs
+  }]);
+```
+
+When the `willBreak` service is instantiated, Angular will throw an error because of strict mode.
+This is useful when using a tool like [ng-annotate](https://github.com/olov/ng-annotate) to
+ensure that all of your application components have annotations.
+
+If you're using manual bootstrapping, you can also use strict DI by providing `strictDi: true` in
+the optional config argument:
+
+```js
+angular.bootstrap(document, ['myApp'], {
+  strictDi: true
+});
+```
+
+
+
+## Why Dependency Injection?
+
+This section motivates and explains Angular's use of DI. For how to use DI, see above.
+
 For in-depth discussion about DI, see
 [Dependency Injection](http://en.wikipedia.org/wiki/Dependency_injection) at Wikipedia,
 [Inversion of Control](http://martinfowler.com/articles/injection.html) by Martin Fowler,
 or read about DI in your favorite software design pattern book.
 
-## DI in a Nutshell
-
 There are only three ways a component (object or function) can get a hold of its dependencies:
 
   1. The component can create the dependency, typically using the `new` operator.
@@ -117,186 +331,7 @@ controller ever knowing about the injector.
 This is the best outcome. The application code simply declares the dependencies it needs, without
 having to deal with the injector. This setup does not break the Law of Demeter.
 
-
-## Dependency Annotation
-
-**How does the injector know what components need to be injected?**
-
-The application developer needs to provide annotation information that the injector uses in order
-to resolve the dependencies. Throughout Angular, certain API functions are invoked using the
-injector, as per the API documentation. The injector needs to know what services to inject into
-the function. There are three equivalent ways of annotating your code with service name
-information:
-
-- Implicitly from the function parameter names
-- Using the `$inject` property annotation
-- Using the inline array annotation
-
-These can be used interchangeably as you see fit and are equivalent.
-
-### Implicit Dependencies
-
-The simplest way to get hold of the dependencies is to assume that the function parameter names
-are the names of the dependencies.
-
-```js
-function MyController($scope, greeter) {
-  // ...
-}
-```
-
-Given a function the injector can infer the names of the services to inject by examining the
-function declaration and extracting the parameter names. In the above example `$scope`, and
-`greeter` are two services which need to be injected into the function.
-
-While straightforward, this method will not work with JavaScript minifiers/obfuscators as they
-rename the method parameter names. This makes this way of annotating only useful for
-[pretotyping](http://www.pretotyping.org/), and demo applications.
-
-### `$inject` Property Annotation
-
-To allow the minifiers to rename the function parameters and still be able to inject the right services,
-the function needs to be annotated with the `$inject` property. The `$inject` property is an array
-of service names to inject.
-
-```js
-var MyController = function(renamed$scope, renamedGreeter) {
-  ...
-}
-MyController['$inject'] = ['$scope', 'greeter'];
-```
-
-In this scenario the ordering of the values in the `$inject` array must match the ordering of the
-arguments to inject. Using the above code snippet as an example, `$scope` will be injected into
-`renamed$scope` and `greeter` into `renamedGreeter`. Care must be taken that the `$inject`
-annotation is kept in sync with the actual arguments in the function declaration.
-
-This method of annotation is useful for controller declarations since it assigns the annotation
-information with the function.
-
-### Inline Array Annotation
-
-Sometimes using the `$inject` annotation style is not convenient such as when annotating
-directives or services defined inline by a factory function.
-
-For example:
-
-```js
-someModule.factory('greeter', function($window) {
-  // ...
-});
-```
-
-Results in code bloat due to needing a temporary variable:
-
-```js
-var greeterFactory = function(renamed$window) {
-  // ...
-};
-
-greeterFactory.$inject = ['$window'];
-
-someModule.factory('greeter', greeterFactory);
-```
-
-For this reason the third annotation style is provided as well.
-
-```js
-someModule.factory('greeter', ['$window', function(renamed$window) {
-  // ...
-}]);
-```
-
-Here, instead of simply providing the factory function, we pass an array whose elements consist of
-a list of strings (the names of the dependencies) followed by the function itself.
-
-Keep in mind that all of the annotation styles are equivalent and can be used anywhere in Angular
-where injection is supported.
-
-## Where Can I Use DI?
-
-DI is pervasive throughout Angular. You can use it when defining components or when providing `run`
-and `config` blocks for a module.
-
-- Components such as services, directives, filters and animations are defined by an injectable factory
-method or constructor function.  These components can be injected with "service" and "value"
-components as dependencies.
-
-- The `run` method accepts a function, which can be injected with "service", "value" and "constant"
-components as dependencies. Note that you cannot inject "providers" into `run` blocks.
-
-- The `config` method accepts a function, which can be injected with "provider" and "constant"
-components as dependencies.  Note that you cannot inject "service" or "value" components into
-configuration
-
-- Controllers are defined by a constructor function, which can be injected with any of the "service"
-and "value" components as dependencies, but they can also be provided with special dependencies. See
-{@link di#controllers Controllers} below for a list of these special dependencies.
-
-See {@link module#module-loading-dependencies Modules} for more details about injecting dependencies
-into `run` and `config` blocks.
-
-
-### Factory Methods
-
-Factory methods are responsible for creating most objects in Angular. Examples are directives,
-services, and filters. The factory methods are registered with the module, and the recommended way
-of declaring factories is:
-
-```js
-angular.module('myModule', [])
-  .factory('serviceId', ['depService', function(depService) {
-    ...
-  }])
-  .directive('directiveName', ['depService', function(depService) {
-    ...
-  }])
-  .filter('filterName', ['depService', function(depService) {
-    ...
-  }]);
-```
-
-### Module Methods
-
-We can specify functions to run at configuration and run time for a module by calling the `run` and
-`config` methods. These functions are injectable with dependencies just like the factory functions
-above.
-
-```js
-angular.module('myModule', [])
-  .config(['depProvider', function(depProvider){
-    ...
-  }])
-  .run(['depService', function(depService) {
-    ...
-  }]);
-```
-
-### Controllers
-
-Controllers are "classes" or "constructor functions" that are responsible for providing the
-application behavior that supports the declarative markup in the template. The recommended way of
-declaring Controllers is using the array notation:
-
-```js
-someModule.controller('MyController', ['$scope', 'dep1', 'dep2', function($scope, dep1, dep2) {
-  ...
-  $scope.aMethod = function() {
-    ...
-  }
-  ...
-}]);
-```
-
-This avoids the creation of global functions for controllers and also protects against minification.
-
-Controllers are special in that, unlike services, there can be many instances of them in the
-application. For example, there would be one instance for every `ng-controller` directive in the template.
-
-Moreover, additional dependencies are made available to Controllers:
-
-* {@link scope `$scope`}: Controllers are always associated with a point in the DOM and so are provided with
-  access to the {@link scope scope} at that point. Other components, such as services only have access to the
-  singleton {@link $rootScope} service.
-* {@link $route} resolves: If a controller is instantiated as part of a route, then any values that
-  are resolved as part of the route are made available for injection into the controller.
+<div class="alert alert-info">
+**Note:** Angular uses
+[**constructor injection**](http://misko.hevery.com/2009/02/19/constructor-injection-vs-setter-injection/).
+</div>

docs/content/guide/directive.ngdoc

@@ -66,15 +66,9 @@ The **normalization** process is as follows:
 1. Strip `x-` and `data-` from the front of the element/attributes.
 2. Convert the `:`, `-`, or `_`-delimited name to `camelCase`.
 
-Here are some equivalent examples of elements that match `ngBind`:
+For example, the following forms are all equivalent and match the {@link ngBind} directive:
 
 <example module="docsBindExample">
-  <file name="script.js">
-    angular.module('docsBindExample', [])
-      .controller('Controller', ['$scope', function($scope) {
-        $scope.name = 'Max Karl Ernst Ludwig Planck (April 23, 1858 – October 4, 1947)';
-      }]);
-  </file>
   <file name="index.html">
     <div ng-controller="Controller">
       Hello <input ng-model='name'> <hr/>
@@ -85,6 +79,12 @@ Here are some equivalent examples of elements that match `ngBind`:
       <span x-ng-bind="name"></span> <br/>
     </div>
   </file>
+  <file name="script.js">
+    angular.module('docsBindExample', [])
+      .controller('Controller', ['$scope', function($scope) {
+        $scope.name = 'Max Karl Ernst Ludwig Planck (April 23, 1858 – October 4, 1947)';
+      }]);
+  </file>
   <file name="protractor.js" type="protractor">
     it('should show off bindings', function() {
       expect(element(by.css('div[ng-controller="Controller"] span[ng-bind]')).getText())
@@ -282,7 +282,7 @@ using `templateUrl` instead:
   </file>
 </example>
 
-`templateUrl` can also be a function which returns the URL of an HMTL template to be loaded and
+`templateUrl` can also be a function which returns the URL of an HTML template to be loaded and
 used for the directive. Angular will call the `templateUrl` function with two parameters: the
 element that the directive was called on, and an `attr` object associated with that element.
 

docs/content/guide/e2e-testing.ngdoc

@@ -27,8 +27,8 @@ Protractor is a [Node.js](http://nodejs.org) program, and runs end to end tests
 written in JavaScript and run with node. Protractor uses [WebDriver](https://code.google.com/p/selenium/wiki/GettingStarted)
 to control browsers and simulate user actions.
 
-For more information on Protractor, view [getting started](https://github.com/angular/protractor/blob/master/docs/getting-started.md)
-or the [api docs](https://github.com/angular/protractor/blob/master/docs/api.md).
+For more information on Protractor, view [getting started](http://angular.github.io/protractor/#/getting-started)
+or the [api docs](http://angular.github.io/protractor/#/api).
 
 Protractor uses [Jasmine](http://jasmine.github.io/1.3/introduction.html) for its test syntax.
 As in unit testing, a test file is comprised of one or

docs/content/guide/expression.ngdoc

@@ -164,6 +164,12 @@ expression. The reason behind this is core to the Angular philosophy that applic
 be in controllers, not the views. If you need a real conditional, loop, or to throw from a view
 expression, delegate to a JavaScript method instead.
 
+## No RegExp creation with literal notation
+
+You can't create regular expressions from within AngularJS expressions. This is to avoid complex
+model transformation logic inside templates. Such logic is better placed in a controller or in a dedicated
+filter where it can be tested properly.
+
 ## `$event`
 
 Directives like {@link ng.directive:ngClick `ngClick`} and {@link ng.directive:ngFocus `ngFocus`}
@@ -278,9 +284,9 @@ digest cycle as long as that value is not undefined. If the value of the express
 within the digest loop and later, within the same digest loop, it is set to undefined,
 then the expression is not fulfilled and will remain watched.
 
-  1. Given an expression that starts with `::` when a digest loop is entered and expression
-     is dirty-checked store the value as V
-  2. If V is not undefined mark the result of the expression as stable and schedule a task
+  1. Given an expression that starts with `::`, when a digest loop is entered and expression
+     is dirty-checked, store the value as V
+  2. If V is not undefined, mark the result of the expression as stable and schedule a task
      to deregister the watch for this expression when we exit the digest loop
   3. Process the digest loop as normal
   4. When digest loop is done and all the values have settled process the queue of watch
@@ -314,7 +320,7 @@ someModule.directive('someDirective', function() {
 ```
 
 ```html
-  <div some-directive name=“::myName” color=“My color is {{::myColor}}”></div>
+  <div some-directive name="::myName" color="My color is {{::myColor}}"></div>
 ```
 
 

docs/content/guide/filter.ngdoc

@@ -91,6 +91,11 @@ The filter function should be a [pure function](http://en.wikipedia.org/wiki/Pur
 means that it should be stateless and idempotent. Angular relies on these properties and executes
 the filter only when the inputs to the function change.
 
+<div class="alert alert-warning">
+**Note:** filter names must be valid angular expression identifiers, such as `uppercase` or `orderBy`.
+Names with special characters, such as hyphens and dots, are not allowed.
+</div>
+
 The following sample filter reverses a text string. In addition, it conditionally makes the
 text upper-case.
 

docs/content/guide/forms.ngdoc

@@ -7,15 +7,17 @@ Controls (`input`, `select`, `textarea`) are ways for a user to enter data.
 A Form is a collection of controls for the purpose of grouping related controls together.
 
 Form and controls provide validation services, so that the user can be notified of invalid input.
-This provides a better user experience, because the user gets instant feedback on how to correct the error.
-Keep in mind that while client-side validation plays an important role in providing good user experience, it can easily be circumvented and thus can not be trusted.
+This provides a better user experience, because the user gets instant feedback on how to
+correct the error. Keep in mind that while client-side validation plays an important role
+in providing good user experience, it can easily be circumvented and thus can not be trusted.
 Server-side validation is still necessary for a secure application.
 
 
 # Simple form
 The key directive in understanding two-way data-binding is {@link ng.directive:ngModel ngModel}.
-The `ngModel` directive provides the two-way data-binding by synchronizing the model to the view, as well as view to the model.
-In addition it provides an {@link ngModel.NgModelController API} for other directives to augment its behavior.
+The `ngModel` directive provides the two-way data-binding by synchronizing the model to the view,
+as well as view to the model. In addition it provides an {@link ngModel.NgModelController API}
+for other directives to augment its behavior.
 
 <example module="formExample">
   <file name="index.html">
@@ -54,22 +56,29 @@ In addition it provides an {@link ngModel.NgModelController API} for other direc
 
 Note that `novalidate` is used to disable browser's native form validation.
 
+The value of `ngModel` won't be set unless it passes validation for the input field.
+For example: inputs of type `email` must have a value in the form of `user@domain`.
+
 
 
 # Using CSS classes
 
 To allow styling of form as well as controls, `ngModel`  adds these CSS classes:
 
-- `ng-valid`
-- `ng-invalid`
-- `ng-pristine`
-- `ng-dirty`
-- `ng-touched`
-- `ng-untouched`
+- `ng-valid`: the model is valid
+- `ng-invalid`: the model is invalid
+- `ng-valid-[key]`: for each valid key added by `$setValidity`
+- `ng-invalid-[key]`: for each invalid key added by `$setValidity`
+- `ng-pristine`: the control hasn't been interacted with yet
+- `ng-dirty`: the control has been interacted with
+- `ng-touched`: the control has been blurred
+- `ng-untouched`: the control hasn't been blurred
+- `ng-pending`: any `$asyncValidators` are unfulfilled
 
 The following example uses the CSS to display validity of each form control.
-In the example both `user.name` and `user.email` are required, but are rendered with red background only when they are dirty.
-This ensures that the user is not distracted with an error until after interacting with the control, and failing to satisfy its validity.
+In the example both `user.name` and `user.email` are required, but are rendered
+with red background only when they are dirty. This ensures that the user is not distracted
+with an error until after interacting with the control, and failing to satisfy its validity.
 
 <example module="formExample">
   <file name="index.html">
@@ -122,9 +131,9 @@ A form is an instance of {@link form.FormController FormController}.
 The form instance can optionally be published into the scope using the `name` attribute.
 
 Similarly, an input control that has the {@link ng.directive:ngModel ngModel} directive holds an
-instance of {@link ngModel.NgModelController NgModelController}.
-Such a control instance can be published as a property of the form instance using the `name` attribute
-on the input control.  The name attribute specifies the name of the property on the form instance.
+instance of {@link ngModel.NgModelController NgModelController}.Such a control instance
+can be published as a property of the form instance using the `name` attribute on the input control.
+The name attribute specifies the name of the property on the form instance.
 
 This implies that the internal state of both the form and the control is available for binding in
 the view using the standard binding primitives.
@@ -187,7 +196,7 @@ This allows us to extend the above example with these features:
 
 
 
-# Custom triggers
+# Custom model update triggers
 
 By default, any change to the content will trigger a model update and form validation. You can
 override this behavior using the {@link ng.directive:ngModelOptions ngModelOptions} directive to
@@ -195,13 +204,15 @@ bind only to specified list of events. I.e. `ng-model-options="{ updateOn: 'blur
 and validate only after the control loses focus. You can set several events using a space delimited
 list. I.e. `ng-model-options="{ updateOn: 'mousedown blur' }"`
 
+<img alt="animation showing debounced input" src="img/guide/forms-update-on-blur.gif">
+
 If you want to keep the default behavior and just add new events that may trigger the model update
 and validation, add "default" as one of the specified events.
 
 I.e. `ng-model-options="{ updateOn: 'default blur' }"`
 
-The following example shows how to override immediate updates. Changes on the inputs within the form will update the model
-only when the control loses focus (blur event).
+The following example shows how to override immediate updates. Changes on the inputs within the form
+will update the model only when the control loses focus (blur event).
 
 <example module="customTriggerExample">
   <file name="index.html">
@@ -232,6 +243,8 @@ You can delay the model update/validation by using the `debounce` key with the
 {@link ng.directive:ngModelOptions ngModelOptions} directive. This delay will also apply to
 parsers, validators and model flags like `$dirty` or `$pristine`.
 
+<img alt="animation showing debounced input" src="img/guide/forms-debounce.gif">
+
 I.e. `ng-model-options="{ debounce: 500 }"` will wait for half a second since
 the last content change before triggering the model update and form validation.
 
@@ -241,10 +254,11 @@ in `debounce`. This can be useful to force immediate updates on some specific ci
 
 I.e. `ng-model-options="{ updateOn: 'default blur', debounce: { default: 500, blur: 0 } }"`
 
-If those attributes are added to an element, they will be applied to all the child elements and controls that inherit from it unless they are
-overridden.
+If those attributes are added to an element, they will be applied to all the child elements and
+controls that inherit from it unless they are overridden.
 
-This example shows how to debounce model changes. Model will be updated only 250 milliseconds after last change.
+This example shows how to debounce model changes. Model will be updated only 250 milliseconds
+after last change.
 
 <example module="debounceExample">
   <file name="index.html">
@@ -264,35 +278,40 @@ This example shows how to debounce model changes. Model will be updated only 250
   </file>
 </example>
 
-
-
 # Custom Validation
 
-Angular provides basic implementation for most common html5 {@link ng.directive:input input}
-types: ({@link input[text] text}, {@link input[number] number}, {@link input[url] url}, {@link input[email] email}, {@link input[radio] radio}, {@link input[checkbox] checkbox}), as well as some directives for validation (`required`, `pattern`, `minlength`, `maxlength`, `min`, `max`).
+Angular provides basic implementation for most common HTML5 {@link ng.directive:input input}
+types: ({@link input[text] text}, {@link input[number] number}, {@link input[url] url},
+{@link input[email] email}, {@link input[radio] radio}, {@link input[checkbox] checkbox}),
+as well as some directives for validation (`required`, `pattern`, `minlength`, `maxlength`,
+`min`, `max`).
 
-Defining your own validator can be done by defining your own directive which adds a custom validation function to the `ngModel` {@link ngModel.NgModelController controller}.
-To get a hold of the controller the directive specifies a dependency as shown in the example below.
-The validation can occur in two places:
+With a custom directive, you can add your own validation functions to the `$validators` object on
+the {@link ngModel.NgModelController `ngModelController`}. To get a hold of the controller,
+you require it in the directive as shown in the example below.
 
-  * **Model to View update** -
-    Whenever the bound model changes, all functions in {@link ngModel.NgModelController#$formatters NgModelController#$formatters} array are pipe-lined, so that each of these functions has an opportunity to format the value and change validity state of the form control through {@link ngModel.NgModelController#$setValidity NgModelController#$setValidity}.
+Each function in the `$validators` object receives the `modelValue` and the `viewValue`
+as parameters. Angular will then call `$setValidity` internally with the function's return value
+(`true`: valid, `false`: invalid). The validation functions are executed every time an input
+is changed (`$setViewValue` is called) or whenever the bound `model` changes.
+Validation happens after successfully running `$parsers` and `$formatters`, respectively.
+Failed validators are stored by key in
+{@link ngModel.NgModelController#$error `ngModelController.$error`}.
 
-  * **View to Model update** -
-    In a similar way, whenever a user interacts with a control it calls {@link ngModel.NgModelController#$setViewValue NgModelController#$setViewValue}.
-This in turn pipelines all functions in the {@link ngModel.NgModelController#$parsers NgModelController#$parsers} array, so that each of these functions has an opportunity to convert the value and change validity state of the form control through {@link ngModel.NgModelController#$setValidity NgModelController#$setValidity}.
+Additionally, there is the `$asyncValidators` object which handles asynchronous validation,
+such as making an `$http` request to the backend. Functions added to the object must return
+a promise that must be `resolved` when valid or `rejected` when invalid.
+In-progress async validations are stored by key in
+{@link ngModel.NgModelController#$pending `ngModelController.$pending`}.
 
-In the following example we create two directives.
-
-  * The first one is `integer` and it validates whether the input is a valid integer.
-    For example `1.23` is an invalid value, since it contains a fraction.
-    Note that we unshift the array instead of pushing.
-    This is because we want it to be the first parser and consume the control string value, as we need to execute the validation function before a conversion to number occurs.
-
-  * The second directive is a `smart-float`.
-    It parses both `1.2` and `1,2` into a valid float number `1.2`.
-    Note that we can't use input type `number` here as HTML5 browsers would not allow the user to type what it would consider an invalid number such as `1,2`.
+In the following example we create two directives:
+ * An `integer` directive that validates whether the input is a valid integer. For example,
+ `1.23` is an invalid value, since it contains a fraction. Note that we validate the viewValue
+ (the string value of the control), and not the modelValue. This is because input[number] converts
+ the viewValue to a number when running the `$parsers`.
 
+ * A `username` directive that asynchronously checks if a user-entered value is already taken.
+ We mock the server request with a `$q` deferred.
 
 <example module="form-example1">
   <file name="index.html">
@@ -301,18 +320,18 @@ In the following example we create two directives.
         Size (integer 0 - 10):
         <input type="number" ng-model="size" name="size"
                min="0" max="10" integer />{{size}}<br />
-        <span ng-show="form.size.$error.integer">This is not valid integer!</span>
+        <span ng-show="form.size.$error.integer">The value is not a valid integer!</span>
         <span ng-show="form.size.$error.min || form.size.$error.max">
           The value must be in range 0 to 10!</span>
       </div>
 
       <div>
-        Length (float):
-        <input type="text" ng-model="length" name="length" smart-float />
-        {{length}}<br />
-        <span ng-show="form.length.$error.float">
-          This is not a valid float number!</span>
+        Username:
+        <input type="text" ng-model="name" name="name" username />{{name}}<br />
+        <span ng-show="form.name.$pending.username">Checking if this name is available ...</span>
+        <span ng-show="form.name.$error.username">This username is already taken!</span>
       </div>
+
     </form>
   </file>
 
@@ -324,35 +343,96 @@ In the following example we create two directives.
       return {
         require: 'ngModel',
         link: function(scope, elm, attrs, ctrl) {
-          ctrl.$parsers.unshift(function(viewValue) {
+          ctrl.$validators.integer = function(modelValue, viewValue) {
+            if (ctrl.$isEmpty(modelValue)) {
+              // consider empty models to be valid
+              return true;
+            }
+
             if (INTEGER_REGEXP.test(viewValue)) {
               // it is valid
-              ctrl.$setValidity('integer', true);
-              return viewValue;
-            } else {
-              // it is invalid, return undefined (no model update)
-              ctrl.$setValidity('integer', false);
-              return undefined;
+              return true;
             }
-          });
+
+            // it is invalid
+            return false;
+          };
         }
       };
     });
 
-    var FLOAT_REGEXP = /^\-?\d+((\.|\,)\d+)?$/;
-    app.directive('smartFloat', function() {
+    app.directive('username', function($q, $timeout) {
       return {
         require: 'ngModel',
         link: function(scope, elm, attrs, ctrl) {
-          ctrl.$parsers.unshift(function(viewValue) {
-            if (FLOAT_REGEXP.test(viewValue)) {
-              ctrl.$setValidity('float', true);
-              return parseFloat(viewValue.replace(',', '.'));
-            } else {
-              ctrl.$setValidity('float', false);
-              return undefined;
+        var usernames = ['Jim', 'John', 'Jill', 'Jackie'];
+
+          ctrl.$asyncValidators.username = function(modelValue, viewValue) {
+
+            if (ctrl.$isEmpty(modelValue)) {
+              // consider empty model valid
+              return $q.when();
             }
-          });
+
+            var def = $q.defer();
+
+            $timeout(function() {
+              // Mock a delayed response
+              if (usernames.indexOf(modelValue) === -1) {
+                // The username is available
+                def.resolve();
+              } else {
+                def.reject();
+              }
+
+            }, 2000);
+
+            return def.promise;
+          };
+        }
+      };
+    });
+  </file>
+</example>
+
+# Modifying built-in validators
+
+Since Angular itself uses `$validators`, you can easily replace or remove built-in validators,
+should you find it necessary. The following example shows you how to overwrite the email validator
+in `input[email]` from a custom directive so that it requires a specific top-level domain,
+`example.com` to be present.
+Note that you can alternatively use `ng-pattern` to further restrict the validation.
+
+<example module="form-example-modify-validators">
+  <file name="index.html">
+    <form name="form" class="css-form" novalidate>
+      <div>
+        Overwritten Email:
+        <input type="email" ng-model="myEmail" overwrite-email name="overwrittenEmail" />
+        <span ng-show="form.overwrittenEmail.$error.email">This email format is invalid!</span><br>
+        Model: {{myEmail}}
+        </div>
+    </form>
+  </file>
+
+  <file name="script.js">
+    var app = angular.module('form-example-modify-validators', []);
+
+    app.directive('overwriteEmail', function() {
+      var EMAIL_REGEXP = /^[a-z0-9!#$%&'*+/=?^_`{|}~.-]+@example\.com$/i;
+
+      return {
+        require: 'ngModel',
+        restrict: '',
+        link: function(scope, elm, attrs, ctrl) {
+          // only apply the validator if ngModel is present and Angular has added the email validator
+          if (ctrl && ctrl.$validators.email) {
+
+            // this will overwrite the default Angular email validator
+            ctrl.$validators.email = function(modelValue) {
+              return ctrl.$isEmpty(modelValue) || EMAIL_REGEXP.test(modelValue);
+            };
+          }
         }
       };
     });
@@ -361,15 +441,19 @@ In the following example we create two directives.
 
 
 # Implementing custom form controls (using `ngModel`)
-Angular implements all of the basic HTML form controls ({@link ng.directive:input input}, {@link ng.directive:select select}, {@link ng.directive:textarea textarea}), which should be sufficient for most cases.
-However, if you need more flexibility, you can write your own form control as a directive.
+Angular implements all of the basic HTML form controls ({@link ng.directive:input input},
+{@link ng.directive:select select}, {@link ng.directive:textarea textarea}),
+which should be sufficient for most cases. However, if you need more flexibility,
+you can write your own form control as a directive.
 
 In order for custom control to work with `ngModel` and to achieve two-way data-binding it needs to:
 
-  - implement `$render` method, which is responsible for rendering the data after it passed the {@link ngModel.NgModelController#$formatters NgModelController#$formatters},
-  - call `$setViewValue` method, whenever the user interacts with the control and model needs to be updated. This is usually done inside a DOM Event listener.
+  - implement `$render` method, which is responsible for rendering the data after it passed the
+  {@link ngModel.NgModelController#$formatters `NgModelController.$formatters`},
+  - call `$setViewValue` method, whenever the user interacts with the control and model
+  needs to be updated. This is usually done inside a DOM Event listener.
 
-See {@link guide/directive $compileProvider.directive} for more info.
+See {@link guide/directive `$compileProvider.directive`} for more info.
 
 The following example shows how to add two-way data-binding to contentEditable elements.
 

docs/content/guide/index.ngdoc

@@ -41,9 +41,10 @@ In Angular applications, you move the job of filling page templates with data fr
 ### Other AngularJS Features
 
 * **Animation:** {@link guide/animations Core concepts}, {@link ngAnimate ngAnimate API}, and [Animation in AngularJS 1.2](http://www.yearofmoo.com/2013/08/remastered-animation-in-angularjs-1-2.html)
-* **Security:** {@link ng.$sce Strict Contextual Escaping}, {@link ng.directive:ngCsp Content Security Policy}, {@link ngSanitize.$sanitize $sanitize}, [video](https://www.youtube.com/watch?v=18ifoT-Id54)
+* **Security:** {@link guide/security Security Docs}, {@link ng.$sce Strict Contextual Escaping}, {@link ng.directive:ngCsp Content Security Policy}, {@link ngSanitize.$sanitize $sanitize}, [video](https://www.youtube.com/watch?v=18ifoT-Id54)
 * **Internationalization and Localization:** {@link guide/i18n Angular Guide to i18n and l10n}, {@link ng.filter:date date filter}, {@link ng.filter:currency currency filter}, [Creating multilingual support](http://www.novanet.no/blog/hallstein-brotan/dates/2013/10/creating-multilingual-support-using-angularjs/)
 * **Mobile:** {@link ngTouch Touch events}
+* **Accessibility:** {@link guide/accessibility ngAria}
 
 ### Testing
 
@@ -95,6 +96,7 @@ This is a short list of libraries with specific support and documentation for wo
 * **MEAN Stack: **[Blog post](http://blog.mongodb.org/post/49262866911/the-mean-stack-mongodb-expressjs-angularjs-and), [Setup](http://thecodebarbarian.wordpress.com/2013/07/22/introduction-to-the-mean-stack-part-one-setting-up-your-tools/), [GDL Video](https://developers.google.com/live/shows/913996610)
 * **Rails: **[Tutorial](http://coderberry.me/blog/2013/04/22/angularjs-on-rails-4-part-1/), [AngularJS with Rails4](https://shellycloud.com/blog/2013/10/how-to-integrate-angularjs-with-rails-4), [angularjs-rails](https://github.com/hiravgandhi/angularjs-rails)
 * **PHP: **[Building a RESTful web service](http://blog.brunoscopelliti.com/building-a-restful-web-service-with-angularjs-and-php-more-power-with-resource), [End to End with Laravel 4 (video)](http://www.youtube.com/watch?v=hqAyiqUs93c)
+* **Meteor: **[angular-meteor package](https://github.com/Urigo/angular-meteor)
 
 ## Learning Resources
 
@@ -106,6 +108,7 @@ This is a short list of libraries with specific support and documentation for wo
 * [Developing an AngularJS Edge](http://www.amazon.com/Developing-AngularJS-Edge-Christopher-Hiller-ebook/dp/B00CJLFF8K) by Christopher Hiller
 * [ng-book: The Complete Book on AngularJS](http://ng-book.com/) by Ari Lerner
 * [AngularJS : Novice to Ninja](http://www.amazon.in/AngularJS-Novice-Ninja-Sandeep-Panda/dp/0992279453) by Sandeep Panda
+* [AngularJS UI Development](http://www.amazon.com/AngularJS-UI-Development-Amit-Ghart-ebook/dp/B00OXVAK7A) by Amit Gharat and Matthias Nehlsen
 
 ###Videos:
 * [egghead.io](http://egghead.io/)

docs/content/guide/introduction.ngdoc

@@ -33,7 +33,7 @@ browser new syntax through a construct we call directives. Examples include:
   * Data binding, as in `{{}}`.
   * DOM control structures for repeating/hiding DOM fragments.
   * Support for forms and form validation.
-  * Attaching code-behind to DOM elements.
+  * Attaching new behavior to DOM elements, such as DOM event handling.
   * Grouping of HTML into reusable components.
 
 

docs/content/guide/migration.ngdoc

@@ -23,7 +23,7 @@ This is to disallow changing the behaviour of existing functions
 in an unforseen fashion.
   - due to [6081f207](https://github.com/angular/angular.js/commit/6081f20769e64a800ee8075c168412b21f026d99),
 
-The (deprecated) __proto__ propery does not work inside angular expressions
+The (deprecated) __proto__ property does not work inside angular expressions
 anymore.
   - due to [48fa3aad](https://github.com/angular/angular.js/commit/48fa3aadd546036c7e69f71046f659ab1de244c6),
 

docs/content/guide/module.ngdoc

@@ -140,7 +140,7 @@ The above is a suggestion. Tailor it to your needs.
 # Module Loading & Dependencies
 
 A module is a collection of configuration and run blocks which get applied to the application
-during the bootstrap process. In its simplest form the module consist of collection of two kinds
+during the bootstrap process. In its simplest form the module consist of a collection of two kinds
 of blocks:
 
   1. **Configuration blocks** - get executed during the provider registrations and configuration

docs/content/guide/production.ngdoc

@@ -41,3 +41,35 @@ The page should reload and the debug information should now be available.
 
 For more see the docs pages on {@link ng.$compileProvider#debugInfoEnabled `$compileProvider`}
 and {@link angular.reloadWithDebugInfo `angular.reloadWithDebugInfo`}.
+
+## Strict DI Mode
+
+Using strict di mode in your production application will throw errors when a injectable
+function is not
+{@link di#dependency-annotation annotated explicitly}. Strict di mode is intended to help
+you make sure that your code will work when minified. However, it also will force you to
+make sure that your injectable functions are explicitly annotated which will improve
+angular's performance when injecting dependencies in your injectable functions because it
+doesn't have to dynamically discover a function's dependencies. It is recommended to
+automate the explicit annotation via a tool like
+[ng-annotate](https://github.com/olov/ng-annotate) when you deploy to production (and enable
+strict di mode)
+
+To enable strict di mode, you have two options:
+
+```html
+<div ng-app="myApp" ng-strict-di>
+  <!-- your app here -->
+</div>
+```
+
+or
+
+```js
+angular.bootstrap(document, ['myApp'], {
+  strictDi: true
+});
+```
+
+For more information, see the
+{@link di#using-strict-dependency-injection DI Guide}.

docs/content/guide/scope.ngdoc

@@ -39,7 +39,7 @@ linking} phase the {@link ng.$compileProvider#directive directives} set up
 render the updated value to the DOM.
 
 Both controllers and directives have reference to the scope, but not to each other. This
-arrangement isolates the controller from the directive as well as from DOM. This is an important
+arrangement isolates the controller from the directive as well as from the DOM. This is an important
 point since it makes the controllers view agnostic, which greatly improves the testing story of
 the applications.
 
@@ -339,6 +339,18 @@ the dirty checking function must be efficient. Care should be taken that the dir
 function does not do any DOM access, as DOM access is orders of magnitude slower than property
 access on JavaScript object.
 
+### Scope `$watch` Depths
+<img class="pull-right" style="padding-left: 3em; padding-bottom: 1em;" src="img/guide/concepts-scope-watch-strategies.png">
+
+Dirty checking can be done with three strategies: By reference, by collection contents, and by value. The strategies differ in the kinds of changes they detect, and in their performance characteristics.
+
+   - Watching *by reference* ({@link
+      ng.$rootScope.Scope#$watch scope.$watch} `(watchExpression, listener)`) detects a change when the whole value returned by the watch expression switches to a new value. If the value is an array or an object, changes inside it are not detected. This is the most efficient stategy.
+   - Watching *collection contents* ({@link
+      ng.$rootScope.Scope#$watchCollection scope.$watchCollection} `(watchExpression, listener)`) detects changes that occur inside an array or an object: When items are added, removed, or reordered. The detection is shallow - it does not reach into nested collections. Watching collection contents is more expensive than watching by reference, because copies of the collection contents need to be maintained. However, the strategy attempts to minimize the amount of copying required.
+   - Watching *by value* ({@link
+      ng.$rootScope.Scope#$watch scope.$watch} `(watchExpression, listener, true)`) detects any change in an arbitrarily nested data structure. It is the most powerful change detection strategy, but also the most expensive. A full traversal of the nested data structure is needed on each digest, and a full copy of it needs to be held in memory.
+
 ## Integration with the browser event loop
 <img class="pull-right" style="padding-left: 3em; padding-bottom: 1em;" src="img/guide/concepts-runtime.png">
 

docs/content/guide/security.ngdoc

@@ -0,0 +1,60 @@
+@ngdoc overview
+@name  Security
+@sortOrder 525
+@description
+
+# Security
+
+This document explains some of AngularJS's security features and best practices that you should
+keep in mind as you build your application.
+
+
+## Expression Sandboxing
+
+AngularJS's expressions are sandboxed not for security reasons, but instead to maintain a proper
+separation of application responsibilities. For example, access to `window` is disallowed
+because it makes it easy to introduce brittle global state into your application.
+
+However, this sandbox is not intended to stop attackers who can edit the template before it's
+processed by Angular. It may be possible to run arbitrary JavaScript inside double-curly bindings
+if an attacker can modify them.
+
+But if an attacker can change arbitrary HTML templates, there's nothing stopping them from doing:
+
+```html
+<script>somethingEvil();</script>
+```
+
+It's better to design your application in such a way that users cannot change client-side templates.
+For instance:
+
+* Do not mix client and server templates
+* Do not use user input to generate templates dynamically
+* Do not run user input through `$scope.$eval`
+* Consider using {@link ng.directive:ngCsp CSP} (but don't rely only on CSP)
+
+## Mixing client-side and server-side templates
+
+In general, we recommend against this because it can create unintended XSS vectors.
+
+However, it's ok to mix server-side templating in the bootstrap template (`index.html`) as long
+as user input cannot be used on the server to output html that would then be processed by Angular
+in a way that would cause allow for arbitrary code execution.
+
+For instance, you can use server-side templating to dynamically generate CSS, URLs, etc, but not
+for generating templates that are bootstrapped/compiled by Angular.
+
+
+## Reporting a security issue
+
+Email us at [security@angularjs.org](mailto:security@angularjs.org) to report any potential
+security issues in AngularJS.
+
+Please keep in mind the above points about Angular's expression language.
+
+
+## See also
+
+* {@link ng.directive:ngCsp Content Security Policy}
+* {@link ng.$sce Strict Contextual Escaping}
+* {@link ngSanitize.$sanitize $sanitize}

docs/content/guide/services.ngdoc

@@ -19,7 +19,7 @@ Angular offers several useful services (like {@link ng.$http `$http`}), but for
 you'll also want to {@link services#creating-services create your own}.
 
 <div class="alert alert-info">
-**Note:** Like other core Angular identifiers built-in services always start with `$`
+**Note:** Like other core Angular identifiers, built-in services always start with `$`
 (e.g. `$http`).
 </div>
 
@@ -68,79 +68,6 @@ subsystem takes care of the rest.
   </file>
 </example>
 
-<div class="alert alert-info">
-**Note:** Angular uses
-[**constructor injection**](http://misko.hevery.com/2009/02/19/constructor-injection-vs-setter-injection/).
-</div>
-
-### Explicit Dependency Injection
-
-A component should explicitly define its dependencies using one of the {@link di injection
-annotation} methods:
-
-1. Inline array injection annotation (preferred):
-  ```js
-  myModule.controller('MyController', ['$location', function($location) { ... }]);
-  ```
-
-2. `$inject` property:
-  ```js
-  var MyController = function($location) { ... };
-  MyController.$inject = ['$location'];
-  myModule.controller('MyController', MyController);
-  ```
-
-<div class="alert alert-success">
-**Best Practice:** Use the array annotation shown above.
-</div>
-
-### Implicit Dependency Injection
-
-Even if you don't annotate your dependencies, Angular's DI can determine the dependency from the
-name of the parameter. Let's rewrite the above example to show the use of this implicit dependency
-injection of `$window`, `$scope`, and our `notify` service:
-
-<example module="myServiceModuleDI">
-  <file name="index.html">
-    <div id="implicit" ng-controller="MyController">
-      <p>Let's try the notify service, that is implicitly injected into the controller...</p>
-      <input ng-init="message='test'" ng-model="message">
-      <button ng-click="callNotify(message);">NOTIFY</button>
-      <p>(you have to click 3 times to see an alert)</p>
-    </div>
-  </file>
-
-  <file name="script.js">
-    angular.module('myServiceModuleDI', []).
-      factory('notify', function($window) {
-        var msgs = [];
-        return function(msg) {
-          msgs.push(msg);
-          if (msgs.length == 3) {
-            $window.alert(msgs.join("\n"));
-            msgs = [];
-          }
-        };
-      }).
-      controller('MyController', function($scope, notify) {
-        $scope.callNotify = function(msg) {
-          notify(msg);
-        };
-      });
-  </file>
-</example>
-
-<div class="alert alert-danger">
-**Careful:** If you plan to [minify](http://en.wikipedia.org/wiki/Minification_(programming&#41;) your
-code, your variable names will get renamed unless you use one of the annotation techniques above.
-</div>
-
-<div class="alert alert-info">
-  If you use a tool like [ng-annotate](https://github.com/olov/ng-annotate) in your workflow you can
-  use implicit dependency notation within your codebase and let **ng-annotate** automatically convert such
-  injectable functions to the array notation prior to minifying.
-</div>
-
 
 ## Creating Services
 
@@ -157,11 +84,11 @@ on the service.
 Services are registered to modules via the {@link angular.Module Module API}.
 Typically you use the {@link angular.module Module#factory} API to register a service:
 
-```javascript
+```js
 var myModule = angular.module('myModule', []);
 myModule.factory('serviceId', function() {
   var shinyNewServiceInstance;
-  //factory function body that constructs shinyNewServiceInstance
+  // factory function body that constructs shinyNewServiceInstance
   return shinyNewServiceInstance;
 });
 ```
@@ -174,6 +101,8 @@ will create this instance when called.
 Services can have their own dependencies. Just like declaring dependencies in a controller, you
 declare dependencies by specifying them in the service's factory function signature.
 
+For more on dependencies, see the {@link guide/di dependency injection} docs.
+
 The example module below has two services, each with various dependencies:
 
 ```js
@@ -231,14 +160,14 @@ In the example, note that:
 You can also register services via the {@link auto.$provide `$provide`} service inside of a
 module's `config` function:
 
-```javascript
-angular.module('myModule', []).config(function($provide) {
+```js
+angular.module('myModule', []).config(['$provide', function($provide) {
   $provide.factory('serviceId', function() {
     var shinyNewServiceInstance;
-    //factory function body that constructs shinyNewServiceInstance
+    // factory function body that constructs shinyNewServiceInstance
     return shinyNewServiceInstance;
   });
-});
+}]);
 ```
 
 This technique is often used in unit tests to mock out a service's dependencies.

docs/content/guide/unit-testing.ngdoc

@@ -8,15 +8,15 @@ comes with almost no help from the compiler. For this reason we feel very strong
 written in JavaScript needs to come with a strong set of tests. We have built many features into
 Angular which makes testing your Angular applications easy. So there is no excuse for not testing.
 
-# Separation of Concerns
+## Separation of Concerns
 
-Unit testing as the name implies is about testing individual units of code. Unit tests try to
+Unit testing, as the name implies, is about testing individual units of code. Unit tests try to
 answer questions such as "Did I think about the logic correctly?" or "Does the sort function order
 the list in the right order?"
 
 In order to answer such a question it is very important that we can isolate the unit of code under test.
 That is because when we are testing the sort function we don't want to be forced into creating
-related pieces such as the DOM elements, or making any XHR calls in getting the data to sort.
+related pieces such as the DOM elements, or making any XHR calls to fetch the data to sort.
 
 While this may seem obvious it can be very difficult to call an individual function on a
 typical project. The reason is that the developers often mix concerns resulting in a
@@ -24,12 +24,10 @@ piece of code which does everything. It makes an XHR request, it sorts the respo
 manipulates the DOM.
 
 With Angular we try to make it easy for you to do the right thing, and so we
-provide dependency injection for your XHR (which you can mock out) and we created abstractions which
-allow you to sort your model without having to resort to manipulating the DOM. So that in the end,
-it is easy to write a sort function which sorts some data, so that your test can create a data set,
-apply the function, and assert that the resulting model is in the correct order. The test does not
-have to wait for the XHR response to arrive, create the right kind of test DOM, nor assert that your
-function has mutated the DOM in the right way.
+provide dependency injection for your XHR requests, which can be mocked, and we provide abstractions which
+allow you to test your model without having to resort to manipulating the DOM. The test can then
+assert that the data has been sorted without having to create or look at the state of the DOM or
+wait for any XHR requests to return data. The individual sort function can be tested in isolation.
 
 ## With great power comes great responsibility
 
@@ -38,230 +36,218 @@ We tried to make the right thing easy, but if you ignore these guidelines you ma
 untestable application.
 
 ## Dependency Injection
-There are several ways in which you can get a hold of a dependency. You can:
-1. Create it using the `new` operator.
-2. Look for it in a well-known place, also known as a global singleton.
-3. Ask a registry (also known as service registry) for it. (But how do you get a hold of
-the registry? Most likely by looking it up in a well known place. See #2.)
-4. Expect it to be handed to you.
 
-Out of the four options in the list above, only the last one is testable. Let's look at why:
+Angular comes with {@link di dependency injection} built-in, which makes testing components much
+easier, because you can pass in a component's dependencies and stub or mock them as you wish.
 
-### Using the `new` operator
+Components that have their dependencies injected allow them to be easily mocked on a test by
+test basis, without having to mess with any global variables that could inadvertently affect
+another test.
 
-While there is nothing wrong with the `new` operator fundamentally, a problem arises when calling `new`
-on a constructor. This permanently binds the call site to the type. For example, let's say that we try to
-instantiate an `XHR` that will retrieve data from the server.
+## Additional tools for testing Angular applications
+
+For testing Angular applications there are certain tools that you should use that will make testing much
+easier to set up and run.
+
+### Karma
+
+[Karma](http://karma-runner.github.io/) is a JavaScript command line tool that can be used to spawn
+a web server which loads your application's source code and executes your tests. You can configure
+Karma to run against a number of browsers, which is useful for being confident that your application
+works on all browsers you need to support. Karma is executed on the command line and will display
+the results of your tests on the command line once they have run in the browser.
+
+Karma is a NodeJS application, and should be installed through npm. Full installation instructions
+are available on [the Karma website](http://karma-runner.github.io/0.12/intro/installation.html).
+
+### Jasmine
+
+[Jasmine](http://jasmine.github.io/1.3/introduction.html) is a test driven development framework for
+JavaScript that has become the most popular choice for testing Angular applications. Jasmine
+provides functions to help with structuring your tests and also making assertions. As your tests
+grow, keeping them well structured and documented is vital, and Jasmine helps achieve this.
+
+In Jasmine we use the `describe` function to group our tests together:
 
 ```js
-function MyClass() {
-  this.doWork = function() {
-    var xhr = new XHR();
-    xhr.open(method, url, true);
-    xhr.onreadystatechange = function() {...}
-    xhr.send();
-  }
-}
+describe("sorting the list of users", function() {
+  // individual tests go here
+});
 ```
 
-A problem surfaces in tests when we would like to instantiate a `MockXHR` that would
-allow us to return fake data and simulate network failures. By calling `new XHR()` we are
-permanently bound to the actual XHR and there is no way to replace it. Yes, we could monkey
-patch, but that is a bad idea for many reasons which are outside the scope of this document.
-
-Here's an example of how the class above becomes hard to test when resorting to monkey patching:
+And then each individual test is defined within a call to the `it` function:
 
 ```js
-var oldXHR = XHR;
-XHR = function MockXHR() {};
-var myClass = new MyClass();
-myClass.doWork();
-// assert that MockXHR got called with the right arguments
-XHR = oldXHR; // if you forget this bad things will happen
+describe('sorting the list of users', function() {
+  it('sorts in descending order by default', function() {
+    // your test assertion goes here
+  });
+});
 ```
 
+Grouping related tests within `describe` blocks and describing each individual test within an
+`it` call keeps your tests self documenting.
 
-### Global look-up:
-Another way to approach the problem is to look for the service in a well-known location.
+Finally, Jasmine provides matchers which let you make assertions:
 
 ```js
-function MyClass() {
-  this.doWork = function() {
-    global.xhr({
-      method:'...',
-      url:'...',
-      complete:function(response){ ... }
-    })
-  }
-}
+describe('sorting the list of users', function() {
+  it('sorts in descending order by default', function() {
+    var users = ['jack', 'igor', 'jeff'];
+    var sorted = sortUsers(users);
+    expect(sorted).toEqual(['jeff', 'jack', 'igor']);
+  });
+});
 ```
 
-While no new dependency instance is created, it is fundamentally the same as `new` in
-that no way exists to intercept the call to `global.xhr` for testing purposes, other than
-through monkey patching. The basic issue for testing is that a global variable needs to be mutated in
-order to replace it with call to a mock method. For further explanation of why this is bad see: [Brittle Global
-State & Singletons](http://misko.hevery.com/code-reviewers-guide/flaw-brittle-global-state-singletons/)
+Jasmine comes with a number of matchers that help you make a variety of assertions. You should [read
+the Jasmine documentation](http://jasmine.github.io/1.3/introduction.html#section-Matchers) to see
+what they are. To use Jasmine with Karma, we use the
+[karma-jasmine](https://github.com/karma-runner/karma-jasmine) test runner.
 
-The class above is hard to test since we have to change the global state:
+### angular-mocks
+
+Angular also provides the {@link ngMock} module, which provides mocking for your tests. This is used
+to inject and mock Angular services within unit tests. In addition, it is able to extend other
+modules so they are synchronous. Having tests synchronous keeps them much cleaner and easier to work
+with. One of the most useful parts of ngMock is {@link ngMock.$httpBackend}, which lets us mock XHR
+requests in tests, and return sample data instead.
+
+## Testing a Controller
+
+Because Angular separates logic from the view layer, it keeps controllers easy to test. Let's take a
+look at how we might test the controller below, which provides `$scope.grade`, which sets a property
+on the scope based on the length of the password.
 
 ```js
-var oldXHR = global.xhr;
-global.xhr = function mockXHR() {};
-var myClass = new MyClass();
-myClass.doWork();
-// assert that mockXHR got called with the right arguments
-global.xhr = oldXHR; // if you forget this bad things will happen
+angular.module('app', [])
+  .controller('PasswordController', function PasswordController($scope) {
+    $scope.password = '';
+    $scope.grade = function() {
+      var size = $scope.password.length;
+      if (size > 8) {
+        $scope.strength = 'strong';
+      } else if (size > 3) {
+        $scope.strength = 'medium';
+      } else {
+        $scope.strength = 'weak';
+      }
+    };
+  });
 ```
 
-
-### Service Registry:
-
-It may seem that this can be solved by having a registry of all the services and then
-having the tests replace the services as needed.
+Because controllers are not available on the global scope, we need to use {@link
+angular.mock.inject} to inject our controller first. The first step is to use the `module` function,
+which is provided by angular-mocks. This loads in the module it's given, so it is available in your
+tests. We pass this into `beforeEach`, which is a function Jasmine provides that lets us run code
+before each test. Then we can use `inject` to access `$controller`, the service that is responsible
+for instantiating controllers.
 
 ```js
-function MyClass() {
-  var serviceRegistry = ????;
-  this.doWork = function() {
-    var xhr = serviceRegistry.get('xhr');
-    xhr({
-      method:'...',
-      url:'...',
-      complete:function(response){ ... }
-    })
-}
+describe('PasswordController', function() {
+  beforeEach(module('app'));
+
+  var $controller;
+
+  beforeEach(inject(function(_$controller_){
+    // The injector unwraps the underscores (_) from around the parameter names when matching
+    $controller = _$controller_;
+  }));
+
+  describe('$scope.grade', function() {
+    it('sets the strength to "strong" if the password length is >8 chars', function() {
+      var $scope = {};
+      var controller = $controller('PasswordController', { $scope: $scope });
+      $scope.password = 'longerthaneightchars';
+      $scope.grade();
+      expect($scope.strength).toEqual('strong');
+    });
+  });
+});
 ```
 
-However, where does the serviceRegistry come from? If it is:
-* `new`-ed up, the test has no chance to reset the services for testing.
-* a global look-up then the service returned is global as well (but resetting is easier, since
-only one global variable exists to be reset).
-
-The class above is hard to test since we have to change the global state:
+Notice how by nesting the `describe` calls and being descriptive when calling them with strings, the
+test is very clear. It documents exactly what it is testing, and at a glance you can quickly see
+what is happening. Now let's add the test for when the password is less than three characters, which
+should see `$scope.strength` set to "weak":
 
 ```js
-var oldServiceLocator = global.serviceLocator;
-global.serviceLocator.set('xhr', function mockXHR() {});
-var myClass = new MyClass();
-myClass.doWork();
-// assert that mockXHR got called with the right arguments
-global.serviceLocator = oldServiceLocator; // if you forget this bad things will happen
+describe('PasswordController', function() {
+  beforeEach(module('app'));
+
+  var $controller;
+
+  beforeEach(inject(function(_$controller_){
+    // The injector unwraps the underscores (_) from around the parameter names when matching
+    $controller = _$controller_;
+  }));
+
+  describe('$scope.grade', function() {
+    it('sets the strength to "strong" if the password length is >8 chars', function() {
+      var $scope = {};
+      var controller = $controller('PasswordController', { $scope: $scope });
+      $scope.password = 'longerthaneightchars';
+      $scope.grade();
+      expect($scope.strength).toEqual('strong');
+    });
+
+    it('sets the strength to "weak" if the password length <3 chars', function() {
+      var $scope = {};
+      var controller = $controller('PasswordController', { $scope: $scope });
+      $scope.password = 'a';
+      $scope.grade();
+      expect($scope.strength).toEqual('weak');
+    });
+  });
+});
 ```
 
-
-### Passing in Dependencies:
-Last, the dependency can be passed in.
+Now we have two tests, but notice the duplication between the tests. Both have to
+create the `$scope` variable and create the controller. As we add new tests, this duplication is
+only going to get worse. Thankfully, Jasmine provides `beforeEach`, which lets us run a function
+before each individual test. Let's see how that would tidy up our tests:
 
 ```js
-function MyClass(xhr) {
-  this.doWork = function() {
-    xhr({
-      method:'...',
-      url:'...',
-      complete:function(response){ ... }
-    })
-}
+describe('PasswordController', function() {
+  beforeEach(module('app'));
+
+  var $controller;
+
+  beforeEach(inject(function(_$controller_){
+    // The injector unwraps the underscores (_) from around the parameter names when matching
+    $controller = _$controller_;
+  }));
+
+  describe('$scope.grade', function() {
+    var $scope, controller;
+
+    beforeEach(function() {
+      $scope = {};
+      controller = $controller('PasswordController', { $scope: $scope });
+    });
+
+    it('sets the strength to "strong" if the password length is >8 chars', function() {
+      $scope.password = 'longerthaneightchars';
+      $scope.grade();
+      expect($scope.strength).toEqual('strong');
+    });
+
+    it('sets the strength to "weak" if the password length <3 chars', function() {
+      $scope.password = 'a';
+      $scope.grade();
+      expect($scope.strength).toEqual('weak');
+    });
+  });
+});
 ```
 
-This is the preferred method since the code makes no assumptions about the origin of `xhr` and cares
-instead about whoever created the class  responsible for passing it in. Since the creator of the
-class should be different code than the user of the class, it separates the responsibility of
-creation from the logic. This is dependency-injection in a nutshell.
+We've moved the duplication out and into the `beforeEach` block. Each individual test now
+only contains the code specific to that test, and not code that is general across all tests. As you
+expand your tests, keep an eye out for locations where you can use `beforeEach` to tidy up tests.
+`beforeEach` isn't the only function of this sort that Jasmine provides, and the [documentation
+lists the others](http://jasmine.github.io/1.3/introduction.html#section-Setup_and_Teardown).
 
-The class above is testable, since in the test we can write:
-
-```js
-function xhrMock(args) {...}
-var myClass = new MyClass(xhrMock);
-myClass.doWork();
-// assert that xhrMock got called with the right arguments
-```
-
-Notice that no global variables were harmed in the writing of this test.
-
-Angular comes with {@link di dependency injection} built-in, making the right thing
-easy to do, but you still need to do it if you wish to take advantage of the testability story.
-
-## Controllers
-What makes each application unique is its logic, and the logic is what we would like to test. If the logic
-for your application contains DOM manipulation, it will be hard to test. See the example
-below:
-
-```js
-function PasswordCtrl() {
-  // get references to DOM elements
-  var msg = $('.ex1 span');
-  var input = $('.ex1 input');
-  var strength;
-
-  this.grade = function() {
-    msg.removeClass(strength);
-    var pwd = input.val();
-    password.text(pwd);
-    if (pwd.length > 8) {
-      strength = 'strong';
-    } else if (pwd.length > 3) {
-      strength = 'medium';
-    } else {
-      strength = 'weak';
-    }
-    msg
-     .addClass(strength)
-     .text(strength);
-  }
-}
-```
-
-The code above is problematic from a testability point of view since it requires your test to have the right kind
-of DOM present when the code executes. The test would look like this:
-
-```js
-var input = $('<input type="text"/>');
-var span = $('<span>');
-$('body').html('<div class="ex1">')
-  .find('div')
-    .append(input)
-    .append(span);
-var pc = new PasswordCtrl();
-input.val('abc');
-pc.grade();
-expect(span.text()).toEqual('weak');
-$('body').empty();
-```
-
-In angular the controllers are strictly separated from the DOM manipulation logic and this results in
-a much easier testability story as the following example shows:
-
-```js
-function PasswordCtrl($scope) {
-  $scope.password = '';
-  $scope.grade = function() {
-    var size = $scope.password.length;
-    if (size > 8) {
-      $scope.strength = 'strong';
-    } else if (size > 3) {
-      $scope.strength = 'medium';
-    } else {
-      $scope.strength = 'weak';
-    }
-  };
-}
-```
-
-and the test is straight forward:
-
-```js
-var $scope = {};
-var pc = $controller('PasswordCtrl', { $scope: $scope });
-$scope.password = 'abc';
-$scope.grade();
-expect($scope.strength).toEqual('weak');
-```
-
-Notice that the test is not only much shorter, it is also easier to follow what is happening. We say
-that such a test tells a story, rather than asserting random bits which don't seem to be related.
-
-## Filters
+## Testing Filters
 {@link ng.$filterProvider Filters} are functions which transform the data into a user readable
 format. They are important because they remove the formatting responsibility from the application
 logic, further simplifying the application logic.
@@ -273,12 +259,20 @@ myModule.filter('length', function() {
   }
 });
 
-var length = $filter('length');
-expect(length(null)).toEqual(0);
-expect(length('abc')).toEqual(3);
+describe('length filter', function() {
+  it('returns 0 when given null', function() {
+    var length = $filter('length');
+    expect(length(null)).toEqual(0);
+  });
+
+  it('returns the correct value when given a string of chars', function() {
+    var length = $filter('length');
+    expect(length('abc')).toEqual(3);
+  });
+});
 ```
 
-## Directives
+## Testing Directives
 Directives in angular are responsible for encapsulating complex functionality within custom HTML tags,
 attributes, classes or comments. Unit tests are very important for directives because the components
 you create with directives may be used throughout your application and in many different contexts.
@@ -309,28 +303,28 @@ verify this functionality. Note that the expression `{{1 + 1}}` times will also
 
 ```js
 describe('Unit testing great quotes', function() {
-    var $compile;
-    var $rootScope;
+  var $compile,
+      $rootScope;
 
-    // Load the myApp module, which contains the directive
-    beforeEach(module('myApp'));
+  // Load the myApp module, which contains the directive
+  beforeEach(module('myApp'));
 
-    // Store references to $rootScope and $compile
-    // so they are available to all tests in this describe block
-    beforeEach(inject(function(_$compile_, _$rootScope_){
-      // The injector unwraps the underscores (_) from around the parameter names when matching
-      $compile = _$compile_;
-      $rootScope = _$rootScope_;
-    }));
+  // Store references to $rootScope and $compile
+  // so they are available to all tests in this describe block
+  beforeEach(inject(function(_$compile_, _$rootScope_){
+    // The injector unwraps the underscores (_) from around the parameter names when matching
+    $compile = _$compile_;
+    $rootScope = _$rootScope_;
+  }));
 
-    it('Replaces the element with the appropriate content', function() {
-        // Compile a piece of HTML containing the directive
-        var element = $compile("<a-great-eye></a-great-eye>")($rootScope);
-        // fire all the watches, so the scope expression {{1 + 1}} will be evaluated
-        $rootScope.$digest();
-        // Check that the compiled element contains the templated content
-        expect(element.html()).toContain("lidless, wreathed in flame, 2 times");
-    });
+  it('Replaces the element with the appropriate content', function() {
+    // Compile a piece of HTML containing the directive
+    var element = $compile("<a-great-eye></a-great-eye>")($rootScope);
+    // fire all the watches, so the scope expression {{1 + 1}} will be evaluated
+    $rootScope.$digest();
+    // Check that the compiled element contains the templated content
+    expect(element.html()).toContain("lidless, wreathed in flame, 2 times");
+  });
 });
 ```
 
@@ -431,4 +425,3 @@ Otherwise you may run into issues if the test directory hierarchy differs from t
 
 ## Sample project
 See the [angular-seed](https://github.com/angular/angular-seed) project for an example.
-

docs/content/misc/contribute.ngdoc

@@ -31,7 +31,7 @@ development web server, run tests, and generate distributable files. Depending o
 pre-packaged bundle.
 
 * [Java](http://www.java.com): We minify JavaScript using our
-[Closure Tools](https://developers.google.com/closure/) jar. Make sure you have Java (version 6 or higher) installed
+[Closure Tools](https://developers.google.com/closure/) jar. Make sure you have Java (version 7 or higher) installed
 and included in your [PATH](http://docs.oracle.com/javase/tutorial/essential/environment/paths.html) variable.
 
 * [Grunt](http://gruntjs.com): We use Grunt as our build system. Install the grunt command-line tool globally with:

docs/content/misc/faq.ngdoc

@@ -50,7 +50,7 @@ Yes. See instructions in {@link downloading}.
 
 ### What browsers does Angular work with?
 
-We run our extensive test suite against the following browsers: Safari, Chrome, Firefox, Opera,
+We run our extensive test suite against the following browsers: Safari, Chrome, Firefox, Opera 15,
 IE9 and mobile browsers (Android, Chrome Mobile, iOS Safari). See {@link guide/ie Internet
 Explorer Compatibility} for more details in supporting legacy IE browsers.
 

docs/content/tutorial/index.ngdoc

@@ -110,8 +110,9 @@ suggested solution is to also install the `nodejs-legacy` apt package, which ren
 `nodejs`.
 
 ```
-apt-get install nodejs-legacy
+apt-get install nodejs-legacy npm
 nodejs --version
+npm --version
 ```
 
 

docs/content/tutorial/step_02.ngdoc

@@ -40,7 +40,7 @@ __`app/index.html`:__
 
   <ul>
     <li ng-repeat="phone in phones">
-      {{phone.name}}
+      <span>{{phone.name}}</span>
       <p>{{phone.snippet}}</p>
     </li>
   </ul>

docs/content/tutorial/step_03.ngdoc

@@ -120,7 +120,7 @@ really is that easy to set up any functional, readable, end-to-end test.
 ### Running End to End Tests with Protractor
 Even though the syntax of this test looks very much like our controller unit test written with
 Jasmine, the end-to-end test uses APIs of [Protractor](https://github.com/angular/protractor). Read
-about the Protractor APIs at https://github.com/angular/protractor/blob/master/docs/api.md.
+about the Protractor APIs at http://angular.github.io/protractor/#/api.
 
 Much like Karma is the test runner for unit tests, we use Protractor to run end-to-end tests.
 Try it with `npm run protractor`. End-to-end tests are slow, so unlike with unit tests, Protractor

docs/content/tutorial/step_04.ngdoc

@@ -150,7 +150,7 @@ __`test/e2e/scenarios.js`:__
 ...
     it('should be possible to control phone order via the drop down select box', function() {
 
-      var phoneNameColumn = element.all(by.repeater('phone in phones').column('{{phone.name}}'));
+      var phoneNameColumn = element.all(by.repeater('phone in phones').column('phone.name'));
       var query = element(by.model('query'));
 
       function getNames() {
@@ -182,7 +182,7 @@ You can now rerun `npm run protractor` to see the tests run.
 # Experiments
 
 * In the `PhoneListCtrl` controller, remove the statement that sets the `orderProp` value and
-you'll see that Angular will temporarily add a new "unknown" option to the drop-down list and the
+you'll see that Angular will temporarily add a new blank ("unknown") option to the drop-down list and the
 ordering will default to unordered/natural order.
 
 * Add an `{{orderProp}}` binding into the `index.html` template to display its current value as

docs/content/tutorial/step_05.ngdoc

@@ -236,7 +236,9 @@ the response is received:
 ```
 
 * We flush the request queue in the browser by calling `$httpBackend.flush()`. This causes the
-promise returned by the `$http` service to be resolved with the trained response.
+promise returned by the `$http` service to be resolved with the trained response. See 
+'Flushing HTTP requests' in the {@link ngMock.$httpBackend mock $httpBackend} documentation for 
+a full explanation of why this is necessary.
 
 * We make the assertions, verifying that the phone model now exists on the scope.
 
@@ -256,8 +258,8 @@ You should now see the following output in the Karma tab:
 
 # Experiments
 
-* At the bottom of `index.html`, add a `<pre>{{phones | json}}</pre>` binding to see the list of phones
-  displayed in json format.
+* At the bottom of `index.html`, add a `<pre>{{phones | filter:query | orderBy:orderProp | json}}</pre>` 
+binding to see the list of phones displayed in json format.  
 
 * In the `PhoneListCtrl` controller, pre-process the http response by limiting the number of phones
 to the first 5 in the list. Use the following code in the `$http` callback:

docs/content/tutorial/step_07.ngdoc

@@ -9,7 +9,7 @@
 In this step, you will learn how to create a layout template and how to build an app that has
 multiple views by adding routing, using an Angular module called 'ngRoute'.
 
-* When you now navigate to `app/index.html`, you are redirected to `app/index.html#/phones`
+* When you now navigate to `app/index.html`, you are redirected to `app/index.html/#/phones`
   and the phone list appears in the browser.
 * When you click on a phone link the url changes to one specific to that phone and the stub of a
   phone detail page is displayed.

docs/content/tutorial/step_08.ngdoc

@@ -184,7 +184,7 @@ You can now rerun `npm run protractor` to see the tests run.
 
 # Experiments
 
-* Using the [Protractor API](https://github.com/angular/protractor/blob/master/docs/api.md),
+* Using the [Protractor API](http://angular.github.io/protractor/#/api),
 write a test that verifies that we display 4 thumbnail images on the Nexus S details page.
 
 

docs/content/tutorial/step_11.ngdoc

@@ -171,7 +171,7 @@ we require, so in these cases, we can add a callback to process the server respo
 
 ## Test
 
-Because we're now using the {@link ngResource ngResource} module, it's necessary to also need to
+Because we're now using the {@link ngResource ngResource} module, it's necessary to
 update the Karma config file with angular-resource so the new tests will pass.
 
 __`test/karma.conf.js`:__
@@ -276,7 +276,7 @@ describe('PhoneCat controllers', function() {
 
 You should now see the following output in the Karma tab:
 
-<pre>Chrome 22.0: Executed 4 of 4 SUCCESS (0.038 secs / 0.01 secs)</pre>
+<pre>Chrome 22.0: Executed 5 of 5 SUCCESS (0.038 secs / 0.01 secs)</pre>
 
 
 # Summary

docs/content/tutorial/step_12.ngdoc

@@ -9,8 +9,8 @@
 In this final step, we will enhance our phonecat web application by attaching CSS and JavaScript
 animations on top of the template code we created before.
 
-* Used the `ngAnimate` to enable animations throughout the application.
-* Common `ng` directives automatically trigger hooks for animations to tap into.
+* We now use the `ngAnimate` module to enable animations throughout the application.
+* We also use common `ng` directives to automatically trigger hooks for animations to tap into.
 * When an animation is found then the animation will run in between the standard DOM operation that
   is being issued on the element at the given time (e.g. inserting and removing nodes on
   {@link ngRepeat `ngRepeat`} or adding and removing classes on
@@ -369,7 +369,8 @@ occur whenever the CSS class itself changes.
 Whenever a new phone thumbnail is selected, the state changes and the `.active` CSS class is added
 to the matching profile image and the animation plays.
 
-Let's get started and tweak our HTML code on the `phone-detail.html` page first:
+Let's get started and tweak our HTML code on the `phone-detail.html` page first. Notice that we 
+have changed the way we display our large image:
 
 __`app/partials/phone-detail.html`.__
 

docs/gulpfile.js

@@ -63,8 +63,8 @@ gulp.task('build-app', function() {
 gulp.task('assets', ['bower'], function() {
   var JS_EXT = /\.js$/;
   return merge(
-    gulp.src([assets])
-      .pipe(gulp.dest(outputFolder)),
+    gulp.src(['img/**/*']).pipe(gulp.dest(outputFolder + '/img')),
+    gulp.src([assets]).pipe(gulp.dest(outputFolder)),
     gulp.src([assets])
       .pipe(foreach(function(stream, file) {
         if (JS_EXT.test(file.relative)) {

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

@@ -1,41 +0,0 @@
-<?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="0" y="0" 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>

i18n/closure/currencySymbols.js

@@ -267,7 +267,7 @@ goog.i18n.currency.adjustPrecision = function(pattern, currencyCode) {
  * 18: two decimals precision (2), currency sign last (16), no space (0)
  * 50: two decimals precision (2), currency sign last (16), space (32)
  *
- * @type {!Object.<!Array>}
+ * @const {!Object<!Array<?>>}
  */
 goog.i18n.currency.CurrencyInfo = {
   'AED': [2, 'dh', '\u062f.\u0625.', 'DH'],
@@ -334,7 +334,7 @@ goog.i18n.currency.CurrencyInfo = {
 
 /**
  * Tier 2 currency information.
- * @type {!Object.<!Array>}
+ * @const {!Object<!Array<?>>}
  */
 goog.i18n.currency.CurrencyInfoTier2 = {
   'AFN': [48, 'Af.', 'AFN'],