From f16150d5f1b20b3d633b4402095ea89baa4be042 Mon Sep 17 00:00:00 2001 From: Igor Minar Date: Mon, 11 Jun 2012 23:49:24 -0700 Subject: [PATCH] docs(*): simplify doc urls we now have two types of namespaces: - true namespace: angular.* - used for all global apis - virtual namespace: ng.*, ngMock.*, ... - used for all DI modules the virual namespaces have services under the second namespace level (e.g. ng.) and filters and directives prefixed with filter: and directive: respectively (e.g. ng.filter:orderBy, ng.directive:ngRepeat) this simplifies urls and makes them a lot shorter while still avoiding name collisions --- .../api/{angular.module.ng.ngdoc => ng.ngdoc} | 2 +- docs/content/cookbook/deeplinking.ngdoc | 6 +- docs/content/cookbook/form.ngdoc | 6 +- docs/content/cookbook/helloworld.ngdoc | 4 +- docs/content/cookbook/index.ngdoc | 2 +- docs/content/cookbook/mvc.ngdoc | 2 +- docs/content/guide/bootstrap.ngdoc | 18 +- docs/content/guide/compiler.ngdoc | 18 +- .../content/guide/dev_guide.e2e-testing.ngdoc | 8 +- ...v_guide.mvc.understanding_controller.ngdoc | 12 +- .../dev_guide.mvc.understanding_model.ngdoc | 4 +- .../dev_guide.mvc.understanding_view.ngdoc | 4 +- .../guide/dev_guide.services.$location.ngdoc | 14 +- ...dev_guide.services.creating_services.ngdoc | 6 +- ...guide.services.injecting_controllers.ngdoc | 2 +- ...guide.services.managing_dependencies.ngdoc | 8 +- docs/content/guide/dev_guide.services.ngdoc | 2 +- .../dev_guide.services.testing_services.ngdoc | 2 +- ...uide.services.understanding_services.ngdoc | 4 +- .../dev_guide.templates.css-styling.ngdoc | 4 +- ...e.templates.filters.creating_filters.ngdoc | 2 +- .../guide/dev_guide.templates.filters.ngdoc | 4 +- ...uide.templates.filters.using_filters.ngdoc | 4 +- docs/content/guide/dev_guide.templates.ngdoc | 6 +- .../guide/dev_guide.unit-testing.ngdoc | 2 +- docs/content/guide/directive.ngdoc | 50 ++--- docs/content/guide/expression.ngdoc | 8 +- docs/content/guide/forms.ngdoc | 24 +-- docs/content/guide/i18n.ngdoc | 16 +- docs/content/guide/overview.ngdoc | 2 +- docs/content/guide/scope.ngdoc | 66 +++--- docs/content/misc/faq.ngdoc | 2 +- docs/content/tutorial/step_00.ngdoc | 6 +- docs/content/tutorial/step_02.ngdoc | 6 +- docs/content/tutorial/step_03.ngdoc | 8 +- docs/content/tutorial/step_04.ngdoc | 2 +- docs/content/tutorial/step_05.ngdoc | 16 +- docs/content/tutorial/step_06.ngdoc | 2 +- docs/content/tutorial/step_07.ngdoc | 10 +- docs/content/tutorial/step_08.ngdoc | 2 +- docs/content/tutorial/step_09.ngdoc | 2 +- docs/content/tutorial/step_10.ngdoc | 2 +- docs/content/tutorial/step_11.ngdoc | 12 +- docs/spec/ngdocSpec.js | 20 +- docs/src/ngdoc.js | 25 +-- docs/src/templates/js/docs.js | 46 ++-- src/Angular.js | 7 +- src/auto/injector.js | 64 +++--- src/jqLite.js | 2 +- src/loader.js | 20 +- src/ng/anchorScroll.js | 2 +- src/ng/browser.js | 32 +-- src/ng/cacheFactory.js | 6 +- src/ng/compile.js | 34 +-- src/ng/controller.js | 14 +- src/ng/defer.js | 10 +- src/ng/directive/booleanAttrs.js | 14 +- src/ng/directive/form.js | 20 +- src/ng/directive/input.js | 62 +++--- src/ng/directive/ngBind.js | 12 +- src/ng/directive/ngClass.js | 14 +- src/ng/directive/ngCloak.js | 2 +- src/ng/directive/ngController.js | 4 +- src/ng/directive/ngCsp.js | 4 +- src/ng/directive/ngEventDirs.js | 32 +-- src/ng/directive/ngInclude.js | 8 +- src/ng/directive/ngInit.js | 2 +- src/ng/directive/ngNonBindable.js | 2 +- src/ng/directive/ngPluralize.js | 2 +- src/ng/directive/ngRepeat.js | 2 +- src/ng/directive/ngShowHide.js | 4 +- src/ng/directive/ngStyle.js | 2 +- src/ng/directive/ngSwitch.js | 2 +- src/ng/directive/ngTransclude.js | 2 +- src/ng/directive/ngView.js | 8 +- src/ng/directive/script.js | 2 +- src/ng/directive/select.js | 4 +- src/ng/document.js | 2 +- src/ng/exceptionHandler.js | 4 +- src/ng/filter.js | 8 +- src/ng/filter/filter.js | 4 +- src/ng/filter/filters.js | 12 +- src/ng/filter/limitTo.js | 4 +- src/ng/filter/orderBy.js | 4 +- src/ng/http.js | 60 +++--- src/ng/httpBackend.js | 8 +- src/ng/interpolate.js | 16 +- src/ng/locale.js | 2 +- src/ng/location.js | 48 ++--- src/ng/log.js | 18 +- src/ng/parse.js | 2 +- src/ng/q.js | 20 +- src/ng/rootElement.js | 6 +- src/ng/rootScope.js | 184 ++++++++-------- src/ng/route.js | 60 +++--- src/ng/routeParams.js | 6 +- src/ng/sniffer.js | 2 +- src/ng/timeout.js | 12 +- src/ng/window.js | 2 +- src/ngCookies/cookies.js | 18 +- src/ngMock/angular-mocks.js | 204 +++++++++--------- src/ngResource/resource.js | 8 +- src/ngSanitize/directive/ngBindHtml.js | 6 +- src/ngSanitize/filter/linky.js | 2 +- src/ngSanitize/sanitize.js | 4 +- src/ngScenario/dsl.js | 8 +- 106 files changed, 803 insertions(+), 799 deletions(-) rename docs/content/api/{angular.module.ng.ngdoc => ng.ngdoc} (81%) diff --git a/docs/content/api/angular.module.ng.ngdoc b/docs/content/api/ng.ngdoc similarity index 81% rename from docs/content/api/angular.module.ng.ngdoc rename to docs/content/api/ng.ngdoc index 2ac39e5602fd..95295e69c190 100644 --- a/docs/content/api/angular.module.ng.ngdoc +++ b/docs/content/api/ng.ngdoc @@ -1,5 +1,5 @@ @ngdoc overview -@name angular.module.ng +@name ng @description The `ng` is an angular module which contains all of the core angular services. diff --git a/docs/content/cookbook/deeplinking.ngdoc b/docs/content/cookbook/deeplinking.ngdoc index 1e9c01616cfe..f55096212560 100644 --- a/docs/content/cookbook/deeplinking.ngdoc +++ b/docs/content/cookbook/deeplinking.ngdoc @@ -141,11 +141,11 @@ In this example we have a simple app which consist of two screens: # Things to notice * Routes are defined in the `AppCntl` class. The initialization of the controller causes the - initialization of the {@link api/angular.module.ng.$route $route} service with the proper URL + initialization of the {@link api/ng.$route $route} service with the proper URL routes. -* The {@link api/angular.module.ng.$route $route} service then watches the URL and instantiates the +* The {@link api/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.ngView ngView} widget loads the +* The {@link api/ng.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. diff --git a/docs/content/cookbook/form.ngdoc b/docs/content/cookbook/form.ngdoc index 829547f4ec8d..3b85b80b42a1 100644 --- a/docs/content/cookbook/form.ngdoc +++ b/docs/content/cookbook/form.ngdoc @@ -102,11 +102,11 @@ allow a user to enter data. # Things to notice -* 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. +* The user data model is initialized {@link api/ng.directive:ngController controller} and is + available in the {@link api/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. -* The {@link api/angular.module.ng.$compileProvider.directive.input input directives} simply refer +* The {@link api/ng.directive:input input directives} simply refer to the model and are data-bound. * The inputs validate. (Try leaving them blank or entering non digits in the zip field) * In your application you can simply read from or write to the model and the form will be updated. diff --git a/docs/content/cookbook/helloworld.ngdoc b/docs/content/cookbook/helloworld.ngdoc index 92c50cf2557c..786511e913d5 100644 --- a/docs/content/cookbook/helloworld.ngdoc +++ b/docs/content/cookbook/helloworld.ngdoc @@ -29,10 +29,10 @@ Take a look through the source and note: * The script tag that {@link guide/bootstrap bootstraps} the angular environment. -* The text {@link api/angular.module.ng.$compileProvider.directive.input input widget} which is +* The text {@link api/ng.directive:input input form control} which is bound to the greeting name text. * No need for listener registration and event firing on change events. -* The implicit presence of the `name` variable which is in the root {@link api/angular.module.ng.$rootScope.Scope scope}. +* The implicit presence of the `name` variable which is in the root {@link api/ng.$rootScope.Scope scope}. * The double curly brace `{{markup}}`, which binds the name variable to the greeting text. * The concept of {@link guide/dev_guide.templates.databinding data binding}, which reflects any changes to the diff --git a/docs/content/cookbook/index.ngdoc b/docs/content/cookbook/index.ngdoc index 43ac9bb20fa7..45ba21232293 100644 --- a/docs/content/cookbook/index.ngdoc +++ b/docs/content/cookbook/index.ngdoc @@ -44,7 +44,7 @@ allowing you to send links to specific screens in your app. # Services -{@link api/angular.module.ng Services}: Services are long lived objects in your applications that are +{@link api/ng Services}: Services are long lived objects in your applications that are available across controllers. A collection of useful services are pre-bundled with angular but you will likely add your own. Services are initialized using dependency injection, which resolves the order of initialization. This safeguards you from the perils of global state (a common way to diff --git a/docs/content/cookbook/mvc.ngdoc b/docs/content/cookbook/mvc.ngdoc index da8f48e224ca..c362174c02d4 100644 --- a/docs/content/cookbook/mvc.ngdoc +++ b/docs/content/cookbook/mvc.ngdoc @@ -125,4 +125,4 @@ board variable. * The view can call any controller function. * In this example, the `setUrl()` and `readUrl()` functions copy the game state to/from the URL's hash so the browser's back button will undo game steps. See deep-linking. This example calls {@link -api/angular.module.ng.$rootScope.Scope#$watch $watch()} to set up a listener that invokes `readUrl()` when needed. +api/ng.$rootScope.Scope#$watch $watch()} to set up a listener that invokes `readUrl()` when needed. diff --git a/docs/content/guide/bootstrap.ngdoc b/docs/content/guide/bootstrap.ngdoc index b2c681b573c5..383aabf5dca9 100644 --- a/docs/content/guide/bootstrap.ngdoc +++ b/docs/content/guide/bootstrap.ngdoc @@ -41,26 +41,26 @@ initialization. * If you chose to use the old style directive syntax `ng:` then include xml-namespace in `html` to make IE happy. (This is here for historical resons, and we no longer recomend use of `ng:`.) - + - - + + # Automatic Initialization Angular initializes automatically upon `DOMContentLoaded` event, at which point angular looks for -the {@link api/angular.module.ng.$compileProvider.directive.ngApp `ng-app`} directive which +the {@link api/ng.directive:ngApp `ng-app`} directive which designates your application root. If {@link -api/angular.module.ng.$compileProvider.directive.ngApp `ng-app`} directive is found then Angular +api/ng.directive:ngApp `ng-app`} directive is found then Angular will: * load the {@link guide/module module} associated with the directive. - * create the application {@link api/angular.module.AUTO.$injector injector} - * compile the DOM treating the {@link api/angular.module.ng.$compileProvider.directive.ngApp + * create the application {@link api/AUTO.$injector injector} + * compile the DOM treating the {@link api/ng.directive:ngApp `ng-app`} directive as the root of the compilation. This allows you to tell it to treat only a portion of the DOM as an Angular application. - + 
 
 
@@ -82,7 +82,7 @@ or the need to perform an operation before the Angular compiles a page.
 
 
 Here is an example of manually initializing Angular. The example is equivalent to using the {@link
-api/angular.module.ng.$compileProvider.directive.ngApp ng-app} directive.
+api/ng.directive:ngApp ng-app} directive.
 
 
 
diff --git a/docs/content/guide/compiler.ngdoc b/docs/content/guide/compiler.ngdoc
index 493b611fd27b..afd4d115306d 100644
--- a/docs/content/guide/compiler.ngdoc
+++ b/docs/content/guide/compiler.ngdoc
@@ -4,10 +4,10 @@
 
 # Overview
 
-Angular's {@link api/angular.module.ng.$compile HTML compiler} allows the developer to teach the
+Angular's {@link api/ng.$compile HTML compiler} allows the developer to teach the
 browser new HTML syntax. The compiler allows you to attach behavior to any HTML element or attribute
 and even create new HTML element or attributes with custom behavior. Angular calls these behavior
-extensions {@link api/angular.module.ng.$compileProvider.directive directives}.
+extensions {@link api/ng.$compileProvider.directive directives}.
 
 HTML has a lot of constructs for formatting the HTML for static documents in declarative fashion.
 For example if something needs to be centered, there is no need to provide instructions to the
@@ -17,7 +17,7 @@ element to achieve the desired behavior. Such is the power of declarative langua
 
 But the declarative language is also limited, since it does not allow you to teach the browser new
 syntax. For example there is no easy way to get the browser to align the text at 1/3 the position
-instead of 1/2. What is needed is a way to teach browser new HTML syntax. 
+instead of 1/2. What is needed is a way to teach browser new HTML syntax.
 
 Angular comes pre-bundled with common directives which are useful for building any app. We also
 expect that you will create directives that are specific to your app. These extension become a
@@ -29,7 +29,7 @@ involved.
 
 # Compiler
 
-Compiler is an angular service which traverses the DOM looking for attributes. The compilation 
+Compiler is an angular service which traverses the DOM looking for attributes. The compilation
 process happens into two phases.
 
   1. **Compile:** traverse the DOM and collect all of the directives. The result is a linking
@@ -39,7 +39,7 @@ process happens into two phases.
   scope model are reflected in the view, and any user interactions with the view are reflected
   in the scope model. Making the scope model a single source of truth.
 
-Some directives such {@link api/angular.module.ng.$compileProvider.directive.ngRepeat
+Some directives such {@link api/ng.directive:ngRepeat
 `ng-repeat`} clone DOM elements once for each item in collection. Having a compile and link phase
 improves performance since the cloned template only needs to be compiled once, and then linked
 once for each clone instance.
@@ -50,7 +50,7 @@ once for each clone instance.
 Directive is a behavior which should be triggered when specific HTML constructs are encountered in
 compilation process. The directives can be placed in element names, attributes, class names, as
 well as comments. Here are some equivalent examples of invoking {@link
-api/angular.module.ng.$compileProvider.directive.ngBind `ng-bind`} directive.
+api/ng.directive:ngBind `ng-bind`} directive.
 
 
   
@@ -60,7 +60,7 @@ api/angular.module.ng.$compileProvider.directive.ngBind `ng-bind`} directive.
 

 
 Directive is just a function which executes when the compiler encounters it in the DOM. See {@link
-api/angular.module.ng.$compileProvider.directive directive API} for in depth documentation on how
+api/ng.$compileProvider.directive directive API} for in depth documentation on how
 to write directives.
 
 Here is a directive which makes any element draggable. Notice the `draggable` attribute on the
@@ -115,9 +115,9 @@ principles.
 
 # Understanding View
 
-There are many templating systems out there. Most of them consume a static string template and 
+There are many templating systems out there. Most of them consume a static string template and
 combine it with data, resulting in a new string. The resulting text is then `innerHTML`ed into
-an element. 
+an element.
 
 
 
diff --git a/docs/content/guide/dev_guide.e2e-testing.ngdoc b/docs/content/guide/dev_guide.e2e-testing.ngdoc
index bc0480949167..7cb048414049 100644
--- a/docs/content/guide/dev_guide.e2e-testing.ngdoc
+++ b/docs/content/guide/dev_guide.e2e-testing.ngdoc
@@ -78,19 +78,19 @@ Returns the window.location.search of the currently loaded page in the test fram
 Returns the window.location.hash (without `#`) of the currently loaded page in the test frame.
 
 ## browser().location().url()
-Returns the {@link api/angular.module.ng.$location $location.url()} of the currently loaded page in
+Returns the {@link api/ng.$location $location.url()} of the currently loaded page in
 the test frame.
 
 ## browser().location().path()
-Returns the {@link api/angular.module.ng.$location $location.path()} of the currently loaded page in
+Returns the {@link api/ng.$location $location.path()} of the currently loaded page in
 the test frame.
 
 ## browser().location().search()
-Returns the {@link api/angular.module.ng.$location $location.search()} of the currently loaded page
+Returns the {@link api/ng.$location $location.search()} of the currently loaded page
 in the test frame.
 
 ## browser().location().hash()
-Returns the {@link api/angular.module.ng.$location $location.hash()} of the currently loaded page in
+Returns the {@link api/ng.$location $location.hash()} of the currently loaded page in
 the test frame.
 
 ## expect(future).{matcher}
diff --git a/docs/content/guide/dev_guide.mvc.understanding_controller.ngdoc b/docs/content/guide/dev_guide.mvc.understanding_controller.ngdoc
index ce3c74e3b2e0..df7db2e2cfdc 100644
--- a/docs/content/guide/dev_guide.mvc.understanding_controller.ngdoc
+++ b/docs/content/guide/dev_guide.mvc.understanding_controller.ngdoc
@@ -4,7 +4,7 @@
 
 In angular, a controller is a JavaScript function(type/class) that is used to augment instances of
 angular {@link scope Scope}, excluding the root scope. When you or angular create a new
