make/jdk/src/classes/build/tools/cldrconverter/ResourceBundleGenerator.java

/*
 * Copyright (c) 2012, 2018, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package build.tools.cldrconverter;

import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Formatter;
import java.util.HashSet;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Locale;
import java.util.Objects;
import java.util.Set;
import java.util.SortedSet;

class ResourceBundleGenerator implements BundleGenerator {
    // preferred timezones - keeping compatibility with JDK1.1 3 letter abbreviations
    private static final String[] preferredTZIDs = {
        "America/Los_Angeles",
        "America/Denver",
        "America/Phoenix",
        "America/Chicago",
        "America/New_York",
        "America/Indianapolis",
        "Pacific/Honolulu",
        "America/Anchorage",
        "America/Halifax",
        "America/Sitka",
        "America/St_Johns",
        "Europe/Paris",
        // Although CLDR does not support abbreviated zones, handle "GMT" as a
        // special case here, as it is specified in the javadoc.
        "GMT",
        "Africa/Casablanca",
        "Asia/Jerusalem",
        "Asia/Tokyo",
        "Europe/Bucharest",
        "Asia/Shanghai",
        "UTC",
    };

    // For duplicated values
    private static final String META_VALUE_PREFIX = "metaValue_";

    @Override
    public void generateBundle(String packageName, String baseName, String localeID, boolean useJava,
                               Map<String, ?> map, BundleType type) throws IOException {
        String suffix = useJava ? ".java" : ".properties";
        String dirName = CLDRConverter.DESTINATION_DIR + File.separator + "sun" + File.separator
                + packageName + File.separator + "resources" + File.separator + "cldr";
        packageName = packageName + ".resources.cldr";

        if (CLDRConverter.isBaseModule ^ isBaseLocale(localeID)) {
            return;
        }

        // Assume that non-base resources go into jdk.localedata
        if (!CLDRConverter.isBaseModule) {
            dirName = dirName + File.separator + "ext";
            packageName = packageName + ".ext";
        }

        File dir = new File(dirName);
        if (!dir.exists()) {
            dir.mkdirs();
        }
        File file = new File(dir, baseName + ("root".equals(localeID) ? "" : "_" + localeID) + suffix);
        if (!file.exists()) {
            file.createNewFile();
        }
        CLDRConverter.info("\tWriting file " + file);

        String encoding;
        if (useJava) {
            if (CLDRConverter.USE_UTF8) {
                encoding = "utf-8";
            } else {
                encoding = "us-ascii";
            }
        } else {
            encoding = "iso-8859-1";
        }

        Formatter fmt = null;
        if (type == BundleType.TIMEZONE) {
            fmt = new Formatter();
            Set<String> metaKeys = new HashSet<>();
            for (String key : map.keySet()) {
                if (key.startsWith(CLDRConverter.METAZONE_ID_PREFIX)) {
                    String meta = key.substring(CLDRConverter.METAZONE_ID_PREFIX.length());
                    String[] value;
                    value = (String[]) map.get(key);
                    fmt.format("        final String[] %s = new String[] {\n", meta);
                    for (String s : value) {
                        fmt.format("               \"%s\",\n", CLDRConverter.saveConvert(s, useJava));
                    }
                    fmt.format("            };\n");
                    metaKeys.add(key);
                }
            }
            for (String key : metaKeys) {
                map.remove(key);
            }

            // Make it preferred ordered
            LinkedHashMap<String, Object> newMap = new LinkedHashMap<>();
            for (String preferred : preferredTZIDs) {
                if (map.containsKey(preferred)) {
                    newMap.put(preferred, map.remove(preferred));
                } else if (("GMT".equals(preferred) || "UTC".equals(preferred)) &&
                           metaKeys.contains(CLDRConverter.METAZONE_ID_PREFIX+preferred)) {
                    newMap.put(preferred, preferred);
                }
            }
            newMap.putAll(map);
            map = newMap;
        } else {
            // generic reduction of duplicated values
            Map<String, Object> newMap = null;
            for (String key : map.keySet()) {
                Object val = map.get(key);
                String metaVal = null;

                for (Map.Entry<String, ?> entry : map.entrySet()) {
                    String k = entry.getKey();
                    if (!k.equals(key) &&
                        Objects.deepEquals(val, entry.getValue()) &&
                        !(Objects.nonNull(newMap) && newMap.containsKey(k))) {
                        if (Objects.isNull(newMap)) {
                            newMap = new HashMap<>();
                            fmt = new Formatter();
                        }

                        if (Objects.isNull(metaVal)) {
                            metaVal = META_VALUE_PREFIX + key.replaceAll("\\.", "_");

                            if (val instanceof String[]) {
                                fmt.format("        final String[] %s = new String[] {\n", metaVal);
                                for (String s : (String[])val) {
                                    fmt.format("               \"%s\",\n", CLDRConverter.saveConvert(s, useJava));
                                }
                                fmt.format("            };\n");
                            } else {
                                fmt.format("        final String %s = \"%s\";\n", metaVal, CLDRConverter.saveConvert((String)val, useJava));
                            }
                        }

                        newMap.put(k, metaVal);
                    }
                }

                if (Objects.nonNull(metaVal)) {
                    newMap.put(key, metaVal);
                }
            }

            if (Objects.nonNull(newMap)) {
                for (String key : map.keySet()) {
                    newMap.putIfAbsent(key, map.get(key));
                }
                map = newMap;
            }
        }

        try (PrintWriter out = new PrintWriter(file, encoding)) {
            // Output copyright headers
            out.println(CopyrightHeaders.getOpenJDKCopyright());
            out.println(CopyrightHeaders.getUnicodeCopyright());

            if (useJava) {
                out.println("package sun." + packageName + ";\n");
                out.printf("import %s;\n\n", type.getPathName());
                out.printf("public class %s%s extends %s {\n", baseName, "root".equals(localeID) ? "" : "_" + localeID, type.getClassName());

                out.println("    @Override\n" +
                            "    protected final Object[][] getContents() {");
                if (fmt != null) {
                    out.print(fmt.toString());
                }
                out.println("        final Object[][] data = new Object[][] {");
            }
            for (String key : map.keySet()) {
                if (useJava) {
                    Object value = map.get(key);
                    if (value == null) {
                        CLDRConverter.warning("null value for " + key);
                    } else if (value instanceof String) {
                        String valStr = (String)value;
                        if (type == BundleType.TIMEZONE &&
                            !key.startsWith(CLDRConverter.EXEMPLAR_CITY_PREFIX) ||
                            valStr.startsWith(META_VALUE_PREFIX)) {
                            out.printf("            { \"%s\", %s },\n", key, CLDRConverter.saveConvert(valStr, useJava));
                        } else {
                            out.printf("            { \"%s\", \"%s\" },\n", key, CLDRConverter.saveConvert(valStr, useJava));
                        }
                    } else if (value instanceof String[]) {
                        String[] values = (String[]) value;
                        out.println("            { \"" + key + "\",\n                new String[] {");
                        for (String s : values) {
                            out.println("                    \"" + CLDRConverter.saveConvert(s, useJava) + "\",");
                        }
                        out.println("                }\n            },");
                    } else {
                        throw new RuntimeException("unknown value type: " + value.getClass().getName());
                    }
                } else {
                    out.println(key + "=" + CLDRConverter.saveConvert((String) map.get(key), useJava));
                }
            }
            if (useJava) {
                out.println("        };\n        return data;\n    }\n}");
            }
        }
    }

    @Override
    public void generateMetaInfo(Map<String, SortedSet<String>> metaInfo) throws IOException {
        String dirName = CLDRConverter.DESTINATION_DIR + File.separator + "sun" + File.separator + "util" +
            File.separator +
            (CLDRConverter.isBaseModule ? "cldr" + File.separator + File.separator :
                      "resources" + File.separator + "cldr" + File.separator + "provider" + File.separator);
        File dir = new File(dirName);
        if (!dir.exists()) {
            dir.mkdirs();
        }
        String className =
            (CLDRConverter.isBaseModule ? "CLDRBaseLocaleDataMetaInfo" : "CLDRLocaleDataMetaInfo");
        File file = new File(dir, className + ".java");
        if (!file.exists()) {
            file.createNewFile();
        }
        CLDRConverter.info("Generating file " + file);

        try (PrintWriter out = new PrintWriter(file, "us-ascii")) {
            out.printf(CopyrightHeaders.getOpenJDKCopyright());

            out.printf((CLDRConverter.isBaseModule ? "package sun.util.cldr;\n\n" :
                                  "package sun.util.resources.cldr.provider;\n\n")
                      + "import java.util.HashMap;\n"
                      + "import java.util.Locale;\n"
                      + "import java.util.Map;\n"
                      + "import sun.util.locale.provider.LocaleDataMetaInfo;\n"
                      + "import sun.util.locale.provider.LocaleProviderAdapter;\n\n");
            out.printf("public class %s implements LocaleDataMetaInfo {\n", className);
            out.printf("    private static final Map<String, String> resourceNameToLocales = new HashMap<>();\n" +
                       (CLDRConverter.isBaseModule ?
                       "    private static final Map<Locale, String[]> parentLocalesMap = new HashMap<>();\n" +
                       "    private static final Map<String, String> languageAliasMap = new HashMap<>();\n\n" :
                       "\n") +
                       "    static {\n");

            for (String key : metaInfo.keySet()) {
                if (key.startsWith(CLDRConverter.PARENT_LOCALE_PREFIX)) {
                    String parentTag = key.substring(CLDRConverter.PARENT_LOCALE_PREFIX.length());
                    if ("root".equals(parentTag)) {
                        out.printf("        parentLocalesMap.put(Locale.ROOT,\n");
                    } else {
                        out.printf("        parentLocalesMap.put(Locale.forLanguageTag(\"%s\"),\n",
                                   parentTag);
                    }
                    String[] children = toLocaleList(metaInfo.get(key), true).split(" ");
                    Arrays.sort(children);
                    out.printf("             new String[] {\n" +
                               "                 ");
                    int count = 0;
                    for (int i = 0; i < children.length; i++) {
                        String child = children[i];
                        out.printf("\"%s\", ", child);
                        count += child.length() + 4;
                        if (i != children.length - 1 && count > 64) {
                            out.printf("\n                 ");
                            count = 0;
                        }
                    }
                    out.printf("\n             });\n");
                } else {
                    if ("AvailableLocales".equals(key)) {
                        out.printf("        resourceNameToLocales.put(\"%s\",\n", key);
                        out.printf("              \"%s\");\n", toLocaleList(applyLanguageAliases(metaInfo.get(key)), false));
                    }
                }
            }
            // for languageAliasMap
            if (CLDRConverter.isBaseModule) {
                CLDRConverter.handlerSupplMeta.getLanguageAliasData().forEach((key, value) -> {
                    out.printf("                languageAliasMap.put(\"%s\", \"%s\");\n", key, value);
                });
            }

            out.printf("    }\n\n");

            // end of static initializer block.

            // Canonical TZ names for delayed initialization
            if (CLDRConverter.isBaseModule) {
                out.printf("    private static class TZCanonicalIDMapHolder {\n");
                out.printf("        static final Map<String, String> tzCanonicalIDMap = new HashMap<>(600);\n");
                out.printf("        static {\n");
                CLDRConverter.handlerTimeZone.getData().entrySet().stream()
                    .forEach(e -> {
                        String[] ids = ((String)e.getValue()).split("\\s");
                        out.printf("            tzCanonicalIDMap.put(\"%s\", \"%s\");\n", e.getKey(),
                                ids[0]);
                        for (int i = 1; i < ids.length; i++) {
                            out.printf("            tzCanonicalIDMap.put(\"%s\", \"%s\");\n", ids[i],
                                ids[0]);
                        }
                    });
                out.printf("        }\n    }\n\n");
            }

            out.printf("    @Override\n" +
                        "    public LocaleProviderAdapter.Type getType() {\n" +
                        "        return LocaleProviderAdapter.Type.CLDR;\n" +
                        "    }\n\n");

            out.printf("    @Override\n" +
                        "    public String availableLanguageTags(String category) {\n" +
                        "        return resourceNameToLocales.getOrDefault(category, \"\");\n" +
                        "    }\n\n");

            if (CLDRConverter.isBaseModule) {
                out.printf("    @Override\n" +
                           "    public Map<String, String> getLanguageAliasMap() {\n" +
                           "        return languageAliasMap;\n" +
                           "    }\n\n");
                out.printf("    @Override\n" +
                           "    public Map<String, String> tzCanonicalIDs() {\n" +
                           "        return TZCanonicalIDMapHolder.tzCanonicalIDMap;\n" +
                           "    }\n\n");
                out.printf("    public Map<Locale, String[]> parentLocales() {\n" +
                           "        return parentLocalesMap;\n" +
                           "    }\n}");
            } else {
                out.printf("}");
            }
        }
    }

    private static final Locale.Builder LOCALE_BUILDER = new Locale.Builder();
    private static boolean isBaseLocale(String localeID) {
        localeID = localeID.replaceAll("-", "_");
        // ignore script here
        Locale locale = LOCALE_BUILDER
                            .clear()
                            .setLanguage(CLDRConverter.getLanguageCode(localeID))
                            .setRegion(CLDRConverter.getRegionCode(localeID))
                            .build();
        return CLDRConverter.BASE_LOCALES.contains(locale);
    }

    private static String toLocaleList(SortedSet<String> set, boolean all) {
        StringBuilder sb = new StringBuilder(set.size() * 6);
        for (String id : set) {
            if (!"root".equals(id)) {
                if (!all && CLDRConverter.isBaseModule ^ isBaseLocale(id)) {
                    continue;
                }
                sb.append(' ');
                sb.append(id);
            }
        }
        return sb.toString();
    }

    private static SortedSet<String> applyLanguageAliases(SortedSet<String> tags) {
        CLDRConverter.handlerSupplMeta.getLanguageAliasData().forEach((key, value) -> {
            if (tags.remove(key)) {
                tags.add(value);
            }
        });
        return tags;
    }
}