Minor cleanups to take advantage of lazy initialization

pkg/intl/lib/intl.dart

 // Copyright (c) 2012, 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.
 
 /**
  * Internationalization object providing access to message formatting objects,
  * date formatting, parsing, bidirectional text relative to a specific locale.
  */
 #library('intl');
 
 #import('date_format.dart');
 #import('src/intl_helpers.dart');
 
 #source('bidi_formatter.dart');
 #source('bidi_utils.dart');
 
 class Intl {
   /**
    * String indicating the locale code with which the message is to be
    * formatted (such as en-CA).
    */
   String _locale;
 
   /** The default locale. This defaults to being set from systemLocale, but
    * can also be set explicitly, and will then apply to any new instances where
    * the locale isn't specified.
    */
-  static String _defaultLocale;
+  static String _defaultLocale = systemLocale;

[Emily Fortuna, 2012/10/02 00:17:19]

sorry, why are the changes in this file preferable?

[Alan Knight, 2012/10/02 00:24:29]

It sets the systemLocale on creation so it can avoid a couple of lines with null
checks that then set it to that value. That seemed cleaner to me.

[Emily Fortuna, 2012/10/02 00:48:35]

Seems good if we can initialize systemLocale and _defaultLocale when they are
declared:

static String systemLocale = getSystemLocale() <-- which depends on the browser
or the os depending on environment

can we actually do that? If not, it's probably better to set _defaultLocale
after some initialization has occurred so it actually gets set when we have a
real value for it we want to use.

[Alan Knight, 2012/10/02 16:21:42]

No, we can't, because getting the real value may involve an async call, and also
may be set by the user, who knows better than we do. For example, if we set it
to the browser's default, but the application knows a more appropriate value by
looking at the user account once they've logged in and sets the default
explicitly.

My assumption was that if someone was going to set the default locale they would
be unlikely to create an Intl object until they had done so. But it isn't a big
deal either way. If you think the previous setup was preferable, I'm happy
enough to leave it that way.

[Emily Fortuna, 2012/10/02 17:11:37]

Right, that's what I figured. So are we going to make withLocale and the others
async because we might need to pull down locale info in that step? I just don't
like setting it to some value that shouldn't really ever be used because it may
trick the user later into thinking things are initialized when they're not.

[Alan Knight, 2012/10/02 20:22:03]

I don't want to make withLocale async. The only operation that's async is the
findSystemLocale, and the user has to explicitly invoke that, because they may
have a better answer and not want to call that at all. So I'd rather just revert
the initialization here back to the way it was. So did that.

 
   /**
    * The system's locale, as obtained from the window.navigator.language
    * or other operating system mechanism. Note that due to system limitations
    * this is not automatically set, and must be set by importing one of
    * intl_browser.dart or intl_standalone.dart and calling findSystemLocale().
    */
   // TODO(alanknight): Detect this without forcing the jump through hoops.
   // Issue 5171.
   static String systemLocale = 'en_US';
@@ skipping 121 matching lines @@
 
   /**
    * Format the given function with a specific [locale], given a
    * [msg_function] that takes no parameters and returns a String. We
    * basically delay calling the message function proper until after the proper
    * locale has been set.
    */
   static String withLocale(String locale, Function msg_function) {
     // We have to do this silliness because Locale is not known at compile time,
     // but must be a static variable.
-    if (_defaultLocale == null) _defaultLocale = systemLocale;
-    var oldLocale = _defaultLocale;
+     var oldLocale = _defaultLocale;

[Emily Fortuna, 2012/10/02 00:17:19]

alert alert spurious whitespace

[Alan Knight, 2012/10/02 00:24:29]

Done.

     _defaultLocale = locale;
     var result = msg_function();
     _defaultLocale = oldLocale;
     return result;
   }
 
   /**
    * Support method for message formatting. Select the correct exact (gender,
    * usually) form from [cases] given the user [choice].
    */
   static String select(String choice, Map cases) {
     if (cases.containsKey(choice)) {
       return cases[choice];
     } else if (cases.containsKey('other')){
       return cases['other'];
     } else {
       return '';
     }
   }
 
   /**
    * Accessor for the current locale. This should always == the default locale,
    * unless for some reason this gets called inside a message that resets the
    * locale.
    */
   static String getCurrentLocale() {
-    if (_defaultLocale == null) _defaultLocale = systemLocale;
     return _defaultLocale;
   }
 }
 
 /**
  * The internal mechanism for looking up messages. We expect this to be set
  * by the implementing package so that we're not dependent on its
  * implementation.
  */
 var _messageLookup = const
     UninitializedLocaleData('initializeMessages(<locale>)');
 
 /**
  * Initialize the message lookup mechanism. This is for internal use only.
  * User applications should import message_lookup_local.dart and call
  * initializeMessages
  */
 void initializeInternalMessageLookup(Function lookupFunction) {
   if (_messageLookup is UninitializedLocaleData) {
     _messageLookup = lookupFunction();
   }
 }