org.nuiton.i18n.plugin.bundle.TapestryBundleMojo Maven / Gradle / Ivy

Go to download
package org.nuiton.i18n.plugin.bundle;

import org.nuiton.i18n.bundle.I18nBundleEntry;
import org.nuiton.i18n.bundle.I18nBundleUtil;
import org.nuiton.io.SortedProperties;
import org.nuiton.plugin.PluginHelper;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Locale;
import java.util.Map;


/**
 * Créer un bundle pour une application finale.
 * 
 * Cela génère un merge de tous les fichiers i18n utilisés en un seul.
 * 

 * On utilise la dépendance sur les artifacts pour connaitre l'ordre le
 * chargement des bundles.
 * 

 * Si dans un bundle childs, la valeur de la clef est vide, on conserve alors
 * celui du parent,
 * 

 * Ainsi on obtient un bundle dont toutes les clefs sont traduites.
 * 

 * Le but aussi d'utiliser un unique bundle est de gagner du temps au runtime
 * car la recherche des bundles devient trop couteuse en temps lorsque l'on a de
 * nombreuses dépendances (au dessus de 100 deps cela peut prendre plusieurs
 * secondes, ce qui 'est pas acceptable).
 * 
 * On a ajoute un second mode d'initialisation dans la clesse I18n pour
 * n'utiliser qu'un seul bundle et courcircuiter le chargement couteux...
 *
 * @author tchemit 
 * @goal tapestry-bundle
 * @phase generate-resources
 * @execute goal=collect-i18n-artifacts
 * @requiresProject true
 * @requiresDependencyResolution runtime
 * @since 1.2
 */
public class TapestryBundleMojo extends AbstractI18nBundleMojo {

    /**
     * Repertoire ou generer les bundles.
     *
     * @parameter expression="${i18n.bundleOutputDir}" default-value="${basedir}/src/main/webapp/WEB-INF"
     * @required
     * @since 1.0.0
     */
    protected File bundleOutputDir;

    /**
     * Nom du bundle a generer.
     *
     * @parameter expression="${i18n.bundleOutputName}" default-value="app"
     * @required
     * @since 1.0.2
     */
    protected String bundleOutputName;

    /**
     * Un drapeau pour vérifier que les bundles ne contiennent pas d'entrées
     * vides.
     *
     * @parameter expression="${i18n.checkBundle}" default-value="true"
     * @required
     * @since 1.0.0
     */
    protected boolean checkBundle;

    /**
     * Un drapeau pour afficher les entrées vides. (nécessite {@link
     * #checkBundle} activé).
     *
     * @parameter expression="${i18n.showEmpty}" default-value="false"
     * @required
     * @since 1.0.0
     */
    protected boolean showEmpty;

    @Override
    public void init() throws Exception {
        super.init();

        createDirectoryIfNecessary(bundleOutputDir);
    }

    @Override
    protected void doAction() throws Exception {
        long t00 = System.nanoTime();

        if (!silent) {
            getLog().info("config - bundle name : " + bundleOutputName);
            getLog().info("config - basedir     : " + bundleOutputDir);
            getLog().info("config - locales     : " + Arrays.toString(locales));
        }

        Map bundleDico =
                new LinkedHashMap(locales.length);

        for (Locale locale : locales) {

            long t0 = System.nanoTime();

            File bundleOut = getTapestryI18nFile(
                    bundleOutputDir,
                    bundleOutputName,
                    locale,
                    false
            );

            if (!silent) {
                getLog().info("generate bundle for locale " + locale +
                              " in file " + bundleOut.getName());
            }

            SortedProperties propertiesOut =
                    new SortedProperties(encoding, false);
            StringBuilder buffer = new StringBuilder();

            URL[] urls = getCollectI18nResources(locale);
            if (urls.length == 0) {
                getLog().warn("no bundle for locale " + locale);
                continue;
            }

            for (URL url : urls) {
                long t000 = System.nanoTime();
                I18nBundleEntry bundleEntry =
                        new I18nBundleEntry(url, locale, null);
                bundleEntry.load(propertiesOut);
                String strPath = bundleEntry.getPath().toString();
                int index = strPath.indexOf("i18n/");

                buffer.append(',').append(strPath.substring(index));
                if (verbose) {
                    getLog().info(
                            "loaded " + bundleEntry.getPath() + " in " +
                            PluginHelper.convertTime(t000, System.nanoTime()));
                }
            }

            if (buffer.length() > 0) {
                bundleDico.put(locale, buffer.substring(1));
                if (!silent) {
                    getLog().info(
                            "bundles for locale : " + bundleDico.get(locale));
                }
            }
            propertiesOut.store(bundleOut);
            if (!silent && verbose) {
                getLog().info(
                        "bundle created in " +
                        PluginHelper.convertTime(t0, System.nanoTime()) +
                        " (detected sentences : " + propertiesOut.size() + ")");
            }
            if (checkBundle) {
                checkBundle(locale, propertiesOut, showEmpty);
            }
        }

        if (!silent && verbose) {
            getLog().info("done in " +
                          PluginHelper.convertTime(t00, System.nanoTime()));
        }
    }

    /**
     * @param root       le repertoire ou sont stockes les fichiers i18n
     * @param artifactId le nom de l'artifact
     * @param locale     le nom du bundle
     * @param create     true pour creer le fichier si non present
     * @return le fichier i18n
     * @throws IOException si probleme lors de la creation du fichier
     */
    public File getTapestryI18nFile(File root,
                                    String artifactId,
                                    Locale locale,
                                    boolean create) throws IOException {
        File file = new File(
                root.getAbsolutePath() + File.separatorChar + artifactId +
                "_" + locale.getLanguage() + ".properties");
        if (create && !file.exists()) {
            createNewFile(file);
        }
        return file;
    }

    @Override
    protected URL[] getCollectI18nResources(Locale locale) throws IOException {
        File file = getCollectOutputFile(locale, false);
        if (!file.exists()) {
            return I18nBundleUtil.EMPTY_URL_ARRAY;
        }
        URL[] urls = getLinesAsURL(file);
        return urls;
    }


}