Added WorldConverter.java

worldedit-core/src/main/java/com/sk89q/worldedit/command/argument/WorldConverter.java

@@ -0,0 +1,81 @@
+/*
+ * WorldEdit, a Minecraft world manipulation toolkit
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) WorldEdit team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.sk89q.worldedit.command.argument;
+
+import com.sk89q.worldedit.WorldEdit;
+import com.sk89q.worldedit.extension.platform.Capability;
+import com.sk89q.worldedit.util.formatting.text.Component;
+import com.sk89q.worldedit.util.formatting.text.TextComponent;
+import com.sk89q.worldedit.world.World;
+import org.enginehub.piston.CommandManager;
+import org.enginehub.piston.converter.ArgumentConverter;
+import org.enginehub.piston.converter.ConversionResult;
+import org.enginehub.piston.converter.FailedConversion;
+import org.enginehub.piston.converter.SuccessfulConversion;
+import org.enginehub.piston.inject.InjectedValueAccess;
+import org.enginehub.piston.inject.Key;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class WorldConverter implements ArgumentConverter<World> {
+
+    public static void register(CommandManager commandManager) {
+        commandManager.registerConverter(Key.of(World.class),
+                new WorldConverter()
+        );
+    }
+
+    private final TextComponent choices;
+
+    private WorldConverter() {
+        this.choices = TextComponent.of("any world");
+    }
+
+    @Override
+    public Component describeAcceptableArguments() {
+        return this.choices;
+    }
+
+    private Stream<? extends World> getWorlds() {
+        return WorldEdit.getInstance().getPlatformManager()
+                .queryCapability(Capability.GAME_HOOKS).getWorlds().stream();
+    }
+
+    @Override
+    public List<String> getSuggestions(String input) {
+        return getWorlds()
+                .map(World::getId)
+                .filter(world -> world.startsWith(input))
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public ConversionResult<World> convert(String s, InjectedValueAccess injectedValueAccess) {
+        World result = getWorlds()
+                .filter(world -> world.getId().equals(s))
+                .findAny().orElse(null);
+        return result == null
+                ? FailedConversion.from(new IllegalArgumentException(
+                "Not a valid world: " + s))
+                : SuccessfulConversion.fromSingle(result);
+    }
+}

worldedit-core/src/main/java/com/sk89q/worldedit/extension/platform/PlatformCommandManager.java

@@ -96,6 +96,7 @@ import com.sk89q.worldedit.command.argument.FactoryConverter;
 import com.sk89q.worldedit.command.argument.RegionFactoryConverter;
 import com.sk89q.worldedit.command.argument.RegistryConverter;
 import com.sk89q.worldedit.command.argument.VectorConverter;
+import com.sk89q.worldedit.command.argument.WorldConverter;
 import com.sk89q.worldedit.command.argument.ZonedDateTimeConverter;
 import com.sk89q.worldedit.command.util.CommandPermissions;
 import com.sk89q.worldedit.command.util.CommandQueuedCondition;
@@ -258,6 +259,7 @@ public final class PlatformCommandManager {
         BooleanConverter.register(commandManager);
         EntityRemoverConverter.register(commandManager);
         RegionFactoryConverter.register(commandManager);
+        WorldConverter.register(commandManager);
     }
 
     public void registerAlwaysInjectedValues() {
@@ -356,7 +358,9 @@ public final class PlatformCommandManager {
                 new SuperPickaxeCommands(worldEdit)
             );
             registerSubCommands(
-                    "brush", Arrays.asList("br", "/brush", "/br", "/tool", "tool"), "Brushing commands",
+                    "brush",
+                    ImmutableList.of("br", "/brush", "/br", "/tool", "tool"),
+                    "Brushing commands",
                     commandManager,
                     c -> {
                         c.accept(BrushCommandsRegistration.builder(), new BrushCommands(worldEdit));
@@ -627,7 +631,6 @@ public final class PlatformCommandManager {
         Request.reset();
         Actor actor = event.getActor();
         String args = event.getArguments();
-        CommandEvent finalEvent = event;
         final FawePlayer<Object> fp = FawePlayer.wrap(actor);
         System.out.println(1);
         TaskManager.IMP.taskNow(() -> {
@@ -635,20 +638,21 @@ public final class PlatformCommandManager {
             String arg0 = space0 == -1 ? args : args.substring(0, space0);
             Optional<Command> optional = commandManager.getCommand(arg0);
             if (!optional.isPresent()) {
-                System.out.println("No command for '" + arg0 + "' " + StringMan.getString(commandManager.getAllCommands().map(command -> command.getName()).collect(Collectors.toList())));
+                System.out.println("No command for '" + arg0 + "' " + StringMan.getString(commandManager.getAllCommands().map(
+                    Command::getName).collect(Collectors.toList())));
                 return;
             }
             Command cmd = optional.get();
             CommandQueuedCondition queued = cmd.getCondition().as(CommandQueuedCondition.class).orElse(null);
             if (queued != null && !queued.isQueued()) {
-                handleCommandOnCurrentThread(finalEvent);
+                handleCommandOnCurrentThread(event);
                 return;
             }
             LocalSession session = worldEdit.getSessionManager().get(actor);
             synchronized (session) {
                 SessionKey key = actor.getSessionKey();
                 if (key.isActive()) {
-                    PlatformCommandManager.this.handleCommandOnCurrentThread(finalEvent);
+                    PlatformCommandManager.this.handleCommandOnCurrentThread(event);
                 }
             }
         }, Fawe.isMainThread());
@@ -694,8 +698,7 @@ public final class PlatformCommandManager {
             // exceptions without writing a hook into every dispatcher, we need to unwrap these
             // exceptions and rethrow their converted form, if their is one.
             try {
-                //Why the hell do we need to return an object if we aren't doing anything with it?
-                Object result = task.get();
+                task.get();
             } catch (Throwable t) {
                 // Use the exception converter to convert the exception if any of its causes
                 // can be converted, otherwise throw the original exception