fix(docs): change all directive references to use the normalized names

Author: IgorMinar

CHANGELOG.md

@@ -238,9 +238,9 @@ docs. The biggest improvements and changes are listed below.
     So instead of `{{ someRawHtml | html }}` use `<div ng-bind-html="someRawHtml"></div>` and
     instead of `{{ someRawHtml | html:"unsafe" }}` use `<div ng-bind-html-unsafe="someRawHtml"></div>`.
     Please check out the
-    [ng-bind-html](http://docs-next.angularjs.org/api/angular.module.ng.$compileProvider.directive.ng-bind-html)
+    [ng-bind-html](http://docs-next.angularjs.org/api/angular.module.ng.$compileProvider.directive.ngBindHtml)
     and
-    [ng-bind-html-unsafe](http://docs-next.angularjs.org/api/angular.module.ng.$compileProvider.directive.ng-bind-html-unsafe)
+    [ng-bind-html-unsafe](http://docs-next.angularjs.org/api/angular.module.ng.$compileProvider.directive.ngBindHtmlUnsafe)
     directive docs.
 
   - Custom markup has been used by developers only to switch from `{{ }}` markup to `(( ))` or
@@ -389,13 +389,13 @@ behavior and migrate your controllers one at a time: <https://gist.github.com/16
 
 ## New directives:
 
-- [ng-mouseleave](http://docs-next.angularjs.org/api/angular.module.ng.$compileProvider.directive.ng-mouseleave)
-- [ng-mousemove](http://docs-next.angularjs.org/api/angular.module.ng.$compileProvider.directive.ng-mousemove)
-- [ng-mouseover](http://docs-next.angularjs.org/api/angular.module.ng.$compileProvider.directive.ng-mouseover)
-- [ng-mouseup](http://docs-next.angularjs.org/api/angular.module.ng.$compileProvider.directive.ng-mouseup)
-- [ng-mousedown](http://docs-next.angularjs.org/api/angular.module.ng.$compileProvider.directive.ng-mousedown)
-- [ng-dblclick](http://docs-next.angularjs.org/api/angular.module.ng.$compileProvider.directive.ng-dblclick)
-- [ng-model-instant](http://docs-next.angularjs.org/api/angular.module.ng.$compileProvider.directive.ng-model-instant)
+- [ng-mouseleave](http://docs-next.angularjs.org/api/angular.module.ng.$compileProvider.directive.ngMouseleave)
+- [ng-mousemove](http://docs-next.angularjs.org/api/angular.module.ng.$compileProvider.directive.ngMousemove)
+- [ng-mouseover](http://docs-next.angularjs.org/api/angular.module.ng.$compileProvider.directive.ngMouseover)
+- [ng-mouseup](http://docs-next.angularjs.org/api/angular.module.ng.$compileProvider.directive.ngMouseup)
+- [ng-mousedown](http://docs-next.angularjs.org/api/angular.module.ng.$compileProvider.directive.ngMousedown)
+- [ng-dblclick](http://docs-next.angularjs.org/api/angular.module.ng.$compileProvider.directive.ngDblclick)
+- [ng-model-instant](http://docs-next.angularjs.org/api/angular.module.ng.$compileProvider.directive.ngModelInstant)
 
 
 ## $injector / modules

docs/content/api/angular.module.ng.$compileProvider.directive.ngdoc

@@ -126,8 +126,8 @@ a change in DOM structure such as in repeaters.
 
 When the above example is compiled, the compiler visits every node and looks for directives. The
 `{{user}}` is an example of {@link angular.module.ng.$interpolate interpolation} directive. {@link
-angular.module.ng.$compileProvider.directive.ng-repeat ng-repeat} is another directive. But {@link
-angular.module.ng.$compileProvider.directive.ng-repeat ng-repeat} has a dilemma. It needs to be
+angular.module.ng.$compileProvider.directive.ngRepeat ngRepeat} is another directive. But {@link
+angular.module.ng.$compileProvider.directive.ngRepeat ngRepeat} has a dilemma. It needs to be
 able to quickly stamp out new `li`s for every `action` in `user.actions`. This means that it needs
 to save a clean copy of the `li` element for cloning purposes and as new `action`s are inserted,
 the template `li` element needs to be cloned and inserted into `ul`. But cloning the `li` element
@@ -143,12 +143,12 @@ the directives are identified and sorted by priority, and a linking phase where
 links a specific instance of the {@link angular.module.ng.$rootScope.Scope scope} and the specific
 instance of an `li` is performed.
 
-{@link angular.module.ng.$compileProvider.directive.ng-repeat ng-repeat} works by preventing the
+{@link angular.module.ng.$compileProvider.directive.ngRepeat ngRepeat} works by preventing the
 compilation process form descending into `li` element. Instead the {@link
-angular.module.ng.$compileProvider.directive.ng-repeat ng-repeat} directive compiles `li`
+angular.module.ng.$compileProvider.directive.ngRepeat ngRepeat} directive compiles `li`
 seperatly. The result of of the `li` element compilation is a linking function which contains all
 of the directives contained in the `li` element ready to be attached to a specific clone of `li`
-element. At runtime the {@link angular.module.ng.$compileProvider.directive.ng-repeat ng-repeat}
+element. At runtime the {@link angular.module.ng.$compileProvider.directive.ngRepeat ngRepeat}
 watches the expression and as items are added to the array it clones the `li` element, creates a
 new {@link angular.module.ng.$rootScope.Scope scope} for the cloned `li` element and calls the
 link function on the cloned `li`.
@@ -415,8 +415,8 @@ compiler}. The attributes are:
     append the template to the element.
 
   * `transclude` - compile the content of the element and make it available to the directive.
-    Typically used with {@link api/angular.module.ng.$compileProvider.directive.ng-transclude
-    ng-transclude}. The advantage of transclusion is that the linking function receives a
+    Typically used with {@link api/angular.module.ng.$compileProvider.directive.ngTransclude
+    ngTransclude}. The advantage of transclusion is that the linking function receives a
     transclusion function which is pre-bound to the correct scope. In a typical setup the widget
     creates an `isolate` scope, but the transclusion is not a child, but a sibling of the `isolate`
     scope. This makes it possible for the widget to have private state, and the transclusion to
@@ -440,8 +440,8 @@ compiler}. The attributes are:
 Compile function deals with transforming the template DOM. Since most directives do not do
 template transformation, it is not used often. Examples which require compile functions are
 directives which transform template DOM such as {@link
-angular.module.ng.$compileProvider.directive.ng-repeat ng-repeat} or load the contents
-asynchronously such as {@link angular.module.ng.$compileProvider.directive.ng-view ng-view}. The
+angular.module.ng.$compileProvider.directive.ngRepeat ngRepeat} or load the contents
+asynchronously such as {@link angular.module.ng.$compileProvider.directive.ngView ngView}. The
 compile functions takes the following arguments.
 
   * `tElement` - template element - The element where the directive has been declared. It is

docs/content/cookbook/deeplinking.ngdoc

@@ -106,7 +106,7 @@ The two partials are defined in the following URLs:
   routes.
 * The  {@link api/angular.module.ng.$route $route} service then watches the URL and instantiates the
   appropriate controller when the URL changes.
-* The  {@link api/angular.module.ng.$compileProvider.directive.ng-view ng-view} widget loads the
+* The  {@link api/angular.module.ng.$compileProvider.directive.ngView ngView} widget loads the
   view when the URL changes. It also sets the view scope to the newly instantiated controller.
 * Changing the URL is sufficient to change the controller and view. It makes no difference whether
   the URL is changed programatically or by the user.

docs/content/cookbook/form.ngdoc

@@ -102,7 +102,7 @@ allow a user to enter data.
 
 # Things to notice
 
-* The user data model is initialized {@link api/angular.module.ng.$compileProvider.directive.ng-controller controller} and is
+* The user data model is initialized {@link api/angular.module.ng.$compileProvider.directive.ngController controller} and is
   available in the {@link api/angular.module.ng.$rootScope.Scope scope} with the initial data.
 * For debugging purposes we have included a debug view of the model to better understand what
   is going on.

docs/content/guide/dev_guide.bootstrap.auto_bootstrap.ngdoc

@@ -2,7 +2,7 @@
 @name Developer Guide: Initializing Angular: Automatic Initialization
 @description
 
-For Angular to manage the DOM for your application, it needs to compile some or all of an HTML page.  Angular does this initialization automatically when you load the angular.js script into your page and insert an `ng-app` directive (attribute) into one of the page's elements.  For example, we can tell Angular to initialize the entire document:
+For Angular to manage the DOM for your application, it needs to compile some or all of an HTML page.  Angular does this initialization automatically when you load the angular.js script into your page and insert an `ngApp` directive (attribute) into one of the page's elements.  For example, we can tell Angular to initialize the entire document:
 
 <pre>
 <!doctype html>
@@ -16,15 +16,15 @@ For Angular to manage the DOM for your application, it needs to compile some or
 </html>
 </pre>
 
-You can also tell Angular to manage only a portion of a page.  You would want to do this if you are using some other framework to manage other parts of the page.  You do this by placing the `ng-app` directive on one or more container elements in the document.  For example:
+You can also tell Angular to manage only a portion of a page.  You would want to do this if you are using some other framework to manage other parts of the page.  You do this by placing the `ngApp` directive on one or more container elements in the document.  For example:
 
 <pre>
 <div ng-app>
   I can add: {{ 1+2 }}
 </div>
 </pre>
 
-You can also ask `ng-app` to load additional {@link api/angular.module modules} containing services, directives or filers that you'll use on the page.
+You can also ask `ngApp` to load additional {@link api/angular.module modules} containing services, directives or filers that you'll use on the page.
 
 <pre>
 <div ng-app="AwesomeModule">
@@ -38,7 +38,7 @@ From a high-level, here's what Angular does during the initialization process:
 1. The browser loads the page, and then runs the Angular script. Angular then waits for the
 `DOMContentLoaded` (or 'Load') event to attempt to initialize.
 
-2. Angular looks for the `ng-app` directive. If found it compilies the DOM element containing `ng-app` and its children.
+2. Angular looks for the `ngApp` directive. If found it compilies the DOM element containing `ngApp` and its children.
 
 3. Angular creates a global variable `angular` and binds all Angular APIs to this object's fields.
 

docs/content/guide/dev_guide.bootstrap.manual_bootstrap.ngdoc

@@ -2,14 +2,14 @@
 @name  Developer Guide: Initializing Angular: Manual Initialization
 @description
 
-In the vast majority of cases you'll want to let Angular handle initialization automatically.  
-If, however, you need to delay Angular from managing the page right after the DOMContentLoaded 
+In the vast majority of cases you'll want to let Angular handle initialization automatically.
+If, however, you need to delay Angular from managing the page right after the DOMContentLoaded
 event fires, you'll need to control this initialization manually.
 
-To initialize Angular -- after you've done your own special-purpose initialization -- just call 
+To initialize Angular -- after you've done your own special-purpose initialization -- just call
 the {@link api/angular.bootstrap bootstrap()} function with the HTML container node that you want
-Angular to manage.  In automatic initialization you'd do this by adding the `ng-app` attribute to 
-the same node.  Now, you won't use `ng-app` anywhere in your document.
+Angular to manage.  In automatic initialization you'd do this by adding the `ngApp` attribute to
+the same node.  Now, you won't use `ngApp` anywhere in your document.
 
 To show the contrast of manual vs. automatic initialization, this automatic method:
 

docs/content/guide/dev_guide.bootstrap.ngdoc

@@ -7,7 +7,7 @@ Angular should process and manage the page. To initialize Angular you do the fol
 
 * Specify the Angular namespace in the `<html>` page
 * Choose which flavor of Angular script to load (debug or production)
-* Specify whether or not Angular should process and manage the page automatically (`ng-app`)
+* Specify whether or not Angular should process and manage the page automatically (`ngApp`)
 
 The simplest way to initialize Angular is to load the Angular script and tell Angular to compile
 and manage the whole page. You do this as follows:

docs/content/guide/dev_guide.di.understanding_di.ngdoc

@@ -27,9 +27,9 @@ In the illustration above, the dependency injection sequence proceeds as follows
 
 1. Module "phonecat" is created and all the service providers are registered with this module.
    (the "ng" module is created by Angular behind the scenes as well)
-2. `ng-app` triggers bootstrap sequence on given element, during which angular creates injector,
+2. `ngApp` triggers bootstrap sequence on given element, during which angular creates injector,
 loads "phonecat" and "ng" modules and compiles the template.
-3. The `ng-controller` directive implicitly creates a new child scope and instantiates
+3. The `ngController` directive implicitly creates a new child scope and instantiates
 `PhoneListCtrl` controller.
 4. Injector identifies the `$http` service as `PhoneListCtrl` controller's only dependency.
 5. Injector checks its instances cache whether the `$http` service has already been instantiated.

docs/content/guide/dev_guide.forms.ngdoc

@@ -12,9 +12,9 @@ Server-side validation is still necessary for a secure application.
 
 
 # Simple form
-The key directive in understanding two-way data-binding is  {@link api/angular.module.ng.$compileProvider.directive.ng-model ng-model}.
-The `ng-model` provides the two-way data-binding by synchronizing the model to the view, as well as view to the model.
-In addition it provides {@link api/angular.module.ng.$compileProvider.directive.ng-model.NgModelController API} for other directives to augment its behavior.
+The key directive in understanding two-way data-binding is  {@link api/angular.module.ng.$compileProvider.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 {@link api/angular.module.ng.$compileProvider.directive.ngModel.NgModelController API} for other directives to augment its behavior.
 
 <doc:example>
 <doc:source>
@@ -56,7 +56,7 @@ Note that `novalidate` is used to disable browser's native form validation.
 
 # Using CSS classes
 
-To allow styling of form as well as controls, `ng-model`  add these CSS classes:
+To allow styling of form as well as controls, `ngModel`  add these CSS classes:
 
 - `ng-valid`
 - `ng-invalid`
@@ -115,7 +115,7 @@ This ensures that the user is not distracted with an error until after interacti
 
 A form is in instance of {@link api/angular.module.ng.$compileProvider.directive.form.FormController FormController}.
 The form instance can optionally be published into the scope using the `name` attribute.
-Similarly control is an instance of {@link api/angular.module.ng.$compileProvider.directive.ng-model.NgModelController NgModelController}.
+Similarly control is an instance of {@link api/angular.module.ng.$compileProvider.directive.ngModel.NgModelController NgModelController}.
 The control instance can similarly be published into the form instance using the `name` attribute.
 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.
 
@@ -181,16 +181,16 @@ This allows us to extend the above example with these features:
 Angular provides basic implementation for most common html5 {@link api/angular.module.ng.$compileProvider.directive.input input}
 types: ({@link api/angular.module.ng.$compileProvider.directive.input.text text}, {@link api/angular.module.ng.$compileProvider.directive.input.number number}, {@link api/angular.module.ng.$compileProvider.directive.input.url url}, {@link api/angular.module.ng.$compileProvider.directive.input.email email}, {@link api/angular.module.ng.$compileProvider.directive.input.radio radio}, {@link api/angular.module.ng.$compileProvider.directive.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 `ng-model` {@link api/angular.module.ng.$compileProvider.directive.ng-model.NgModelController controller}.
+Defining your own validator can be done by defining your own directive which adds a custom validation function to the `ngModel` {@link api/angular.module.ng.$compileProvider.directive.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:
 
   * **Model to View update** -
-    Whenever the bound model changes, all functions in {@link   api/angular.module.ng.$compileProvider.directive.ng-model.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 api/angular.module.ng.$compileProvider.directive.ng-model.NgModelController#$setValidity NgModelController#$setValidity}.
+    Whenever the bound model changes, all functions in {@link   api/angular.module.ng.$compileProvider.directive.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 api/angular.module.ng.$compileProvider.directive.ngModel.NgModelController#$setValidity NgModelController#$setValidity}.
 
   * **View to Model update** -
-    In a similar way, whenever a user interacts with a control, the controll calls {@link api/angular.module.ng.$compileProvider.directive.ng-model.NgModelController#$setViewValue NgModelController#$setViewValue}.
-This in turn pipelines all functions in {@link api/angular.module.ng.$compileProvider.directive.ng-model.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 api/angular.module.ng.$compileProvider.directive.ng-model.NgModelController#$setValidity NgModelController#$setValidity}.
+    In a similar way, whenever a user interacts with a control, the controll calls {@link api/angular.module.ng.$compileProvider.directive.ngModel.NgModelController#$setViewValue NgModelController#$setViewValue}.
+This in turn pipelines all functions in {@link api/angular.module.ng.$compileProvider.directive.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 api/angular.module.ng.$compileProvider.directive.ngModel.NgModelController#$setValidity NgModelController#$setValidity}.
 
 In the following example we create two directives.
 
@@ -272,13 +272,13 @@ In the following example we create two directives.
 </doc:example>
 
 
-# Implementing custom form control (using ng-model)
+# Implementing custom form control (using `ngModel`)
 Angular implements all of the basic HTML form controls ({@link api/angular.module.ng.$compileProvider.directive.input input}, {@link api/angular.module.ng.$compileProvider.directive.select select}, {@link api/angular.module.ng.$compileProvider.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 `ng-model` and to achieve two-way data-binding it needs to:
+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   api/angular.module.ng.$compileProvider.directive.ng-model.NgModelController#$formatters NgModelController#$formatters},
+  - implement `render` method, which is responsible for rendering the data after it passed the {@link   api/angular.module.ng.$compileProvider.directive.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 api/angular.module.ng.$compileProvider.directive $compileProvider.directive} for more info.