Merge remote-tracking branch 'upstream/master' into ng-repeat-start

Author: lgalfaso

docs/content/guide/di.ngdoc

@@ -14,7 +14,7 @@ book.
 
 ## DI in a nutshell
 
-There are only three ways how an object or a function can get a hold of its dependencies:
+There are only three ways an object or a function can get a hold of its dependencies:
 
   1. The dependency can be created, typically using the `new` operator.
 
@@ -23,8 +23,8 @@ There are only three ways how an object or a function can get a hold of its depe
   3. The dependency can be passed in to where it is needed.
 
 
-The first two options of creating or looking up dependencies are not optimal, because they hard
-code the dependency, making it difficult, if not impossible, to modify the dependencies.
+The first two options of creating or looking up dependencies are not optimal because they hard
+code the dependency. This make it difficult, if not impossible, to modify the dependencies.
 This is especially problematic in tests, where it is often desirable to provide mock dependencies
 for test isolation.
 
@@ -33,26 +33,26 @@ dependency from the component. The dependency is simply handed to the component.
 
 <pre>
   function SomeClass(greeter) {
-    this.greeter = greeter
+    this.greeter = greeter;
   }
 
   SomeClass.prototype.doSomething = function(name) {
     this.greeter.greet(name);
   }
 </pre>
 
-In the above example the `SomeClass` is not concerned with locating the `greeter` dependency, it
+In the above example `SomeClass` is not concerned with locating the `greeter` dependency, it
 is simply handed the `greeter` at runtime.
 
-This is desirable, but it puts the responsibility of getting hold of the dependency onto the
-code responsible for the construction of `SomeClass`.
+This is desirable, but it puts the responsibility of getting hold of the dependency on the
+code that constructs `SomeClass`.
 
 To manage the responsibility of dependency creation, each Angular application has an {@link
 api/angular.injector injector}. The injector is a service locator that is responsible for
 construction and lookup of dependencies.
 
+Here is an example of using the injector service:
 
-Here is an example of using  the injector service. 
 <pre>
   // Provide the wiring information in a module
   angular.module('myModule', []).
@@ -101,7 +101,7 @@ dependency lookup responsibility to the injector by declaring the dependencies a
 </pre>
 
 Notice that by having the `ng-controller` instantiate the class, it can satisfy all of the
-dependencies of the `MyController` without the controller ever knowing about the injector. This is
+dependencies of `MyController` without the controller ever knowing about the injector. This is
 the best outcome. The application code simply ask for the dependencies it needs, without having to
 deal with the injector. This setup does not break the Law of Demeter.
 
@@ -159,16 +159,18 @@ Sometimes using the `$inject` annotation style is not convenient such as when an
 directives.
 
 For example:
+
 <pre>
   someModule.factory('greeter', function($window) {
-    ...;
+    ...
   });
 </pre>
 
-Results in code bloat due to the need of temporary variable:
+Results in code bloat due to needing a temporary variable:
+
 <pre>
   var greeterFactory = function(renamed$window) {
-    ...;
+    ...
   };
 
   greeterFactory.$inject = ['$window'];
@@ -177,9 +179,10 @@ Results in code bloat due to the need of temporary variable:
 </pre>
 
 For this reason the third annotation style is provided as well.
+
 <pre>
   someModule.factory('greeter', ['$window', function(renamed$window) {
-    ...;
+    ...
   }]);
 </pre>
 

docs/content/guide/directive.ngdoc

@@ -269,6 +269,7 @@ Here's an example directive declared with a Directive Definition Object:
       transclude: false,
       restrict: 'A',
       scope: false,
+      controller: function($scope, $element, $attrs, $transclude, otherInjectables) { ... },
       compile: function compile(tElement, tAttrs, transclude) {
         return {
           pre: function preLink(scope, iElement, iAttrs, controller) { ... },
@@ -392,6 +393,12 @@ compiler}. The attributes are:
     * `$transclude` - A transclude linking function pre-bound to the correct transclusion scope:
       `function(cloneLinkingFn)`.
 
+    To avoid errors after minification the bracket notation should be used:
+
+    <pre>
+    controller: ['$scope', '$element', '$attrs', '$transclude', function($scope, $element, $attrs, $transclude) { ... }]
+    </pre>
+
   * `require` - Require another controller be passed into current directive linking function. The
     `require` takes a name of the directive controller to pass in. If no such controller can be
     found an error is raised. The name can be prefixed with:

docs/content/misc/contribute.ngdoc

@@ -88,6 +88,10 @@ quite a good source for information on Git.
 development web server, run tests, and generate a build. Depending on your system, you can install Node either from source or as a
 pre-packaged bundle.
 
+* {@link http://www.java.com Java}: JavaScript is minified using
+{@link https://developers.google.com/closure/ Closure Tools} jar. Make sure you have Java (version 6 or higher) installed
+and included in your {@link http://docs.oracle.com/javase/tutorial/essential/environment/paths.html PATH} variable.
+
   Once installed, you'll also need several npms (node packages), which you can install once you checked out a local copy
   of the Angular repository (see below) with:
 

docs/src/ngdoc.js

@@ -2,7 +2,7 @@
  * All parsing/transformation code goes here. All code here should be sync to ease testing.
  */
 
-var Showdown = require('../../lib/showdown').Showdown;
+var Showdown = require('showdown');
 var DOM = require('./dom.js').DOM;
 var htmlEscape = require('./dom.js').htmlEscape;
 var Example = require('./example.js').Example;
@@ -216,7 +216,7 @@ Doc.prototype = {
         });
     });
     text = parts.join('');
-    text = new Showdown.converter().makeHtml(text);
+    text = new Showdown.converter({ extensions : ['table'] }).makeHtml(text);
     text = text.replace(/(?:<p>)?(REPLACEME\d+)(?:<\/p>)?/g, function(_, id) {
       return placeholderMap[id];
     });