docs(ng.$rootScope.Scope): fix API links

gurdiga · petebacondarwin · commit 9e538e7c311f · 2013-12-12T11:19:16.000Z
Also added a note to the Writing AngularJS Documentation: https://github.com/angular/angular.js/wiki/Writing-AngularJS-Documentation/d0c715ef89 Closes #5261
diff --git a/src/ng/rootScope.js b/src/ng/rootScope.js
@@ -156,11 +156,11 @@ function $RootScopeProvider(){
        * @description
        * Creates a new child {@link ng.$rootScope.Scope scope}.
        *
-       * The parent scope will propagate the {@link ng.$rootScope.Scope#$digest $digest()} and
-       * {@link ng.$rootScope.Scope#$digest $digest()} events. The scope can be removed from the
-       * scope hierarchy using {@link ng.$rootScope.Scope#$destroy $destroy()}.
+       * The parent scope will propagate the {@link ng.$rootScope.Scope#methods_$digest $digest()} and
+       * {@link ng.$rootScope.Scope#methods_$digest $digest()} events. The scope can be removed from the
+       * scope hierarchy using {@link ng.$rootScope.Scope#methods_$destroy $destroy()}.
        *
-       * {@link ng.$rootScope.Scope#$destroy $destroy()} must be called on a scope when it is
+       * {@link ng.$rootScope.Scope#methods_$destroy $destroy()} must be called on a scope when it is
        * desired for the scope and its child scopes to be permanently detached from the parent and
        * thus stop participating in model change detection and listener notification by invoking.
        *
@@ -213,11 +213,11 @@ function $RootScopeProvider(){
        * @description
        * Registers a `listener` callback to be executed whenever the `watchExpression` changes.
        *
-       * - The `watchExpression` is called on every call to {@link ng.$rootScope.Scope#$digest
+       * - The `watchExpression` is called on every call to {@link ng.$rootScope.Scope#methods_$digest
        *   $digest()} and should return the value that will be watched. (Since
-       *   {@link ng.$rootScope.Scope#$digest $digest()} reruns when it detects changes the
+       *   {@link ng.$rootScope.Scope#methods_$digest $digest()} reruns when it detects changes the
        *   `watchExpression` can execute multiple times per
-       *   {@link ng.$rootScope.Scope#$digest $digest()} and should be idempotent.)
+       *   {@link ng.$rootScope.Scope#methods_$digest $digest()} and should be idempotent.)
        * - The `listener` is called only when the value from the current `watchExpression` and the
        *   previous call to `watchExpression` are not equal (with the exception of the initial run,
        *   see below). The inequality is determined according to
@@ -229,13 +229,13 @@ function $RootScopeProvider(){
        *   iteration limit is 10 to prevent an infinite loop deadlock.
        *
        *
-       * If you want to be notified whenever {@link ng.$rootScope.Scope#$digest $digest} is called,
+       * If you want to be notified whenever {@link ng.$rootScope.Scope#methods_$digest $digest} is called,
        * you can register a `watchExpression` function with no `listener`. (Since `watchExpression`
-       * can execute multiple times per {@link ng.$rootScope.Scope#$digest $digest} cycle when a
+       * can execute multiple times per {@link ng.$rootScope.Scope#methods_$digest $digest} cycle when a
        * change is detected, be prepared for multiple calls to your listener.)
        *
        * After a watcher is registered with the scope, the `listener` fn is called asynchronously
-       * (via {@link ng.$rootScope.Scope#$evalAsync $evalAsync}) to initialize the
+       * (via {@link ng.$rootScope.Scope#methods_$evalAsync $evalAsync}) to initialize the
        * watcher. In rare cases, this is undesirable because the listener is called when the result
        * of `watchExpression` didn't change. To detect this scenario within the `listener` fn, you
        * can compare the `newVal` and `oldVal`. If these two values are identical (`===`) then the
@@ -299,7 +299,7 @@ function $RootScopeProvider(){
        *
        *
        * @param {(function()|string)} watchExpression Expression that is evaluated on each
-       *    {@link ng.$rootScope.Scope#$digest $digest} cycle. A change in the return value triggers
+       *    {@link ng.$rootScope.Scope#methods_$digest $digest} cycle. A change in the return value triggers
        *    a call to the `listener`.
        *
        *    - `string`: Evaluated as {@link guide/expression expression}
@@ -397,7 +397,7 @@ function $RootScopeProvider(){
        *
        * @param {string|Function(scope)} obj Evaluated as {@link guide/expression expression}. The
        *    expression value should evaluate to an object or an array which is observed on each
-       *    {@link ng.$rootScope.Scope#$digest $digest} cycle. Any shallow change within the
+       *    {@link ng.$rootScope.Scope#methods_$digest $digest} cycle. Any shallow change within the
        *    collection will trigger a call to the `listener`.
        *
        * @param {function(newCollection, oldCollection, scope)} listener a callback function that is
@@ -502,22 +502,22 @@ function $RootScopeProvider(){
        * @function
        *
        * @description
-       * Processes all of the {@link ng.$rootScope.Scope#$watch watchers} of the current scope and
-       * its children. Because a {@link ng.$rootScope.Scope#$watch watcher}'s listener can change
-       * the model, the `$digest()` keeps calling the {@link ng.$rootScope.Scope#$watch watchers}
+       * Processes all of the {@link ng.$rootScope.Scope#methods_$watch watchers} of the current scope and
+       * its children. Because a {@link ng.$rootScope.Scope#methods_$watch watcher}'s listener can change
+       * the model, the `$digest()` keeps calling the {@link ng.$rootScope.Scope#methods_$watch watchers}
        * until no more listeners are firing. This means that it is possible to get into an infinite
        * loop. This function will throw `'Maximum iteration limit exceeded.'` if the number of
        * iterations exceeds 10.
        *
        * Usually, you don't call `$digest()` directly in
        * {@link ng.directive:ngController controllers} or in
        * {@link ng.$compileProvider#methods_directive directives}.
-       * Instead, you should call {@link ng.$rootScope.Scope#$apply $apply()} (typically from within
+       * Instead, you should call {@link ng.$rootScope.Scope#methods_$apply $apply()} (typically from within
        * a {@link ng.$compileProvider#methods_directive directives}), which will force a `$digest()`.
        *
        * If you want to be notified whenever `$digest()` is called,
        * you can register a `watchExpression` function with
-       * {@link ng.$rootScope.Scope#$watch $watch()} with no `listener`.
+       * {@link ng.$rootScope.Scope#methods_$watch $watch()} with no `listener`.
        *
        * In unit tests, you may need to call `$digest()` to simulate the scope life cycle.
        *
@@ -672,7 +672,7 @@ function $RootScopeProvider(){
        *
        * @description
        * Removes the current scope (and all of its children) from the parent scope. Removal implies
-       * that calls to {@link ng.$rootScope.Scope#$digest $digest()} will no longer
+       * that calls to {@link ng.$rootScope.Scope#methods_$digest $digest()} will no longer
        * propagate to the current scope and its children. Removal also implies that the current
        * scope is eligible for garbage collection.
        *
@@ -754,7 +754,7 @@ function $RootScopeProvider(){
        *
        *   - it will execute after the function that scheduled the evaluation (preferably before DOM
        *     rendering).
-       *   - at least one {@link ng.$rootScope.Scope#$digest $digest cycle} will be performed after
+       *   - at least one {@link ng.$rootScope.Scope#methods_$digest $digest cycle} will be performed after
        *     `expression` execution.
        *
        * Any exceptions from the execution of the expression are forwarded to the
@@ -799,7 +799,7 @@ function $RootScopeProvider(){
        * framework. (For example from browser DOM events, setTimeout, XHR or third party libraries).
        * Because we are calling into the angular framework we need to perform proper scope life
        * cycle of {@link ng.$exceptionHandler exception handling},
-       * {@link ng.$rootScope.Scope#$digest executing watches}.
+       * {@link ng.$rootScope.Scope#methods_$digest executing watches}.
        *
        * ## Life cycle
        *
@@ -820,11 +820,11 @@ function $RootScopeProvider(){
        * Scope's `$apply()` method transitions through the following stages:
        *
        * 1. The {@link guide/expression expression} is executed using the
-       *    {@link ng.$rootScope.Scope#$eval $eval()} method.
+       *    {@link ng.$rootScope.Scope#methods_$eval $eval()} method.
        * 2. Any exceptions from the execution of the expression are forwarded to the
        *    {@link ng.$exceptionHandler $exceptionHandler} service.
-       * 3. The {@link ng.$rootScope.Scope#$watch watch} listeners are fired immediately after the
-       *    expression was executed using the {@link ng.$rootScope.Scope#$digest $digest()} method.
+       * 3. The {@link ng.$rootScope.Scope#methods_$watch watch} listeners are fired immediately after the
+       *    expression was executed using the {@link ng.$rootScope.Scope#methods_$digest $digest()} method.
        *
        *
        * @param {(string|function())=} exp An angular expression to be executed.
@@ -858,7 +858,7 @@ function $RootScopeProvider(){
        * @function
        *
        * @description
-       * Listens on events of a given type. See {@link ng.$rootScope.Scope#$emit $emit} for
+       * Listens on events of a given type. See {@link ng.$rootScope.Scope#methods_$emit $emit} for
        * discussion of event life cycle.
        *
        * The event listener function format is: `function(event, args...)`. The `event` object
@@ -899,20 +899,20 @@ function $RootScopeProvider(){
        *
        * @description
        * Dispatches an event `name` upwards through the scope hierarchy notifying the
-       * registered {@link ng.$rootScope.Scope#$on} listeners.
+       * registered {@link ng.$rootScope.Scope#methods_$on} listeners.
        *
        * The event life cycle starts at the scope on which `$emit` was called. All
-       * {@link ng.$rootScope.Scope#$on listeners} listening for `name` event on this scope get
+       * {@link ng.$rootScope.Scope#methods_$on listeners} listening for `name` event on this scope get
        * notified. Afterwards, the event traverses upwards toward the root scope and calls all
        * registered listeners along the way. The event will stop propagating if one of the listeners
        * cancels it.
        *
-       * Any exception emitted from the {@link ng.$rootScope.Scope#$on listeners} will be passed
+       * Any exception emitted from the {@link ng.$rootScope.Scope#methods_$on listeners} will be passed
        * onto the {@link ng.$exceptionHandler $exceptionHandler} service.
        *
        * @param {string} name Event name to emit.
        * @param {...*} args Optional set of arguments which will be passed onto the event listeners.
-       * @return {Object} Event object (see {@link ng.$rootScope.Scope#$on}).
+       * @return {Object} Event object (see {@link ng.$rootScope.Scope#methods_$on}).
        */
       $emit: function(name, args) {
         var empty = [],
@@ -968,19 +968,19 @@ function $RootScopeProvider(){
        *
        * @description
        * Dispatches an event `name` downwards to all child scopes (and their children) notifying the
-       * registered {@link ng.$rootScope.Scope#$on} listeners.
+       * registered {@link ng.$rootScope.Scope#methods_$on} listeners.
        *
        * The event life cycle starts at the scope on which `$broadcast` was called. All
-       * {@link ng.$rootScope.Scope#$on listeners} listening for `name` event on this scope get
+       * {@link ng.$rootScope.Scope#methods_$on listeners} listening for `name` event on this scope get
        * notified. Afterwards, the event propagates to all direct and indirect scopes of the current
        * scope and calls all registered listeners along the way. The event cannot be canceled.
        *
-       * Any exception emitted from the {@link ng.$rootScope.Scope#$on listeners} will be passed
+       * Any exception emitted from the {@link ng.$rootScope.Scope#methods_$on listeners} will be passed
        * onto the {@link ng.$exceptionHandler $exceptionHandler} service.
        *
        * @param {string} name Event name to broadcast.
        * @param {...*} args Optional set of arguments which will be passed onto the event listeners.
-       * @return {Object} Event object, see {@link ng.$rootScope.Scope#$on}
+       * @return {Object} Event object, see {@link ng.$rootScope.Scope#methods_$on}
        */
       $broadcast: function(name, args) {
         var target = this,

Original file line number	Diff line number	Diff line change
`@@ -156,11 +156,11 @@ function $RootScopeProvider(){`
`156`	`156`	`* @description`
`157`	`157`	`* Creates a new child {@link ng.$rootScope.Scope scope}.`
`158`	`158`	`*`
`159`		`- * The parent scope will propagate the {@link ng.$rootScope.Scope#$digest $digest()} and`
`160`		`- * {@link ng.$rootScope.Scope#$digest $digest()} events. The scope can be removed from the`
`161`		`- * scope hierarchy using {@link ng.$rootScope.Scope#$destroy $destroy()}.`
	`159`	`+ * The parent scope will propagate the {@link ng.$rootScope.Scope#methods_$digest $digest()} and`
	`160`	`+ * {@link ng.$rootScope.Scope#methods_$digest $digest()} events. The scope can be removed from the`
	`161`	`+ * scope hierarchy using {@link ng.$rootScope.Scope#methods_$destroy $destroy()}.`
`162`	`162`	`*`
`163`		`- * {@link ng.$rootScope.Scope#$destroy $destroy()} must be called on a scope when it is`
	`163`	`+ * {@link ng.$rootScope.Scope#methods_$destroy $destroy()} must be called on a scope when it is`
`164`	`164`	`* desired for the scope and its child scopes to be permanently detached from the parent and`
`165`	`165`	`* thus stop participating in model change detection and listener notification by invoking.`
`166`	`166`	`*`
`@@ -213,11 +213,11 @@ function $RootScopeProvider(){`
`213`	`213`	`* @description`
`214`	`214`	* Registers a `listener` callback to be executed whenever the `watchExpression` changes.
`215`	`215`	`*`
`216`		- * - The `watchExpression` is called on every call to {@link ng.$rootScope.Scope#$digest
	`216`	+ * - The `watchExpression` is called on every call to {@link ng.$rootScope.Scope#methods_$digest
`217`	`217`	`* $digest()} and should return the value that will be watched. (Since`
`218`		`- * {@link ng.$rootScope.Scope#$digest $digest()} reruns when it detects changes the`
	`218`	`+ * {@link ng.$rootScope.Scope#methods_$digest $digest()} reruns when it detects changes the`
`219`	`219`	* `watchExpression` can execute multiple times per
`220`		`- * {@link ng.$rootScope.Scope#$digest $digest()} and should be idempotent.)`
	`220`	`+ * {@link ng.$rootScope.Scope#methods_$digest $digest()} and should be idempotent.)`
`221`	`221`	* - The `listener` is called only when the value from the current `watchExpression` and the
`222`	`222`	* previous call to `watchExpression` are not equal (with the exception of the initial run,
`223`	`223`	`* see below). The inequality is determined according to`
`@@ -229,13 +229,13 @@ function $RootScopeProvider(){`
`229`	`229`	`* iteration limit is 10 to prevent an infinite loop deadlock.`
`230`	`230`	`*`
`231`	`231`	`*`
`232`		`- * If you want to be notified whenever {@link ng.$rootScope.Scope#$digest $digest} is called,`
	`232`	`+ * If you want to be notified whenever {@link ng.$rootScope.Scope#methods_$digest $digest} is called,`
`233`	`233`	* you can register a `watchExpression` function with no `listener`. (Since `watchExpression`
`234`		`- * can execute multiple times per {@link ng.$rootScope.Scope#$digest $digest} cycle when a`
	`234`	`+ * can execute multiple times per {@link ng.$rootScope.Scope#methods_$digest $digest} cycle when a`
`235`	`235`	`* change is detected, be prepared for multiple calls to your listener.)`
`236`	`236`	`*`
`237`	`237`	* After a watcher is registered with the scope, the `listener` fn is called asynchronously
`238`		`- * (via {@link ng.$rootScope.Scope#$evalAsync $evalAsync}) to initialize the`
	`238`	`+ * (via {@link ng.$rootScope.Scope#methods_$evalAsync $evalAsync}) to initialize the`
`239`	`239`	`* watcher. In rare cases, this is undesirable because the listener is called when the result`
`240`	`240`	* of `watchExpression` didn't change. To detect this scenario within the `listener` fn, you
`241`	`241`	* can compare the `newVal` and `oldVal`. If these two values are identical (`===`) then the
`@@ -299,7 +299,7 @@ function $RootScopeProvider(){`
`299`	`299`	`*`
`300`	`300`	`*`
`301`	`301`	`* @param {(function()\|string)} watchExpression Expression that is evaluated on each`
`302`		`- * {@link ng.$rootScope.Scope#$digest $digest} cycle. A change in the return value triggers`
	`302`	`+ * {@link ng.$rootScope.Scope#methods_$digest $digest} cycle. A change in the return value triggers`
`303`	`303`	* a call to the `listener`.
`304`	`304`	`*`
`305`	`305`	* - `string`: Evaluated as {@link guide/expression expression}
`@@ -397,7 +397,7 @@ function $RootScopeProvider(){`
`397`	`397`	`*`
`398`	`398`	`* @param {string\|Function(scope)} obj Evaluated as {@link guide/expression expression}. The`
`399`	`399`	`* expression value should evaluate to an object or an array which is observed on each`
`400`		`- * {@link ng.$rootScope.Scope#$digest $digest} cycle. Any shallow change within the`
	`400`	`+ * {@link ng.$rootScope.Scope#methods_$digest $digest} cycle. Any shallow change within the`
`401`	`401`	* collection will trigger a call to the `listener`.
`402`	`402`	`*`
`403`	`403`	`* @param {function(newCollection, oldCollection, scope)} listener a callback function that is`
`@@ -502,22 +502,22 @@ function $RootScopeProvider(){`
`502`	`502`	`* @function`
`503`	`503`	`*`
`504`	`504`	`* @description`
`505`		`- * Processes all of the {@link ng.$rootScope.Scope#$watch watchers} of the current scope and`
`506`		`- * its children. Because a {@link ng.$rootScope.Scope#$watch watcher}'s listener can change`
`507`		- * the model, the `$digest()` keeps calling the {@link ng.$rootScope.Scope#$watch watchers}
	`505`	`+ * Processes all of the {@link ng.$rootScope.Scope#methods_$watch watchers} of the current scope and`
	`506`	`+ * its children. Because a {@link ng.$rootScope.Scope#methods_$watch watcher}'s listener can change`
	`507`	+ * the model, the `$digest()` keeps calling the {@link ng.$rootScope.Scope#methods_$watch watchers}
`508`	`508`	`* until no more listeners are firing. This means that it is possible to get into an infinite`
`509`	`509`	* loop. This function will throw `'Maximum iteration limit exceeded.'` if the number of
`510`	`510`	`* iterations exceeds 10.`
`511`	`511`	`*`
`512`	`512`	* Usually, you don't call `$digest()` directly in
`513`	`513`	`* {@link ng.directive:ngController controllers} or in`
`514`	`514`	`* {@link ng.$compileProvider#methods_directive directives}.`
`515`		`- * Instead, you should call {@link ng.$rootScope.Scope#$apply $apply()} (typically from within`
	`515`	`+ * Instead, you should call {@link ng.$rootScope.Scope#methods_$apply $apply()} (typically from within`
`516`	`516`	* a {@link ng.$compileProvider#methods_directive directives}), which will force a `$digest()`.
`517`	`517`	`*`
`518`	`518`	* If you want to be notified whenever `$digest()` is called,
`519`	`519`	* you can register a `watchExpression` function with
`520`		- * {@link ng.$rootScope.Scope#$watch $watch()} with no `listener`.
	`520`	+ * {@link ng.$rootScope.Scope#methods_$watch $watch()} with no `listener`.
`521`	`521`	`*`
`522`	`522`	* In unit tests, you may need to call `$digest()` to simulate the scope life cycle.
`523`	`523`	`*`
`@@ -672,7 +672,7 @@ function $RootScopeProvider(){`
`672`	`672`	`*`
`673`	`673`	`* @description`
`674`	`674`	`* Removes the current scope (and all of its children) from the parent scope. Removal implies`
`675`		`- * that calls to {@link ng.$rootScope.Scope#$digest $digest()} will no longer`
	`675`	`+ * that calls to {@link ng.$rootScope.Scope#methods_$digest $digest()} will no longer`
`676`	`676`	`* propagate to the current scope and its children. Removal also implies that the current`
`677`	`677`	`* scope is eligible for garbage collection.`
`678`	`678`	`*`
`@@ -754,7 +754,7 @@ function $RootScopeProvider(){`
`754`	`754`	`*`
`755`	`755`	`* - it will execute after the function that scheduled the evaluation (preferably before DOM`
`756`	`756`	`* rendering).`
`757`		`- * - at least one {@link ng.$rootScope.Scope#$digest $digest cycle} will be performed after`
	`757`	`+ * - at least one {@link ng.$rootScope.Scope#methods_$digest $digest cycle} will be performed after`
`758`	`758`	* `expression` execution.
`759`	`759`	`*`
`760`	`760`	`* Any exceptions from the execution of the expression are forwarded to the`
`@@ -799,7 +799,7 @@ function $RootScopeProvider(){`
`799`	`799`	`* framework. (For example from browser DOM events, setTimeout, XHR or third party libraries).`
`800`	`800`	`* Because we are calling into the angular framework we need to perform proper scope life`
`801`	`801`	`* cycle of {@link ng.$exceptionHandler exception handling},`
`802`		`- * {@link ng.$rootScope.Scope#$digest executing watches}.`
	`802`	`+ * {@link ng.$rootScope.Scope#methods_$digest executing watches}.`
`803`	`803`	`*`
`804`	`804`	`* ## Life cycle`
`805`	`805`	`*`
`@@ -820,11 +820,11 @@ function $RootScopeProvider(){`
`820`	`820`	* Scope's `$apply()` method transitions through the following stages:
`821`	`821`	`*`
`822`	`822`	`* 1. The {@link guide/expression expression} is executed using the`
`823`		`- * {@link ng.$rootScope.Scope#$eval $eval()} method.`
	`823`	`+ * {@link ng.$rootScope.Scope#methods_$eval $eval()} method.`
`824`	`824`	`* 2. Any exceptions from the execution of the expression are forwarded to the`
`825`	`825`	`* {@link ng.$exceptionHandler $exceptionHandler} service.`
`826`		`- * 3. The {@link ng.$rootScope.Scope#$watch watch} listeners are fired immediately after the`
`827`		`- * expression was executed using the {@link ng.$rootScope.Scope#$digest $digest()} method.`
	`826`	`+ * 3. The {@link ng.$rootScope.Scope#methods_$watch watch} listeners are fired immediately after the`
	`827`	`+ * expression was executed using the {@link ng.$rootScope.Scope#methods_$digest $digest()} method.`
`828`	`828`	`*`
`829`	`829`	`*`
`830`	`830`	`* @param {(string\|function())=} exp An angular expression to be executed.`
`@@ -858,7 +858,7 @@ function $RootScopeProvider(){`
`858`	`858`	`* @function`
`859`	`859`	`*`
`860`	`860`	`* @description`
`861`		`- * Listens on events of a given type. See {@link ng.$rootScope.Scope#$emit $emit} for`
	`861`	`+ * Listens on events of a given type. See {@link ng.$rootScope.Scope#methods_$emit $emit} for`
`862`	`862`	`* discussion of event life cycle.`
`863`	`863`	`*`
`864`	`864`	* The event listener function format is: `function(event, args...)`. The `event` object
`@@ -899,20 +899,20 @@ function $RootScopeProvider(){`
`899`	`899`	`*`
`900`	`900`	`* @description`
`901`	`901`	* Dispatches an event `name` upwards through the scope hierarchy notifying the
`902`		`- * registered {@link ng.$rootScope.Scope#$on} listeners.`
	`902`	`+ * registered {@link ng.$rootScope.Scope#methods_$on} listeners.`
`903`	`903`	`*`
`904`	`904`	* The event life cycle starts at the scope on which `$emit` was called. All
`905`		- * {@link ng.$rootScope.Scope#$on listeners} listening for `name` event on this scope get
	`905`	+ * {@link ng.$rootScope.Scope#methods_$on listeners} listening for `name` event on this scope get
`906`	`906`	`* notified. Afterwards, the event traverses upwards toward the root scope and calls all`
`907`	`907`	`* registered listeners along the way. The event will stop propagating if one of the listeners`
`908`	`908`	`* cancels it.`
`909`	`909`	`*`
`910`		`- * Any exception emitted from the {@link ng.$rootScope.Scope#$on listeners} will be passed`
	`910`	`+ * Any exception emitted from the {@link ng.$rootScope.Scope#methods_$on listeners} will be passed`
`911`	`911`	`* onto the {@link ng.$exceptionHandler $exceptionHandler} service.`
`912`	`912`	`*`
`913`	`913`	`* @param {string} name Event name to emit.`
`914`	`914`	`* @param {...*} args Optional set of arguments which will be passed onto the event listeners.`
`915`		`- * @return {Object} Event object (see {@link ng.$rootScope.Scope#$on}).`
	`915`	`+ * @return {Object} Event object (see {@link ng.$rootScope.Scope#methods_$on}).`
`916`	`916`	`*/`
`917`	`917`	`$emit: function(name, args) {`
`918`	`918`	`var empty = [],`
`@@ -968,19 +968,19 @@ function $RootScopeProvider(){`
`968`	`968`	`*`
`969`	`969`	`* @description`
`970`	`970`	* Dispatches an event `name` downwards to all child scopes (and their children) notifying the
`971`		`- * registered {@link ng.$rootScope.Scope#$on} listeners.`
	`971`	`+ * registered {@link ng.$rootScope.Scope#methods_$on} listeners.`
`972`	`972`	`*`
`973`	`973`	* The event life cycle starts at the scope on which `$broadcast` was called. All
`974`		- * {@link ng.$rootScope.Scope#$on listeners} listening for `name` event on this scope get
	`974`	+ * {@link ng.$rootScope.Scope#methods_$on listeners} listening for `name` event on this scope get
`975`	`975`	`* notified. Afterwards, the event propagates to all direct and indirect scopes of the current`
`976`	`976`	`* scope and calls all registered listeners along the way. The event cannot be canceled.`
`977`	`977`	`*`
`978`		`- * Any exception emitted from the {@link ng.$rootScope.Scope#$on listeners} will be passed`
	`978`	`+ * Any exception emitted from the {@link ng.$rootScope.Scope#methods_$on listeners} will be passed`
`979`	`979`	`* onto the {@link ng.$exceptionHandler $exceptionHandler} service.`
`980`	`980`	`*`
`981`	`981`	`* @param {string} name Event name to broadcast.`
`982`	`982`	`* @param {...*} args Optional set of arguments which will be passed onto the event listeners.`
`983`		`- * @return {Object} Event object, see {@link ng.$rootScope.Scope#$on}`
	`983`	`+ * @return {Object} Event object, see {@link ng.$rootScope.Scope#methods_$on}`
`984`	`984`	`*/`
`985`	`985`	`$broadcast: function(name, args) {`
`986`	`986`	`var target = this,`