feat($interpolate): MessageFormat extensions

Extend interpolation with MessageFormat like syntax.

Ref: <https://docs.google.com/a/google.com/document/d/1pbtW2yvtmFBikfRrJd8VAsabiFkKezmYZ_PbgdjQOVU/edit>

Example:

```html
{{recipients.length, plural, offset:1
    =0 {You gave no gifts}
    =1 { {{ recipients[0].gender, select,
              male {You gave him a gift.}
              female {You gave her a gift.}
              other {You gave them a gift.}
          }}
       }
    one { {{ recipients[0].gender, select,
              male {You gave him and one other person a gift.}
              female {You gave her and one other person a gift.}
              other {You gave them and one other person a gift.}
          }}
       }
    other {You gave {{recipients.length}} people gifts. ({{name}}) }
}}
```

Quick note on syntax differences from MessageFormat:
- MessageFormat directives are always inside {{ }} instead of
  single { }.  This ensures a consistent interpolation syntax (else you
  could interpolate in more than one way and have to pick one based on
  feature availability for that syntax.)
- The first word inside such syntax can be an arbitrary Angular
  expression instead of a single identifier.
- You can nest them as deep as you want.  As mentioned earlier, you
  would use {{ }} to start the nested interpolation that may optionally
  include select/plural extensions.
- Only "select" and "plural" keywords are currently recognized.
- Quoting support is coming in a future commit.
- Positional arguments/placeholders are not supported. They don't make
  sense in Angular templates anyway (they are only helpful when using
  API calls from a programming language.)
- The "#" character is not special in plural messages.  This will be
  supported in a future commit.  However, since you can embed any
  Angular expression inside the message, you can still play around with
  it.  (Also, the "#" symbol doesn't nest with plurals if you're wanting
  to write full messages. Alternative syntax would be nice.)

Author: chirayuk

angularFiles.js

