Merge pull request #162 from athinaslime/switch-minestom-fix

fix minestom switch issues

Author: Revxrsal

common/src/main/java/revxrsal/commands/util/Permutations.java

@@ -37,7 +37,7 @@ public static <A extends CommandActor> List<List<ParameterNode<A, Object>>> gene
         List<List<ParameterNode<A, Object>>> falsePermutations = new ArrayList<>();
 
         permute(required, 0, truePermutations);
-        permute(optional, 0, falsePermutations);
+        permuteAllSubsets(optional, falsePermutations);
 
         List<List<ParameterNode<A, Object>>> result = new ArrayList<>();
 
@@ -63,4 +63,37 @@ private static <A extends CommandActor> void permute(List<ParameterNode<A, Objec
             Collections.swap(list, start, i);
         }
     }
+
+    /**
+     * Generates every ordering of every subset of {@code list}, including the
+     * empty subset. Every element of {@code list} is optional (a flag or a
+     * switch), so it may either be omitted entirely or supplied alongside the
+     * others in any order.
+     */
+    private static <A extends CommandActor> void permuteAllSubsets(
+            List<ParameterNode<A, Object>> list,
+            List<List<ParameterNode<A, Object>>> result
+    ) {
+        List<List<ParameterNode<A, Object>>> subsets = new ArrayList<>();
+        generateSubsets(list, 0, new ArrayList<>(), subsets);
+        for (List<ParameterNode<A, Object>> subset : subsets) {
+            permute(subset, 0, result);
+        }
+    }
+
+    private static <A extends CommandActor> void generateSubsets(
+            List<ParameterNode<A, Object>> list,
+            int index,
+            List<ParameterNode<A, Object>> current,
+            List<List<ParameterNode<A, Object>>> result
+    ) {
+        if (index == list.size()) {
+            result.add(new ArrayList<>(current));
+            return;
+        }
+        generateSubsets(list, index + 1, current, result);
+        current.add(list.get(index));
+        generateSubsets(list, index + 1, current, result);
+        current.remove(current.size() - 1);
+    }
 }

minestom/src/main/java/revxrsal/commands/minestom/hooks/MinestomCommandHooks.java

@@ -171,19 +171,24 @@ else if (node instanceof ParameterNode<A, ?> parameter) {
 
                 List<ParameterNode<A, Object>> flags = filter(command.parameters().values(), v -> v.isFlag() || v.isSwitch());
                 for (List<ParameterNode<A, Object>> permutation : Permutations.generatePermutations(flags)) {
-                    List<Argument<?>> path = new ArrayList<>(arguments.size() + permutation.size());
-                    path.addAll(arguments);
+                    List<List<ArgumentColl>> formsPerParameter = new ArrayList<>(permutation.size());
                     for (ParameterNode<A, Object> parameter : permutation) {
                         if (parameter.isSwitch()) {
-                            ArgumentColl sw = ofSwitch(parameter);
-                            path.addAll(sw.arguments());
+                            formsPerParameter.add(ofSwitchForms(parameter));
                         } else if (parameter.isFlag()) {
-                            ArgumentColl argumentColl = ofFlag(parameter);
-                            path.addAll(argumentColl.arguments());
+                            formsPerParameter.add(ofFlagForms(parameter));
                         }
                     }
 
-                    minestomCommand.addSyntax(generateAction(command), path.toArray(Argument[]::new));
+                    // a switch/flag with a shorthand has two equivalent forms (e.g. --silent
+                    // and -s), each of which must be registered as its own Minestom syntax
+                    for (List<ArgumentColl> combination : cartesianProduct(formsPerParameter)) {
+                        List<Argument<?>> path = new ArrayList<>(arguments);
+                        for (ArgumentColl coll : combination) {
+                            path.addAll(coll.arguments());
+                        }
+                        minestomCommand.addSyntax(generateAction(command), path.toArray(Argument[]::new));
+                    }
                 }
                 // we have <= 4 flags, so we create all possible permutations
             }
@@ -218,14 +223,70 @@ private ArgumentColl ofSwitch(ParameterNode<A, ?> parameter) {
     }
 
     private ArgumentColl ofFlag(ParameterNode<A, ?> parameter) {
-        ArgumentLiteral first = new ArgumentLiteral(DispatcherSettings.LONG_FORMAT_PREFIX + parameter.flagName());
+        return ofFlag(parameter, DispatcherSettings.LONG_FORMAT_PREFIX + parameter.flagName());
+    }
+
+    private ArgumentColl ofFlag(ParameterNode<A, ?> parameter, String literal) {
+        ArgumentLiteral first = new ArgumentLiteral(literal);
         first.setCallback(createCallback(parameter));
         return new ArgumentColl(
                 first,
                 toArgument(parameter)
         );
     }
 
