EventSchemaUsageFormatter.java

package client.teavm.common.parameter.usage;

import com.beust.jcommander.DefaultUsageFormatter;
import com.beust.jcommander.JCommander;
import com.beust.jcommander.ParameterDescription;
import com.beust.jcommander.Parameters;
import com.beust.jcommander.internal.Lists;

import java.util.EnumSet;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * Change the usage message to represent a JSON schema to validate parameters of the web worker events.
 *
 * @author khaendel
 *
 */
public class EventSchemaUsageFormatter extends DefaultUsageFormatter {

    private final JCommander commander;
    private final boolean isExport;

    public EventSchemaUsageFormatter(JCommander commander, boolean isExport) {
        super(commander);
        this.commander = commander;
        this.isExport = isExport;
    }

    @Override
    public void appendMainLine(StringBuilder out, boolean hasOptions, boolean hasCommands, int indentCount,
                               String indent) {
        if (isExport && !hasCommands) {
            if (commander.getFields().values().stream().filter(pd -> !pd.getParameter().hidden()).anyMatch(pd -> !pd.getParameter().isHelp())) {
                out.append("      eventData: {\n");
                out.append("        type: 'object',\n");
            }
        }

    }

    @Override
    @SuppressWarnings({"unchecked", "rawtypes"})
    public void appendAllParametersDetails(StringBuilder out, int indentCount, String indent,
                                           List<ParameterDescription> sortedParameters) {
        boolean hasCommands = !commander.getCommands().isEmpty();
        if (!sortedParameters.isEmpty()) {
            List<ParameterDescription> collect = sortedParameters.stream().filter(p -> p.getParameter().required())
                    .collect(Collectors.toList());
            if (!hasCommands && !collect.isEmpty()) {
                out.append("        required: [").append(collect.stream().map(p -> "'" + p.getNames() + "'").collect(Collectors.joining(","))).append("],\n");
            }
            out.append("        properties: {\n");
        }
        for (ParameterDescription pd : sortedParameters) {
            if (pd.getParameter().hidden() || pd.getParameter().isHelp()) {
                continue;
            }
            // First line, command name
            out.append(indent).append("    ").append(getEventDataParameterNames(pd.getNames())).append(": {");

            Class<?> type = pd.getParameterized().getType();
            if (type.equals(int.class) || type.equals(Integer.class)) {
                out.append(" type: 'integer'");
/*
            } else if (type.equals(long.class) || type.equals(Long.class)) {
                out.append(" type: 'BigInt'"); // BigInt unsupported by JSON Schema
*/
            } else if (type.equals(boolean.class) || type.equals(Boolean.class)) {
                out.append(" type: 'boolean'");
            } else if (type.equals(String.class)) {
                out.append(" type: 'string'");
            } else if (type.equals(double.class) || type.equals(Double.class)) {
                out.append(" type: 'number'");
            } else if (type.equals(float.class) || type.equals(Float.class)) {
                out.append(" type: 'number'");
            } else if (type.equals(byte[].class)) {
                out.append(" elements: { type: \"uint8\" }");
            } else if (type.isEnum()) {
                out.append(" enum: [");
                for (Object o : EnumSet.allOf((Class<? extends Enum>) type)) {
                    Enum en = (Enum) o;
                    out.append("'").append(en.toString()).append("',");
                }
                out.append("]");
            }
            out.append("},\n");
        }
        if (sortedParameters.stream().filter(pd -> !pd.getParameter().hidden()).anyMatch(pd -> !pd.getParameter().isHelp())) {
            out.append("        },\n");
            out.append("        additionalProperties: false,\n");
            out.append("      },\n");
        }

        if (!hasCommands) {
            out.append("    },\n");
        }
    }

    public void usage(StringBuilder out, String indent) {
        if (commander.getDescriptions() == null) {
            commander.createDescriptions();
        }
        boolean hasCommands = !commander.getCommands().isEmpty();
        boolean hasOptions = !commander.getDescriptions().isEmpty();

        // Indentation constants
        final int descriptionIndent = 6;
        final int indentCount = indent.length() + descriptionIndent;

        // Append the first line (aka main line) of the usage
        appendMainLine(out, hasOptions, hasCommands, indentCount, indent);

        List<ParameterDescription> sortedParameters = Lists.newArrayList();

        for (ParameterDescription pd : commander.getFields().values()) {
            if (pd.getParameter().hidden() || pd.getParameter().isHelp()) {
                continue;
            }
            sortedParameters.add(pd);
        }

        // Sort the options
        sortedParameters.sort(commander.getParameterDescriptionComparator());

        // Append all the parameter names and descriptions
        appendAllParametersDetails(out, indentCount, indent, sortedParameters);

        // Append commands if they were specified
        if (hasCommands) {
            appendCommands(out, indentCount, descriptionIndent, indent);
        }
    }

    public void appendCommands(StringBuilder out, int indentCount, int descriptionIndent, String indent) {
        boolean hasOnlyHiddenCommands = true;
        for (Map.Entry<JCommander.ProgramName, JCommander> commands : commander.getRawCommands().entrySet()) {
            Object arg = commands.getValue().getObjects().get(0);
            Parameters p = arg.getClass().getAnnotation(Parameters.class);

            if (p == null || !p.hidden()) {
                hasOnlyHiddenCommands = false;
                break;
            }
        }

        if (hasOnlyHiddenCommands)
            return;

        out.append("\n// myModule.js\n" + "(function (global, factory) {\n" + "    global.myModule = factory();\n"
                + "})(typeof self !== \"undefined\" ? self : this, function () {\n\n");

        out.append("const schema = {\n" + "  type: 'object',\n" + "  discriminator: { propertyName: 'eventType' },\n"
                + "  required: ['eventType'],\n" + "  oneOf: [\n");

        for (Map.Entry<JCommander.ProgramName, JCommander> commands : commander.getRawCommands().entrySet()) {
            Object arg = commands.getValue().getObjects().get(0);
            Parameters p = arg.getClass().getAnnotation(Parameters.class);

            if (p == null || !p.hidden()) {
                JCommander.ProgramName progName = commands.getKey();
                String dispName = progName.getDisplayName();

                // Options for this command
                JCommander jc = commander.findCommandByAlias(progName.getName());
                out.append("  {\n").append(jc.getFields().values().stream().filter(pd -> !pd.getParameter().hidden()).anyMatch(pd -> !pd.getParameter().isHelp())
                        ? "    required: ['eventData'],\n"
                        : "").append("    properties: {\n").append("      eventType: {enum: ['").append(dispName).append("'] },\n");

                jc.setUsageFormatter(new EventSchemaUsageFormatter(jc, isExport));
                jc.getUsageFormatter().usage(out, indent + s(6));
                out.append("  },\n");
            }
        }

        out.append("  ],\n" + "}\n");
        out.append("    return {\n" + "        schema\n" + "    };\n" + "});\n");
    }

    private String getEventDataParameterNames(String names) {
        return String.join(", ", names.split(", "));
    }

}