@@ -28,6 +28,7 @@ var angularFiles = {
     'src/ng/locale.js',
     'src/ng/location.js',
     'src/ng/log.js',
+    'src/ng/messageformat.js',
     'src/ng/parse.js',
     'src/ng/q.js',
     'src/ng/raf.js',

src/AngularPublic.js

@@ -224,6 +224,7 @@ function publishExternalAPI(angular) {
         $httpBackend: $HttpBackendProvider,
         $location: $LocationProvider,
         $log: $LogProvider,
+        $$messageFormat: $$MessageFormatProvider,
         $parse: $ParseProvider,
         $rootScope: $RootScopeProvider,
         $q: $QProvider,

src/ng/interpolate.js

@@ -40,6 +40,7 @@ var $interpolateMinErr = minErr('$interpolate');
 function $InterpolateProvider() {
   var startSymbol = '{{';
   var endSymbol = '}}';
+  var fastIsMsgFormatTestRe = /,\s*(?:select|plural)\s*,/;
 
   /**
    * @ngdoc method
@@ -78,7 +79,7 @@ function $InterpolateProvider() {
   };
 
 
-  this.$get = ['$parse', '$exceptionHandler', '$sce', function($parse, $exceptionHandler, $sce) {
+  this.$get = ['$parse', '$exceptionHandler', '$sce', '$$messageFormat', function($parse, $exceptionHandler, $sce, $$messageFormat) {
     var startSymbolLength = startSymbol.length,
         endSymbolLength = endSymbol.length,
         escapedStartRegexp = new RegExp(startSymbol.replace(/./g, escape), 'g'),
@@ -110,6 +111,50 @@ function $InterpolateProvider() {
       return value;
     }
 
+    // Interpolation expressions support MessageFormat like extensions for plural and
+    // select(gender).  Delegate to $$messageFormat is such extensions are being used.
+    function parseExtendedExpression(text, interceptorFn) {
+      if (text.search(fastIsMsgFormatTestRe) == -1) {
+        return $parse(text, interceptorFn);
+      } else {
+        return $$messageFormat.parse(text);
+      }
+    }
+
+    function findEndIndex(text, startIndex) {
+      var endIndex = text.indexOf(endSymbol, startIndex + startSymbolLength);
+      if (endIndex == -1) {
+        return endIndex;
+      }
+      var nestingLevel = 0;
+      startIndex = text.indexOf(startSymbol, startIndex + startSymbolLength);
+      for (;;) {
+        if (startIndex == -1 || startIndex >= endIndex + endSymbolLength) {
+          if (nestingLevel == 0) {
+            return endIndex;
+          }
+          nestingLevel--;
+          endIndex = text.indexOf(endSymbol, endIndex + endSymbolLength);
+          if (endIndex == -1) {
+            return -1;
+          }
+        } else {
+          nestingLevel++;
+          startIndex = text.indexOf(startSymbol, startIndex + startSymbolLength);
+        }
+      }
+    }
+
+    // No messageformat support when we
+    //   1. Can't nest expressions.
+    //   2. Have redefined the startSymbol/endSymbol.
+    // (2) will go away with updates to the $messageFormat service, but (1) will always remain.
+    if (startSymbol == endSymbol || (startSymbol != "{{" || endSymbol != "}}")) {
+      findEndIndex = function findEndIndex(text, startIndex) {
+        return text.indexOf(endSymbol, startIndex + startSymbolLength);
+      }
+    }
+
     /**
      * @ngdoc service
      * @name $interpolate
@@ -218,13 +263,13 @@ function $InterpolateProvider() {
 
       while (index < textLength) {
         if (((startIndex = text.indexOf(startSymbol, index)) != -1) &&
-             ((endIndex = text.indexOf(endSymbol, startIndex + startSymbolLength)) != -1)) {
+             ((endIndex = findEndIndex(text, startIndex)) != -1)) {
           if (index !== startIndex) {
             concat.push(unescapeText(text.substring(index, startIndex)));
           }
           exp = text.substring(startIndex + startSymbolLength, endIndex);
           expressions.push(exp);
-          parseFns.push($parse(exp, parseStringifyInterceptor));
+          parseFns.push(parseExtendedExpression(exp, parseStringifyInterceptor));
           index = endIndex + endSymbolLength;
           expressionPositions.push(concat.length);
           concat.push('');
@@ -250,54 +295,56 @@ function $InterpolateProvider() {
               "required.  See http://docs.angularjs.org/api/ng.$sce", text);
       }
 
-      if (!mustHaveExpression || expressions.length) {
-        var compute = function(values) {
-          for (var i = 0, ii = expressions.length; i < ii; i++) {
-            if (allOrNothing && isUndefined(values[i])) return;
-            concat[expressionPositions[i]] = values[i];
-          }
-          return concat.join('');
-        };
-
-        var getValue = function(value) {
-          return trustedContext ?
-            $sce.getTrusted(trustedContext, value) :
-            $sce.valueOf(value);
-        };
-
-        return extend(function interpolationFn(context) {
-            var i = 0;
-            var ii = expressions.length;
-            var values = new Array(ii);
-
-            try {
-              for (; i < ii; i++) {
-                values[i] = parseFns[i](context);
-              }
-
-              return compute(values);
-            } catch (err) {
-              var newErr = $interpolateMinErr('interr', "Can't interpolate: {0}\n{1}", text,
-                  err.toString());
-              $exceptionHandler(newErr);
+      if (mustHaveExpression && expressions.length == 0) {
+        return null;
+      }
+
+      var compute = function(values) {
+        for (var i = 0, ii = expressions.length; i < ii; i++) {
+          if (allOrNothing && isUndefined(values[i])) return;
+          concat[expressionPositions[i]] = values[i];
+        }
+        return concat.join('');
+      };
+
+      var getValue = function(value) {
+        return trustedContext ?
+          $sce.getTrusted(trustedContext, value) :
+          $sce.valueOf(value);
+      };
+
+      return extend(function interpolationFn(context) {
+          var i = 0;
+          var ii = expressions.length;
+          var values = new Array(ii);
+
+          try {
+            for (; i < ii; i++) {
+              values[i] = parseFns[i](context);
             }
 
-          }, {
-          // all of these properties are undocumented for now
-          exp: text, //just for compatibility with regular watchers created via $watch
-          expressions: expressions,
-          $$watchDelegate: function(scope, listener, objectEquality) {
-            var lastValue;
-            return scope.$watchGroup(parseFns, function interpolateFnWatcher(values, oldValues) {
-              var currValue = compute(values);
-              if (isFunction(listener)) {
-                listener.call(this, currValue, values !== oldValues ? lastValue : currValue, scope);
-              }
-              lastValue = currValue;
-            }, objectEquality);
+            return compute(values);
+          } catch (err) {
+            var newErr = $interpolateMinErr('interr', "Can't interpolate: {0}\n{1}", text,
+                err.toString());
+            $exceptionHandler(newErr);
           }
-        });
-      }
+
+        }, {
+        // all of these properties are undocumented for now
+        exp: text, //just for compatibility with regular watchers created via $watch
+        expressions: expressions,
+        $$watchDelegate: function(scope, listener, objectEquality) {
+          var lastValue;
+          return scope.$watchGroup(parseFns, function interpolateFnWatcher(values, oldValues) {
+            var currValue = compute(values);
+            if (isFunction(listener)) {
+              listener.call(this, currValue, values !== oldValues ? lastValue : currValue, scope);
+            }
+            lastValue = currValue;
+          }, objectEquality);
+        }
+      });
 
       function parseStringifyInterceptor(value) {
         try {