/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.gwt.tools.datetimefmtcreator;
import com.google.gwt.i18n.client.constants.DateTimeConstantsImpl;
import com.google.gwt.i18n.rebind.LocaleUtils;
import com.google.gwt.i18n.shared.GwtLocale;
import com.google.gwt.i18n.shared.GwtLocaleFactory;
import com.ibm.icu.text.DateTimePatternGenerator;
import com.ibm.icu.util.ULocale;
import org.apache.tapestry.util.text.LocalizedProperties;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.Map.Entry;
import java.util.regex.Pattern;
/**
* Generate implementations of DateTimeFormatInfoImpl for all the supported
* locales.
*/
public class DateTimeFormatCreator {
private static class DtfiGenerator {
private static void buildPatterns(GwtLocale locale, TreeMap<Key, String[]> properties) {
ULocale ulocale = new ULocale(ULocale.canonicalize(locale.getAsString()));
DateTimePatternGenerator dtpg = DateTimePatternGenerator.getInstance(ulocale);
for (Map.Entry<String, String> entry : patterns.entrySet()) {
properties.put(new Key(locale, "format" + entry.getKey()), new String[] {dtpg
.getBestPattern(entry.getValue())});
}
}
private static GwtLocale findEarliestAncestor(GwtLocale locale, Set<GwtLocale> set) {
if (set == null) {
return null;
}
for (GwtLocale search : locale.getInheritanceChain()) {
if (set.contains(search)) {
return search;
}
}
return null;
}
private static String quote(String value) {
return value.replaceAll("\"", "\\\\\"");
}
private static String[] split(String target) {
// We add an artificial end character to avoid the odd split() behavior
// that drops the last item if it is only whitespace.
target = target + "~";
// Do not split on escaped commas.
String[] args = target.split("(?<![\\\\]),");
// Now remove the artificial ending we added above.
// We have to do it before we escape and trim because otherwise
// the artificial trailing '~' would prevent the last item from being
// properly trimmed.
if (args.length > 0) {
int last = args.length - 1;
args[last] = args[last].substring(0, args[last].length() - 1);
}
for (int i = 0; i < args.length; i++) {
args[i] = args[i].replaceAll("\\\\,", ",").trim();
}
return args;
}
private File propDir;
private File src;
public DtfiGenerator(File src) {
this.src = src;
String packageName = DateTimeConstantsImpl.class.getPackage().getName();
propDir = new File(src, packageName.replaceAll("\\.", "/"));
if (!propDir.exists()) {
System.err.println("Can't find directory for " + packageName);
return;
}
}
public void generate() throws FileNotFoundException, IOException {
final Pattern dtcProps = Pattern.compile("DateTimeConstantsImpl(.*)\\.properties");
String[] propFiles = propDir.list(new FilenameFilter() {
public boolean accept(File dir, String name) {
return dtcProps.matcher(name).matches();
}
});
TreeMap<Key, String[]> properties = new TreeMap<Key, String[]>();
GwtLocaleFactory factory = LocaleUtils.getLocaleFactory();
collectPropertyData(propFiles, properties, factory);
Map<GwtLocale, Set<GwtLocale>> parents = removeInheritedValues(properties);
generateSources(properties, parents);
}
private void addLocaleParent(Map<GwtLocale, Set<GwtLocale>> parents, GwtLocale keyLocale,
GwtLocale parentLocale) {
Set<GwtLocale> parentSet = parents.get(keyLocale);
if (parentSet == null) {
parentSet = new HashSet<GwtLocale>();
parents.put(keyLocale, parentSet);
}
parentSet.add(parentLocale);
}
@SuppressWarnings("unchecked")
private void collectPropertyData(String[] propFiles, TreeMap<Key, String[]> properties,
GwtLocaleFactory factory) throws FileNotFoundException, IOException {
for (String propFile : propFiles) {
if (!propFile.startsWith("DateTimeConstantsImpl") || !propFile.endsWith(".properties")) {
continue;
}
int len = propFile.length();
String suffix = propFile.substring(21, len - 11);
if (suffix.startsWith("_")) {
suffix = suffix.substring(1);
}
GwtLocale locale = factory.fromString(suffix).getCanonicalForm();
File f = new File(propDir, propFile);
FileInputStream str = null;
try {
str = new FileInputStream(f);
LocalizedProperties props = new LocalizedProperties();
props.load(str);
Map<String, String> map = props.getPropertyMap();
for (Map.Entry<String, String> entry : map.entrySet()) {
String[] value = split(entry.getValue());
if ("dateFormats".equals(entry.getKey()) || "timeFormats".equals(entry.getKey())
|| "weekendRange".equals(entry.getKey())) {
// split these out into separate fields
for (int i = 0; i < value.length; ++i) {
Key key = new Key(locale, entry.getKey() + i);
properties.put(key, new String[] {value[i]});
}
} else {
Key key = new Key(locale, entry.getKey());
properties.put(key, value);
}
}
buildPatterns(locale, properties);
} finally {
if (str != null) {
str.close();
}
}
}
}
private PrintWriter createClassSource(String packageName, String className)
throws FileNotFoundException {
String path = packageName.replace('.', '/') + "/" + className + ".java";
File f = new File(src, path);
FileOutputStream ostr = new FileOutputStream(f);
PrintWriter out = new PrintWriter(ostr);
out.println("/*");
out.println(" * Copyright 2010 Google Inc.");
out.println(" * ");
out.println(" * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not");
out.println(" * use this file except in compliance with the License. You may obtain a copy of");
out.println(" * the License at");
out.println(" * ");
out.println(" * http://www.apache.org/licenses/LICENSE-2.0");
out.println(" *");
out.println(" * Unless required by applicable law or agreed to in writing, software");
out.println(" * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT");
out.println(" * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the");
out.println(" * License for the specific language governing permissions and limitations under");
out.println(" * the License.");
out.println(" */");
out.println("package " + packageName + ";");
out.println();
out.println("// DO NOT EDIT - GENERATED FROM CLDR DATA");
out.println();
return out;
}
private void generateAlias(GwtLocale locale, GwtLocale parent) throws IOException {
System.out.println("Generating alias " + locale);
String suffix;
if (parent.isDefault()) {
suffix = "";
} else {
suffix = "_" + parent.getAsString();
}
String packageName = "com.google.gwt.i18n.client.impl.cldr";
String className = "DateTimeFormatInfoImpl_" + locale.getAsString();
PrintWriter out = null;
try {
out = createClassSource(packageName, className);
out.println("/**");
out.println(" * Locale \"" + locale + "\" is an alias for \"" + parent + "\".");
out.println(" */");
out.println("public class " + className + " extends DateTimeFormatInfoImpl" + suffix + " {");
out.println("}");
} finally {
if (out != null) {
out.close();
}
}
}
private void generateLocale(GwtLocale locale, GwtLocale parent, Map<String, String[]> values)
throws IOException {
System.out.println("Generating locale " + locale);
boolean addOverrides = true;
PrintWriter out = null;
try {
if (locale.isDefault()) {
String packageName = "com.google.gwt.i18n.client";
String className = "DefaultDateTimeFormatInfo";
out = createClassSource(packageName, className);
out.println("/**");
out.println(" * Default implementation of DateTimeFormatInfo interface, using values from");
out.println(" * the CLDR root locale.");
out.println(" * <p>");
out.println(" * Users who need to create their own DateTimeFormatInfo implementation are");
out.println(" * encouraged to extend this class so their implementation won't break when");
out.println(" * new methods are added.");
out.println(" */");
out.println("public class DefaultDateTimeFormatInfo implements DateTimeFormatInfo {");
addOverrides = false;
} else {
String suffix;
if (parent.isDefault()) {
suffix = "";
} else {
suffix = "_" + parent.getAsString();
}
String packageName = "com.google.gwt.i18n.client.impl.cldr";
String className = "DateTimeFormatInfoImpl_" + locale.getAsString();
out = createClassSource(packageName, className);
out.println("/**");
out.println(" * Implementation of DateTimeFormatInfo for locale \"" + locale + "\".");
out.println(" */");
out.println("public class " + className + " extends DateTimeFormatInfoImpl" + suffix
+ " {");
}
Set<String> keySet = values.keySet();
String[] keys = keySet.toArray(new String[keySet.size()]);
Arrays.sort(keys, new Comparator<String>() {
public int compare(String a, String b) {
String mappedA = a;
String mappedB = b;
FieldMapping field = fieldMap.get(a);
if (field != null) {
mappedA = field.methodName;
}
field = fieldMap.get(b);
if (field != null) {
mappedB = field.methodName;
}
return mappedA.compareTo(mappedB);
}
});
for (String key : keys) {
String[] value = values.get(key);
FieldMapping mapping = fieldMap.get(key);
Class<?> type = value.length > 1 ? String[].class : String.class;
String related = null;
String name = key;
if (mapping != null) {
name = mapping.methodName;
type = mapping.type;
related = mapping.related;
}
String[] relatedValue = values.get(related);
String relayMethod = null;
if (Arrays.equals(value, relatedValue)) {
relayMethod = fieldMap.get(related).methodName;
}
out.println();
if (addOverrides) {
out.println(" @Override");
}
out.println(" public " + type.getSimpleName() + " " + name + "() {");
out.print(" return ");
if (relayMethod != null) {
out.println(relayMethod + "();");
} else {
if (type.isArray()) {
out.println("new " + type.getSimpleName() + " { ");
out.print(" ");
}
boolean first = true;
for (String oneValue : value) {
if (!first) {
out.println(",");
out.print(" ");
}
if (type == int.class || type == int[].class) {
out.print(Integer.valueOf(oneValue) - 1);
} else {
out.print("\"" + quote(oneValue) + "\"");
}
first = false;
}
if (type.isArray()) {
out.println();
out.println(" };");
} else {
out.println(";");
}
}
out.println(" }");
}
if (locale.isDefault()) {
// TODO(jat): actually generate these from CLDR data
out.println();
out.println(" public String dateFormat() {");
out.println(" return dateFormatMedium();");
out.println(" }");
out.println();
out.println(" public String dateTime(String timePattern, String datePattern) {");
out.println(" return datePattern + \" \" + timePattern;");
out.println(" }");
out.println();
out.println(" public String dateTimeFull(String timePattern, String datePattern) {");
out.println(" return dateTime(timePattern, datePattern);");
out.println(" }");
out.println();
out.println(" public String dateTimeLong(String timePattern, String datePattern) {");
out.println(" return dateTime(timePattern, datePattern);");
out.println(" }");
out.println();
out.println(" public String dateTimeMedium(String timePattern, String datePattern) {");
out.println(" return dateTime(timePattern, datePattern);");
out.println(" }");
out.println();
out.println(" public String dateTimeShort(String timePattern, String datePattern) {");
out.println(" return dateTime(timePattern, datePattern);");
out.println(" }");
out.println();
out.println(" public String timeFormat() {");
out.println(" return timeFormatMedium();");
out.println(" }");
}
out.println("}");
} finally {
if (out != null) {
out.close();
}
}
}
private void generateSources(TreeMap<Key, String[]> properties,
Map<GwtLocale, Set<GwtLocale>> parents) throws IOException {
Set<GwtLocale> locales = new HashSet<GwtLocale>();
// process sorted locales/keys, generating each locale on change
GwtLocale lastLocale = null;
Map<String, String[]> thisLocale = new HashMap<String, String[]>();
for (Entry<Key, String[]> entry : properties.entrySet()) {
if (lastLocale != null && lastLocale != entry.getKey().locale) {
GwtLocale parent = findEarliestAncestor(lastLocale, parents.get(lastLocale));
generateLocale(lastLocale, parent, thisLocale);
thisLocale.clear();
lastLocale = null;
}
if (lastLocale == null) {
lastLocale = entry.getKey().locale;
locales.add(lastLocale);
}
thisLocale.put(entry.getKey().key, entry.getValue());
}
if (lastLocale != null) {
GwtLocale parent = findEarliestAncestor(lastLocale, parents.get(lastLocale));
generateLocale(lastLocale, parent, thisLocale);
}
Set<GwtLocale> seen = new HashSet<GwtLocale>(locales);
for (GwtLocale locale : locales) {
for (GwtLocale alias : locale.getAliases()) {
if (!seen.contains(alias)) {
seen.add(alias);
// generateAlias(alias, locale);
}
}
}
}
/**
* Check if a given entry within a locale is inherited from a parent.
*
* @param properties
* @param parents
* @param key
* @param value
* @return true if the value is the same as the first parent defining that
* value
*/
private boolean isInherited(TreeMap<Key, String[]> properties,
Map<GwtLocale, Set<GwtLocale>> parents, Key key, String[] value) {
GwtLocale keyLocale = key.locale;
if (keyLocale.isDefault()) {
// never delete entries from default
return false;
}
List<GwtLocale> list = keyLocale.getInheritanceChain();
String[] parent = null;
for (int i = 1; i < list.size(); ++i) {
Key parentKey = new Key(list.get(i), key.key);
parent = properties.get(parentKey);
if (parent != null) {
GwtLocale parentLocale = parentKey.locale;
addLocaleParent(parents, keyLocale, parentLocale);
break;
}
}
return Arrays.equals(value, parent);
}
/**
* Remove inherited values and return a map of inherited-from locales for
* each locale.
*
* @param properties
* @return inheritance map
*/
private Map<GwtLocale, Set<GwtLocale>> removeInheritedValues(TreeMap<Key, String[]> properties) {
// remove entries identical to a parent locale
Map<GwtLocale, Set<GwtLocale>> parents = new HashMap<GwtLocale, Set<GwtLocale>>();
Set<Entry<Key, String[]>> entrySet = properties.entrySet();
Iterator<Entry<Key, String[]>> it = entrySet.iterator();
while (it.hasNext()) {
Entry<Key, String[]> entry = it.next();
if (isInherited(properties, parents, entry.getKey(), entry.getValue())) {
it.remove();
}
}
return parents;
}
}
private static class FieldMapping {
public final String methodName;
public final Class<?> type;
public final String related;
public FieldMapping(String methodName, Class<?> type) {
this(methodName, type, null);
}
public FieldMapping(String methodName, Class<?> type, String related) {
this.methodName = methodName;
this.type = type;
this.related = related;
}
}
private static class Key implements Comparable<Key> {
public final GwtLocale locale;
public final String key;
public Key(GwtLocale locale, String key) {
this.locale = locale;
this.key = key;
}
public int compareTo(Key other) {
int c = locale.compareTo(other.locale);
if (c == 0) {
c = key.compareTo(other.key);
}
return c;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null || getClass() != obj.getClass()) {
return false;
}
Key other = (Key) obj;
return locale.equals(other.locale) && key.equals(other.key);
}
@Override
public int hashCode() {
return locale.hashCode() * 31 + key.hashCode();
}
@Override
public String toString() {
return locale.toString() + "/" + key;
}
}
private static final Map<String, FieldMapping> fieldMap = new HashMap<String, FieldMapping>();
private static Map<String, String> patterns = new HashMap<String, String>();
static {
fieldMap.put("ampms", new FieldMapping("ampms", String[].class));
fieldMap.put("dateFormats0", new FieldMapping("dateFormatFull", String.class));
fieldMap.put("dateFormats1", new FieldMapping("dateFormatLong", String.class));
fieldMap.put("dateFormats2", new FieldMapping("dateFormatMedium", String.class));
fieldMap.put("dateFormats3", new FieldMapping("dateFormatShort", String.class));
fieldMap.put("timeFormats0", new FieldMapping("timeFormatFull", String.class));
fieldMap.put("timeFormats1", new FieldMapping("timeFormatLong", String.class));
fieldMap.put("timeFormats2", new FieldMapping("timeFormatMedium", String.class));
fieldMap.put("timeFormats3", new FieldMapping("timeFormatShort", String.class));
fieldMap.put("eraNames", new FieldMapping("erasFull", String[].class));
fieldMap.put("eras", new FieldMapping("erasShort", String[].class));
fieldMap.put("quarters", new FieldMapping("quartersFull", String[].class));
fieldMap.put("shortQuarters", new FieldMapping("quartersShort", String[].class));
fieldMap.put("firstDayOfTheWeek", new FieldMapping("firstDayOfTheWeek", Integer.class));
fieldMap.put("months", new FieldMapping("monthsFull", String[].class));
fieldMap.put("standaloneMonths", new FieldMapping("monthsFullStandalone", String[].class,
"months"));
fieldMap.put("narrowMonths", new FieldMapping("monthsNarrow", String[].class));
fieldMap.put("standaloneNarrowMonths", new FieldMapping("monthsNarrowStandalone",
String[].class, "narrowMonths"));
fieldMap.put("shortMonths", new FieldMapping("monthsShort", String[].class));
fieldMap.put("standaloneShortMonths", new FieldMapping("monthsShortStandalone", String[].class,
"shortMonths"));
fieldMap.put("weekendRange0", new FieldMapping("weekendStart", int.class));
fieldMap.put("weekendRange1", new FieldMapping("weekendEnd", int.class));
fieldMap.put("firstDayOfTheWeek", new FieldMapping("firstDayOfTheWeek", int.class));
fieldMap.put("weekdays", new FieldMapping("weekdaysFull", String[].class));
fieldMap.put("standaloneWeekdays", new FieldMapping("weekdaysFullStandalone", String[].class,
"weekdays"));
fieldMap.put("shortWeekdays", new FieldMapping("weekdaysShort", String[].class));
fieldMap.put("standaloneShortWeekdays", new FieldMapping("weekdaysShortStandalone",
String[].class, "shortWeekdays"));
fieldMap.put("narrowWeekdays", new FieldMapping("weekdaysNarrow", String[].class));
fieldMap.put("standaloneNarrowWeekdays", new FieldMapping("weekdaysNarrowStandalone",
String[].class, "narrowWeekdays"));
// patterns to use with DateTimePatternGenerator
patterns.put("Day", "d");
patterns.put("Hour12Minute", "hmm");
patterns.put("Hour12MinuteSecond", "hmmss");
patterns.put("Hour24Minute", "Hmm");
patterns.put("Hour24MinuteSecond", "Hmmss");
patterns.put("MinuteSecond", "mss");
patterns.put("MonthAbbrev", "MMM");
patterns.put("MonthAbbrevDay", "MMMd");
patterns.put("MonthFull", "MMMM");
patterns.put("MonthFullDay", "MMMMd");
patterns.put("MonthFullWeekdayDay", "MMMMEEEEd");
patterns.put("MonthNumDay", "Md");
patterns.put("Year", "y");
patterns.put("YearMonthAbbrev", "yMMM");
patterns.put("YearMonthAbbrevDay", "yMMMd");
patterns.put("YearMonthFull", "yMMMM");
patterns.put("YearMonthFullDay", "yMMMMd");
patterns.put("YearMonthNum", "yM");
patterns.put("YearMonthNumDay", "yMd");
patterns.put("YearMonthWeekdayDay", "yMMMEEEd");
patterns.put("YearQuarterFull", "yQQQQ");
patterns.put("YearQuarterShort", "yQ");
}
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
if (args.length != 1) {
System.err.println("Usage: " + DateTimeFormatCreator.class.getSimpleName() + " gwt-root-dir");
return;
}
File gwt = new File(args[0]);
File src = new File(gwt, "user/src");
if (!gwt.exists() || !src.exists()) {
System.err.println(args[0] + " doesn't appear to be a GWT root directory");
return;
}
new DtfiGenerator(src).generate();
}
}