+    /**
+     * Returns every equivalent form a switch may be written as: its long form
+     * (e.g. {@code --silent}), plus its shorthand form (e.g. {@code -s}) if
+     * one is defined. Each form must be registered as its own Minestom syntax,
+     * since {@link ArgumentLiteral} only matches a single fixed string.
+     */
+    private List<ArgumentColl> ofSwitchForms(ParameterNode<A, ?> parameter) {
+        List<ArgumentColl> forms = new ArrayList<>(2);
+        forms.add(ofSwitch(parameter));
+        Character shorthand = parameter.shorthand();
+        if (shorthand != null) {
+            forms.add(new ArgumentColl(
+                    new ArgumentLiteral(DispatcherSettings.SHORT_FORMAT_PREFIX + shorthand)
+            ));
+        }
+        return forms;
+    }
+
+    /**
+     * Returns every equivalent form a flag may be written as. See {@link #ofSwitchForms}.
+     */
+    private List<ArgumentColl> ofFlagForms(ParameterNode<A, ?> parameter) {
+        List<ArgumentColl> forms = new ArrayList<>(2);
+        forms.add(ofFlag(parameter));
+        Character shorthand = parameter.shorthand();
+        if (shorthand != null) {
+            forms.add(ofFlag(parameter, DispatcherSettings.SHORT_FORMAT_PREFIX + shorthand));
+        }
+        return forms;
+    }
+
+    /**
+     * Computes the cartesian product of the given dimensions, i.e. every
+     * combination obtained by picking exactly one element from each dimension.
+     */
+    private static List<List<ArgumentColl>> cartesianProduct(List<List<ArgumentColl>> dimensions) {
+        List<List<ArgumentColl>> result = new ArrayList<>();
+        result.add(new ArrayList<>());
+        for (List<ArgumentColl> dimension : dimensions) {
+            List<List<ArgumentColl>> next = new ArrayList<>();
+            for (List<ArgumentColl> partial : result) {
+                for (ArgumentColl choice : dimension) {
+                    List<ArgumentColl> combined = new ArrayList<>(partial);
+                    combined.add(choice);
+                    next.add(combined);
+                }
+            }
+            result = next;
+        }
+        return result;
+    }
+
     /**
      * Generates a {@link CommandExecutor} that invokes the given command from
      * the Minestom-provided context

minestom/src/main/java/revxrsal/commands/minestom/util/MinestomUtils.java

@@ -69,24 +69,33 @@ public static <A extends MinestomCommandActor> void readIntoLampContext(
         for (ParameterNode<A, ?> parameter : executionContext.command().parameters().values()) {
             Object o;
             if (parameter.isSwitch()) {
-                o = containsFlag(context, parameter.switchName());
+                o = containsFlag(context, parameter, parameter.switchName());
             } else {
                 o = context.get(parameter.name());
             }
             if (o != null)
                 executionContext.addResolvedArgument(parameter.name(), o);
             else {
-                if (parameter.isFlag() && containsFlag(context, parameter.flagName()))
+                if (parameter.isFlag() && containsFlag(context, parameter, parameter.flagName()))
                     throw new MissingArgumentException(parameter, parameter.command());
                 Object def = parameter.parse(StringStream.createMutable(""), executionContext);
                 executionContext.addResolvedArgument(parameter.name(), def);
             }
         }
     }
 
-    private static boolean containsFlag(CommandContext context, String name) {
-        return context.has(DispatcherSettings.LONG_FORMAT_PREFIX + name)
-                || context.has(DispatcherSettings.SHORT_FORMAT_PREFIX + name);
+    /**
+     * Checks whether the given flag/switch was supplied, in either its long
+     * form (e.g. {@code --silent}) or its shorthand form (e.g. {@code -s}).
+     * The shorthand is a single character, not the full name, so it must be
+     * looked up separately via {@link ParameterNode#shorthand()} rather than
+     * by prefixing the full name with the short format prefix.
+     */
+    private static boolean containsFlag(CommandContext context, ParameterNode<?, ?> parameter, String name) {
+        if (context.has(DispatcherSettings.LONG_FORMAT_PREFIX + name))
+            return true;
+        Character shorthand = parameter.shorthand();
+        return shorthand != null && context.has(DispatcherSettings.SHORT_FORMAT_PREFIX + shorthand);
     }
 
 }