libs/js/globalize/generator/Program.cs

   1 using System;
   2 using System.Collections.Generic;
   3 using System.Linq;
   4 using System.Text;
   5 using System.IO;
   6 using System.Globalization;
   7 using System.Web.Script.Serialization;
   8 using System.Collections.Specialized;
   9 using System.Collections;
  10 using System.Text.RegularExpressions;
  11 using System.Reflection;
  12 using System.Diagnostics;
  13 using Globalization;
  14
  15 namespace Globalization {
  16     public class GlobalizationInfo {
  17         public string name = "";
  18         public string englishName;
  19         public string nativeName;
  20         public string language;
  21         public bool isRTL;
  22         public NumberFormatInfo numberFormat;
  23         public Dictionary<String, DateFormatInfo> calendars;
  24         private CultureInfo culture;
  25         public static Dictionary<String, Object> BasisGlobInfo;
  26
  27
  28         private static string[] _numberNegativePatterns = "(n)|-n|- n|n-|n -".Split('|');
  29         private static string[] _currencyNegativePatterns = "($n)|-$n|$-n|$n-|(n$)|-n$|n-$|n$-|-n $|-$ n|n $-|$ n-|$ -n|n- $|($ n)|(n $)".Split('|');
  30         private static string[] _percentNegativePatterns = "-n %|-n%|-%n|%-n|%n-|n-%|n%-|-% n|n %-|% n-|% -n|n- %".Split('|');
  31         private static string[] _currencyPositivePatterns = "$n|n$|$ n|n $".Split('|');
  32         private static string[] _percentPositivePatterns = "n %|n%|%n|% n".Split('|');
  33
  34         public static GlobalizationInfo GetGlobInfo(CultureInfo culture) {
  35             var info = new GlobalizationInfo {
  36                 culture = culture,
  37                 language = (culture == CultureInfo.InvariantCulture || culture.IsNeutralCulture) ? culture.Name : culture.Parent.Name,
  38                 name = String.IsNullOrEmpty(culture.Name) ? "invariant" : culture.Name,
  39                 englishName = String.IsNullOrEmpty(culture.Name) ? "invariant" : culture.EnglishName,
  40                 nativeName = String.IsNullOrEmpty(culture.Name) ? "invariant" : culture.NativeName,
  41                 isRTL = culture.TextInfo.IsRightToLeft,
  42                 numberFormat = GetNumberFormatInfo(culture),
  43                 calendars = GetCalendars(culture)
  44             };
  45             return info;
  46         }
  47
  48         public static Dictionary<String, DateFormatInfo> GetCalendars(CultureInfo culture) {
  49             var calendars = new Dictionary<String, DateFormatInfo>();
  50             bool foundStandard = false;
  51             var gregorianType = typeof(GregorianCalendar);
  52             var defaultCalendar = culture.DateTimeFormat.Calendar;
  53             var defaultCalendarType = defaultCalendar.GetType();
  54             GregorianCalendarTypes? gregorianCalendarType = null;
  55             if (defaultCalendarType == gregorianType) {
  56                 gregorianCalendarType = ((GregorianCalendar)defaultCalendar).CalendarType;
  57             }
  58             var optionalCalendars = culture.OptionalCalendars;
  59             foreach (var calendar in optionalCalendars) {
  60                 var type = calendar.GetType();
  61                 string name;
  62                 bool isStandard = false;
  63                 if (type == gregorianType) {
  64                     var calendarType = ((GregorianCalendar)calendar).CalendarType;
  65                     if (calendarType == GregorianCalendarTypes.USEnglish) {
  66                         // we include the Gregorian_USEnglish culture as part of the built-in 'en' culture
  67                         // because it is so common -- it is an optional calendar of every single english
  68                         // speaking culture. So, skip it when found for any other culture.
  69                         continue;
  70                     }
  71                     else if (culture == CultureInfo.InvariantCulture) {
  72                         // invariant has one calendar, Gregorian_Localized, which is identical
  73                         // to Gregorian_USEnglish.
  74                         name = " Gregorian_USEnglish";
  75                     }
  76                     else {
  77                         name = "Gregorian_" + calendarType.ToString();
  78                     }
  79                     if (!foundStandard && gregorianCalendarType.HasValue && gregorianCalendarType == gregorianCalendarType.Value) {
  80                         isStandard = true;
  81                         foundStandard = true;
  82                     }
  83                 }
  84                 else {
  85                     name = type.Name.Replace("Calendar", "");
  86                     if (!foundStandard) {
  87                         isStandard = true;
  88                         foundStandard = true;
  89                     }
  90                 }
  91                 string key = name;
  92                 if (isStandard) {
  93                     key = "standard";
  94                 }
  95                 if (culture != CultureInfo.InvariantCulture) {
  96                     culture.DateTimeFormat.Calendar = calendar;
  97                 }
  98                 var calendarInfo = GetDateTimeFormatInfo(culture, name);
  99                 calendars.Add(key, calendarInfo);
 100             }
 101             if (!foundStandard) {
 102                 throw new ApplicationException("Could not locate the standard calendar type for culture '" + culture.Name + "'.");
 103             }
 104             return calendars;
 105         }
 106
 107         public static GlobalizationInfo.NumberFormatInfo GetNumberFormatInfo(CultureInfo culture) {
 108             var nf = culture.NumberFormat;
 109             return new GlobalizationInfo.NumberFormatInfo {
 110                 decimals = nf.NumberDecimalDigits,
 111                 decimalSeparator = nf.NumberDecimalSeparator,
 112                 groupSeparator = nf.NumberGroupSeparator,
 113                 groupSizes = nf.NumberGroupSizes,
 114                 NaN = nf.NaNSymbol,
 115                 negative = nf.NegativeSign,
 116                 negativeInfinity = nf.NegativeInfinitySymbol,
 117                 positive = nf.PositiveSign,
 118                 positiveInfinity = nf.PositiveInfinitySymbol,
 119                 pattern = new string[] { GetFromStringList(_numberNegativePatterns, nf.NumberNegativePattern) },
 120                 currency = new GlobalizationInfo.NumberFormatInfo.NumberClassFormatInfo {
 121                     decimals = nf.CurrencyDecimalDigits,
 122                     decimalSeparator = nf.CurrencyDecimalSeparator,
 123                     groupSeparator = nf.CurrencyGroupSeparator,
 124                     groupSizes = nf.CurrencyGroupSizes,
 125                     pattern = new string[] {
 126                         GetFromStringList(_currencyNegativePatterns, nf.CurrencyNegativePattern),
 127                         GetFromStringList(_currencyPositivePatterns, nf.CurrencyPositivePattern)
 128                     },
 129                     symbol = nf.CurrencySymbol
 130                 },
 131                 percent = new GlobalizationInfo.NumberFormatInfo.NumberClassFormatInfo {
 132                     decimals = nf.PercentDecimalDigits,
 133                     decimalSeparator = nf.PercentDecimalSeparator,
 134                     groupSeparator = nf.PercentGroupSeparator,
 135                     groupSizes = nf.PercentGroupSizes,
 136                     pattern = new string[] {
 137                         GetFromStringList(_percentNegativePatterns, nf.PercentNegativePattern),
 138                         GetFromStringList(_percentPositivePatterns, nf.PercentPositivePattern)
 139                     },
 140                     symbol = nf.PercentSymbol
 141                 }
 142             };
 143         }
 144
 145         public static string[] GetAMPMDesignators(CultureInfo culture, string ampm) {
 146             return String.IsNullOrEmpty(ampm) ? null : new string[] { ampm, culture.TextInfo.ToLower(ampm), culture.TextInfo.ToUpper(ampm) };
 147         }
 148
 149         public static GlobalizationInfo.DateFormatInfo GetDateTimeFormatInfo(CultureInfo culture, string calendarName) {
 150             var df = culture.DateTimeFormat;
 151             var info = new GlobalizationInfo.DateFormatInfo {
 152                 name = calendarName,
 153                 months = new DateFormatInfo.MonthInfo { names = df.MonthNames, namesAbbr = df.AbbreviatedMonthNames },
 154                 monthsGenitive = new DateFormatInfo.MonthInfo { names = df.MonthGenitiveNames, namesAbbr = df.AbbreviatedMonthGenitiveNames },
 155                 firstDay = (int) df.FirstDayOfWeek,
 156                 dateSeparator = df.DateSeparator,
 157                 timeSeparator = df.TimeSeparator,
 158                 days = new DateFormatInfo.DayInfo { names = df.DayNames, namesAbbr = df.AbbreviatedDayNames, namesShort = df.ShortestDayNames },
 159                 eras = GetEraInfo(culture),
 160                 twoDigitYearMax = df.Calendar.TwoDigitYearMax,
 161                 patterns = GetPatterns(df)
 162             };
 163             info.AM = GetAMPMDesignators(culture, df.AMDesignator);
 164             info.PM = GetAMPMDesignators(culture, df.PMDesignator);
 165             if (df.Calendar != null) {
 166                 var type = df.Calendar.GetType();
 167                 if (type == typeof(HijriCalendar)) {
 168                     string convert;
 169                     using (var sr = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream("Generator.HijriCalendar.js"))) {
 170                         convert = sr.ReadToEnd();
 171                     }
 172                     int adjustment = ((HijriCalendar)df.Calendar).HijriAdjustment;
 173                     convert = convert.Replace("%HIJRIADJUSTMENT%", adjustment.ToString(CultureInfo.InvariantCulture));
 174                     info.convertScriptBlock = convert;
 175                 }
 176                 else if (type == typeof(UmAlQuraCalendar)) {
 177                     using (var sr = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream("Generator.UmAlQuraCalendar.js"))) {
 178                         info.convertScriptBlock = sr.ReadToEnd();
 179                     }
 180                 }
 181             }
 182             return info;
 183         }
 184
 185         private static GlobalizationInfo.DateFormatInfo.EraInfo[] GetEraInfo(CultureInfo culture) {
 186             Calendar cal = culture.DateTimeFormat.Calendar;
 187             List<GlobalizationInfo.DateFormatInfo.EraInfo> eras = null;
 188             if (cal != null) {
 189                 eras = new List<GlobalizationInfo.DateFormatInfo.EraInfo>();
 190                 foreach (var eraNum in cal.Eras) {
 191                     eras.Add(GetEraInfo(culture, eraNum));
 192                 }
 193             }
 194             return eras == null ? null : eras.ToArray();
 195         }
 196
 197         private static GlobalizationInfo.DateFormatInfo.EraInfo GetEraInfo(CultureInfo culture, int eraNum) {
 198             var era = new GlobalizationInfo.DateFormatInfo.EraInfo {
 199                 name = culture.DateTimeFormat.GetEraName(eraNum),
 200                 offset = 0,
 201                 start = null
 202             };
 203             var calendar = culture.DateTimeFormat.Calendar;
 204
 205             Type type = calendar.GetType();
 206             if (type != typeof(GregorianCalendar)) {
 207                 if (type == typeof(TaiwanCalendar)) {
 208                     era.offset = 0x777;
 209                 }
 210                 else if (type == typeof(KoreanCalendar)) {
 211                     era.offset = -2333;
 212                 }
 213                 else if (type == typeof(ThaiBuddhistCalendar)) {
 214                     era.offset = -543;
 215                 }
 216                 else if (type == typeof(JapaneseCalendar)) {
 217                     switch (eraNum) {
 218                         case 1:
 219                             era.start = 0xdf9984200L;
 220                             era.offset = 0x7c4;
 221                             break;
 222                         case 2:
 223                             era.start = -1357603200000L;
 224                             era.offset = 0x785;
 225                             break;
 226                         case 3:
 227                             era.start = -1812153600000L;
 228                             era.offset = 0x777;
 229                             break;
 230                         case 4:
 231                             era.start = null;
 232                             era.offset = 0x74b;
 233                             break;
 234                         default:
 235                             throw new InvalidOperationException("Invalid era number for JapaneseCalendar: " + eraNum.ToString());
 236                     }
 237                 }
 238             }
 239             return era;
 240         }
 241
 242         private static Dictionary<String, String> GetPatterns(DateTimeFormatInfo df) {
 243             var patterns = new Dictionary<String, String> {
 244                 { "d", df.ShortDatePattern },
 245                 { "D", df.LongDatePattern },
 246                 { "t", df.ShortTimePattern },
 247                 { "T", df.LongTimePattern },
 248                 { "f", df.LongDatePattern + " " + df.ShortTimePattern },
 249                 { "F", df.FullDateTimePattern },
 250                 { "M", df.MonthDayPattern },
 251                 { "S", df.SortableDateTimePattern },
 252                 { "Y", df.YearMonthPattern }
 253             };
 254             return patterns;
 255         }
 256
 257         private static bool ArrayEquality(Array arr1, Array arr2) {
 258             if (arr1.Length == arr2.Length) {
 259                 for (int i = 0; i < arr1.Length; i++) {
 260                     if (!arr1.GetValue(i).Equals(arr2.GetValue(i))) {
 261                         return false;
 262                     }
 263                 }
 264                 return true;
 265             }
 266             return false;
 267         }
 268
 269         private static bool ListEquality(IList arr1, IList arr2) {
 270             if (arr1.Count == arr2.Count) {
 271                 for (int i = 0; i < arr1.Count; i++) {
 272                     var val1 = arr1[i];
 273                     var val2 = arr2[i];
 274                     if (val1 == null || !val1.Equals(val2)) {
 275                         if (val1 is IList && val2 is IList) {
 276                             if (!ListEquality(val1 as IList, val2 as IList)) {
 277                                 return false;
 278                             }
 279                         }
 280                         else if (val1 is Dictionary<String, Object> && val2 is Dictionary<String, Object>) {
 281                             var diff = DiffGlobInfos((Dictionary<String, Object>)val1, (Dictionary<String, Object>)val2);
 282                             if (diff.Count > 0) {
 283                                 return false;
 284                             }
 285                         }
 286                         else {
 287                             return false;
 288                         }
 289                     }
 290                 }
 291                 return true;
 292             }
 293             return false;
 294         }
 295
 296         private static string GetFromStringList(string[] list, int value) {
 297             return value < list.Length ? list[value] : null;
 298         }
 299
 300         public Dictionary<String, Object> ToDictionary(bool diffCalendars) {
 301             var jss = new JavaScriptSerializer();
 302             var str = jss.Serialize(this);
 303             var dictionary = jss.Deserialize<Dictionary<String, Object>>(str);
 304             var cals = (Dictionary<String, Object>) dictionary["calendars"];
 305             Dictionary<String, Object> basisStandardCal = null;
 306             if (GlobalizationInfo.BasisGlobInfo != null) {
 307                 basisStandardCal = (Dictionary<String, Object>)((Dictionary<String, Object>)GlobalizationInfo.BasisGlobInfo["calendars"])["standard"];
 308                 foreach (var pair in this.calendars) {
 309                     var cal = (Dictionary<String, Object>)cals[pair.Key];
 310                     if (diffCalendars) {
 311                         // make each calendar a diff from the standard basis calendar
 312                         cals[pair.Key] = cal = DiffGlobInfos(basisStandardCal, cal);
 313                     }
 314                     // apply convert script if it exists
 315                     if (!String.IsNullOrEmpty(pair.Value.convertScriptBlock)) {
 316                         cal["convert"] = pair.Value.convertScriptBlock;
 317                     }
 318                     // remove redundant monthsGenitive array if it is equivilent to months
 319                     Dictionary<String, Object> months = cal.ContainsKey("months") ? (Dictionary<String, Object>)cal["months"] : null;
 320                     Dictionary<String, Object> monthsGenitive = cal.ContainsKey("monthsGenitive") ? (Dictionary<String, Object>)cal["monthsGenitive"] : null;
 321                     Dictionary<String, Object> diff = (months != null && monthsGenitive != null) ? DiffGlobInfos(months, monthsGenitive) : null;
 322                     if (diff != null && diff.Count == 0) {
 323                         // the genitive months are the same as months, so remove it since it's optional
 324                         cal.Remove("monthsGenitive");
 325                     }
 326                 }
 327             }
 328             return dictionary;
 329         }
 330
 331         public static string GenerateJavaScript(string extend, string global, CultureInfo culture, string name, Dictionary<String, Object> dictionary, StringBuilder aggregateScript) {
 332             string cultureFragment = ToJavaScript(extend, culture, dictionary, 1, false);
 333
 334             if (aggregateScript != null) {
 335                 aggregateScript.AppendFormat(CultureInfo.InvariantCulture, @"
 336 Globalize.addCultureInfo( ""{0}"", ""default"", {{
 337 {1}
 338 }});
 339 ", name, cultureFragment, extend);
 340             }
 341
 342                 return string.Format(CultureInfo.InvariantCulture, @"/*
 343  * Globalize Culture {0}
 344  *
 345  * http://github.com/jquery/globalize
 346  *
 347  * Copyright Software Freedom Conservancy, Inc.
 348  * Dual licensed under the MIT or GPL Version 2 licenses.
 349  * http://jquery.org/license
 350  *
 351  * This file was generated by the Globalize Culture Generator
 352  * Translation: bugs found in this file need to be fixed in the generator
 353  */
 354
 355 (function( window, undefined ) {{
 356
 357 var Globalize;
 358
 359 if ( typeof require !== ""undefined""
 360         && typeof exports !== ""undefined""
 361         && typeof module !== ""undefined"" ) {{
 362         // Assume CommonJS
 363         Globalize = require( ""globalize"" );
 364 }} else {{
 365         // Global variable
 366         Globalize = window.Globalize;
 367 }}
 368
 369 Globalize.addCultureInfo( ""{0}"", ""default"", {{
 370 {1}
 371 }});
 372
 373 }}( this ));
 374 ", name, cultureFragment);
 375         }
 376
 377         private static string Serialize(object value) {
 378             // no need to escape single quotes
 379             return _jss.Serialize(value).Replace("\\u0027", "'");
 380         }
 381
 382         private static string ToJavaScript(string extend, CultureInfo culture, Dictionary<String, Object> dictionary, int level, bool isCalendars) {
 383             StringBuilder sb = new StringBuilder();
 384             string padding = _padding.Substring(0, level);
 385             bool first = true;
 386             foreach (var pair in dictionary) {
 387                 if (!first) {
 388                     sb.Append(",\n");
 389                 }
 390                 first = false;
 391                 if (pair.Value is Dictionary<String, Object>) {
 392                     sb.AppendFormat("{0}{1}: {{\n{2}\n{0}}}", padding, pair.Key, ToJavaScript(extend, culture, (Dictionary<String, Object>)pair.Value, level + 1, pair.Key.Equals("calendars")));
 393                 }
 394                 else if (pair.Key.Equals("convert")) {
 395                     sb.AppendFormat("{0}convert: {{\n{1}\n{0}}}", padding, pair.Value);
 396                 }
 397                 else if (pair.Key.Equals("groupSeparator")) {
 398                     sb.AppendFormat("{0}\",\": {1}", padding, Serialize(pair.Value));
 399                 }
 400                 else if (pair.Key.Equals("decimalSeparator")) {
 401                     sb.AppendFormat("{0}\".\": {1}", padding, Serialize(pair.Value));
 402                 }
 403                 else if (pair.Key.Equals("positive")) {
 404                     sb.AppendFormat("{0}\"+\": {1}", padding, Serialize(pair.Value));
 405                 }
 406                 else if (pair.Key.Equals("negative")) {
 407                     sb.AppendFormat("{0}\"-\": {1}", padding, Serialize(pair.Value));
 408                 }
 409                 else if (pair.Key.Equals("dateSeparator")) {
 410                     sb.AppendFormat("{0}\"/\": {1}", padding, Serialize(pair.Value));
 411                 }
 412                 else if (pair.Key.Equals("timeSeparator")) {
 413                     sb.AppendFormat("{0}\":\": {1}", padding, Serialize(pair.Value));
 414                 }
 415                 else {
 416                     sb.AppendFormat("{0}{1}: {2}", padding, pair.Key, Serialize(pair.Value));
 417                 }
 418             }
 419             return sb.ToString();
 420         }
 421
 422         private static JavaScriptSerializer _jss = new JavaScriptSerializer();
 423         private static string _padding = "                                                                                                                                      ";
 424
 425         private static Dictionary<String, Object> ToDictionary(IEnumerable<KeyValuePair<String, Object>> pairs) {
 426             var d = new Dictionary<String, Object>();
 427             foreach (var pair in pairs) {
 428                 d.Add(pair.Key, pair.Value);
 429             }
 430             return d;
 431         }
 432
 433         public static Dictionary<String, Object> DiffGlobInfos(Dictionary<String, Object> glob1, Dictionary<String, Object> glob2) {
 434             var unique = new Dictionary<String, Object>();
 435             var comparer = new KeyValueComparer();
 436
 437             var diff = ToDictionary(glob2.Except(glob1, comparer));
 438             foreach (var pair in glob2) {
 439                 if (diff.ContainsKey(pair.Key) && pair.Value != null) {
 440                     if (pair.Value is Dictionary<String, Object>) {
 441                         var subdiff = glob1.ContainsKey(pair.Key) ? DiffGlobInfos((Dictionary<String, Object>)glob1[pair.Key], (Dictionary<String, Object>)pair.Value) : (Dictionary<String, Object>)pair.Value;
 442                         if (subdiff.Count > 0) {
 443                             //Debug.WriteLine("Replacing\n    {0}\nwith\n    {1}", _jss.Serialize(diff[pair.Key]), _jss.Serialize(subdiff));
 444                             diff[pair.Key] = subdiff;
 445                         }
 446                         else {
 447                             //Debug.WriteLine("\nRemoving {0}\n", _jss.Serialize(pair.Key));
 448                             diff.Remove(pair.Key);
 449                         }
 450                     }
 451                     else if (pair.Value is IList) {
 452                         if (glob1.ContainsKey(pair.Key) && ListEquality((IList)pair.Value, (IList)glob1[pair.Key])) {
 453                             diff.Remove(pair.Key);
 454                         }
 455                     }
 456                 }
 457             }
 458
 459             return diff;
 460         }
 461
 462         public class KeyValueComparer : IEqualityComparer<KeyValuePair<String, Object>> {
 463             public bool Equals(KeyValuePair<String, Object> x, KeyValuePair<String, Object> y) {
 464                 if (x.Key.Equals(y.Key)) {
 465                     if ((x.Value == null && y.Value == null) || (x.Value != null && x.Value.Equals(y.Value))) {
 466                         return true;
 467                     }
 468                     else if (x.Value is ArrayList && y.Value is ArrayList) {
 469                         return ListEquality((IList)x.Value, (IList)y.Value);
 470                     }
 471                     else if (x.Value is Array && y.Value is Array) {
 472                         return ArrayEquality(x.Value as Array, y.Value as Array);
 473                     }
 474                     else if (x.Value is Dictionary<String, Object> && y.Value is Dictionary<String, Object>) {
 475                         var diff = DiffGlobInfos((Dictionary<String, Object>)x.Value, (Dictionary<String, Object>)y.Value);
 476                         if (diff.Count == 0) {
 477                             return true;
 478                         }
 479                         //else {
 480                         //    Debug.WriteLine("    Dictionaries diff:\n        {0}\n        {1}", _jss.Serialize(x.Value), _jss.Serialize(y.Value));
 481                         //}
 482                     }
 483                 }
 484                 //Debug.WriteLine("    Diff found: {0}={1}, {2}={3}", x.Key, x.Value, y.Key, y.Value);
 485                 return false;
 486             }
 487
 488             public int GetHashCode(KeyValuePair<String, Object> obj) {
 489                 return obj.GetHashCode();
 490             }
 491         }
 492
 493         public class NumberFormatInfo {
 494             public string[] pattern;
 495             public int decimals;
 496             public string groupSeparator;
 497             public string decimalSeparator;
 498             public int[] groupSizes;
 499             public string NaN;
 500             public string negative;
 501             public string negativeInfinity;
 502             public string positive;
 503             public string positiveInfinity;
 504             public NumberClassFormatInfo percent;
 505             public NumberClassFormatInfo currency;
 506
 507             public class NumberClassFormatInfo {
 508                 public string[] pattern;
 509                 public int decimals;
 510                 public int[] groupSizes;
 511                 public string groupSeparator;
 512                 public string decimalSeparator;
 513                 public string symbol;
 514             }
 515         }
 516
 517         public class DateFormatInfo {
 518             public string name;
 519             public string dateSeparator;
 520             public string timeSeparator;
 521             public int firstDay;
 522             public DayInfo days;
 523             public MonthInfo months;
 524             public MonthInfo monthsGenitive;
 525             public string[] AM;
 526             public string[] PM;
 527             public EraInfo[] eras;
 528             public int twoDigitYearMax;
 529             public Dictionary<String, String> patterns;
 530             internal string convertScriptBlock;
 531
 532             public class EraInfo {
 533                 public string name;
 534                 public long? start;
 535                 public long offset;
 536             }
 537
 538             public class MonthInfo {
 539                 public string[] names;
 540                 public string[] namesAbbr;
 541             }
 542
 543             public class DayInfo {
 544                 public string[] names;
 545                 public string[] namesAbbr;
 546                 public string[] namesShort;
 547             }
 548         }
 549
 550     }
 551
 552     public class Program {
 553
 554         private static void WriteCulture(string outputdir, string fileName, string extend, string global, CultureInfo culture, StringBuilder aggregateScript) {
 555             var globInfo = GlobalizationInfo.GetGlobInfo(culture);
 556             var diff = (String.IsNullOrEmpty(extend) || culture == CultureInfo.InvariantCulture || culture.Name.Equals("en")) ? globInfo.ToDictionary(false) : GlobalizationInfo.DiffGlobInfos(GlobalizationInfo.BasisGlobInfo, globInfo.ToDictionary(true));
 557
 558             // Fix for Issue #31 - en-US 'englishName' is wrong
 559             // Special case diff of englishName for en-US. The generator diff seemingly finds both "en" and "en-US" to
 560             // have englishName "English (United States)" but globalize.js (correctly) has the neutral "English" for "en"/"default"
 561             if (culture.Name.Equals("en-US")) {
 562                 diff.Add("name", globInfo.name);
 563                 diff.Add("englishName", globInfo.englishName);
 564             }
 565
 566             var script = GlobalizationInfo.GenerateJavaScript(extend, global, culture, culture.Name, diff, aggregateScript);
 567             var filePath = Path.Combine(outputdir, String.Format(fileName, (String.IsNullOrEmpty(culture.Name) ? "invariant" : culture.Name)));
 568
 569             File.WriteAllText(filePath, script);
 570             Console.WriteLine(filePath);
 571         }
 572
 573         [STAThread]
 574         static void Main(string[] args) {
 575             string outputdir = "lib\\cultures";
 576             string extend = "extend";
 577             string global = "Globalization";
 578             string fileName = "globalize.culture.{0}.js";
 579             string aggregateFileName = "globalize.cultures.js";
 580             foreach (string param in string.Join(" ", args).SplitCommandLine()) {
 581                 if (param.StartsWith("/o:")) {
 582                     outputdir = param.Substring("/o:".Length);
 583                 }
 584                 else if (param == "/?") {
 585                     Console.Write(@"
 586 Usage:glob-generator [<options>]
 587
 588 options:
 589
 590     /o: The directory to put the culture scripts into. The directory will be
 591         created if it does not exist. Existing scripts there will be
 592         overwritten if necessary.
 593         default: ""lib\cultures""
 594
 595 ");
 596                     return;
 597                 }
 598             }
 599             Directory.CreateDirectory(outputdir);
 600             GlobalizationInfo.BasisGlobInfo = GlobalizationInfo.GetGlobInfo(CultureInfo.CreateSpecificCulture("en")).ToDictionary(false);
 601
 602             StringBuilder aggregateScript = new StringBuilder();
 603
 604 /*
 605
 606 Globalize.addCultureInfo( ""{0}"", ""default"", {{
 607 {1}
 608 }});
 609
 610 }}( this ));
 611 "
 612 */
 613
 614             aggregateScript.Append(
 615     @"/*
 616  * Globalize Cultures
 617  *
 618  * http://github.com/jquery/globalize
 619  *
 620  * Copyright Software Freedom Conservancy, Inc.
 621  * Dual licensed under the MIT or GPL Version 2 licenses.
 622  * http://jquery.org/license
 623  *
 624  * This file was generated by the Globalize Culture Generator
 625  * Translation: bugs found in this file need to be fixed in the generator
 626  */
 627
 628 (function( window, undefined ) {
 629
 630 var Globalize;
 631
 632 if ( typeof require !== ""undefined""
 633         && typeof exports !== ""undefined""
 634         && typeof module !== ""undefined"" ) {
 635         // Assume CommonJS
 636         Globalize = require( ""globalize"" );
 637 } else {
 638         // Global variable
 639         Globalize = window.Globalize;
 640 }
 641 ");
 642
 643             int count = 0;
 644             foreach (var culture in CultureInfo.GetCultures(CultureTypes.AllCultures)) {
 645                 if (!String.IsNullOrEmpty(culture.Name) && culture != CultureInfo.InvariantCulture && culture.Name != "en") {
 646                     WriteCulture(outputdir, fileName, extend, global, culture, aggregateScript);
 647                     count++;
 648                 }
 649             }
 650
 651             aggregateScript.Append("\r\n}( this ));\r\n");
 652             string aggregateScriptString = aggregateScript.ToString();
 653             string aggregatePath = Path.Combine(outputdir, aggregateFileName);
 654             File.WriteAllText(aggregatePath, aggregateScriptString);
 655             Console.WriteLine(aggregatePath);
 656
 657             Console.WriteLine("Done! Generated scripts for a total of {0} cultures, and 1 aggregate script.", count);
 658         }
 659     }
 660 }