Adds facilities for extracting Intl.message calls and generating code from translations

pkg/intl/test/message_extraction/sample_with_messages.dart

+// Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/**
+ * This is a program with various [Intl.message] messages. It just prints
+ * all of them, and is used for testing of message extraction, translation,
+ * and code generation.
+ */
+library sample;
+
+import "package:intl/intl.dart";
+import "package:intl/message_lookup_by_library.dart";
+import "dart:async";
+import "package:intl/src/intl_helpers.dart";
+import "messages_all.dart";
+
+part 'part_of_sample_with_messages.dart';
+
+message1() => Intl.message("This is a message", name: 'message1', desc: 'foo' );
+
+message2(x) => Intl.message("Another message with parameter $x",
+    name: 'message2', desc: 'Description 2', args: [x]);
+
+// A string with multiple adjacent strings concatenated together, verify
+// that the parser handles this properly.
+multiLine() => Intl.message("This "
+    "string "
+    "extends "
+    "across "
+    "multiple "
+    "lines.",
+    name: "multiLine");
+
+// Have types on the enclosing function's arguments.
+types(int a, String b, List c) => Intl.message("$a, $b, $c", name: 'types',
+    args: [a, b, c]);
+
+// This string will be printed with a French locale, so it will always show
+// up in the French version, regardless of the current locale.
+alwaysAccented() =>
+    Intl.message("This string is always translated", locale: 'fr',
+        name: 'alwaysTranslated');
+
+// Test interpolation with curly braces around the expression, but it must
+// still be just a variable reference.
+trickyInterpolation(s) =>
+    Intl.message("Interpolation is tricky when it ends a sentence like ${s}.",
+        name: 'trickyInterpolation', args: [s]);
+
+leadingQuotes() => Intl.message("\"So-called\"", name: 'leadingQuotes');
+
+// A message with characters not in the basic multilingual plane.
+originalNotInBMP() => Intl.message("Ancient Greek hangman characters: 𐅆𐅇.",
+    name: "originalNotInBMP");
+
+// A string for which we don't provide all translations.
+notAlwaysTranslated() => Intl.message("This is missing some translations",
+    name: "notAlwaysTranslated");
+
+// This is invalid and should be recognized as such, because the message has
+// to be a literal. Otherwise, interpolations would be outside of the function
+// scope.
+var someString = "No, it has to be a literal string";
+noVariables() => Intl.message(someString, name: "noVariables");
+
+// This is unremarkable in English, but the translated versions will contain
+// characters that ought to be escaped during code generation.
+escapable() => Intl.message("Escapable characters here: ", name: "escapable");
+
+printStuff(Intl locale) {
+
+  // Use a name that's not a literal so this will get skipped. Then we have
+  // a name that's not in the original but we include it in the French
+  // translation. Because it's not in the original it shouldn't get included
+  // in the generated catalog and shouldn't get translated.
+  if (locale.locale == 'fr') {
+    var badName = "thisNameIsNotInTheOriginal";
+    var notInOriginal = Intl.message("foo", name: badName);
+    if (notInOriginal != "foo") {
+      throw "You shouldn't be able to introduce a new message in a translation";
+    }
+  }
+
+  // A function that is unnamed and assigned to a variable. It's also nested
+  // within another function definition.
+  var messageVariable = (a, b, c) => Intl.message(
+      "Characters that need escaping, e.g slashes \\ dollars \${ (curly braces "
+      "are ok) and xml reserved characters <& and quotes \" "
+      "parameters $a, $b, and $c",
+      name: 'message3',
+      args: [a, b, c]);
+
+  print("-------------------------------------------");
+  print("Printing messages for ${locale.locale}");
+  Intl.withLocale(locale.locale, () {
+    print(message1());
+    print(message2("hello"));
+    print(messageVariable(1,2,3));
+    print(multiLine());
+    print(types(1, "b", ["c", "d"]));
+    print(leadingQuotes());
+    print(alwaysAccented());
+    print(trickyInterpolation("this"));
+    var thing = new YouveGotMessages();
+    print(thing.method());
+    print(thing.nonLambda());
+    var x = YouveGotMessages.staticMessage();
+    print(YouveGotMessages.staticMessage());
+    print(notAlwaysTranslated());
+    print(originalNotInBMP());
+    // TODO(alanknight): Support named arguments.
+//    print(thing.namedArgs(thing: 'well...'));
+    // TODO(alanknight): Support plurals. Do we need to consider changing
+    // the form so as not to have a difficult to validate interpolation
+    // in our translation output?
+//    print(thing.plurals(1));
+//    print(thing.plurals(2));
+    print(escapable());
+  });
+}
+
+var localeToUse = 'en_US';
+
+main() {
+  var fr = new Intl("fr");
+  var english = new Intl("en_US");
+  var de = new Intl("de_DE");
+  initializeMessages(fr.locale).then((_) => printStuff(fr));
+  initializeMessages(de.locale).then((_) => printStuff(de));
+  printStuff(english);
+}