com.vaadin.server.widgetsetutils.WidgetSetBuilder Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of vaadin-server Show documentation
Vaadin server
There is a newer version: 8.27.3
/*
 * Copyright (C) 2000-2024 Vaadin Ltd
 *
 * This program is available under Vaadin Commercial License and Service Terms.
 *
 * See  for the full
 * license.
 */
package com.vaadin.server.widgetsetutils;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.Reader;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.Collection;
import java.util.HashSet;
import java.util.Locale;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Helper class to update widgetsets GWT module configuration file. Can be used
 * command line or via IDE tools.
 *
 * 
 * If module definition file contains text "WS Compiler: manually edited", tool
 * will skip editing file.
 *
 */
public class WidgetSetBuilder {

    public static void main(String[] args)
            throws IOException, URISyntaxException {
        if (args.length == 0) {
            printUsage();
        } else {
            String widgetsetname = args[0];
            updateWidgetSet(widgetsetname);

        }
    }

    public static void updateWidgetSet(final String widgetset)
            throws IOException, FileNotFoundException, URISyntaxException {
        boolean changed = false;

        Map availableWidgetSets = ClassPathExplorer
                .getAvailableWidgetSets();

        String widgetsetFileName = widgetset.replace(".", "/") + ".gwt.xml";
        URL sourceUrl = availableWidgetSets.get(widgetset);
        if (sourceUrl == null) {
            // find first/default source directory
            sourceUrl = ClassPathExplorer
                    .getWidgetsetSourceDirectory(widgetsetFileName);
        }

        File widgetsetFile = new File(new File(sourceUrl.toURI()),
                widgetsetFileName);
        if (!widgetsetFile.exists()) {
            // create empty gwt module file
            File parent = widgetsetFile.getParentFile();
            if (parent != null && !parent.exists()) {
                if (!parent.mkdirs()) {
                    throw new IOException(
                            "Could not create directory for the widgetset: "
                                    + parent.getPath());
                }
            }
            widgetsetFile.createNewFile();
            try (PrintStream printStream = new PrintStream(
                    new FileOutputStream(widgetsetFile))) {
                printStream.print("\n"
                        + "\n");
                printStream.print("\n");
                printStream.print("    \n"
                        + "    \n\n"
                        + "    \n"
                        + "    \n\n");
                printStream.print("\n\n");
            }
            changed = true;
        }

        String content = readFile(widgetsetFile);
        if (isEditable(content)) {
            String originalContent = content;

            Collection oldInheritedWidgetsets = getCurrentInheritedWidgetsets(
                    content);

            // add widgetsets that do not exist
            for (String ws : availableWidgetSets.keySet()) {
                if (ws.equals(widgetset)) {
                    // do not inherit the module itself
                    continue;
                }
                if (!oldInheritedWidgetsets.contains(ws)) {
                    content = addWidgetSet(ws, content);
                }
            }

            for (String ws : oldInheritedWidgetsets) {
                if (!availableWidgetSets.containsKey(ws)) {
                    // widgetset not available in classpath
                    content = removeWidgetSet(ws, content);
                }
            }

            changed = changed || !content.equals(originalContent);
            if (changed) {
                commitChanges(widgetsetFile, content);
            }
        } else {
            System.out
                    .println("Widgetset is manually edited. Skipping updates.");
        }
    }

    private static boolean isEditable(String content) {
        return !content.contains("WS Compiler: manually edited");
    }

    private static String removeWidgetSet(String ws, String content) {
        return content.replaceFirst("", "");
    }

    private static void commitChanges(File widgetsetFile, String content)
            throws IOException {
        try (BufferedWriter bufferedWriter = new BufferedWriter(
                new OutputStreamWriter(new FileOutputStream(widgetsetFile)))) {
            bufferedWriter.write(content);
        }
    }

    private static String addWidgetSet(String ws, String content) {
        return content.replace("",
                "\n    " + "\n");
    }

    private static Collection getCurrentInheritedWidgetsets(
            String content) {
        HashSet hashSet = new HashSet<>();
        Pattern inheritsPattern = Pattern.compile(" name=\"([^\"]*)\"");

        Matcher matcher = inheritsPattern.matcher(content);

        while (matcher.find()) {
            String gwtModule = matcher.group(1);
            if (isWidgetset(gwtModule)) {
                hashSet.add(gwtModule);
            }
        }
        return hashSet;
    }

    static boolean isWidgetset(String gwtModuleName) {
        return gwtModuleName.toLowerCase(Locale.ROOT).contains("widgetset");
    }

    private static String readFile(File widgetsetFile) throws IOException {
        StringBuilder sb;
        try (Reader fi = new FileReader(widgetsetFile)) {
            BufferedReader bufferedReader = new BufferedReader(fi);
            sb = new StringBuilder();
            String line;
            while ((line = bufferedReader.readLine()) != null) {
                sb.append(line);
                sb.append("\n");
            }
        }
        return sb.toString();
    }

    private static void printUsage() {
        PrintStream o = System.out;
        o.println(WidgetSetBuilder.class.getSimpleName() + " usage:");
        o.println("    1. Set the same classpath as you will "
                + "have for the GWT compiler.");
        o.println("    2. Give the widgetsetname (to be created or updated)"
                + " as first parameter");
        o.println();
        o.println(
                "All found vaadin widgetsets will be inherited in given widgetset");

    }

}