feat($controller): support controller registration via $controllerProvider

It's now possible to register controllers as:

.register('MyCtrl', function($scope) { ... });
// or
.register('MyCtrl', ['$scope', function($scope) { ... });

Additionally a module loader shortcut api was added as well:

myModule.controller('MyCtr', function($scope) { ... });

2 files changed, 55 insertions, 9 deletions

diff --git a/src/loader.js b/src/loader.js
index fdfdaebd..b25fc40e 100644
--- a/src/loader.js
+++ b/src/loader.js
@@ -167,7 +167,7 @@ function setupModuleLoader(window) {
            * @ngdoc method
            * @name angular.Module#filter
            * @methodOf angular.Module
-           * @param {string} name filter name
+           * @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()}.
@@ -176,6 +176,17 @@ function setupModuleLoader(window) {
 
           /**
            * @ngdoc method
+           * @name angular.Module#controller
+           * @methodOf angular.Module
+           * @param {string} name Controller name.
+           * @param {Function} constructor Controller constructor function.
+           * @description
+           * See {@link angular.module.ng.$controllerProvider#register $controllerProvider.register()}.
+           */
+          controller: invokeLater('$controllerProvider', 'register'),
+
+          /**
+           * @ngdoc method
            * @name angular.Module#directive
            * @methodOf angular.Module
            * @param {string} name directive name
diff --git a/src/service/controller.js b/src/service/controller.js
index 229ce14a..fa90f8cd 100644
--- a/src/service/controller.js
+++ b/src/service/controller.js
@@ -1,6 +1,32 @@
 'use strict';
 
+/**
+ * @ngdoc object
+ * @name angular.module.ng.$controllerProvider
+ * @description
+ * The {@link angular.module.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.
+ */
 function $ControllerProvider() {
+  var controllers = {};
+
+
+  /**
+   * @ngdoc function
+   * @name angular.module.ng.$controllerProvider#register
+   * @methodOf angular.module.ng.$controllerProvider
+   * @param {string} name Controller name
+   * @param {Function|Array} constructor Controller constructor fn (optionally decorated with DI
+   *    annotations in the array notation).
+   */
+  this.register = function(name, constructor) {
+    controllers[name] = constructor;
+  };
+
+
   this.$get = ['$injector', '$window', function($injector, $window) {
 
     /**
@@ -8,8 +34,14 @@ function $ControllerProvider() {
      * @name angular.module.ng.$controller
      * @requires $injector
      *
-     * @param {Function|string} Class Constructor function of a controller to instantiate, or
-     *        expression to read from current scope or window.
+     * @param {Function|string} constructor If called with a function then it's considered to be the
+     *    controller constructor function. Otherwise it's considered to be a string which is used
+     *    to retrieve the controller constructor using the following steps:
+     *
+     *    * check if a controller with given name is registered via `$controllerProvider`
+     *    * check if evaluating the string on the current scope returns a constructor
+     *    * check `window[constructor]` on the global `window` object
+     *
      * @param {Object} locals Injection locals for Controller.
      * @return {Object} Instance of given controller.
      *
@@ -20,14 +52,17 @@ function $ControllerProvider() {
      * a service, so that one can override this service with {@link https://gist.github.com/1649788
      * BC version}.
      */
-    return function(Class, locals) {
-      if(isString(Class)) {
-        var expression = Class;
-        Class = getter(locals.$scope, expression, true) || getter($window, expression, true);
-        assertArgFn(Class, expression);
+    return function(constructor, locals) {
+      if(isString(constructor)) {
+        var name = constructor;
+        constructor = controllers.hasOwnProperty(name)
+            ? controllers[name]
+            : getter(locals.$scope, name, true) || getter($window, name, true);
+
+        assertArgFn(constructor, name, true);
       }
 
-      return $injector.instantiate(Class, locals);
+      return $injector.instantiate(constructor, locals);
     };
   }];
 }