docs: fix typos throughout the codebase

jutaz · gkalpak · commit e57cf13d5da2 · 2015-12-11T21:04:18.000+02:00
Closes #13507
diff --git a/.travis.yml b/.travis.yml
@@ -47,7 +47,7 @@ install:
   # Log HTTP requests
   - npm config set loglevel http
   - npm install -g npm@2.5
-  # Instal npm dependecies and ensure that npm cache is not stale
+  # Install npm dependencies and ensure that npm cache is not stale
   - npm install
 
 before_script:
diff --git a/CHANGELOG.md b/CHANGELOG.md
diff --git a/i18n/closure/numberSymbolsExt.js b/i18n/closure/numberSymbolsExt.js
@@ -20,7 +20,7 @@
  * using the --for_closure flag.
  * File generated from CLDR ver. 27.0.1
  *
- * This file coveres those locales that are not covered in
+ * This file covers those locales that are not covered in
  * "numberformatsymbols.js".
  *
  * Before checkin, this file could have been manually edited. This is
diff --git a/i18n/src/parser.js b/i18n/src/parser.js
@@ -11,7 +11,7 @@ var PATTERN_SEP = ';',
     DIGIT       = '#';
 
 /**
- * main funciton for parser
+ * main function for parser
  * @param str {string} pattern to be parsed (e.g. #,##0.###).
  */
 function parsePattern(pattern) {
diff --git a/lib/versions/version-info.js b/lib/versions/version-info.js
@@ -178,7 +178,7 @@ var getSnapshotVersion = function() {
     // last release was a non beta release. Increment the patch level to
     // indicate the next release that we will be doing.
     // E.g. last release was 1.3.0, then the snapshot will be
-    // 1.3.1-build.1, which is lesser than 1.3.1 accorind the semver!
+    // 1.3.1-build.1, which is lesser than 1.3.1 according to the semver!
 
     // If the last release was a beta release we don't update the
     // beta number by purpose, as otherwise the semver comparison
diff --git a/src/Angular.js b/src/Angular.js
@@ -204,7 +204,7 @@ function isArrayLike(obj) {
 
   // arrays, strings and jQuery/jqLite objects are array like
   // * jqLite is either the jQuery or jqLite constructor function
-  // * we have to check the existance of jqLite first as this method is called
+  // * we have to check the existence of jqLite first as this method is called
   //   via the forEach method when constructing the jqLite object in the first place
   if (isArray(obj) || isString(obj) || (jqLite && obj instanceof jqLite)) return true;
 
diff --git a/src/jqLite.js b/src/jqLite.js
@@ -504,7 +504,7 @@ function jqLiteRemove(element, keepData) {
 function jqLiteDocumentLoaded(action, win) {
   win = win || window;
   if (win.document.readyState === 'complete') {
-    // Force the action to be run async for consistent behaviour
+    // Force the action to be run async for consistent behavior
     // from the action's point of view
     // i.e. it will definitely not be in a $apply
     win.setTimeout(action);
diff --git a/src/ng/animate.js b/src/ng/animate.js
@@ -551,14 +551,14 @@ var $AnimateProvider = ['$provide', function($provide) {
        * If any detected CSS transition, keyframe or JavaScript matches the provided className value then the animation will take
        * on the provided styles. For example, if a transition animation is set for the given className then the provided from and
        * to styles will be applied alongside the given transition. If a JavaScript animation is detected then the provided styles
-       * will be given in as function paramters into the `animate` method (or as apart of the `options` parameter).
+       * will be given in as function parameters into the `animate` method (or as apart of the `options` parameter).
        *
        * @param {DOMElement} element the element which the CSS styles will be applied to
        * @param {object} from the from (starting) CSS styles that will be applied to the element and across the animation.
        * @param {object} to the to (destination) CSS styles that will be applied to the element and across the animation.
        * @param {string=} className an optional CSS class that will be applied to the element for the duration of the animation. If
        *    this value is left as empty then a CSS class of `ng-inline-animate` will be applied to the element.
-       *    (Note that if no animation is detected then this value will not be appplied to the element.)
+       *    (Note that if no animation is detected then this value will not be applied to the element.)
        * @param {object=} options an optional collection of options/styles that will be applied to the element
        *
        * @return {Promise} the animation callback promise
diff --git a/src/ng/compile.js b/src/ng/compile.js
@@ -128,7 +128,7 @@
  * When this property is set to true, the HTML compiler will collect DOM nodes between
  * nodes with the attributes `directive-name-start` and `directive-name-end`, and group them
  * together as the directive elements. It is recommended that this feature be used on directives
- * which are not strictly behavioural (such as {@link ngClick}), and which
+ * which are not strictly behavioral (such as {@link ngClick}), and which
  * do not manipulate or replace child nodes (such as {@link ngInclude}).
  *
  * #### `priority`
@@ -517,7 +517,7 @@
  * content and the `scope` is the newly created transclusion scope, to which the clone is bound.
  *
  * <div class="alert alert-info">
- * **Best Practice**: Always provide a `cloneFn` (clone attach function) when you call a translude function
+ * **Best Practice**: Always provide a `cloneFn` (clone attach function) when you call a transclude function
  * since you then get a fresh clone of the original DOM and also have access to the new transclusion scope.
  * </div>
  *
@@ -549,7 +549,7 @@
  * </div>
  *
  * The built-in DOM manipulation directives, such as {@link ngIf}, {@link ngSwitch} and {@link ngRepeat}
- * automatically destroy their transluded clones as necessary so you do not need to worry about this if
+ * automatically destroy their transcluded clones as necessary so you do not need to worry about this if
  * you are simply using {@link ngTransclude} to inject the transclusion into your directive.
  *
  *
diff --git a/src/ng/directive/form.js b/src/ng/directive/form.js
@@ -127,7 +127,7 @@ function FormController(element, attrs, $scope, $animate, $interpolate) {
    *
    * However, if the method is used programmatically, for example by adding dynamically created controls,
    * or controls that have been previously removed without destroying their corresponding DOM element,
-   * it's the developers responsiblity to make sure the current state propagates to the parent form.
+   * it's the developers responsibility to make sure the current state propagates to the parent form.
    *
    * For example, if an input control is added that is already `$dirty` and has `$error` properties,
    * calling `$setDirty()` and `$validate()` afterwards will propagate the state to the parent form.
diff --git a/src/ng/directive/ngCsp.js b/src/ng/directive/ngCsp.js
@@ -47,7 +47,7 @@
  *
  * * no-inline-style: this stops Angular from injecting CSS styles into the DOM
  *
- * * no-unsafe-eval: this stops Angular from optimising $parse with unsafe eval of strings
+ * * no-unsafe-eval: this stops Angular from optimizing $parse with unsafe eval of strings
  *
  * You can use these values in the following combinations:
  *
@@ -64,7 +64,7 @@
  * inline styles. E.g. `<body ng-csp="no-unsafe-eval">`.
  *
  * * Specifying only `no-inline-style` tells Angular that we must not inject styles, but that we can
- * run eval - no automcatic check for unsafe eval will occur. E.g. `<body ng-csp="no-inline-style">`
+ * run eval - no automatic check for unsafe eval will occur. E.g. `<body ng-csp="no-inline-style">`
  *
  * * Specifying both `no-unsafe-eval` and `no-inline-style` tells Angular that we must not inject
  * styles nor use eval, which is the same as an empty: ng-csp.
diff --git a/src/ng/directive/ngModel.js b/src/ng/directive/ngModel.js
@@ -793,7 +793,7 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
    * However, custom controls might also pass objects to this method. In this case, we should make
    * a copy of the object before passing it to `$setViewValue`. This is because `ngModel` does not
    * perform a deep watch of objects, it only looks for a change of identity. If you only change
-   * the property of the object then ngModel will not realise that the object has changed and
+   * the property of the object then ngModel will not realize that the object has changed and
    * will not invoke the `$parsers` and `$validators` pipelines. For this reason, you should
    * not change properties of the copy once it has been passed to `$setViewValue`.
    * Otherwise you may cause the model value on the scope to change incorrectly.
diff --git a/src/ng/directive/ngPluralize.js b/src/ng/directive/ngPluralize.js
@@ -215,7 +215,7 @@ var ngPluralizeDirective = ['$locale', '$interpolate', '$log', function($locale,
         }
 
         // If both `count` and `lastCount` are NaN, we don't need to re-register a watch.
-        // In JS `NaN !== NaN`, so we have to exlicitly check.
+        // In JS `NaN !== NaN`, so we have to explicitly check.
         if ((count !== lastCount) && !(countIsNaN && isNumber(lastCount) && isNaN(lastCount))) {
           watchRemover();
           var whenExpFn = whensExpFns[count];
diff --git a/src/ng/directive/ngRepeat.js b/src/ng/directive/ngRepeat.js
@@ -93,7 +93,7 @@
  * by the identifier instead of the whole object. Should you reload your data later, `ngRepeat`
  * will not have to rebuild the DOM elements for items it has already rendered, even if the
  * JavaScript objects in the collection have been substituted for new ones. For large collections,
- * this signifincantly improves rendering performance. If you don't have a unique identifier,
+ * this significantly improves rendering performance. If you don't have a unique identifier,
  * `track by $index` can also provide a performance boost.
  * </div>
  * ```html
diff --git a/src/ng/directive/select.js b/src/ng/directive/select.js
@@ -164,7 +164,7 @@ var SelectController =
  *
  * <div class="alert alert-warning">
  * Note that the value of a `select` directive used without `ngOptions` is always a string.
- * When the model needs to be bound to a non-string value, you must either explictly convert it
+ * When the model needs to be bound to a non-string value, you must either explicitly convert it
  * using a directive (see example below) or use `ngOptions` to specify the set of options.
  * This is because an option element can only be bound to string values at present.
  * </div>
diff --git a/src/ng/http.js b/src/ng/http.js
@@ -1034,7 +1034,7 @@ function $HttpProvider() {
 
         defHeaders = extend({}, defHeaders.common, defHeaders[lowercase(config.method)]);
 
-        // using for-in instead of forEach to avoid unecessary iteration after header has been found
+        // using for-in instead of forEach to avoid unnecessary iteration after header has been found
         defaultHeadersIteration:
         for (defHeaderName in defHeaders) {
           lowercaseDefHeaderName = lowercase(defHeaderName);
diff --git a/src/ng/q.js b/src/ng/q.js
@@ -53,7 +53,7 @@
  *
  * Note: progress/notify callbacks are not currently supported via the ES6-style interface.
  *
- * Note: unlike ES6 behaviour, an exception thrown in the constructor function will NOT implicitly reject the promise.
+ * Note: unlike ES6 behavior, an exception thrown in the constructor function will NOT implicitly reject the promise.
  *
  * However, the more traditional CommonJS-style usage is still available, and documented below.
  *
diff --git a/src/ngAnimate/animateCss.js b/src/ngAnimate/animateCss.js
@@ -167,7 +167,7 @@ var ANIMATE_TIMER_KEY = '$$animateCss';
  * ```
  *
  * To actually start the animation we need to run `animation.start()` which will then return a promise that we can hook into to detect when the animation ends.
- * If we choose not to run the animation then we MUST run `animation.end()` to perform a cleanup on the element (since some CSS classes and stlyes may have been
+ * If we choose not to run the animation then we MUST run `animation.end()` to perform a cleanup on the element (since some CSS classes and styles may have been
  * applied to the element during the preparation phase). Note that all other properties such as duration, delay, transitions and keyframes are just properties
  * and that changing them will not reconfigure the parameters of the animation.
  *
@@ -205,10 +205,10 @@ var ANIMATE_TIMER_KEY = '$$animateCss';
  * ({@link ngAnimate#css-staggering-animations Click here to learn how CSS-based staggering works in ngAnimate.})
  * * `staggerIndex` - The numeric index representing the stagger item (e.g. a value of 5 is equal to the sixth item in the stagger; therefore when a
  *   `stagger` option value of `0.1` is used then there will be a stagger delay of `600ms`)
- * * `applyClassesEarly` - Whether or not the classes being added or removed will be used when detecting the animation. This is set by `$animate` when enter/leave/move animations are fired to ensure that the CSS classes are resolved in time. (Note that this will prevent any transitions from occuring on the classes being added and removed.)
+ * * `applyClassesEarly` - Whether or not the classes being added or removed will be used when detecting the animation. This is set by `$animate` when enter/leave/move animations are fired to ensure that the CSS classes are resolved in time. (Note that this will prevent any transitions from occurring on the classes being added and removed.)
  * * `cleanupStyles` - Whether or not the provided `from` and `to` styles will be removed once
  *    the animation is closed. This is useful for when the styles are used purely for the sake of
- *    the animation and do not have a lasting visual effect on the element (e.g. a colapse and open animation).
+ *    the animation and do not have a lasting visual effect on the element (e.g. a collapse and open animation).
  *    By default this value is set to `false`.
  *
  * @return {object} an object with start and end methods and details about the animation.
@@ -261,7 +261,7 @@ function computeCssStyles($window, element, properties) {
       }
 
       // by setting this to null in the event that the delay is not set or is set directly as 0
-      // then we can still allow for zegative values to be used later on and not mistake this
+      // then we can still allow for negative values to be used later on and not mistake this
       // value for being greater than any other negative value.
       if (val === 0) {
         val = null;
@@ -377,7 +377,7 @@ var $AnimateCssProvider = ['$animateProvider', function($animateProvider) {
       }
 
       // we keep putting this in multiple times even though the value and the cacheKey are the same
-      // because we're keeping an interal tally of how many duplicate animations are detected.
+      // because we're keeping an internal tally of how many duplicate animations are detected.
       gcsLookup.put(cacheKey, timings);
       return timings;
     }
@@ -839,9 +839,9 @@ var $AnimateCssProvider = ['$animateProvider', function($animateProvider) {
           }
         };
 
-        // checking the stagger duration prevents an accidently cascade of the CSS delay style
+        // checking the stagger duration prevents an accidentally cascade of the CSS delay style
         // being inherited from the parent. If the transition duration is zero then we can safely
-        // rely that the delay value is an intential stagger delay style.
+        // rely that the delay value is an intentional stagger delay style.
         var maxStagger = itemIndex > 0
                          && ((timings.transitionDuration && stagger.transitionDuration === 0) ||
                             (timings.animationDuration && stagger.animationDuration === 0))
diff --git a/src/ngAnimate/animateCssDriver.js b/src/ngAnimate/animateCssDriver.js
@@ -24,7 +24,7 @@ var $$AnimateCssDriverProvider = ['$$animationProvider', function($$animationPro
 
     var rootBodyElement = jqLite(
       // this is to avoid using something that exists outside of the body
-      // we also special case the doc fragement case because our unit test code
+      // we also special case the doc fragment case because our unit test code
       // appends the $rootElement to the body after the app has been bootstrapped
       isDocumentFragment(rootNode) || bodyNode.contains(rootNode) ? rootNode : bodyNode
     );
@@ -124,7 +124,7 @@ var $$AnimateCssDriverProvider = ['$$animationProvider', function($$animationPro
         var coords = getDomNode(anchor).getBoundingClientRect();
 
         // we iterate directly since safari messes up and doesn't return
-        // all the keys for the coods object when iterated
+        // all the keys for the coords object when iterated
         forEach(['width','height','top','left'], function(key) {
           var value = coords[key];
           switch (key) {
diff --git a/src/ngAnimate/animation.js b/src/ngAnimate/animation.js
@@ -305,7 +305,7 @@ var $$AnimationProvider = ['$animateProvider', function($animateProvider) {
             };
 
             // the anchor animations require that the from and to elements both have at least
-            // one shared CSS class which effictively marries the two elements together to use
+            // one shared CSS class which effectively marries the two elements together to use
             // the same animation driver and to properly sequence the anchor animation.
             if (group.classes.length) {
               preparedAnimations.push(group);
diff --git a/src/ngAnimate/module.js b/src/ngAnimate/module.js
@@ -286,7 +286,7 @@
  *
  * ngAnimate also allows for animations to be consumed by JavaScript code. The approach is similar to CSS-based animations (where there is a shared
  * CSS class that is referenced in our HTML code) but in addition we need to register the JavaScript animation on the module. By making use of the
- * `module.animation()` module function we can register the ainmation.
+ * `module.animation()` module function we can register the animation.
  *
  * Let's see an example of a enter/leave animation using `ngRepeat`:
  *
diff --git a/src/ngAnimate/rafScheduler.js b/src/ngAnimate/rafScheduler.js
@@ -14,7 +14,7 @@ var $$rAFSchedulerFactory = ['$$rAF', function($$rAF) {
   queue = scheduler.queue = [];
 
   /* waitUntilQuiet does two things:
-   * 1. It will run the FINAL `fn` value only when an uncancelled RAF has passed through
+   * 1. It will run the FINAL `fn` value only when an uncanceled RAF has passed through
    * 2. It will delay the next wave of tasks from running until the quiet `fn` has run.
    *
    * The motivation here is that animation code can request more time from the scheduler

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@`
`20`	`20`	`* using the --for_closure flag.`
`21`	`21`	`* File generated from CLDR ver. 27.0.1`
`22`	`22`	`*`
`23`		`- * This file coveres those locales that are not covered in`
	`23`	`+ * This file covers those locales that are not covered in`
`24`	`24`	`* "numberformatsymbols.js".`
`25`	`25`	`*`
`26`	`26`	`* Before checkin, this file could have been manually edited. This is`
Original file line number	Diff line number	Diff line change
`@@ -128,7 +128,7 @@`
`128`	`128`	`* When this property is set to true, the HTML compiler will collect DOM nodes between`
`129`	`129`	* nodes with the attributes `directive-name-start` and `directive-name-end`, and group them
`130`	`130`	`* together as the directive elements. It is recommended that this feature be used on directives`
`131`		`- * which are not strictly behavioural (such as {@link ngClick}), and which`
	`131`	`+ * which are not strictly behavioral (such as {@link ngClick}), and which`
`132`	`132`	`* do not manipulate or replace child nodes (such as {@link ngInclude}).`
`133`	`133`	`*`
`134`	`134`	* #### `priority`
`@@ -517,7 +517,7 @@`
`517`	`517`	* content and the `scope` is the newly created transclusion scope, to which the clone is bound.
`518`	`518`	`*`
`519`	`519`	`* <div class="alert alert-info">`
`520`		- * Best Practice: Always provide a `cloneFn` (clone attach function) when you call a translude function
	`520`	+ * Best Practice: Always provide a `cloneFn` (clone attach function) when you call a transclude function
`521`	`521`	`* since you then get a fresh clone of the original DOM and also have access to the new transclusion scope.`
`522`	`522`	`* </div>`
`523`	`523`	`*`
`@@ -549,7 +549,7 @@`
`549`	`549`	`* </div>`
`550`	`550`	`*`
`551`	`551`	`* The built-in DOM manipulation directives, such as {@link ngIf}, {@link ngSwitch} and {@link ngRepeat}`
`552`		`- * automatically destroy their transluded clones as necessary so you do not need to worry about this if`
	`552`	`+ * automatically destroy their transcluded clones as necessary so you do not need to worry about this if`
`553`	`553`	`* you are simply using {@link ngTransclude} to inject the transclusion into your directive.`
`554`	`554`	`*`
`555`	`555`	`*`
Original file line number	Diff line number	Diff line change
`@@ -127,7 +127,7 @@ function FormController(element, attrs, $scope, $animate, $interpolate) {`
`127`	`127`	`*`
`128`	`128`	`* However, if the method is used programmatically, for example by adding dynamically created controls,`
`129`	`129`	`* or controls that have been previously removed without destroying their corresponding DOM element,`
`130`		`- * it's the developers responsiblity to make sure the current state propagates to the parent form.`
	`130`	`+ * it's the developers responsibility to make sure the current state propagates to the parent form.`
`131`	`131`	`*`
`132`	`132`	* For example, if an input control is added that is already `$dirty` and has `$error` properties,
`133`	`133`	* calling `$setDirty()` and `$validate()` afterwards will propagate the state to the parent form.