-child scope object via the {@link api/angular.module.ng.$rootScope.Scope#$new scope.$new} API        , there is an
+child scope object via the {@link api/ng.$rootScope.Scope#$new scope.$new} API        , there is an
 option to pass in a controller as a method argument. This will tell angular to associate the
 controller with the new scope and to augment its behavior.
 
@@ -38,7 +38,7 @@ template/view. This behavior interacts with and modifies the application model.
 As discussed in the {@link dev_guide.mvc.understanding_model Model} section of this guide, any
 objects (or primitives) assigned to the scope become model properties. Any functions assigned to
 the scope are available in the template/view, and can be invoked via angular expressions
-and `ng` event handler directives (e.g. {@link api/angular.module.ng.$compileProvider.directive.ngClick ngClick}).
+and `ng` event handler directives (e.g. {@link api/ng.directive:ngClick ngClick}).
 
 # Using Controllers Correctly
 
@@ -68,9 +68,9 @@ instances).
 
 # Associating Controllers with Angular Scope Objects
 
-You can associate controllers with scope objects explicitly via the {@link api/angular.module.ng.$rootScope.Scope#$new
-scope.$new} api or implicitly via the {@link api/angular.module.ng.$compileProvider.directive.ngController ngController
-directive} or {@link api/angular.module.ng.$route $route service}.
+You can associate controllers with scope objects explicitly via the {@link api/ng.$rootScope.Scope#$new
+scope.$new} api or implicitly via the {@link api/ng.directive:ngController ngController
+directive} or {@link api/ng.$route $route service}.
 
 
 ## Controller Constructor and Methods Example
@@ -157,7 +157,7 @@ input box) in the second button.
 
 ## Controller Inheritance Example
 
-Controller inheritance in angular is based on {@link api/angular.module.ng.$rootScope.Scope Scope} inheritance. Let's
+Controller inheritance in angular is based on {@link api/ng.$rootScope.Scope Scope} inheritance. Let's
 have a look at an example:
 
 
diff --git a/docs/content/guide/dev_guide.mvc.understanding_model.ngdoc b/docs/content/guide/dev_guide.mvc.understanding_model.ngdoc
index 1853e3856758..80e4139b5c31 100644
--- a/docs/content/guide/dev_guide.mvc.understanding_model.ngdoc
+++ b/docs/content/guide/dev_guide.mvc.understanding_model.ngdoc
@@ -30,7 +30,7 @@ occurs in controllers:
 
          
 
-* Use {@link api/angular.module.ng.$compileProvider.directive.ngInit ngInit directive} in templates (for toy/example apps
+* Use {@link api/ng.directive:ngInit ngInit directive} in templates (for toy/example apps
 only, not recommended for real applications):
 
          
@@ -45,7 +45,7 @@ when processing the following template constructs:
    The code above creates a model called "query" on the current scope with the value set to "fluffy
 cloud".
 
-* An iterator declaration in {@link api/angular.module.ng.$compileProvider.directive.ngRepeat ngRepeater}:
+* An iterator declaration in {@link api/ng.directive:ngRepeat ngRepeater}:
 
          

 
diff --git a/docs/content/guide/dev_guide.mvc.understanding_view.ngdoc b/docs/content/guide/dev_guide.mvc.understanding_view.ngdoc
index 7c6b2e5ab768..71ee81b02062 100644
--- a/docs/content/guide/dev_guide.mvc.understanding_view.ngdoc
+++ b/docs/content/guide/dev_guide.mvc.understanding_view.ngdoc
@@ -9,8 +9,8 @@ the DOM based on information in the template, controller and model.
 
 In the angular implementation of MVC, the view has knowledge of both the model and the controller.
 The view knows about the model where two-way data-binding occurs. The view has knowledge of the
-controller through angular directives, such as {@link api/angular.module.ng.$compileProvider.directive.ngController
-ngController} and {@link api/angular.module.ng.$compileProvider.directive.ngView ngView}, and through bindings of this form:
+controller through angular directives, such as {@link api/ng.directive:ngController
+ngController} and {@link api/ng.directive:ngView ngView}, and through bindings of this form:
 `{{someControllerFunction()}}`. In these ways, the view can call functions in an associated
 controller function.
 
diff --git a/docs/content/guide/dev_guide.services.$location.ngdoc b/docs/content/guide/dev_guide.services.$location.ngdoc
index 209b3abc0cca..b13a47d172c1 100644
--- a/docs/content/guide/dev_guide.services.$location.ngdoc
+++ b/docs/content/guide/dev_guide.services.$location.ngdoc
@@ -89,7 +89,7 @@ setter methods that allow you to get or change the current URL in the browser.
 ## $location service configuration
 
 To configure the `$location` service, retrieve the
-{@link api/angular.module.ng.$locationProvider $locationProvider} and set the parameters as follows:
+{@link api/ng.$locationProvider $locationProvider} and set the parameters as follows:
 
 
 - **html5Mode(mode)**: {boolean}

@@ -134,7 +134,7 @@ current URL without creating a new browser history record you can call:
 

 
 Note that the setters don't update `window.location` immediately. Instead, `$location` service is
-aware of the {@link api/angular.module.ng.$rootScope.Scope scope} life-cycle and coalesces multiple `$location`
+aware of the {@link api/ng.$rootScope.Scope scope} life-cycle and coalesces multiple `$location`
 mutations into one "commit" to the `window.location` object during the scope `$digest` phase. Since
 multiple changes to the $location's state will be pushed to the browser as a single change, it's
 enough to call the `replace()` method just once to make the entire "commit" a replace operation
@@ -489,11 +489,11 @@ In this examples we use ``
 
 The `$location` service allows you to change only the URL; it does not allow you to reload the
 page. When you need to change the URL and reload the page or navigate to a different page, please
-use a lower level API, {@link api/angular.module.ng.$window $window.location.href}.
+use a lower level API, {@link api/ng.$window $window.location.href}.
 
 ## Using $location outside of the scope life-cycle
 
-`$location` knows about Angular's {@link api/angular.module.ng.$rootScope.Scope scope} life-cycle. When a URL changes in
+`$location` knows about Angular's {@link api/ng.$rootScope.Scope scope} life-cycle. When a URL changes in
 the browser it updates the `$location` and calls `$apply` so that all $watchers / $observers are
 notified.
 When you change the `$location` inside the `$digest` phase everything is ok; `$location` will
@@ -513,7 +513,7 @@ hashPrefix.
 # Testing with the $location service
 
 When using `$location` service during testing, you are outside of the angular's {@link
-api/angular.module.ng.$rootScope.Scope scope} life-cycle. This means it's your responsibility to call `scope.$apply()`.
+api/ng.$rootScope.Scope scope} life-cycle. This means it's your responsibility to call `scope.$apply()`.
 
 
 describe('serviceUnderTest', function() {
@@ -612,7 +612,7 @@ then uses the information it obtains to compose hashbang URLs (such as
 
 The Angular's compiler currently does not support two-way binding for methods (see {@link
 https://github.com/angular/angular.js/issues/404 issue}).  If you should require two-way binding
-to the $location object (using {@link api/angular.module.ng.$compileProvider.directive.input.text
+to the $location object (using {@link api/ng.directive:input.text
 ngModel} directive on an input field), you will need to specify an extra model property
 (e.g. `locationPath`) with two watchers which push $location updates in both directions. For
 example:
@@ -634,7 +634,7 @@ $scope.$watch('$location.path()', function(path) {
 
 # Related API
 
-* {@link api/angular.module.ng.$location $location API}
+* {@link api/ng.$location $location API}
 
 
 
diff --git a/docs/content/guide/dev_guide.services.creating_services.ngdoc b/docs/content/guide/dev_guide.services.creating_services.ngdoc
index 891b4dd039b5..060ab38fc90b 100644
--- a/docs/content/guide/dev_guide.services.creating_services.ngdoc
+++ b/docs/content/guide/dev_guide.services.creating_services.ngdoc
@@ -5,7 +5,7 @@
 While angular offers several useful services, for any nontrivial application you'll find it useful
 to write your own custom services. To do this you begin by registering a service factory function
 with a module either via the {@link api/angular.module Module#factory api} or directly
-via the {@link api/angular.module.AUTO.$provide $provide} api inside of module config function.
+via the {@link api/AUTO.$provide $provide} api inside of module config function.
 
 All angular services participate in {@link di dependency injection (DI)} by registering
 themselves with Angular's DI system (injector) under a `name` (id) as well as by declaring
@@ -18,7 +18,7 @@ testable.
 
 To register a service, you must have a module that this service will be part of. Afterwards, you
 can register the service with the module either via the {@link api/angular.Module Module api} or
-by using the {@link api/angular.module.AUTO.$provide $provide} service in the module configuration
+by using the {@link api/AUTO.$provide $provide} service in the module configuration
 function.The following pseudo-code shows both approaches:
 
 Using the angular.Module api:
@@ -101,4 +101,4 @@ important.
 
 ## Related API
 
-* {@link api/angular.module.ng Angular Service API}
+* {@link api/ng Angular Service API}
diff --git a/docs/content/guide/dev_guide.services.injecting_controllers.ngdoc b/docs/content/guide/dev_guide.services.injecting_controllers.ngdoc
index ff674369407a..2da7c248cb7b 100644
--- a/docs/content/guide/dev_guide.services.injecting_controllers.ngdoc
+++ b/docs/content/guide/dev_guide.services.injecting_controllers.ngdoc
@@ -115,4 +115,4 @@ dependencies with the `$inject` property.
 
 ## Related API
 
-{@link api/angular.module.ng Angular Service API}
+{@link api/ng Angular Service API}
diff --git a/docs/content/guide/dev_guide.services.managing_dependencies.ngdoc b/docs/content/guide/dev_guide.services.managing_dependencies.ngdoc
index 01c261469a57..54d7a5d1023a 100644
--- a/docs/content/guide/dev_guide.services.managing_dependencies.ngdoc
+++ b/docs/content/guide/dev_guide.services.managing_dependencies.ngdoc
@@ -88,10 +88,10 @@ provided by Angular's web framework:
 
 Things to notice in this example:
 
-* The `batchLog` service depends on the built-in {@link api/angular.module.ng.$defer $defer} and
-{@link api/angular.module.ng.$log $log} services, and allows messages to be logged into the
+* The `batchLog` service depends on the built-in {@link api/ng.$defer $defer} and
+{@link api/ng.$log $log} services, and allows messages to be logged into the
 `console.log` in batches.
-* The `routeTemplateMonitor` service depends on the built-in {@link api/angular.module.ng.$route
+* The `routeTemplateMonitor` service depends on the built-in {@link api/ng.$route
 $route} service as well as our custom `batchLog` service.
 * Both of our services use the factory function signature and array notation for inject annotations
 to declare their dependencies. It is important that the order of the string identifiers in the array
@@ -110,5 +110,5 @@ that the injector uses to determine which services and in which order to inject.
 
 ## Related API
 
-* {@link api/angular.module.ng Angular Service API}
+* {@link api/ng Angular Service API}
 * {@link api/angular.injector Angular Injector API}
diff --git a/docs/content/guide/dev_guide.services.ngdoc b/docs/content/guide/dev_guide.services.ngdoc
index 022f541ac93a..a090146a5976 100644
--- a/docs/content/guide/dev_guide.services.ngdoc
+++ b/docs/content/guide/dev_guide.services.ngdoc
@@ -18,4 +18,4 @@ most often used with {@link di dependency injection}, also a key feature of angu
 
 ## Related API
 
-* {@link api/angular.module.ng Angular Service API}
+* {@link api/ng Angular Service API}
diff --git a/docs/content/guide/dev_guide.services.testing_services.ngdoc b/docs/content/guide/dev_guide.services.testing_services.ngdoc
index d867215b7735..d6e5e4cef0d3 100644
--- a/docs/content/guide/dev_guide.services.testing_services.ngdoc
+++ b/docs/content/guide/dev_guide.services.testing_services.ngdoc
@@ -59,4 +59,4 @@ it('should clear messages after alert', function() {
 
 ## Related API
 
-* {@link api/angular.module.ng Angular Service API}
+* {@link api/ng Angular Service API}
diff --git a/docs/content/guide/dev_guide.services.understanding_services.ngdoc b/docs/content/guide/dev_guide.services.understanding_services.ngdoc
index d7a8a0f459f4..a580c2a5cd0f 100644
--- a/docs/content/guide/dev_guide.services.understanding_services.ngdoc
+++ b/docs/content/guide/dev_guide.services.understanding_services.ngdoc
@@ -3,7 +3,7 @@
 @description
 
 Angular services are singletons that carry out specific tasks common to web apps, such as the
-{@link api/angular.module.ng.$http $http service} that provides low level access to the browser's
+{@link api/ng.$http $http service} that provides low level access to the browser's
 `XMLHttpRequest` object.
 
 To use an angular service, you identify it as a dependency for the dependent (a controller, or
@@ -32,5 +32,5 @@ above). You can also create your own custom services.
 
 ## Related API
 
-* {@link api/angular.module.ng Angular Service API}
+* {@link api/ng Angular Service API}
 * {@link api/angular.injector Injector API}
diff --git a/docs/content/guide/dev_guide.templates.css-styling.ngdoc b/docs/content/guide/dev_guide.templates.css-styling.ngdoc
index 1a2b2ac51a6b..f88ec6f31479 100644
--- a/docs/content/guide/dev_guide.templates.css-styling.ngdoc
+++ b/docs/content/guide/dev_guide.templates.css-styling.ngdoc
@@ -9,10 +9,10 @@ Angular sets these CSS classes. It is up to your application to provide useful s
 
 * `ng-invalid`, `ng-valid`
   - **Usage:** angular applies this class to an input widget element if that element's input does
-    notpass validation. (see {@link api/angular.module.ng.$compileProvider.directive.input input} directive).
+    notpass validation. (see {@link api/ng.directive:input input} directive).
 
 * `ng-pristine`, `ng-dirty`
-  - **Usage:** angular {@link api/angular.module.ng.$compileProvider.directive.input input} directive applies `ng-pristine` class
+  - **Usage:** angular {@link api/ng.directive:input input} directive applies `ng-pristine` class
     to a new input widget element which did not have user interaction. Once the user interacts with
     the input widget the class is changed to `ng-dirty`.
 
diff --git a/docs/content/guide/dev_guide.templates.filters.creating_filters.ngdoc b/docs/content/guide/dev_guide.templates.filters.creating_filters.ngdoc
index b21e6f0c005e..b497a0861ae7 100644
--- a/docs/content/guide/dev_guide.templates.filters.creating_filters.ngdoc
+++ b/docs/content/guide/dev_guide.templates.filters.creating_filters.ngdoc
@@ -57,4 +57,4 @@ text upper-case and assigns color.
 
 ## Related API
 
-* {@link api/angular.module.ng.$filter Angular Filter API}
+* {@link api/ng.$filter Angular Filter API}
diff --git a/docs/content/guide/dev_guide.templates.filters.ngdoc b/docs/content/guide/dev_guide.templates.filters.ngdoc
index 0308edb251fe..9456ad1821fe 100644
--- a/docs/content/guide/dev_guide.templates.filters.ngdoc
+++ b/docs/content/guide/dev_guide.templates.filters.ngdoc
@@ -12,7 +12,7 @@ displaying it to the user. You can pass expressions through a chain of filters l
         name | uppercase
 
 The expression evaluator simply passes the value of name to
-{@link api/angular.module.ng.$filter.uppercase uppercase filter}.
+{@link api/ng.filter:uppercase uppercase filter}.
 
 In addition to formatting data, filters can also modify the DOM. This allows filters to handle
 tasks such as conditionally applying CSS styles to filtered output.
@@ -25,4 +25,4 @@ tasks such as conditionally applying CSS styles to filtered output.
 
 ## Related API
 
-* {@link api/angular.module.ng.$filter Angular Filter API}
+* {@link api/ng.$filter Angular Filter API}
diff --git a/docs/content/guide/dev_guide.templates.filters.using_filters.ngdoc b/docs/content/guide/dev_guide.templates.filters.using_filters.ngdoc
index a159e1f5a6f2..9de4c943b935 100644
--- a/docs/content/guide/dev_guide.templates.filters.using_filters.ngdoc
+++ b/docs/content/guide/dev_guide.templates.filters.using_filters.ngdoc
@@ -2,7 +2,7 @@
 @name Developer Guide: Templates: Filters: Using Angular Filters
 @description
 
-Filters can be part of any {@link api/angular.module.ng.$rootScope.Scope} evaluation but are typically used to format
+Filters can be part of any {@link api/ng.$rootScope.Scope} evaluation but are typically used to format
 expressions in bindings in your templates:
 
         {{ expression | filter }}
@@ -37,4 +37,4 @@ argument that specifies how many digits to display to the right of the decimal p
 
 ## Related API
 
-* {@link api/angular.module.ng.$filter Angular Filter API}
+* {@link api/ng.$filter Angular Filter API}
diff --git a/docs/content/guide/dev_guide.templates.ngdoc b/docs/content/guide/dev_guide.templates.ngdoc
index f0c0f28018ad..c349f9e28d50 100644
--- a/docs/content/guide/dev_guide.templates.ngdoc
+++ b/docs/content/guide/dev_guide.templates.ngdoc
@@ -12,7 +12,7 @@ These are the types of angular elements and element attributes you can use in a
 
 * {@link guide/directive Directive} — An attribute or element that
   augments an existing DOM element or represents a reusable DOM component - a widget.
-* {@link api/angular.module.ng.$interpolate  Markup} — The double
+* {@link api/ng.$interpolate Markup} — The double
 curly brace notation `{{ }}` to bind expressions to elements is built-in angular markup.
 * {@link dev_guide.templates.filters Filter} — Formats your data for display to the user.
 * {@link forms Form controls} — Lets you validate user input.
@@ -41,8 +41,8 @@ with {@link expression expressions}:
 In a simple single-page app, the template consists of HTML, CSS, and angular directives contained
 in just one HTML file (usually `index.html`). In a more complex app, you can display multiple views
 within one main page using "partials", which are segments of template located in separate HTML
-files.  You "include" the partials in the main page using the {@link api/angular.module.ng.$route
-$route} service in conjunction with the {@link api/angular.module.ng.$compileProvider.directive.ngView ngView} directive. An
+files.  You "include" the partials in the main page using the {@link api/ng.$route
+$route} service in conjunction with the {@link api/ng.directive:ngView ngView} directive. An
 example of this technique is shown in the {@link tutorial/ angular tutorial}, in steps seven and
 eight.
 
diff --git a/docs/content/guide/dev_guide.unit-testing.ngdoc b/docs/content/guide/dev_guide.unit-testing.ngdoc
index 2083f2e4b416..fe3db075ecbb 100644
--- a/docs/content/guide/dev_guide.unit-testing.ngdoc
+++ b/docs/content/guide/dev_guide.unit-testing.ngdoc
@@ -247,7 +247,7 @@ that such a test tells a story, rather then asserting random bits which don't se
 
 
 ## Filters
-{@link api/angular.module.ng.$filter Filters} are functions which transform the data into user readable
+{@link api/ng.$filter Filters} are functions which transform the data into user readable
 format. They are important because they remove the formatting responsibility from the application
 logic, further simplifying the application logic.
 
diff --git a/docs/content/guide/directive.ngdoc b/docs/content/guide/directive.ngdoc
index 8657a5d4406f..975eab1f649f 100644
--- a/docs/content/guide/directive.ngdoc
+++ b/docs/content/guide/directive.ngdoc
@@ -55,11 +55,11 @@ the following example.
 
 # String interpolation
 
-During the compilation process the {@link api/angular.module.ng.$compile compiler} matches text and
-attributes using the {@link api/angular.module.ng.$interpolate $interpolate} service to see if they
+During the compilation process the {@link api/ng.$compile compiler} matches text and
+attributes using the {@link api/ng.$interpolate $interpolate} service to see if they
 contain embedded expressions. These expressions are registered as {@link
-api/angular.module.ng.$rootScope.Scope#$watch watches} and will update as part of normal {@link
-api/angular.module.ng.$rootScope.Scope#$digest digest} cycle. An example of interpolation is shown
+api/ng.$rootScope.Scope#$watch watches} and will update as part of normal {@link
+api/ng.$rootScope.Scope#$digest digest} cycle. An example of interpolation is shown
 here:
 
 
@@ -74,21 +74,21 @@ Compilation of HTML happens in three phases:
   realize because the templates must be parsable HTML. This is in contrast to most templating
   systems that operate on strings, rather then on DOM elements.
 
-  2. The compilation of the DOM is performed by the call to {@link api/angular.module.ng.$compile
+  2. The compilation of the DOM is performed by the call to {@link api/ng.$compile
   $compile()} method. The method traverses the DOM and matches the directives. If a match is found
   it is added to the list of directives associated with the given DOM element. Once all directives
   for a given DOM element have been identified they are sorted by priority and their `compile()`
   functions are executed. The directive compile function has a chance to modify the DOM structure
   and is responsible for producing a `link()` function explained next. The {@link
-  api/angular.module.ng.$compile $compile()} method returns a combined linking function, which is a
+  api/ng.$compile $compile()} method returns a combined linking function, which is a
   collection of all of the linking functions returned from the individual directive compile
   functions.
 
   3. Link the template with scope by calling the linking function returned from the previous step.
   This in turn will call the linking function of the individual directives allowing them to
   register any listeners on the elements and set up any {@link
-  api/angular.module.ng.$rootScope.Scope#$watch watches} with the {@link
-  api/angular.module.ng.$rootScope.Scope scope}. The result of this is a live binding between the
+  api/ng.$rootScope.Scope#$watch watches} with the {@link
+  api/ng.$rootScope.Scope scope}. The result of this is a live binding between the
   scope and the DOM. A change in the scope is reflected in the DOM.
 
 
@@ -125,14 +125,14 @@ The short answer is that compile and link separation is needed any time a change
 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 api/angular.module.ng.$interpolate interpolation} directive. {@link
-api/angular.module.ng.$compileProvider.directive.ngRepeat ngRepeat} is another directive. But {@link
-api/angular.module.ng.$compileProvider.directive.ngRepeat ngRepeat} has a dilemma. It needs to be
+`{{user}}` is an example of {@link api/ng.$interpolate interpolation} directive. {@link
+api/ng.directive:ngRepeat ngRepeat} is another directive. But {@link
+api/ng.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
 is not enough. It also needs to compile the `li` so that its directives such as
-`{{action.descriptions}}` evaluate against the right {@link api/angular.module.ng.$rootScope.Scope
+`{{action.descriptions}}` evaluate against the right {@link api/ng.$rootScope.Scope
 scope}. A naive method would be to simply insert a copy of the `li` element and then compile it.
 But compiling on every `li` element clone would be slow, since the compilation requires that we
 traverse the DOM tree and look for directives and execute them. If we put the compilation inside a
@@ -140,17 +140,17 @@ repeater which needs to unroll 100 items we would quickly run into performance p
 
 The solution is to break the compilation process into two phases the compile phase where all of
 the directives are identified and sorted by priority, and a linking phase where any work which
-links a specific instance of the {@link api/angular.module.ng.$rootScope.Scope scope} and the specific
+links a specific instance of the {@link api/ng.$rootScope.Scope scope} and the specific
 instance of an `li` is performed.
 
-{@link api/angular.module.ng.$compileProvider.directive.ngRepeat ngRepeat} works by preventing the
+{@link api/ng.directive:ngRepeat ngRepeat} works by preventing the
 compilation process form descending into `li` element. Instead the {@link
-api/angular.module.ng.$compileProvider.directive.ngRepeat ngRepeat} directive compiles `li`
+api/ng.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 api/angular.module.ng.$compileProvider.directive.ngRepeat ngRepeat}
+element. At runtime the {@link api/ng.directive:ngRepeat ngRepeat}
 watches the expression and as items are added to the array it clones the `li` element, creates a
-new {@link api/angular.module.ng.$rootScope.Scope scope} for the cloned `li` element and calls the
+new {@link api/ng.$rootScope.Scope scope} for the cloned `li` element and calls the
 link function on the cloned `li`.
 
 Summary:
@@ -288,14 +288,14 @@ further simplification:
 ## Factory method
 
 The factory method is responsible for creating the directive. It is invoked only once, when the
-{@link api/angular.module.ng.$compile compiler} matches the directive for the first time. You can
+{@link api/ng.$compile compiler} matches the directive for the first time. You can
 perform any initialization work here. The method is invoked using the {@link
-http://localhost:8000/build/docs/api/angular.module.AUTO.$injector#invoke $injector.invoke} which
+http://localhost:8000/build/docs/api/AUTO.$injector#invoke $injector.invoke} which
 makes it injectable following all of the rules of injection annotation.
 
 ## Directive Definition Object
 
-The directive definition object provides instructions to the {@link api/angular.module.ng.$compile
+The directive definition object provides instructions to the {@link api/ng.$compile
 compiler}. The attributes are:
 
   * `name` - Name of the current scope. Optional defaults to the name at registration.
@@ -387,7 +387,7 @@ 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.ngTransclude
+    Typically used with {@link api/ng.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`
@@ -412,8 +412,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
-api/angular.module.ng.$compileProvider.directive.ngRepeat ngRepeat} or load the contents
-asynchronously such as {@link api/angular.module.ng.$compileProvider.directive.ngView ngView}. The
+api/ng.directive:ngRepeat ngRepeat} or load the contents
+asynchronously such as {@link api/ng.directive:ngView ngView}. The
 compile functions takes the following arguments.
 
   * `tElement` - template element - The element where the directive has been declared. It is
@@ -450,8 +450,8 @@ Link function is responsible for registering DOM listeners as well as updating t
 executed after the template has been cloned. This is where most of the directive logic will be
 put.
 
-  * `scope` - {@link api/angular.module.ng.$rootScope.Scope Scope} - The scope to be used by the
-    directive for registering {@link api/angular.module.ng.$rootScope.Scope#$watch watches}.
+  * `scope` - {@link api/ng.$rootScope.Scope Scope} - The scope to be used by the
+    directive for registering {@link api/ng.$rootScope.Scope#$watch watches}.
 
   * `iElement` - instance element - The element where the directive is to be used. It is safe to
     manipulate the children of the element only in `postLink` function since the children have
diff --git a/docs/content/guide/expression.ngdoc b/docs/content/guide/expression.ngdoc
index 28edcc22a994..770e356ebd05 100644
--- a/docs/content/guide/expression.ngdoc
+++ b/docs/content/guide/expression.ngdoc
@@ -3,7 +3,7 @@
 @description
 
 Expressions are JavaScript-like code snippets that are usually placed in bindings such as `{{
-expression }}`. Expressions are process by the {@link api/angular.module.ng.$parse $parse}
+expression }}`. Expressions are process by the {@link api/ng.$parse $parse}
 service.
 
 For example, these are all valid expressions in angular:
@@ -35,7 +35,7 @@ differences:
 
 If, on the other hand, you do want to run arbitrary JavaScript code, you should make it a
 controller method and call the method. If you want to `eval()` an angular expression from
-JavaScript, use the {@link api/angular.module.ng.$rootScope.Scope#$eval `$eval()`} method.
+JavaScript, use the {@link api/ng.$rootScope.Scope#$eval `$eval()`} method.
 
 ## Example
 
@@ -92,7 +92,7 @@ You can try evaluating different expressions here:
 # Property Evaluation
 
 Evaluation of all properties takes place against a scope. Unlike JavaScript, where names default
-to global window properties, angular expressions have to use {@link api/angular.module.ng.$window
+to global window properties, angular expressions have to use {@link api/ng.$window
 `$window`} to refer to the global `window` object. For example, if you want to call `alert()`, which is
 defined on `window`, in an expression must use `$window.alert()`. This is done intentionally to
 prevent accidental access to the global state (a common source of subtle bugs).
@@ -162,7 +162,7 @@ of filters like this:
        name | uppercase
 
 The expression evaluator simply passes the value of name to {@link
-api/angular.module.ng.$filter.uppercase `uppercase`} filter.
+api/ng.filter:uppercase `uppercase`} filter.
 
 Chain filters using this syntax:
 
diff --git a/docs/content/guide/forms.ngdoc b/docs/content/guide/forms.ngdoc
index c21ffc937416..b3bfcb30bbd3 100644
--- a/docs/content/guide/forms.ngdoc
+++ b/docs/content/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.ngModel ngModel}.
+The key directive in understanding two-way data-binding is  {@link api/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 {@link api/angular.module.ng.$compileProvider.directive.ngModel.NgModelController API} for other directives to augment its behavior.
+In addition it provides {@link api/ng.directive:ngModel.NgModelController API} for other directives to augment its behavior.
 
 
 
@@ -113,9 +113,9 @@ This ensures that the user is not distracted with an error until after interacti
 
 # Binding to form and control state
 
-A form is in instance of {@link api/angular.module.ng.$compileProvider.directive.form.FormController FormController}.
+A form is in instance of {@link api/ng.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.ngModel.NgModelController NgModelController}.
+Similarly control is an instance of {@link api/ng.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.
 
@@ -178,19 +178,19 @@ This allows us to extend the above example with these features:
 
 # Custom Validation
 
-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`).
+Angular provides basic implementation for most common html5 {@link api/ng.directive:input input}
+types: ({@link api/ng.directive:input.text text}, {@link api/ng.directive:input.number number}, {@link api/ng.directive:input.url url}, {@link api/ng.directive:input.email email}, {@link api/ng.directive:input.radio radio}, {@link api/ng.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 `ngModel` {@link api/angular.module.ng.$compileProvider.directive.ngModel.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/ng.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.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}.
+    Whenever the bound model changes, all functions in {@link   api/ng.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/ng.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.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 a similar way, whenever a user interacts with a control, the controll calls {@link api/ng.directive:ngModel.NgModelController#$setViewValue NgModelController#$setViewValue}.
+This in turn pipelines all functions in {@link api/ng.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/ng.directive:ngModel.NgModelController#$setValidity NgModelController#$setValidity}.
 
 In the following example we create two directives.
 
@@ -273,12 +273,12 @@ In the following example we create two directives.
 
 
 # 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.
+Angular implements all of the basic HTML form controls ({@link api/ng.directive:input input}, {@link api/ng.directive:select select}, {@link api/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   api/angular.module.ng.$compileProvider.directive.ngModel.NgModelController#$formatters NgModelController#$formatters},
+  - implement `render` method, which is responsible for rendering the data after it passed the {@link   api/ng.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 guide/directive $compileProvider.directive} for more info.
diff --git a/docs/content/guide/i18n.ngdoc b/docs/content/guide/i18n.ngdoc
index ba88a2e7c731..946f16c071ea 100644
--- a/docs/content/guide/i18n.ngdoc
+++ b/docs/content/guide/i18n.ngdoc
@@ -17,15 +17,15 @@ abstracted bits.
 **What level of support for i18n/l10n is currently in Angular?**
 
 Currently, Angular supports i18n/l10n for {@link
-http://docs.angularjs.org/#!/api/angular.module.ng.$filter.date datetime}, {@link
-http://docs.angularjs.org/#!/api/angular.module.ng.$filter.number number} and {@link
-http://docs.angularjs.org/#!/api/angular.module.ng.$filter.currency currency} filters.
+http://docs.angularjs.org/#!/api/ng.filter:date datetime}, {@link
+http://docs.angularjs.org/#!/api/ng.filter:number number} and {@link
+http://docs.angularjs.org/#!/api/ng.filter:currency currency} filters.
 
 Additionally, Angular supports localizable pluralization support provided by the {@link
-api/angular.module.ng.$compileProvider.directive.ngPluralize ngPluralize directive}.
+api/ng.directive:ngPluralize ngPluralize directive}.
 
 All localizable Angular components depend on locale-specific rule sets managed by the {@link
-api/angular.module.ng.$locale $locale service}.
+api/ng.$locale $locale service}.
 
 For readers who want to jump straight into examples, we have a few web pages that showcase how to
 use Angular filters with various locale rule sets. You can find these examples either on {@link
@@ -90,8 +90,8 @@ because an extra script needs to be loaded.
 
 **Currency symbol "gotcha"**
 
-Angular's {@link http://docs.angularjs.org/#!/api/angular.module.ng.$filter.currency currency filter} allows
-you to use the default currency symbol from the {@link api/angular.module.ng.$locale locale service},
+Angular's {@link http://docs.angularjs.org/#!/api/ng.filter:currency currency filter} allows
+you to use the default currency symbol from the {@link api/ng.$locale locale service},
 or you can provide the filter with a custom currency symbol. If your app will be used only in one
 locale, it is fine to rely on the default currency symbol. However, if you anticipate that viewers
 in other locales might use your app, you should provide your own currency symbol to make sure the
@@ -104,7 +104,7 @@ browser will specify the locale as ja, and the balance of '¥1000.00' will be sh
 will really upset your client.
 
 In this case, you need to override the default currency symbol by providing the {@link
-http://docs.angularjs.org/#!/api/angular.module.ng.$filter.currency currency filter} with a currency symbol as
+http://docs.angularjs.org/#!/api/ng.filter:currency currency filter} with a currency symbol as
 a parameter when you configure the filter, for example, {{ 1000 | currency:"USD$"}}. This way,
 Angular will always show a balance of 'USD$1000' and disregard any locale changes.
 
diff --git a/docs/content/guide/overview.ngdoc b/docs/content/guide/overview.ngdoc
index 71eb90e9c713..88dba5ccdbfc 100644
--- a/docs/content/guide/overview.ngdoc
+++ b/docs/content/guide/overview.ngdoc
@@ -132,7 +132,7 @@ These input widgets look normal enough, but consider these points:
   * When this page loaded, angular bound the names of the input widgets (`qty` and `cost`) to
     variables of the same name. Think of those variables as the "Model" component of the
     Model-View-Controller design pattern.
-  * Note that the HTML widget {@link api/angular.module.ng.$compileProvider.directive.input input}
+  * Note that the HTML widget {@link api/ng.directive:input input}
     has special powers. The input invalidates itself by turning red when you enter invalid data or
     leave the the input fields blank. These new widget behavior make it easier to implement field
     validation common in CRUD applications.
diff --git a/docs/content/guide/scope.ngdoc b/docs/content/guide/scope.ngdoc
index dac69d8abd18..ac0089c96d54 100644
--- a/docs/content/guide/scope.ngdoc
+++ b/docs/content/guide/scope.ngdoc
@@ -4,32 +4,32 @@
 
 # What are Scopes?
 
-{@link api/angular.module.ng.$rootScope.Scope scope} is an object that refers to the application
+{@link api/ng.$rootScope.Scope scope} is an object that refers to the application
 model. It is an execution context for {@link expression expressions}. Scopes are
 arranged in hierarchical structure which mimic the DOM structure of the application. Scopes can
 watch {@link guide/expression expressions} and propagate events.
 
 ## Scope characteristics
 
-  - Scopes provide APIs ({@link api/angular.module.ng.$rootScope.Scope#$watch $watch}) to observe
+  - Scopes provide APIs ({@link api/ng.$rootScope.Scope#$watch $watch}) to observe
     model mutations.
 
-  - Scopes provide APIs ({@link api/angular.module.ng.$rootScope.Scope#$apply $apply}) to
+  - Scopes provide APIs ({@link api/ng.$rootScope.Scope#$apply $apply}) to
     propagate any model changes through the system into the view from outside of the "Angular
     realm" (controllers, services, Angular event handlers).
 
   - Scopes can be nested to isolate application components while providing access to shared model
     properties. A scope (prototypically) inherits properties from its parent scope.
 
-  - Scopes provide context against which {@link guide/expression expressions} are evaluated. For 
+  - Scopes provide context against which {@link guide/expression expressions} are evaluated. For
     example `{{username}}` expression is meaningless, unless it is evaluated against a specific
     scope which defines the `username` property.
 
 ## Scope as Data-Model
 
 Scope is the glue between application controller and the view. During the template {@link compiler
-linking} phase the {@link api/angular.module.ng.$compileProvider.directive directives} set up
-{@link api/angular.module.ng.$rootScope.Scope#$watch `$watch`} expressions on the scope. The
+linking} phase the {@link api/ng.$compileProvider.directive directives} set up
+{@link api/ng.$rootScope.Scope#$watch `$watch`} expressions on the scope. The
 `$watch` allows the directives to be notified of property changes, which allows the directive to
 render the updated value to the DOM.
 
@@ -102,7 +102,7 @@ to test the behavior without being distracted by the rendering details.
 
 ## Scope Hierarchies
 
-Each Angular application has exactly one {@link api/angular.module.ng.$rootScope root scope}, but
+Each Angular application has exactly one {@link api/ng.$rootScope root scope}, but
 may have several child scopes.
 
 The application can have multiple scopes, because some {@link guide/directive directives} create
@@ -164,7 +164,7 @@ where the `department` property is defined.
 Scopes are attached to the DOM as `$scope` data property, and can be retrieved for debugging
 purposes. (It is unlikely that one would need to retrieve scopes in this way inside the
 application.) The location where the root scope is attached to the DOM is defined by the location
-of {@link api/angular.module.ng.$compileProvider.directive.ngApp `ng-app`} directive. Typically
+of {@link api/ng.directive:ngApp `ng-app`} directive. Typically
 `ng-app` is placed an the `` element, but it can be placed on other elements as well, if,
 for example, only a portion of the view needs to be controlled by angular.
 
@@ -182,8 +182,8 @@ To examine the scope in the debugger:
 ## Scope Events Propagation
 
 Scopes can propagate events in similar fashion to DOM events. The event can be {@link
-api/angular.module.ng.$rootScope.Scope#$broadcast broadcasted} to the scope children or {@link
-api/angular.module.ng.$rootScope.Scope#$emit emitted} to scope parents.
+api/ng.$rootScope.Scope#$broadcast broadcasted} to the scope children or {@link
+api/ng.$rootScope.Scope#$emit emitted} to scope parents.
 
 
   
@@ -225,14 +225,14 @@ more events.
 When the browser calls into JavaScript the code executes outside they Angular execution context,
 which means that Angular is unaware of model modifications. To properly process model
 modifications the execution has to enter the Angular execution context using the {@link
-api/angular.module.ng.$rootScope.Scope#$apply `$apply`} method. Only model modifications which
+api/ng.$rootScope.Scope#$apply `$apply`} method. Only model modifications which
 execute inside the `$apply` method will be properly accounted for by Angular. For example if a
 directive listens on DOM events, such as {@link
-api/angular.module.ng.$compileProvider.directive.ngClick `ng-click`} it must evaluate the
+api/ng.directive:ngClick `ng-click`} it must evaluate the
 expression inside the `$apply` method.
 
 After evaluating the expression `$apply` method performs a {@link
-api/angular.module.ng.$rootScope.Scope#$digest `$digest`}. In $digest phase the scope examines all
+api/ng.$rootScope.Scope#$digest `$digest`}. In $digest phase the scope examines all
 of the `$watch` expressions and compares them with previous value. This dirty checking, is done
 asynchronously. This means that assignment such as `$scope.username="angular"` will not
 immediately cause a `$watch` to be notified, instead the `$watch` notification is delayed until
@@ -243,27 +243,27 @@ the `$digest` phase. This delay is desirable, since it coalesces multiple model
 
   1. **Creation**
 
-     The {@link api/angular.module.ng.$rootScope root scope} is created during the application
-     bootstrap by the {@link api/angular.module.AUTO.$injector $injector}. During template
+     The {@link api/ng.$rootScope root scope} is created during the application
+     bootstrap by the {@link api/AUTO.$injector $injector}. During template
      linking, some directives create new child scopes.
 
   2. **Watcher registration**
 
      During template linking directives register {@link
-     api/angular.module.ng.$rootScope.Scope#$watch watches} on the scope. This watches will be
+     api/ng.$rootScope.Scope#$watch watches} on the scope. This watches will be
      used to propagate model values to the DOM.
 
   3. **Model mutation**
 
      For mutations to be properly observed, you should make them only within the {@link
-     api/angular.module.ng.$rootScope.Scope#$apply scope.$apply()}. (Angular apis do this
+     api/ng.$rootScope.Scope#$apply scope.$apply()}. (Angular apis do this
      implicitly, so no extra `$apply` call is needed when doing synchronous work in controllers,
-     or asynchronous work with {@link api/angular.module.ng.$http $http} or {@link
-     api/angular.module.ng.$defer $defer} services.
+     or asynchronous work with {@link api/ng.$http $http} or {@link
+     api/ng.$defer $defer} services.
 
   4. **Mutation observation**
 
-     At the end `$apply`, Angular performs a {@link api/angular.module.ng.$rootScope.Scope#$digest
+     At the end `$apply`, Angular performs a {@link api/ng.$rootScope.Scope#$digest
      $digest} cycle on the root scope, which then propagates throughout all child scopes. During
      the `$digest` cycle, all `$watch`ed expressions or functions are checked for model mutation
      and if a mutation is detected, the `$watch` listener is called.
@@ -271,7 +271,7 @@ the `$digest` phase. This delay is desirable, since it coalesces multiple model
   5. **Scope destruction**
 
      When child scopes are no longer needed, it is the responsibility of the child scope creator
-     to destroy them via {@link api/angular.module.ng.$rootScope.Scope#$destroy scope.$destroy()}
+     to destroy them via {@link api/ng.$rootScope.Scope#$destroy scope.$destroy()}
      API. This will stop propagation of `$digest` calls into the child scope and allow for memory
      used by the child scope models to be reclaimed by the garbage collector.
 
@@ -279,30 +279,30 @@ the `$digest` phase. This delay is desirable, since it coalesces multiple model
 ### Scopes and Directives
 
 During the compilation phase, the {@link compiler compiler} matches {@link
-api/angular.module.ng.$compileProvider.directive directives} against the DOM template. The directives
+api/ng.$compileProvider.directive directives} against the DOM template. The directives
 usually fall into one of two categories:
 
-  - Observing {@link api/angular.module.ng.$compileProvider.directive directives}, such as
+  - Observing {@link api/ng.$compileProvider.directive directives}, such as
     double-curly expressions `{{expression}}`, register listeners using the {@link
-    api/angular.module.ng.$rootScope.Scope#$watch $watch()} method. This type of directive needs
+    api/ng.$rootScope.Scope#$watch $watch()} method. This type of directive needs
     to be notified whenever the expression changes so that it can update the view.
 
-  - Listener directives, such as {@link api/angular.module.ng.$compileProvider.directive.ngClick
+  - Listener directives, such as {@link api/ng.directive:ngClick
     ng-click}, register a listener with the DOM. When the DOM listener fires, the directive
     executes the associated expression and updates the view using the {@link
-    api/angular.module.ng.$rootScope.Scope#$apply $apply()} method.
+    api/ng.$rootScope.Scope#$apply $apply()} method.
 
 When an external event (such as a user action, timer or XHR) is received, the associated {@link
 expression expression} must be applied to the scope through the {@link
-api/angular.module.ng.$rootScope.Scope#$apply $apply()} method so that all listeners are updated
+api/ng.$rootScope.Scope#$apply $apply()} method so that all listeners are updated
 correctly.
 
 ### Directives that Create Scopes
 
-In most cases, {@link api/angular.module.ng.$compileProvider.directive directives} and scopes interact
+In most cases, {@link api/ng.$compileProvider.directive directives} and scopes interact
 but do not create new instances of scope. However, some directives, such as {@link
-api/angular.module.ng.$compileProvider.directive.ngController ng-controller} and {@link
-api/angular.module.ng.$compileProvider.directive.ngRepeat ng-repeat}, create new child scopes
+api/ng.directive:ngController ng-controller} and {@link
+api/ng.directive:ngRepeat ng-repeat}, create new child scopes
 and attach the child scope to the corresponding DOM element. You can retrieve a scope for any DOM
 element by using an `angular.element(aDomElement).scope()` method call.
 
@@ -311,14 +311,14 @@ element by using an `angular.element(aDomElement).scope()` method call.
 Scopes and controllers interact with each other in the following situations:
 
    - Controllers use scopes to expose controller methods to templates (see {@link
-     api/angular.module.ng.$compileProvider.directive.ngController ng-controller}).
+     api/ng.directive:ngController ng-controller}).
 
    - Controllers define methods (behavior) that can mutate the model (properties on the scope).
 
-   - Controllers may register {@link api/angular.module.ng.$rootScope.Scope#$watch watches} on
+   - Controllers may register {@link api/ng.$rootScope.Scope#$watch watches} on
      the model. These watches execute immediately after the controller behavior executes.
 
-See the {@link api/angular.module.ng.$compileProvider.directive.ngController ng-controller} for more
+See the {@link api/ng.directive:ngController ng-controller} for more
 information.
 
 
diff --git a/docs/content/misc/faq.ngdoc b/docs/content/misc/faq.ngdoc
index 1d2deac25916..f32333e8e7a4 100644
--- a/docs/content/misc/faq.ngdoc
+++ b/docs/content/misc/faq.ngdoc
@@ -68,7 +68,7 @@ manipulate the DOM.
 ### What is testability like in angular?
 
 Very testable. It has an integrated dependency injection framework. See
-{@link api/angular.module.ng service} for details.
+{@link api/ng service} for details.
 
 ### How can I learn more about angular?
 
diff --git a/docs/content/tutorial/step_00.ngdoc b/docs/content/tutorial/step_00.ngdoc
index 92f60991df3e..7565595d0c00 100644
--- a/docs/content/tutorial/step_00.ngdoc
+++ b/docs/content/tutorial/step_00.ngdoc
@@ -184,7 +184,7 @@ __`app/index.html`:__
 
   This code downloads the `angular.js` script and registers a callback that will be executed by the
 browser when the containing HTML page is fully downloaded. When the callback is executed, Angular
-looks for the {@link api/angular.module.ng.$compileProvider.directive.ngApp ngApp} directive. If
+looks for the {@link api/ng.directive:ngApp ngApp} directive. If
 Angular finds the directive, it will bootstrap the application with the root of the application DOM
 being the element on which the `ngApp` directive was defined.
 
@@ -215,10 +215,10 @@ for most cases. In advanced cases, such as when using script loaders, you can us
 
 There are 3 important things that happen during the app bootstrap:
 
-1. The {@link api/angular.module.AUTO.$injector injector} that will be used for dependency injection
+1. The {@link api/AUTO.$injector injector} that will be used for dependency injection
    within this app is created.
 
-2. The injector will then create the {@link api/angular.module.ng.$rootScope root scope} that will
+2. The injector will then create the {@link api/ng.$rootScope root scope} that will
    become the context for the model of our application.
 
 3. Angular will then "compile" the DOM starting at the `ngApp` root element, processing any
diff --git a/docs/content/tutorial/step_02.ngdoc b/docs/content/tutorial/step_02.ngdoc
index 03c7a85225e1..766a386992d6 100644
--- a/docs/content/tutorial/step_02.ngdoc
+++ b/docs/content/tutorial/step_02.ngdoc
@@ -52,7 +52,7 @@ __`app/index.html`:__
 

 
 We replaced the hard-coded phone list with the
-{@link api/angular.module.ng.$compileProvider.directive.ngRepeat ngRepeat directive} and two
+{@link api/ng.directive:ngRepeat ngRepeat directive} and two
 {@link guide/expression Angular expressions} enclosed in curly braces:
 `{{phone.name}}` and `{{phone.snippet}}`:
 
@@ -96,7 +96,7 @@ as follows:
 
 * `PhoneListCtrl` — the name of our controller function (located in the JavaScript file
 `controllers.js`), matches the value of the
-{@link api/angular.module.ng.$compileProvider.directive.ngController ngController} directive located
+{@link api/ng.directive:ngController ngController} directive located
 on the `` tag.
 
 * The phone data is then attached to the *scope* (`$scope`) that was injected into our controller
@@ -110,7 +110,7 @@ contained in the template, data model, and controller, to keep models and views
 sync. Any changes made to the model are reflected in the view; any changes that occur in the view
 are reflected in the model.
 
-  To learn more about Angular scopes, see the {@link api/angular.module.ng.$rootScope.Scope angular scope documentation}.
+  To learn more about Angular scopes, see the {@link api/ng.$rootScope.Scope angular scope documentation}.
 
 
 ## Tests
diff --git a/docs/content/tutorial/step_03.ngdoc b/docs/content/tutorial/step_03.ngdoc
index 26bb9d5fd916..a08561f9781b 100644
--- a/docs/content/tutorial/step_03.ngdoc
+++ b/docs/content/tutorial/step_03.ngdoc
@@ -55,7 +55,7 @@ __`app/index.html`:__
 

 
 We added a standard HTML `` tag and used angular's
-{@link api/angular.module.ng.$filter.filter $filter} function to process the input for the
+{@link api/ng.filter:filter $filter} function to process the input for the
 `ngRepeate` directive.
 
 This lets a user enter search criteria and immediately see the effects of their search on the phone
@@ -71,7 +71,7 @@ the DOM to reflect the current state of the model.
 
       
 
-* Use of `filter` filter. The {@link api/angular.module.ng.$filter.filter filter} function uses the
+* Use of `filter` filter. The {@link api/ng.filter:filter filter} function uses the
 `query` value to create a new array that contains only those records that match the `query`.
 
   `ngRepeat` automatically updates the view in response to the changing number of phones returned
@@ -152,8 +152,8 @@ and title elements:
 
   While using double curlies works fine in within the title element, you might have noticed that
 for a split second they are actually displayed to the user while the page is loading. A better
-solution would be to use the {@link api/angular.module.ng.$compileProvider.directive.ngBind
-ngBind} or {@link api/angular.module.ng.$compileProvider.directive.ngBindTemplate
+solution would be to use the {@link api/ng.directive:ngBind
+ngBind} or {@link api/ng.directive:ngBindTemplate
 ngBindTemplate} directives, which are invisible to the user while the page is loading:
 
           Google Phone Gallery
diff --git a/docs/content/tutorial/step_04.ngdoc b/docs/content/tutorial/step_04.ngdoc
index ca452b59933c..2542e21fdf02 100644
--- a/docs/content/tutorial/step_04.ngdoc
+++ b/docs/content/tutorial/step_04.ngdoc
@@ -47,7 +47,7 @@ two provided sorting options.
 
       
 
-* We then chained the `filter` filter with {@link api/angular.module.ng.$filter.orderBy `orderBy`}
+* We then chained the `filter` filter with {@link api/ng.filter:orderBy `orderBy`}
 filter to further process the input into the repeater. `orderBy` is a filter that takes an input
 array, copies it and reorders the copy which is then returned.
 
diff --git a/docs/content/tutorial/step_05.ngdoc b/docs/content/tutorial/step_05.ngdoc
index e0e6c1fe8006..ef8c28ba0f43 100644
--- a/docs/content/tutorial/step_05.ngdoc
+++ b/docs/content/tutorial/step_05.ngdoc
@@ -6,8 +6,8 @@
 
 
 Enough of building an app with three phones in a hard-coded dataset! Let's fetch a larger dataset
-from our server using one of angular's built-in {@link api/angular.module.ng services} called {@link
-api/angular.module.ng.$http $http}. We will use angular's {@link guide/di dependency
+from our server using one of angular's built-in {@link api/ng services} called {@link
+api/ng.$http $http}. We will use angular's {@link guide/di dependency
 injection (DI)} to provide the service to the `PhoneListCtrl` controller.
 
 
@@ -42,9 +42,9 @@ Following is a sample of the file:
 
 ## Controller
 
-We'll use angular's {@link api/angular.module.ng.$http $http} service in our controller to make an HTTP
+We'll use angular's {@link api/ng.$http $http} service in our controller to make an HTTP
 request to your web server to fetch the data in the `app/phones/phones.json` file. `$http` is just
-one of several built-in {@link api/angular.module.ng angular services} that handle common operations
+one of several built-in {@link api/ng angular services} that handle common operations
 in web apps. Angular injects these services for you where you need them.
 
 Services are managed by angular's {@link guide/di DI subsystem}. Dependency injection
@@ -71,7 +71,7 @@ relative to our `index.html` file). The server responds by providing the data in
 browser and our app they both look the same. For the sake of simplicity we used a json file in this
 tutorial.)
 
-The `$http` service returns a {@link api/angular.module.ng.$q promise object} with a `success`
+The `$http` service returns a {@link api/ng.$q promise object} with a `success`
 method. We call this method to handle the asynchronous response and assign the phone data to the
 scope controlled by this controller, as a model called `phones`. Notice that angular detected the
 json response and parsed it for us!
@@ -155,9 +155,9 @@ use to access and configure the injector.
 We created the controller in the test environment, as follows:
 
 * We used the `inject` helper method to inject instances of
-{@link api/angular.module.ng.$rootScope $rootScope},
-{@link api/angular.module.ng.$controller $controller} and
-{@link api/angular.module.ng.$httpBackend $httpBackend} services into the Jasmine's `beforeEach`
+{@link api/ng.$rootScope $rootScope},
+{@link api/ng.$controller $controller} and
+{@link api/ng.$httpBackend $httpBackend} services into the Jasmine's `beforeEach`
 function. These instances come from an injector which is recreated from scratch for every single
 test. This guarantees that each test starts from a well known starting point and each test is
 isolated from the work done in other tests.
diff --git a/docs/content/tutorial/step_06.ngdoc b/docs/content/tutorial/step_06.ngdoc
index 524b6a019d6f..84c97babcad6 100644
--- a/docs/content/tutorial/step_06.ngdoc
+++ b/docs/content/tutorial/step_06.ngdoc
@@ -61,7 +61,7 @@ now-familiar double-curly brace binding in the `href` attribute values. In step
 the element attribute.
 
 We also added phone images next to each record using an image tag with the {@link
-api/angular.module.ng.$compileProvider.directive.ngSrc ngSrc} directive. That directive prevents the
+api/ng.directive:ngSrc ngSrc} directive. That directive prevents the
 browser from treating the angular `{{ expression }}` markup literally, and initiating a request to
 invalid url `http://localhost:8000/app/{{phone.imageUrl}}`, which it would have done if we had only
 specified an attribute binding in a regular `src` attribute (``).
diff --git a/docs/content/tutorial/step_07.ngdoc b/docs/content/tutorial/step_07.ngdoc
index f0812278445e..01c58c13aa0b 100644
--- a/docs/content/tutorial/step_07.ngdoc
+++ b/docs/content/tutorial/step_07.ngdoc
@@ -36,8 +36,8 @@ our application. Other "partial templates" are then included into this layout te
 the current "route" — the view that is currently displayed to the user.
 
 Application routes in angular are declared via the
-{@link api/angular.module.ng.$routeProvider $routeProvider}, which is the provider of the
-{@link api/angular.module.ng.$route $route service}. This service makes it easy to wire together
+{@link api/ng.$routeProvider $routeProvider}, which is the provider of the
+{@link api/ng.$route $route service}. This service makes it easy to wire together
 controllers, view templates, and the current
 URL location in the browser. Using this feature we can implement {@link
 http://en.wikipedia.org/wiki/Deep_linking deep linking}, which lets us utilize the browser's
@@ -104,11 +104,11 @@ the browser address doesn't match either of our routes.
 Note the use of the `:phoneId` parameter in the second route declaration. The `$route` service uses
 the route declaration — `'/phones/:phoneId'` — as a template that is matched against the current
 URL. All variables defined with the `:` notation are extracted into the
-{@link api/angular.module.ng.$routeParams $routeParams} object.
+{@link api/ng.$routeParams $routeParams} object.
 
 
 In order for our application to bootstrap with our newly created module we'll also need to specify
-the module name as the value of the {@link api/angular.module.ng.$compileProvider.directive.ngApp ngApp}
+the module name as the value of the {@link api/ng.directive:ngApp ngApp}
 directive:
 
 __`app/index.html`:__
@@ -134,7 +134,7 @@ function PhoneDetailCtrl($scope, $routeParams) {
 
 ## Template
 
-The `$route` service is usually used in conjunction with the {@link api/angular.module.ng.$compileProvider.directive.ngView
+The `$route` service is usually used in conjunction with the {@link api/ng.directive:ngView
 ngView} directive. The role of the `ngView` directive is to include the view template for the current
 route into the layout template, which makes it a perfect fit for our `index.html` template.
 
diff --git a/docs/content/tutorial/step_08.ngdoc b/docs/content/tutorial/step_08.ngdoc
index 3892abdfb579..563fff983880 100644
--- a/docs/content/tutorial/step_08.ngdoc
+++ b/docs/content/tutorial/step_08.ngdoc
@@ -15,7 +15,7 @@ phone in the phone list.
 Now when you click on a phone on the list, the phone details page with phone-specific information
 is displayed.
 
-To implement the phone details view we will use {@link api/angular.module.ng.$http $http} to fetch
+To implement the phone details view we will use {@link api/ng.$http $http} to fetch
 our data, and we'll flesh out the `phone-details.html` view template.
 
 The most important changes are listed below. You can see the full diff on {@link
diff --git a/docs/content/tutorial/step_09.ngdoc b/docs/content/tutorial/step_09.ngdoc
index 86e4ffc6979f..67accf25e894 100644
--- a/docs/content/tutorial/step_09.ngdoc
+++ b/docs/content/tutorial/step_09.ngdoc
@@ -121,7 +121,7 @@ output.
 
 # Experiments
 
-* Let's experiment with some of the {@link api/angular.module.ng.$filter built-in angular filters} and add the
+* Let's experiment with some of the {@link api/ng.$filter built-in angular filters} and add the
 following bindings to `index.html`:
   * `{{ "lower cap string" | uppercase }}`
   * `{{ {foo: "bar", baz: 23} | json }}`
diff --git a/docs/content/tutorial/step_10.ngdoc b/docs/content/tutorial/step_10.ngdoc
index 85c14072dea5..b674f280722e 100644
--- a/docs/content/tutorial/step_10.ngdoc
+++ b/docs/content/tutorial/step_10.ngdoc
@@ -63,7 +63,7 @@ __`app/partials/phone-detail.html`:__
 
 We bound the `ngSrc` directive of the large image to the `mainImageUrl` property.
 
-We also registered an {@link api/angular.module.ng.$compileProvider.directive.ngClick `ngClick`}
+We also registered an {@link api/ng.directive:ngClick `ngClick`}
 handler with thumbnail images. When a user clicks on one of the thumbnail images, the handler will
 use the `setImage` event handler function to change the value of the `mainImageUrl` property to the
 url of the thumbnail image.
diff --git a/docs/content/tutorial/step_11.ngdoc b/docs/content/tutorial/step_11.ngdoc
index 0efc5bfb8a53..b5bd2fbe19a2 100644
--- a/docs/content/tutorial/step_11.ngdoc
+++ b/docs/content/tutorial/step_11.ngdoc
@@ -14,7 +14,7 @@ In this step, you will improve the way our app fetches data.
 The last improvement we will make to our app is to define a custom service that represents a {@link
 http://en.wikipedia.org/wiki/Representational_State_Transfer RESTful} client. Using this client we
 can make xhr requests for data in an easier way, without having to deal with the lower-level {@link
-api/angular.module.ng.$http $http} API, HTTP methods and URLs.
+api/ng.$http $http} API, HTTP methods and URLs.
 
 The most important changes are listed below. You can see the full diff on {@link
 https://github.com/angular/angular-phonecat/compare/step-10...step-11
@@ -52,17 +52,17 @@ of the service - 'Phone' - and the factory function. The factory function is sim
 controller's constructor in that both can declare dependencies via function arguments. The Phone
 service declared a dependency on the `$resource` service.
 
-The {@link api/angular.module.ngResource.$resource `$resource`} service makes it easy to create a
+The {@link api/ngResource.$resource `$resource`} service makes it easy to create a
 {@link http://en.wikipedia.org/wiki/Representational_State_Transfer RESTful} client with just a few
 lines of code. This client can then be used in our application, instead of the lower-level {@link
-api/angular.module.ng.$http $http} service.
+api/ng.$http $http} service.
 
 
 ## Controller
 
 We simplified our sub-controllers (`PhoneListCtrl` and `PhoneDetailCtrl`) by factoring out the
-lower-level {@link api/angular.module.ng.$http $http} service, replacing it with a new service called
-`Phone`. Angular's {@link api/angular.module.ngResource.$resource `$resource`} service is easier to
+lower-level {@link api/ng.$http $http} service, replacing it with a new service called
+`Phone`. Angular's {@link api/ngResource.$resource `$resource`} service is easier to
 use than `$http for interacting with data sources exposed as RESTful resources. It is also easier
 now to understand what the code in our controllers is doing.
 
@@ -122,7 +122,7 @@ We have modified our unit tests to verify that our new service is issuing HTTP r
 processing them as expected. The tests also check that our controllers are interacting with the
 service correctly.
 
-The {@link api/angular.module.ngResource.$resource $resource} service augments the response object
+The {@link api/ngResource.$resource $resource} service augments the response object
 with methods for updating and deleting the resource. If we were to use the standard `toEqual`
 matcher, our tests would fail because the test values would not match the responses exactly. To
 solve the problem, we use a newly-defined `toEqualData` {@link
diff --git a/docs/spec/ngdocSpec.js b/docs/spec/ngdocSpec.js
index b591a7de7642..0a7979f2fae1 100644
--- a/docs/spec/ngdocSpec.js
+++ b/docs/spec/ngdocSpec.js
@@ -203,17 +203,17 @@ describe('ngdoc', function() {
 
   describe('merge', function() {
     it('should merge child with parent', function() {
-      var parent = new Doc({id: 'angular.module.ng.abc', name: 'angular.module.ng.abc', section: 'api'});
-      var methodA = new Doc({name: 'methodA', methodOf: 'angular.module.ng.abc'});
-      var methodB = new Doc({name: 'methodB', methodOf: 'angular.module.ng.abc'});
-      var propA = new Doc({name: 'propA', propertyOf: 'angular.module.ng.abc'});
-      var propB = new Doc({name: 'propB', propertyOf: 'angular.module.ng.abc'});
-      var eventA = new Doc({name: 'eventA', eventOf: 'angular.module.ng.abc'});
-      var eventB = new Doc({name: 'eventB', eventOf: 'angular.module.ng.abc'});
+      var parent = new Doc({id: 'ng.abc', name: 'ng.abc', section: 'api'});
+      var methodA = new Doc({name: 'methodA', methodOf: 'ng.abc'});
+      var methodB = new Doc({name: 'methodB', methodOf: 'ng.abc'});
+      var propA = new Doc({name: 'propA', propertyOf: 'ng.abc'});
+      var propB = new Doc({name: 'propB', propertyOf: 'ng.abc'});
+      var eventA = new Doc({name: 'eventA', eventOf: 'ng.abc'});
+      var eventB = new Doc({name: 'eventB', eventOf: 'ng.abc'});
       var docs = [methodB, methodA, eventB, eventA, propA, propB, parent]; // keep wrong order;
       ngdoc.merge(docs);
       expect(docs.length).toEqual(1);
-      expect(docs[0].id).toEqual('angular.module.ng.abc');
+      expect(docs[0].id).toEqual('ng.abc');
       expect(docs[0].methods).toEqual([methodA, methodB]);
       expect(docs[0].events).toEqual([eventA, eventB]);
       expect(docs[0].properties).toEqual([propA, propB]);
@@ -283,8 +283,8 @@ describe('ngdoc', function() {
         expect(doc.requires).toEqual([
           {name:'$service', text:'
for \nA
'},
           {name:'$another', text:'
for B
'}]);
-        expect(doc.html()).toContain('$service');
-        expect(doc.html()).toContain('$another');
+        expect(doc.html()).toContain('$service');
+        expect(doc.html()).toContain('$another');
         expect(doc.html()).toContain('
for \nA
');
         expect(doc.html()).toContain('
for B
');
       });
diff --git a/docs/src/ngdoc.js b/docs/src/ngdoc.js
index 441ea2c86fe7..5517fa938688 100644
--- a/docs/src/ngdoc.js
+++ b/docs/src/ngdoc.js
@@ -101,7 +101,7 @@ Doc.prototype = {
 
     var self = this,
       IS_URL = /^(https?:\/\/|ftps?:\/\/|mailto:|\.|\/)/,
-      IS_ANGULAR = /^(api\/)?angular\./,
+      IS_ANGULAR = /^(api\/)?(angular|ng|AUTO)\./,
       IS_HASH = /^#/,
       parts = trim(text).split(/(
[\s\S]*?<\/pre>|[\s\S]*?<\/doc:example>|]*>[\s\S]*?<\/example>)/),
       seq = 0,
@@ -201,7 +201,7 @@ Doc.prototype = {
       }
     });
     flush();
-    this.shortName = this.name.split(this.name.match(/#/) ? /#/ : /\./ ).pop();
+    this.shortName = this.name.split(/[\.:#]/).pop();
     this.id = this.id || // if we have an id just use it
       (((this.file||'').match(/.*\/([^\/]*)\.ngdoc/)||{})[1]) || // try to extract it from file name
       this.name; // default to name
@@ -277,7 +277,7 @@ Doc.prototype = {
       }
       dom.h('Dependencies', self.requires, function(require){
         dom.tag('code', function() {
-          dom.tag('a', {href: 'api/angular.module.ng.' + require.name}, require.name);
+          dom.tag('a', {href: 'api/ng.' + require.name}, require.name);
         });
         dom.html(require.text);
       });
@@ -622,14 +622,15 @@ Doc.prototype = {
 
 
 //////////////////////////////////////////////////////////
-var GLOBALS = /^angular\.([^\.]*)$/,
-  MODULE = /^angular\.module\.([^\.]*)$/,
-  MODULE_MOCK = /^angular\.mock\.([^\.]*)$/,
-  MODULE_DIRECTIVE = /^angular\.module\.([^\.]*)(?:\.\$compileProvider)?\.directive\.([^\.]*)$/,
-  MODULE_DIRECTIVE_INPUT = /^angular\.module\.([^\.]*)\.\$compileProvider\.directive\.input\.([^\.]*)$/,
-  MODULE_FILTER = /^angular\.module\.([^\.]*)\.\$?filter\.([^\.]*)$/,
-  MODULE_SERVICE = /^angular\.module\.([^\.]*)\.([^\.]*?)(Provider)?$/,
-  MODULE_TYPE = /^angular\.module\.([^\.]*)\..*\.([A-Z][^\.]*)$/;
+var GLOBALS = /^angular\.([^\.]+)$/,
+    MODULE = /^((?:(?!^angular\.)[^\.])+)$/,
+    MODULE_MOCK = /^angular\.mock\.([^\.]+)$/,
+    MODULE_DIRECTIVE = /^((?:(?!^angular\.)[^\.])+)\.directive:([^\.]+)$/,
+    MODULE_DIRECTIVE_INPUT = /^((?:(?!^angular\.)[^\.])+)\.directive:input\.([^\.]+)$/,
+    MODULE_FILTER = /^((?:(?!^angular\.)[^\.])+)\.filter:([^\.]+)$/,
+    MODULE_SERVICE = /^((?:(?!^angular\.)[^\.])+)\.([^\.]+?)(Provider)?$/,
+    MODULE_TYPE = /^((?:(?!^angular\.)[^\.])+)\..+\.([A-Z][^\.]+)$/;
+
 
 function title(text) {
   if (!text) return text;
@@ -728,7 +729,7 @@ function scenarios(docs){
 function metadata(docs){
   var pages = [];
   docs.forEach(function(doc){
-    var path = (doc.name || '').split(/(\.|\:\s+)/);
+    var path = (doc.name || '').split(/(\.|\:)/);
     for ( var i = 1; i < path.length; i++) {
       path.splice(i, 1);
     }
diff --git a/docs/src/templates/js/docs.js b/docs/src/templates/js/docs.js
index 5bcb9f6d1429..2eaa7c292877 100644
--- a/docs/src/templates/js/docs.js
+++ b/docs/src/templates/js/docs.js
@@ -229,18 +229,18 @@ docsApp.controller.DocsController = function($scope, $location, $window, $cookie
   var OFFLINE_COOKIE_NAME = 'ng-offline',
       DOCS_PATH = /^\/(api)|(guide)|(cookbook)|(misc)|(tutorial)/,
       INDEX_PATH = /^(\/|\/index[^\.]*.html)$/,
-      GLOBALS = /^angular\.([^\.]*)$/,
-      MODULE = /^angular\.module\.([^\.]*)$/,
-      MODULE_MOCK = /^angular\.mock\.([^\.]*)$/,
-      MODULE_DIRECTIVE = /^angular\.module\.([^\.]*)(?:\.\$compileProvider)?\.directive\.([^\.]*)$/,
-      MODULE_DIRECTIVE_INPUT = /^angular\.module\.([^\.]*)\.\$compileProvider\.directive\.input\.([^\.]*)$/,
-      MODULE_FILTER = /^angular\.module\.([^\.]*)\.\$?filter\.([^\.]*)$/,
-      MODULE_SERVICE = /^angular\.module\.([^\.]*)\.([^\.]*?)(Provider)?$/,
-      MODULE_TYPE = /^angular\.module\.([^\.]*)\..*\.([A-Z][^\.]*)$/,
+      GLOBALS = /^angular\.([^\.]+)$/,
+      MODULE = /^((?:(?!^angular\.)[^\.])+)$/,
+      MODULE_MOCK = /^angular\.mock\.([^\.]+)$/,
+      MODULE_DIRECTIVE = /^((?:(?!^angular\.)[^\.])+)\.directive:([^\.]+)$/,
+      MODULE_DIRECTIVE_INPUT = /^((?:(?!^angular\.)[^\.])+)\.directive:input\.([^\.]+)$/,
+      MODULE_FILTER = /^((?:(?!^angular\.)[^\.])+)\.filter:([^\.]+)$/,
+      MODULE_SERVICE = /^((?:(?!^angular\.)[^\.])+)\.([^\.]+?)(Provider)?$/,
+      MODULE_TYPE = /^((?:(?!^angular\.)[^\.])+)\..+\.([A-Z][^\.]+)$/,
       URL = {
         module: 'guide/module',
         directive: 'guide/directive',
-        input: 'api/angular.module.ng.$compileProvider.directive.input',
+        input: 'api/ng.directive:input',
         filter: 'guide/dev_guide.templates.filters',
         service: 'guide/dev_guide.services',
         type: 'guide/types'
@@ -325,22 +325,22 @@ docsApp.controller.DocsController = function($scope, $location, $window, $cookie
           breadcrumb.push({ name: partialId });
         } else if (match = partialId.match(MODULE)) {
           breadcrumb.push({ name: match[1] });
-        } else if (match = partialId.match(MODULE_SERVICE)) {
-          breadcrumb.push({ name: match[1], url: sectionId + '/angular.module.' + match[1] });
-          breadcrumb.push({ name: match[2] });
         } else if (match = partialId.match(MODULE_FILTER)) {
-          breadcrumb.push({ name: match[1], url: sectionId + '/angular.module.' + match[1] });
+          breadcrumb.push({ name: match[1], url: sectionId + '/' + match[1] });
           breadcrumb.push({ name: match[2] });
         } else if (match = partialId.match(MODULE_DIRECTIVE)) {
-          breadcrumb.push({ name: match[1], url: sectionId + '/angular.module.' + match[1] });
+          breadcrumb.push({ name: match[1], url: sectionId + '/' + match[1] });
           breadcrumb.push({ name: match[2] });
         } else if (match = partialId.match(MODULE_DIRECTIVE_INPUT)) {
-          breadcrumb.push({ name: match[1], url: sectionId + '/angular.module.' + match[1] });
+          breadcrumb.push({ name: match[1], url: sectionId + '/' + match[1] });
           breadcrumb.push({ name: 'input', url: URL.input });
           breadcrumb.push({ name: match[2] });
         } else if (match = partialId.match(MODULE_TYPE)) {
-          breadcrumb.push({ name: match[1], url: sectionId + '/angular.module.' + match[1] });
+          breadcrumb.push({ name: match[1], url: sectionId + '/' + match[1] });
           breadcrumb.push({ name: match[2] });
+        }  else if (match = partialId.match(MODULE_SERVICE)) {
+          breadcrumb.push({ name: match[1], url: sectionId + '/' + match[1] });
+          breadcrumb.push({ name: match[2] + (match[3] || '') });
         } else if (match = partialId.match(MODULE_MOCK)) {
           breadcrumb.push({ name: 'angular.mock.' + match[1] });
         } else {
@@ -405,26 +405,28 @@ docsApp.controller.DocsController = function($scope, $location, $window, $cookie
         bestMatch = match;
       }
 
-      if (id == 'angular.Module') {
+      if (page.id == 'index') {
+        //skip
+      } else if (page.section != 'api') {
+        otherPages.push(page);
+      } else if (id == 'angular.Module') {
         module('ng').types.push(page);
       } else if (match = id.match(GLOBALS)) {
         module('ng').globals.push(page);
       } else if (match = id.match(MODULE)) {
         module(match[1]);
-      } else if (match = id.match(MODULE_SERVICE)) {
-        module(match[1]).service(match[2])[match[3] ? 'provider' : 'instance'] = page;
       } else if (match = id.match(MODULE_FILTER)) {
         module(match[1]).filters.push(page);
       } else if (match = id.match(MODULE_DIRECTIVE)) {
         module(match[1]).directives.push(page);
       } else if (match = id.match(MODULE_DIRECTIVE_INPUT)) {
         module(match[1]).directives.push(page);
+      } else if (match = id.match(MODULE_SERVICE)) {
+        module(match[1]).service(match[2])[match[3] ? 'provider' : 'instance'] = page;
       } else if (match = id.match(MODULE_TYPE)) {
         module(match[1]).types.push(page);
       } else if (match = id.match(MODULE_MOCK)) {
         module('ngMock').globals.push(page);
-      } else if (page.section != 'api' && page.id != 'index'){
-        otherPages.push(page);
       }
 
     });
@@ -438,7 +440,7 @@ docsApp.controller.DocsController = function($scope, $location, $window, $cookie
       if (!module) {
         module = cache[name] = {
           name: name,
-          url: 'api/angular.module.' + name,
+          url: 'api/' + name,
           globals: [],
           directives: [],
           services: [],
diff --git a/src/Angular.js b/src/Angular.js
index c3b57c101bdf..63d04200aba8 100644
--- a/src/Angular.js
+++ b/src/Angular.js
@@ -61,7 +61,6 @@ var Error             = window.Error,
     /** @name angular */
     angular           = window.angular || (window.angular = {}),
     angularModule,
-    /** @name angular.module.ng */
     nodeName_,
     uid               = ['0', '0', '0'];
 
@@ -520,7 +519,7 @@ function isLeafNode (node) {
  * * If  `source` is not an object or array, `source` is returned.
  *
  * Note: this function is used to augment the Object type in Angular expressions. See
- * {@link angular.module.ng.$filter} for more information about Angular arrays.
+ * {@link ng.$filter} for more information about Angular arrays.
  *
  * @param {*} source The source that will be used to make a copy.
  *                   Can be any type, including primitives, `null`, and `undefined`.
@@ -830,7 +829,7 @@ function encodeUriQuery(val, pctEncodeSpaces) {
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngApp
+ * @name ng.directive:ngApp
  *
  * @element ANY
  * @param {angular.Module} ngApp on optional application
@@ -910,7 +909,7 @@ function angularInit(element, bootstrap) {
  *
  * @param {Element} element DOM element which is the root of angular application.
  * @param {Array=} modules an array of module declarations. See: {@link angular.module modules}
- * @returns {angular.module.auto.$injector} Returns the newly created injector for this app.
+ * @returns {AUTO.$injector} Returns the newly created injector for this app.
  */
 function bootstrap(element, modules) {
   element = jqLite(element);
diff --git a/src/auto/injector.js b/src/auto/injector.js
index fd664b0e07ac..e07c03a78594 100644
--- a/src/auto/injector.js
+++ b/src/auto/injector.js
@@ -12,7 +12,7 @@
 
  * @param {Array.} modules A list of module functions or their aliases. See
  *        {@link angular.module}. The `ng` module must be explicitly added.
- * @returns {function()} Injector function. See {@link angular.module.AUTO.$injector $injector}.
+ * @returns {function()} Injector function. See {@link AUTO.$injector $injector}.
  *
  * @example
  * Typical usage
@@ -32,10 +32,10 @@
 
 /**
  * @ngdoc overview
- * @name angular.module.AUTO
+ * @name AUTO
  * @description
  *
- * Implicit module which gets automatically added to each {@link angular.module.AUTO.$injector $injector}.
+ * Implicit module which gets automatically added to each {@link AUTO.$injector $injector}.
  */
 
 var FN_ARGS = /^function\s*[^\(]*\(\s*([^\)]*)\)/m;
@@ -74,13 +74,13 @@ function annotate(fn) {
 
 /**
  * @ngdoc object
- * @name angular.module.AUTO.$injector
+ * @name AUTO.$injector
  * @function
  *
  * @description
  *
  * `$injector` is used to retrieve object instances as defined by
- * {@link angular.module.AUTO.$provide provider}, instantiate types, invoke methods,
+ * {@link AUTO.$provide provider}, instantiate types, invoke methods,
  * and load modules.
  *
  * The following always holds true:
@@ -114,7 +114,7 @@ function annotate(fn) {
  * ## Inference
  *
  * In JavaScript calling `toString()` on a function returns the function definition. The definition can then be
- * parsed and the function arguments can be extracted. *NOTE:* This does not work with minfication, and obfuscation
+ * parsed and the function arguments can be extracted. *NOTE:* This does not work with minification, and obfuscation
  * tools since these tools change the argument names.
  *
  * ## `$inject` Annotation
@@ -126,8 +126,8 @@ function annotate(fn) {
 
 /**
  * @ngdoc method
- * @name angular.module.AUTO.$injector#get
- * @methodOf angular.module.AUTO.$injector
+ * @name AUTO.$injector#get
+ * @methodOf AUTO.$injector
  *
  * @description
  * Return an instance of the service.
@@ -138,8 +138,8 @@ function annotate(fn) {
 
 /**
  * @ngdoc method
- * @name angular.module.AUTO.$injector#invoke
- * @methodOf angular.module.AUTO.$injector
+ * @name AUTO.$injector#invoke
+ * @methodOf AUTO.$injector
  *
  * @description
  * Invoke the method and supply the method arguments from the `$injector`.
@@ -153,8 +153,8 @@ function annotate(fn) {
 
 /**
  * @ngdoc method
- * @name angular.module.AUTO.$injector#instantiate
- * @methodOf angular.module.AUTO.$injector
+ * @name AUTO.$injector#instantiate
+ * @methodOf AUTO.$injector
  * @description
  * Create a new instance of JS type. The method takes a constructor function invokes the new operator and supplies
  * all of the arguments to the constructor function as specified by the constructor annotation.
@@ -167,8 +167,8 @@ function annotate(fn) {
 
 /**
  * @ngdoc method
- * @name angular.module.AUTO.$injector#annotate
- * @methodOf angular.module.AUTO.$injector
+ * @name AUTO.$injector#annotate
+ * @methodOf AUTO.$injector
  *
  * @description
  * Returns an array of service names which the function is requesting for injection. This API is used by the injector
@@ -249,7 +249,7 @@ function annotate(fn) {
 
 /**
  * @ngdoc object
- * @name angular.module.AUTO.$provide
+ * @name AUTO.$provide
  *
  * @description
  *
@@ -299,8 +299,8 @@ function annotate(fn) {
 
 /**
  * @ngdoc method
- * @name angular.module.AUTO.$provide#provider
- * @methodOf angular.module.AUTO.$provide
+ * @name AUTO.$provide#provider
+ * @methodOf AUTO.$provide
  * @description
  *
  * Register a provider for a service. The providers can be retrieved and can have additional configuration methods.
@@ -309,17 +309,17 @@ function annotate(fn) {
  * @param {(Object|function())} provider If the provider is:
  *
  *   - `Object`: then it should have a `$get` method. The `$get` method will be invoked using
- *               {@link angular.module.AUTO.$injector#invoke $injector.invoke()} when an instance needs to be created.
+ *               {@link AUTO.$injector#invoke $injector.invoke()} when an instance needs to be created.
  *   - `Constructor`: a new instance of the provider will be created using
- *               {@link angular.module.AUTO.$injector#instantiate $injector.instantiate()}, then treated as `object`.
+ *               {@link AUTO.$injector#instantiate $injector.instantiate()}, then treated as `object`.
  *
  * @returns {Object} registered provider instance
  */
 
 /**
  * @ngdoc method
- * @name angular.module.AUTO.$provide#factory
- * @methodOf angular.module.AUTO.$provide
+ * @name AUTO.$provide#factory
+ * @methodOf AUTO.$provide
  * @description
  *
  * A short hand for configuring services if only `$get` method is required.
@@ -333,8 +333,8 @@ function annotate(fn) {
 
 /**
  * @ngdoc method
- * @name angular.module.AUTO.$provide#service
- * @methodOf angular.module.AUTO.$provide
+ * @name AUTO.$provide#service
+ * @methodOf AUTO.$provide
  * @description
  *
  * A short hand for registering service of given class.
@@ -347,8 +347,8 @@ function annotate(fn) {
 
 /**
  * @ngdoc method
- * @name angular.module.AUTO.$provide#value
- * @methodOf angular.module.AUTO.$provide
+ * @name AUTO.$provide#value
+ * @methodOf AUTO.$provide
  * @description
  *
  * A short hand for configuring services if the `$get` method is a constant.
@@ -361,13 +361,13 @@ function annotate(fn) {
 
 /**
  * @ngdoc method
- * @name angular.module.AUTO.$provide#constant
- * @methodOf angular.module.AUTO.$provide
+ * @name AUTO.$provide#constant
+ * @methodOf AUTO.$provide
  * @description
  *
- * A constant value, but unlike {@link angular.module.AUTO.$provide#value value} it can be injected
+ * A constant value, but unlike {@link AUTO.$provide#value value} it can be injected
  * into configuration function (other modules) and it is not interceptable by
- * {@link angular.module.AUTO.$provide#decorator decorator}.
+ * {@link AUTO.$provide#decorator decorator}.
  *
  * @param {string} name The name of the constant.
  * @param {*} value The constant value.
@@ -377,8 +377,8 @@ function annotate(fn) {
 
 /**
  * @ngdoc method
- * @name angular.module.AUTO.$provide#decorator
- * @methodOf angular.module.AUTO.$provide
+ * @name AUTO.$provide#decorator
+ * @methodOf AUTO.$provide
  * @description
  *
  * Decoration of service, allows the decorator to intercept the service instance creation. The
@@ -387,7 +387,7 @@ function annotate(fn) {
  *
  * @param {string} name The name of the service to decorate.
  * @param {function()} decorator This function will be invoked when the service needs to be
- *    instanciated. The function is called using the {@link angular.module.AUTO.$injector#invoke
+ *    instanciated. The function is called using the {@link AUTO.$injector#invoke
  *    injector.invoke} method and is therefore fully injectable. Local injection arguments:
  *
  *    * `$delegate` - The original service instance, which can be monkey patched, configured,
diff --git a/src/jqLite.js b/src/jqLite.js
index 3e8fb266cbe8..d012707650f9 100644
--- a/src/jqLite.js
+++ b/src/jqLite.js
@@ -65,7 +65,7 @@
  *   camelCase directive name, then the controller for this directive will be retrieved (e.g.
  *   `'ngModel'`).
  * - `injector()` - retrieves the injector of the current element or its parent.
- * - `scope()` - retrieves the {@link api/angular.module.ng.$rootScope.Scope scope} of the current
+ * - `scope()` - retrieves the {@link api/ng.$rootScope.Scope scope} of the current
  *   element or its parent.
  * - `inheritedData()` - same as `data()`, but walks up the DOM until a value is found or the top
  *   parent element is reached.
diff --git a/src/loader.js b/src/loader.js
index e0dd8d7f26b1..668e9a606226 100644
--- a/src/loader.js
+++ b/src/loader.js
@@ -31,7 +31,7 @@ function setupModuleLoader(window) {
      * # Module
      *
      * A module is a collocation of services, directives, filters, and configure information. Module
-     * is used to configure the {@link angular.module.AUTO.$injector $injector}.
+     * is used to configure the {@link AUTO.$injector $injector}.
      *
      * 
      * // Create a new module
@@ -54,7 +54,7 @@ function setupModuleLoader(window) {
      * 

      *
      * However it's more likely that you'll just use
-     * {@link angular.module.ng.$compileProvider.directive.ngApp ngApp} or
+     * {@link ng.directive:ngApp ngApp} or
      * {@link angular.bootstrap} to simplify this process for you.
      *
      * @param {!string} name The name of the module to create or retrieve.
@@ -114,7 +114,7 @@ function setupModuleLoader(window) {
            * @param {string} name service name
            * @param {Function} providerType Construction function for creating new instance of the service.
            * @description
-           * See {@link angular.module.AUTO.$provide#provider $provide.provider()}.
+           * See {@link AUTO.$provide#provider $provide.provider()}.
            */
           provider: invokeLater('$provide', 'provider'),
 
@@ -125,7 +125,7 @@ function setupModuleLoader(window) {
            * @param {string} name service name
            * @param {Function} providerFunction Function for creating new instance of the service.
            * @description
-           * See {@link angular.module.AUTO.$provide#factory $provide.factory()}.
+           * See {@link AUTO.$provide#factory $provide.factory()}.
            */
           factory: invokeLater('$provide', 'factory'),
 
@@ -136,7 +136,7 @@ function setupModuleLoader(window) {
            * @param {string} name service name
            * @param {Function} constructor A constructor function that will be instantiated.
            * @description
-           * See {@link angular.module.AUTO.$provide#service $provide.service()}.
+           * See {@link AUTO.$provide#service $provide.service()}.
            */
           service: invokeLater('$provide', 'service'),
 
@@ -147,7 +147,7 @@ function setupModuleLoader(window) {
            * @param {string} name service name
            * @param {*} object Service instance object.
            * @description
-           * See {@link angular.module.AUTO.$provide#value $provide.value()}.
+           * See {@link AUTO.$provide#value $provide.value()}.
            */
           value: invokeLater('$provide', 'value'),
 
@@ -159,7 +159,7 @@ function setupModuleLoader(window) {
            * @param {*} object Constant value.
            * @description
            * Because the constant are fixed, they get applied before other provide methods.
-           * See {@link angular.module.AUTO.$provide#constant $provide.constant()}.
+           * See {@link AUTO.$provide#constant $provide.constant()}.
            */
           constant: invokeLater('$provide', 'constant', 'unshift'),
 
@@ -170,7 +170,7 @@ function setupModuleLoader(window) {
            * @param {string} name Filter name.
            * @param {Function} filterFactory Factory function for creating new instance of filter.
            * @description
-           * See {@link angular.module.ng.$filterProvider#register $filterProvider.register()}.
+           * See {@link ng.$filterProvider#register $filterProvider.register()}.
            */
           filter: invokeLater('$filterProvider', 'register'),
 
@@ -181,7 +181,7 @@ function setupModuleLoader(window) {
            * @param {string} name Controller name.
            * @param {Function} constructor Controller constructor function.
            * @description
-           * See {@link angular.module.ng.$controllerProvider#register $controllerProvider.register()}.
+           * See {@link ng.$controllerProvider#register $controllerProvider.register()}.
            */
           controller: invokeLater('$controllerProvider', 'register'),
 
@@ -193,7 +193,7 @@ function setupModuleLoader(window) {
            * @param {Function} directiveFactory Factory function for creating new instance of
            * directives.
            * @description
-           * See {@link angular.module.ng.$compileProvider.directive $compileProvider.directive()}.
+           * See {@link ng.$compileProvider.directive $compileProvider.directive()}.
            */
           directive: invokeLater('$compileProvider', 'directive'),
 
diff --git a/src/ng/anchorScroll.js b/src/ng/anchorScroll.js
index 19a0949880c2..ecaa62e02cac 100644
--- a/src/ng/anchorScroll.js
+++ b/src/ng/anchorScroll.js
@@ -1,6 +1,6 @@
 /**
  * @ngdoc function
- * @name angular.module.ng.$anchorScroll
+ * @name ng.$anchorScroll
  * @requires $window
  * @requires $location
  * @requires $rootScope
diff --git a/src/ng/browser.js b/src/ng/browser.js
index 16a5582ffbcd..0bace2e86efd 100644
--- a/src/ng/browser.js
+++ b/src/ng/browser.js
@@ -2,7 +2,7 @@
 
 /**
  * @ngdoc object
- * @name angular.module.ng.$browser
+ * @name ng.$browser
  * @requires $log
  * @description
  * This object has two goals:
@@ -10,7 +10,7 @@
  * - hide all the global state in the browser caused by the window object
  * - abstract away all the browser specific features and inconsistencies
  *
- * For tests we provide {@link angular.module.ngMock.$browser mock implementation} of the `$browser`
+ * For tests we provide {@link ngMock.$browser mock implementation} of the `$browser`
  * service, which can be used for convenient testing of the application without the interaction with
  * the real browser apis.
  */
@@ -87,8 +87,8 @@ function Browser(window, document, $log, $sniffer) {
 
   /**
    * @ngdoc method
-   * @name angular.module.ng.$browser#addPollFn
-   * @methodOf angular.module.ng.$browser
+   * @name ng.$browser#addPollFn
+   * @methodOf ng.$browser
    *
    * @param {function()} fn Poll function to add
    *
@@ -128,8 +128,8 @@ function Browser(window, document, $log, $sniffer) {
 
   /**
    * @ngdoc method
-   * @name angular.module.ng.$browser#url
-   * @methodOf angular.module.ng.$browser
+   * @name ng.$browser#url
+   * @methodOf ng.$browser
    *
    * @description
    * GETTER:
@@ -142,7 +142,7 @@ function Browser(window, document, $log, $sniffer) {
    * Returns its own instance to allow chaining
    *
    * NOTE: this api is intended for use only by the $location service. Please use the
-   * {@link angular.module.ng.$location $location service} to change url.
+   * {@link ng.$location $location service} to change url.
    *
    * @param {string} url New url (when used as setter)
    * @param {boolean=} replace Should new url replace current history record ?
@@ -184,8 +184,8 @@ function Browser(window, document, $log, $sniffer) {
 
   /**
    * @ngdoc method
-   * @name angular.module.ng.$browser#onUrlChange
-   * @methodOf angular.module.ng.$browser
+   * @name ng.$browser#onUrlChange
+   * @methodOf ng.$browser
    * @TODO(vojta): refactor to use node's syntax for events
    *
    * @description
@@ -201,7 +201,7 @@ function Browser(window, document, $log, $sniffer) {
    * The listener gets called with new url as parameter.
    *
    * NOTE: this api is intended for use only by the $location service. Please use the
-   * {@link angular.module.ng.$location $location service} to monitor url changes in angular apps.
+   * {@link ng.$location $location service} to monitor url changes in angular apps.
    *
    * @param {function(string)} listener Listener function to be called when url changes.
    * @return {function(string)} Returns the registered listener fn - handy if the fn is anonymous.
@@ -250,8 +250,8 @@ function Browser(window, document, $log, $sniffer) {
 
   /**
    * @ngdoc method
-   * @name angular.module.ng.$browser#cookies
-   * @methodOf angular.module.ng.$browser
+   * @name ng.$browser#cookies
+   * @methodOf ng.$browser
    *
    * @param {string=} name Cookie name
    * @param {string=} value Cokkie value
@@ -309,8 +309,8 @@ function Browser(window, document, $log, $sniffer) {
 
   /**
    * @ngdoc method
-   * @name angular.module.ng.$browser#defer
-   * @methodOf angular.module.ng.$browser
+   * @name ng.$browser#defer
+   * @methodOf ng.$browser
    * @param {function()} fn A function, who's execution should be defered.
    * @param {number=} [delay=0] of milliseconds to defer the function execution.
    * @returns {*} DeferId that can be used to cancel the task via `$browser.defer.cancel()`.
@@ -338,8 +338,8 @@ function Browser(window, document, $log, $sniffer) {
   /**
    * THIS DOC IS NOT VISIBLE because ngdocs can't process docs for foo#method.method
    *
-   * @name angular.module.ng.$browser#defer.cancel
-   * @methodOf angular.module.ng.$browser.defer
+   * @name ng.$browser#defer.cancel
+   * @methodOf ng.$browser.defer
    *
    * @description
    * Cancels a defered task identified with `deferId`.
diff --git a/src/ng/cacheFactory.js b/src/ng/cacheFactory.js
index c91ffce74e93..de8004f2805b 100644
--- a/src/ng/cacheFactory.js
+++ b/src/ng/cacheFactory.js
@@ -1,6 +1,6 @@
 /**
  * @ngdoc object
- * @name angular.module.ng.$cacheFactory
+ * @name ng.$cacheFactory
  *
  * @description
  * Factory that constructs cache objects.
@@ -153,12 +153,12 @@ function $CacheFactoryProvider() {
 
 /**
  * @ngdoc object
- * @name angular.module.ng.$templateCache
+ * @name ng.$templateCache
  *
  * @description
  * Cache used for storing html templates.
  *
- * See {@link angular.module.ng.$cacheFactory $cacheFactory}.
+ * See {@link ng.$cacheFactory $cacheFactory}.
  *
  */
 function $TemplateCacheProvider() {
diff --git a/src/ng/compile.js b/src/ng/compile.js
index 1dbb63bede8c..04a1a4388d0d 100644
--- a/src/ng/compile.js
+++ b/src/ng/compile.js
@@ -23,20 +23,20 @@ var NON_ASSIGNABLE_MODEL_EXPRESSION = 'Non-assignable model expression: ';
 
 /**
  * @ngdoc function
- * @name angular.module.ng.$compile
+ * @name ng.$compile
  * @function
  *
  * @description
  * Compiles a piece of HTML string or DOM into a template and produces a template function, which
- * can then be used to link {@link angular.module.ng.$rootScope.Scope scope} and the template together.
+ * can then be used to link {@link ng.$rootScope.Scope scope} and the template together.
  *
  * The compilation is a process of walking the DOM tree and trying to match DOM elements to
- * {@link angular.module.ng.$compileProvider.directive directives}. For each match it
+ * {@link ng.$compileProvider.directive directives}. For each match it
  * executes corresponding template function and collects the
  * instance functions into a single template function which is then returned.
  *
  * The template function can then be used once to produce the view or as it is the case with
- * {@link angular.module.ng.$compileProvider.directive.ngRepeat repeater} many-times, in which
+ * {@link ng.directive:ngRepeat repeater} many-times, in which
  * case each call results in a view that is a DOM clone of the original template.
  *
  
@@ -99,7 +99,7 @@ var NON_ASSIGNABLE_MODEL_EXPRESSION = 'Non-assignable model expression: ';
  * @returns {function(scope[, cloneAttachFn])} a link function which is used to bind template
  * (a DOM element/tree) to a scope. Where:
  *
- *  * `scope` - A {@link angular.module.ng.$rootScope.Scope Scope} to bind to.
+ *  * `scope` - A {@link ng.$rootScope.Scope Scope} to bind to.
  *  * `cloneAttachFn` - If `cloneAttachFn` is provided, then the link function will clone the
  *               `template` and call the `cloneAttachFn` function allowing the caller to attach the
  *               cloned elements to the DOM document at the appropriate place. The `cloneAttachFn` is
@@ -144,7 +144,7 @@ var NON_ASSIGNABLE_MODEL_EXPRESSION = 'Non-assignable model expression: ';
 
 /**
  * @ngdoc service
- * @name angular.module.ng.$compileProvider
+ * @name ng.$compileProvider
  * @function
  *
  * @description
@@ -152,8 +152,8 @@ var NON_ASSIGNABLE_MODEL_EXPRESSION = 'Non-assignable model expression: ';
 
 /**
  * @ngdoc function
- * @name angular.module.ng.$compileProvider#directive
- * @methodOf angular.module.ng.$compileProvider
+ * @name ng.$compileProvider#directive
+ * @methodOf ng.$compileProvider
  * @function
  *
  * @description
@@ -161,7 +161,7 @@ var NON_ASSIGNABLE_MODEL_EXPRESSION = 'Non-assignable model expression: ';
  *
  * @param {string} name name of the directive.
  * @param {function} directiveFactory An injectable directive factory function.
- * @returns {angular.module.ng.$compileProvider} Self for chaining.
+ * @returns {ng.$compileProvider} Self for chaining.
  */
 $CompileProvider.$inject = ['$provide'];
 function $CompileProvider($provide) {
@@ -174,8 +174,8 @@ function $CompileProvider($provide) {
 
   /**
    * @ngdoc function
-   * @name angular.module.ng.$compileProvider.directive
-   * @methodOf angular.module.ng.$compileProvider
+   * @name ng.$compileProvider.directive
+   * @methodOf ng.$compileProvider
    * @function
    *
    * @description
@@ -1085,7 +1085,7 @@ function directiveNormalize(name) {
 
 /**
  * @ngdoc object
- * @name angular.module.ng.$compile.directive.Attributes
+ * @name ng.$compile.directive.Attributes
  * @description
  *
  * A shared object between directive compile / linking functions which contains normalized DOM element
@@ -1097,8 +1097,8 @@ function directiveNormalize(name) {
 
 /**
  * @ngdoc property
- * @name angular.module.ng.$compile.directive.Attributes#$attr
- * @propertyOf angular.module.ng.$compile.directive.Attributes
+ * @name ng.$compile.directive.Attributes#$attr
+ * @propertyOf ng.$compile.directive.Attributes
  * @returns {object} A map of DOM element attribute names to the normalized name. This is
  *          needed to do reverse lookup from normalized name back to actual name.
  */
@@ -1106,8 +1106,8 @@ function directiveNormalize(name) {
 
 /**
  * @ngdoc function
- * @name angular.module.ng.$compile.directive.Attributes#$set
- * @methodOf angular.module.ng.$compile.directive.Attributes
+ * @name ng.$compile.directive.Attributes#$set
+ * @methodOf ng.$compile.directive.Attributes
  * @function
  *
  * @description
@@ -1115,7 +1115,7 @@ function directiveNormalize(name) {
  *
  *
  * @param {string} name Normalized element attribute name of the property to modify. The name is
- *          revers translated using the {@link angular.module.ng.$compile.directive.Attributes#$attr $attr}
+ *          revers translated using the {@link ng.$compile.directive.Attributes#$attr $attr}
  *          property to the original name.
  * @param {string} value Value to set the attribute to.
  */
diff --git a/src/ng/controller.js b/src/ng/controller.js
index 67f70aaddcab..e2f1b6ac7ce3 100644
--- a/src/ng/controller.js
+++ b/src/ng/controller.js
@@ -2,13 +2,13 @@
 
 /**
  * @ngdoc object
- * @name angular.module.ng.$controllerProvider
+ * @name ng.$controllerProvider
  * @description
- * The {@link angular.module.ng.$controller $controller service} is used by Angular to create new
+ * The {@link ng.$controller $controller service} is used by Angular to create new
  * controllers.
  *
  * This provider allows controller registration via the
- * {@link angular.module.ng.$controllerProvider#register register} method.
+ * {@link ng.$controllerProvider#register register} method.
  */
 function $ControllerProvider() {
   var controllers = {};
@@ -16,8 +16,8 @@ function $ControllerProvider() {
 
   /**
    * @ngdoc function
-   * @name angular.module.ng.$controllerProvider#register
-   * @methodOf angular.module.ng.$controllerProvider
+   * @name ng.$controllerProvider#register
+   * @methodOf ng.$controllerProvider
    * @param {string} name Controller name
    * @param {Function|Array} constructor Controller constructor fn (optionally decorated with DI
    *    annotations in the array notation).
@@ -35,7 +35,7 @@ function $ControllerProvider() {
 
     /**
      * @ngdoc function
-     * @name angular.module.ng.$controller
+     * @name ng.$controller
      * @requires $injector
      *
      * @param {Function|string} constructor If called with a function then it's considered to be the
@@ -52,7 +52,7 @@ function $ControllerProvider() {
      * @description
      * `$controller` service is responsible for instantiating controllers.
      *
-     * It's just simple call to {@link angular.module.AUTO.$injector $injector}, but extracted into
+     * It's just simple call to {@link AUTO.$injector $injector}, but extracted into
      * a service, so that one can override this service with {@link https://gist.github.com/1649788
      * BC version}.
      */
diff --git a/src/ng/defer.js b/src/ng/defer.js
index b5dc88440750..850d9cf5aea8 100644
--- a/src/ng/defer.js
+++ b/src/ng/defer.js
@@ -2,15 +2,15 @@
 
 /**
  * @ngdoc function
- * @name angular.module.ng.$defer
+ * @name ng.$defer
  * @deprecated Made obsolete by $timeout service. Please migrate your code. This service will be
  *   removed with 1.0 final.
  * @requires $browser
  *
  * @description
- * Delegates to {@link angular.module.ng.$browser#defer $browser.defer}, but wraps the `fn` function
+ * Delegates to {@link ng.$browser#defer $browser.defer}, but wraps the `fn` function
  * into a try/catch block and delegates any exceptions to
- * {@link angular.module.ng.$exceptionHandler $exceptionHandler} service.
+ * {@link ng.$exceptionHandler $exceptionHandler} service.
  *
  * In tests you can use `$browser.defer.flush()` to flush the queue of deferred functions.
  *
@@ -21,8 +21,8 @@
 
 /**
  * @ngdoc function
- * @name angular.module.ng.$defer#cancel
- * @methodOf angular.module.ng.$defer
+ * @name ng.$defer#cancel
+ * @methodOf ng.$defer
  *
  * @description
  * Cancels a defered task identified with `deferId`.
diff --git a/src/ng/directive/booleanAttrs.js b/src/ng/directive/booleanAttrs.js
index b0c1b78fd5dd..cce10a3b4e45 100644
--- a/src/ng/directive/booleanAttrs.js
+++ b/src/ng/directive/booleanAttrs.js
@@ -2,7 +2,7 @@
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngHref
+ * @name ng.directive:ngHref
  * @restrict A
  *
  * @description
@@ -82,7 +82,7 @@
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngSrc
+ * @name ng.directive:ngSrc
  * @restrict A
  *
  * @description
@@ -107,7 +107,7 @@
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngDisabled
+ * @name ng.directive:ngDisabled
  * @restrict A
  *
  * @description
@@ -146,7 +146,7 @@
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngChecked
+ * @name ng.directive:ngChecked
  * @restrict A
  *
  * @description
@@ -176,7 +176,7 @@
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngMultiple
+ * @name ng.directive:ngMultiple
  * @restrict A
  *
  * @description
@@ -212,7 +212,7 @@
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngReadonly
+ * @name ng.directive:ngReadonly
  * @restrict A
  *
  * @description
@@ -242,7 +242,7 @@
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngSelected
+ * @name ng.directive:ngSelected
  * @restrict A
  *
  * @description
diff --git a/src/ng/directive/form.js b/src/ng/directive/form.js
index 5f1cc1d2f592..cc229759b9cb 100644
--- a/src/ng/directive/form.js
+++ b/src/ng/directive/form.js
@@ -10,7 +10,7 @@ var nullFormCtrl = {
 
 /**
  * @ngdoc object
- * @name angular.module.ng.$compileProvider.directive.form.FormController
+ * @name ng.directive:form.FormController
  *
  * @property {boolean} $pristine True if user has not interacted with the form yet.
  * @property {boolean} $dirty True if user has already interacted with the form.
@@ -27,7 +27,7 @@ var nullFormCtrl = {
  * `FormController` keeps track of all its controls and nested forms as well as state of them,
  * such as being valid/invalid or dirty/pristine.
  *
- * Each {@link angular.module.ng.$compileProvider.directive.form form} directive creates an instance
+ * Each {@link ng.directive:form form} directive creates an instance
  * of `FormController`.
  *
  */
@@ -124,11 +124,11 @@ function FormController(element, attrs) {
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngForm
+ * @name ng.directive:ngForm
  * @restrict EAC
  *
  * @description
- * Nestable alias of {@link angular.module.ng.$compileProvider.directive.form `form`} directive. HTML
+ * Nestable alias of {@link ng.directive:form `form`} directive. HTML
  * does not allow nesting of form elements. It is useful to nest forms, for example if the validity of a
  * sub-group of controls needs to be determined.
  *
@@ -139,21 +139,21 @@ function FormController(element, attrs) {
 
  /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.form
+ * @name ng.directive:form
  * @restrict E
  *
  * @description
  * Directive that instantiates
- * {@link angular.module.ng.$compileProvider.directive.form.FormController FormController}.
+ * {@link ng.directive:form.FormController FormController}.
  *
  * If `name` attribute is specified, the form controller is published onto the current scope under
  * this name.
  *
- * # Alias: {@link angular.module.ng.$compileProvider.directive.ngForm `ngForm`}
+ * # Alias: {@link ng.directive:ngForm `ngForm`}
  *
  * In angular forms can be nested. This means that the outer form is valid when all of the child
  * forms are valid as well. However browsers do not allow nesting of `
` elements, for this
- * reason angular provides {@link angular.module.ng.$compileProvider.directive.ngForm `ngForm`} alias
+ * reason angular provides {@link ng.directive:ngForm `ngForm`} alias
  * which behaves identical to `` but allows form nesting.
  *
  *
@@ -177,8 +177,8 @@ function FormController(element, attrs) {
  * You can use one of the following two ways to specify what javascript method should be called when
  * a form is submitted:
  *
- * - {@link angular.module.ng.$compileProvider.directive.ngSubmit ngSubmit} directive on the form element
- * - {@link angular.module.ng.$compileProvider.directive.ngClick ngClick} directive on the first
+ * - {@link ng.directive:ngSubmit ngSubmit} directive on the form element
+ * - {@link ng.directive:ngClick ngClick} directive on the first
   *  button or input field of type submit (input[type=submit])
  *
  * To prevent double execution of the handler, use only one of ngSubmit or ngClick directives. This
diff --git a/src/ng/directive/input.js b/src/ng/directive/input.js
index 04af4c2a6cb9..40b29b236900 100644
--- a/src/ng/directive/input.js
+++ b/src/ng/directive/input.js
@@ -8,7 +8,7 @@ var inputType = {
 
   /**
    * @ngdoc inputType
-   * @name angular.module.ng.$compileProvider.directive.input.text
+   * @name ng.directive:input.text
    *
    * @description
    * Standard HTML text input with angular data binding.
@@ -74,7 +74,7 @@ var inputType = {
 
   /**
    * @ngdoc inputType
-   * @name angular.module.ng.$compileProvider.directive.input.number
+   * @name ng.directive:input.number
    *
    * @description
    * Text input with number validation and transformation. Sets the `number` validation
@@ -142,7 +142,7 @@ var inputType = {
 
   /**
    * @ngdoc inputType
-   * @name angular.module.ng.$compileProvider.directive.input.url
+   * @name ng.directive:input.url
    *
    * @description
    * Text input with URL validation. Sets the `url` validation error key if the content is not a
@@ -207,7 +207,7 @@ var inputType = {
 
   /**
    * @ngdoc inputType
-   * @name angular.module.ng.$compileProvider.directive.input.email
+   * @name ng.directive:input.email
    *
    * @description
    * Text input with email validation. Sets the `email` validation error key if not a valid email
@@ -270,7 +270,7 @@ var inputType = {
 
   /**
    * @ngdoc inputType
-   * @name angular.module.ng.$compileProvider.directive.input.radio
+   * @name ng.directive:input.radio
    *
    * @description
    * HTML radio button.
@@ -311,7 +311,7 @@ var inputType = {
 
   /**
    * @ngdoc inputType
-   * @name angular.module.ng.$compileProvider.directive.input.checkbox
+   * @name ng.directive:input.checkbox
    *
    * @description
    * HTML checkbox.
@@ -627,13 +627,13 @@ function checkboxInputType(scope, element, attr, ctrl) {
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.textarea
+ * @name ng.directive:textarea
  * @restrict E
  *
  * @description
  * HTML textarea element control with angular data-binding. The data-binding and validation
  * properties of this element are exactly the same as those of the
- * {@link angular.module.ng.$compileProvider.directive.input input element}.
+ * {@link ng.directive:input input element}.
  *
  * @param {string} ngModel Assignable angular expression to data-bind to.
  * @param {string=} name Property name of the form under which the control is published.
@@ -652,7 +652,7 @@ function checkboxInputType(scope, element, attr, ctrl) {
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.input
+ * @name ng.directive:input
  * @restrict E
  *
  * @description
@@ -764,7 +764,7 @@ var VALID_CLASS = 'ng-valid',
 
 /**
  * @ngdoc object
- * @name angular.module.ng.$compileProvider.directive.ngModel.NgModelController
+ * @name ng.directive:ngModel.NgModelController
  *
  * @property {string} $viewValue Actual string value in the view.
  * @property {*} $modelValue The value in the model, that the control is bound to.
@@ -880,8 +880,8 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
 
   /**
    * @ngdoc function
-   * @name angular.module.ng.$compileProvider.directive.ngModel.NgModelController#$render
-   * @methodOf angular.module.ng.$compileProvider.directive.ngModel.NgModelController
+   * @name ng.directive:ngModel.NgModelController#$render
+   * @methodOf ng.directive:ngModel.NgModelController
    *
    * @description
    * Called when the view needs to be updated. It is expected that the user of the ng-model
@@ -908,8 +908,8 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
 
   /**
    * @ngdoc function
-   * @name angular.module.ng.$compileProvider.directive.ngModel.NgModelController#$setValidity
-   * @methodOf angular.module.ng.$compileProvider.directive.ngModel.NgModelController
+   * @name ng.directive:ngModel.NgModelController#$setValidity
+   * @methodOf ng.directive:ngModel.NgModelController
    *
    * @description
    * Change the validity state, and notifies the form when the control changes validity. (i.e. it
@@ -950,15 +950,15 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
 
   /**
    * @ngdoc function
-   * @name angular.module.ng.$compileProvider.directive.ngModel.NgModelController#$setViewValue
-   * @methodOf angular.module.ng.$compileProvider.directive.ngModel.NgModelController
+   * @name ng.directive:ngModel.NgModelController#$setViewValue
+   * @methodOf ng.directive:ngModel.NgModelController
    *
    * @description
    * Read a value from view.
    *
    * This method should be called from within a DOM event handler.
-   * For example {@link angular.module.ng.$compileProvider.directive.input input} or
-   * {@link angular.module.ng.$compileProvider.directive.select select} directives call it.
+   * For example {@link ng.directive:input input} or
+   * {@link ng.directive:select select} directives call it.
    *
    * It internally calls all `formatters` and if resulted value is valid, updates the model and
    * calls all registered change listeners.
@@ -1018,7 +1018,7 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngModel
+ * @name ng.directive:ngModel
  *
  * @element input
  *
@@ -1033,19 +1033,19 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
  * - providing validation behavior (i.e. required, number, email, url),
  * - keeping state of the control (valid/invalid, dirty/pristine, validation errors),
  * - setting related css class onto the element (`ng-valid`, `ng-invalid`, `ng-dirty`, `ng-pristine`),
- * - register the control with parent {@link angular.module.ng.$compileProvider.directive.form form}.
+ * - register the control with parent {@link ng.directive:form form}.
  *
  * For basic examples, how to use `ngModel`, see:
  *
- *  - {@link angular.module.ng.$compileProvider.directive.input input}
- *    - {@link angular.module.ng.$compileProvider.directive.input.text text}
- *    - {@link angular.module.ng.$compileProvider.directive.input.checkbox checkbox}
- *    - {@link angular.module.ng.$compileProvider.directive.input.radio radio}
- *    - {@link angular.module.ng.$compileProvider.directive.input.number number}
- *    - {@link angular.module.ng.$compileProvider.directive.input.email email}
- *    - {@link angular.module.ng.$compileProvider.directive.input.url url}
- *  - {@link angular.module.ng.$compileProvider.directive.select select}
- *  - {@link angular.module.ng.$compileProvider.directive.textarea textarea}
+ *  - {@link ng.directive:input input}
+ *    - {@link ng.directive:input.text text}
+ *    - {@link ng.directive:input.checkbox checkbox}
+ *    - {@link ng.directive:input.radio radio}
+ *    - {@link ng.directive:input.number number}
+ *    - {@link ng.directive:input.email email}
+ *    - {@link ng.directive:input.url url}
+ *  - {@link ng.directive:select select}
+ *  - {@link ng.directive:textarea textarea}
  *
  */
 var ngModelDirective = function() {
@@ -1070,7 +1070,7 @@ var ngModelDirective = function() {
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngChange
+ * @name ng.directive:ngChange
  * @restrict E
  *
  * @description
@@ -1156,7 +1156,7 @@ var requiredDirective = function() {
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngList
+ * @name ng.directive:ngList
  *
  * @description
  * Text input that converts between comma-seperated string into an array of strings.
diff --git a/src/ng/directive/ngBind.js b/src/ng/directive/ngBind.js
index f6ae63249ac4..70f253708861 100644
--- a/src/ng/directive/ngBind.js
+++ b/src/ng/directive/ngBind.js
@@ -2,7 +2,7 @@
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngBind
+ * @name ng.directive:ngBind
  *
  * @description
  * The `ngBind` attribute tells Angular to replace the text content of the specified HTML element
@@ -18,7 +18,7 @@
  * bindings invisible to the user while the page is loading.
  *
  * An alternative solution to this problem would be using the
- * {@link angular.module.ng.$compileProvider.directive.ngCloak ngCloak} directive.
+ * {@link ng.directive:ngCloak ngCloak} directive.
  *
  *
  * @element ANY
@@ -57,7 +57,7 @@ var ngBindDirective = ngDirective(function(scope, element, attr) {
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngBindTemplate
+ * @name ng.directive:ngBindTemplate
  *
  * @description
  * The `ngBindTemplate` directive specifies that the element
@@ -116,15 +116,15 @@ var ngBindTemplateDirective = ['$interpolate', function($interpolate) {
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngBindHtmlUnsafe
+ * @name ng.directive:ngBindHtmlUnsafe
  *
  * @description
  * Creates a binding that will innerHTML the result of evaluating the `expression` into the current
  * element. *The innerHTML-ed content will not be sanitized!* You should use this directive only if
- * {@link angular.module.ngSanitize.directive.ngBindHtml ngBindHtml} directive is too
+ * {@link ngSanitize.directive:ngBindHtml ngBindHtml} directive is too
  * restrictive and when you absolutely trust the source of the content you are binding to.
  *
- * See {@link angular.module.ngSanitize.$sanitize $sanitize} docs for examples.
+ * See {@link ngSanitize.$sanitize $sanitize} docs for examples.
  *
  * @element ANY
  * @param {expression} ngBindHtmlUnsafe {@link guide/expression Expression} to evaluate.
diff --git a/src/ng/directive/ngClass.js b/src/ng/directive/ngClass.js
index 9beed351cefe..e054d4c6d7a4 100644
--- a/src/ng/directive/ngClass.js
+++ b/src/ng/directive/ngClass.js
@@ -19,7 +19,7 @@ function classDirective(name, selector) {
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngClass
+ * @name ng.directive:ngClass
  *
  * @description
  * The `ngClass` allows you to set CSS class on HTML element dynamically by databinding an
@@ -70,15 +70,15 @@ var ngClassDirective = classDirective('', true);
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngClassOdd
+ * @name ng.directive:ngClassOdd
  *
  * @description
  * The `ngClassOdd` and `ngClassEven` directives work exactly as
- * {@link angular.module.ng.$compileProvider.directive.ngClass ngClass}, except it works in
+ * {@link ng.directive:ngClass ngClass}, except it works in
  * conjunction with `ngRepeat` and takes affect only on odd (even) rows.
  *
  * This directive can be applied only within a scope of an
- * {@link angular.module.ng.$compileProvider.directive.ngRepeat ngRepeat}.
+ * {@link ng.directive:ngRepeat ngRepeat}.
  *
  * @element ANY
  * @param {expression} ngClassOdd {@link guide/expression Expression} to eval. The result
@@ -117,15 +117,15 @@ var ngClassOddDirective = classDirective('Odd', 0);
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngClassEven
+ * @name ng.directive:ngClassEven
  *
  * @description
  * The `ngClassOdd` and `ngClassEven` works exactly as
- * {@link angular.module.ng.$compileProvider.directive.ngClass ngClass}, except it works in
+ * {@link ng.directive:ngClass ngClass}, except it works in
  * conjunction with `ngRepeat` and takes affect only on odd (even) rows.
  *
  * This directive can be applied only within a scope of an
- * {@link angular.module.ng.$compileProvider.directive.ngRepeat ngRepeat}.
+ * {@link ng.directive:ngRepeat ngRepeat}.
  *
  * @element ANY
  * @param {expression} ngClassEven {@link guide/expression Expression} to eval. The
diff --git a/src/ng/directive/ngCloak.js b/src/ng/directive/ngCloak.js
index b548193b6ae2..baa7afa8b71f 100644
--- a/src/ng/directive/ngCloak.js
+++ b/src/ng/directive/ngCloak.js
@@ -2,7 +2,7 @@
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngCloak
+ * @name ng.directive:ngCloak
  *
  * @description
  * The `ngCloak` directive is used to prevent the Angular html template from being briefly
diff --git a/src/ng/directive/ngController.js b/src/ng/directive/ngController.js
index 7b7ab06c632a..b6619d319426 100644
--- a/src/ng/directive/ngController.js
+++ b/src/ng/directive/ngController.js
@@ -2,7 +2,7 @@
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngController
+ * @name ng.directive:ngController
  *
  * @description
  * The `ngController` directive assigns behavior to a scope. This is a key aspect of how angular
@@ -15,7 +15,7 @@
  * * Controller — The `ngController` directive specifies a Controller class; the class has
  *   methods that typically express the business logic behind the application.
  *
- * Note that an alternative way to define controllers is via the `{@link angular.module.ng.$route}`
+ * Note that an alternative way to define controllers is via the `{@link ng.$route}`
  * service.
  *
  * @element ANY
diff --git a/src/ng/directive/ngCsp.js b/src/ng/directive/ngCsp.js
index 55fe8b3a2641..16b1a0e36986 100644
--- a/src/ng/directive/ngCsp.js
+++ b/src/ng/directive/ngCsp.js
@@ -2,13 +2,13 @@
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngCsp
+ * @name ng.directive:ngCsp
  * @priority 1000
  *
  * @description
  * Enables [CSP (Content Security Policy)](https://developer.mozilla.org/en/Security/CSP) support.
  * This directive should be used on the root element of the application (typically the ``
- * element or other element with the {@link angular.module.ng.$compileProvider.directive.ngApp ngApp}
+ * element or other element with the {@link ng.directive:ngApp ngApp}
  * directive).
  *
  * If enabled the performance of template expression evaluator will suffer slightly, so don't enable
diff --git a/src/ng/directive/ngEventDirs.js b/src/ng/directive/ngEventDirs.js
index 16635e07eaf2..4d0797188ed1 100644
--- a/src/ng/directive/ngEventDirs.js
+++ b/src/ng/directive/ngEventDirs.js
@@ -2,7 +2,7 @@
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngClick
+ * @name ng.directive:ngClick
  *
  * @description
  * The ngClick allows you to specify custom behavior when
@@ -55,7 +55,7 @@ forEach(
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngDblclick
+ * @name ng.directive:ngDblclick
  *
  * @description
  * The `ngDblclick` directive allows you to specify custom behavior on dblclick event.
@@ -65,13 +65,13 @@ forEach(
  * dblclick. (Event object is available as `$event`)
  *
  * @example
- * See {@link angular.module.ng.$compileProvider.directive.ngClick ngClick}
+ * See {@link ng.directive:ngClick ngClick}
  */
 
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngMousedown
+ * @name ng.directive:ngMousedown
  *
  * @description
  * The ngMousedown directive allows you to specify custom behavior on mousedown event.
@@ -81,13 +81,13 @@ forEach(
  * mousedown. (Event object is available as `$event`)
  *
  * @example
- * See {@link angular.module.ng.$compileProvider.directive.ngClick ngClick}
+ * See {@link ng.directive:ngClick ngClick}
  */
 
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngMouseup
+ * @name ng.directive:ngMouseup
  *
  * @description
  * Specify custom behavior on mouseup event.
@@ -97,12 +97,12 @@ forEach(
  * mouseup. (Event object is available as `$event`)
  *
  * @example
- * See {@link angular.module.ng.$compileProvider.directive.ngClick ngClick}
+ * See {@link ng.directive:ngClick ngClick}
  */
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngMouseover
+ * @name ng.directive:ngMouseover
  *
  * @description
  * Specify custom behavior on mouseover event.
@@ -112,13 +112,13 @@ forEach(
  * mouseover. (Event object is available as `$event`)
  *
  * @example
- * See {@link angular.module.ng.$compileProvider.directive.ngClick ngClick}
+ * See {@link ng.directive:ngClick ngClick}
  */
 
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngMouseenter
+ * @name ng.directive:ngMouseenter
  *
  * @description
  * Specify custom behavior on mouseenter event.
@@ -128,13 +128,13 @@ forEach(
  * mouseenter. (Event object is available as `$event`)
  *
  * @example
- * See {@link angular.module.ng.$compileProvider.directive.ngClick ngClick}
+ * See {@link ng.directive:ngClick ngClick}
  */
 
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngMouseleave
+ * @name ng.directive:ngMouseleave
  *
  * @description
  * Specify custom behavior on mouseleave event.
@@ -144,13 +144,13 @@ forEach(
  * mouseleave. (Event object is available as `$event`)
  *
  * @example
- * See {@link angular.module.ng.$compileProvider.directive.ngClick ngClick}
+ * See {@link ng.directive:ngClick ngClick}
  */
 
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngMousemove
+ * @name ng.directive:ngMousemove
  *
  * @description
  * Specify custom behavior on mousemove event.
@@ -160,13 +160,13 @@ forEach(
  * mousemove. (Event object is available as `$event`)
  *
  * @example
- * See {@link angular.module.ng.$compileProvider.directive.ngClick ngClick}
+ * See {@link ng.directive:ngClick ngClick}
  */
 
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngSubmit
+ * @name ng.directive:ngSubmit
  *
  * @description
  * Enables binding angular expressions to onsubmit events.
diff --git a/src/ng/directive/ngInclude.js b/src/ng/directive/ngInclude.js
index 6d89e847ff28..261072069209 100644
--- a/src/ng/directive/ngInclude.js
+++ b/src/ng/directive/ngInclude.js
@@ -2,7 +2,7 @@
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngInclude
+ * @name ng.directive:ngInclude
  * @restrict ECA
  *
  * @description
@@ -18,7 +18,7 @@
  *                 make sure you wrap it in quotes, e.g. `src="'myPartialTemplate.html'"`.
  * @param {string=} onload Expression to evaluate when a new partial is loaded.
  *
- * @param {string=} autoscroll Whether `ngInclude` should call {@link angular.module.ng.$anchorScroll
+ * @param {string=} autoscroll Whether `ngInclude` should call {@link ng.$anchorScroll
  *                  $anchorScroll} to scroll the viewport after the content is loaded.
  *
  *                  - If the attribute is not set, disable scrolling.
@@ -72,8 +72,8 @@
 
 /**
  * @ngdoc event
- * @name angular.module.ng.$compileProvider.directive.ngInclude#$includeContentLoaded
- * @eventOf angular.module.ng.$compileProvider.directive.ngInclude
+ * @name ng.directive:ngInclude#$includeContentLoaded
+ * @eventOf ng.directive:ngInclude
  * @eventType emit on the current ngInclude scope
  * @description
  * Emitted every time the ngInclude content is reloaded.
diff --git a/src/ng/directive/ngInit.js b/src/ng/directive/ngInit.js
index 733547654a06..d157f3967d51 100644
--- a/src/ng/directive/ngInit.js
+++ b/src/ng/directive/ngInit.js
@@ -2,7 +2,7 @@
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngInit
+ * @name ng.directive:ngInit
  *
  * @description
  * The `ngInit` directive specifies initialization tasks to be executed
diff --git a/src/ng/directive/ngNonBindable.js b/src/ng/directive/ngNonBindable.js
index 6165c6f64cc6..6622677a5815 100644
--- a/src/ng/directive/ngNonBindable.js
+++ b/src/ng/directive/ngNonBindable.js
@@ -2,7 +2,7 @@
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngNonBindable
+ * @name ng.directive:ngNonBindable
  * @priority 1000
  *
  * @description
diff --git a/src/ng/directive/ngPluralize.js b/src/ng/directive/ngPluralize.js
index bf45645f2079..a3424cf5f324 100644
--- a/src/ng/directive/ngPluralize.js
+++ b/src/ng/directive/ngPluralize.js
@@ -2,7 +2,7 @@
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngPluralize
+ * @name ng.directive:ngPluralize
  * @restrict EA
  *
  * @description
diff --git a/src/ng/directive/ngRepeat.js b/src/ng/directive/ngRepeat.js
index d5d3a64ca298..6dd74ef53798 100644
--- a/src/ng/directive/ngRepeat.js
+++ b/src/ng/directive/ngRepeat.js
@@ -2,7 +2,7 @@
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngRepeat
+ * @name ng.directive:ngRepeat
  *
  * @description
  * The `ngRepeat` directive instantiates a template once per item from a collection. Each template
diff --git a/src/ng/directive/ngShowHide.js b/src/ng/directive/ngShowHide.js
index 56197b21d0a7..e381c1b7fc2d 100644
--- a/src/ng/directive/ngShowHide.js
+++ b/src/ng/directive/ngShowHide.js
@@ -2,7 +2,7 @@
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngShow
+ * @name ng.directive:ngShow
  *
  * @description
  * The `ngShow` and `ngHide` directives show or hide a portion of the DOM tree (HTML)
@@ -42,7 +42,7 @@ var ngShowDirective = ngDirective(function(scope, element, attr){
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngHide
+ * @name ng.directive:ngHide
  *
  * @description
  * The `ngHide` and `ngShow` directives hide or show a portion
diff --git a/src/ng/directive/ngStyle.js b/src/ng/directive/ngStyle.js
index 08b99ac432dd..5b0a37285e29 100644
--- a/src/ng/directive/ngStyle.js
+++ b/src/ng/directive/ngStyle.js
@@ -2,7 +2,7 @@
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngStyle
+ * @name ng.directive:ngStyle
  *
  * @description
  * The `ngStyle` directive allows you to set CSS style on an HTML element conditionally.
diff --git a/src/ng/directive/ngSwitch.js b/src/ng/directive/ngSwitch.js
index 52b501a6e261..7d4cc19292a4 100644
--- a/src/ng/directive/ngSwitch.js
+++ b/src/ng/directive/ngSwitch.js
@@ -2,7 +2,7 @@
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngSwitch
+ * @name ng.directive:ngSwitch
  * @restrict EA
  *
  * @description
diff --git a/src/ng/directive/ngTransclude.js b/src/ng/directive/ngTransclude.js
index aab6164094a8..bf09b9c183c5 100644
--- a/src/ng/directive/ngTransclude.js
+++ b/src/ng/directive/ngTransclude.js
@@ -2,7 +2,7 @@
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngTransclude
+ * @name ng.directive:ngTransclude
  *
  * @description
  * Insert the transcluded DOM here.
diff --git a/src/ng/directive/ngView.js b/src/ng/directive/ngView.js
index 286468222960..6bfbb279ab6e 100644
--- a/src/ng/directive/ngView.js
+++ b/src/ng/directive/ngView.js
@@ -2,12 +2,12 @@
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.ngView
+ * @name ng.directive:ngView
  * @restrict ECA
  *
  * @description
  * # Overview
- * `ngView` is a directive that complements the {@link angular.module.ng.$route $route} service by
+ * `ngView` is a directive that complements the {@link ng.$route $route} service by
  * including the rendered template of the current route into the main layout (`index.html`) file.
  * Every time the current route changes, the included view changes with it according to the
  * configuration of the `$route` service.
@@ -98,8 +98,8 @@
 
 /**
  * @ngdoc event
- * @name angular.module.ng.$compileProvider.directive.ngView#$viewContentLoaded
- * @eventOf angular.module.ng.$compileProvider.directive.ngView
+ * @name ng.directive:ngView#$viewContentLoaded
+ * @eventOf ng.directive:ngView
  * @eventType emit on the current ngView scope
  * @description
  * Emitted every time the ngView content is reloaded.
diff --git a/src/ng/directive/script.js b/src/ng/directive/script.js
index 79f8b26e206a..16bd7d15b7d9 100644
--- a/src/ng/directive/script.js
+++ b/src/ng/directive/script.js
@@ -2,7 +2,7 @@
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.script
+ * @name ng.directive:script
  *
  * @description
  * Load content of a script tag, with type `text/ng-template`, into `$templateCache`, so that the
diff --git a/src/ng/directive/select.js b/src/ng/directive/select.js
index b269973f43a7..27a92c4877d9 100644
--- a/src/ng/directive/select.js
+++ b/src/ng/directive/select.js
@@ -2,7 +2,7 @@
 
 /**
  * @ngdoc directive
- * @name angular.module.ng.$compileProvider.directive.select
+ * @name ng.directive:select
  * @restrict E
  *
  * @description
@@ -23,7 +23,7 @@
  * option. See example below for demonstration.
  *
  * Note: `ngOptions` provides iterator facility for `