Tweak formatting, work on dimension, world, and child command elements

Author: zml2008

src/main/java/org/spongepowered/api/service/command/GameArguments.java

@@ -25,6 +25,8 @@
 package org.spongepowered.api.service.command;
 
 
+import static org.spongepowered.api.service.command.TranslationPlaceholder.t;
+
 import com.flowpowered.math.vector.Vector3d;
 import com.google.common.base.Function;
 import com.google.common.base.Optional;
@@ -34,13 +36,15 @@
 import org.spongepowered.api.Game;
 import org.spongepowered.api.entity.player.Player;
 import org.spongepowered.api.text.Text;
-import org.spongepowered.api.text.Texts;
 import org.spongepowered.api.util.StartsWithPredicate;
 import org.spongepowered.api.util.command.CommandSource;
 import org.spongepowered.api.util.command.args.ArgumentParseException;
 import org.spongepowered.api.util.command.args.CommandArgs;
 import org.spongepowered.api.util.command.args.CommandContext;
 import org.spongepowered.api.util.command.args.CommandElement;
+import org.spongepowered.api.world.DimensionType;
+import org.spongepowered.api.world.Location;
+import org.spongepowered.api.world.World;
 
 import java.util.List;
 import java.util.UUID;
@@ -50,32 +54,48 @@
 public class GameArguments {
     private GameArguments() {}
 
-    private static Text t(String input) {
-        return Texts.of(input);
+    /**
+     * Expect an argument to represent an online player,
+     * or if nothing matches and the source is a {@link Player}, give the player.
+     * Gives value of type {@link Player}
+     *
+     * @param key The key to store under
+     * @param game The game to find players in
+     * @return the argument
+     */
+    public static CommandElement playerOrSource(Text key, Game game) {
+        return new PlayerCommandElement(key, game, true);
     }
 
     /**
      * Expect an argument to represent an online player.
+     * Gives value of type {@link Player}
      *
      * @param key The key to store under
      * @param game The game to find players in
      * @return the argument
      */
     public static CommandElement player(Text key, Game game) {
-        return new PlayerCommandElement(key, game);
+        return new PlayerCommandElement(key, game, false);
     }
 
     private static class PlayerCommandElement extends CommandElement {
         private final Game game;
+        private final boolean returnSource;
 
-        protected PlayerCommandElement(Text key, Game game) {
+        protected PlayerCommandElement(Text key, Game game, boolean returnSource) {
             super(key);
             this.game = game;
+            this.returnSource = returnSource;
         }
 
         @Override
         protected Object parseValue(CommandSource source, CommandArgs args) throws ArgumentParseException {
             // TODO: Make player name resolution better -- support selectors, etc
+            if (!args.hasNext() && this.returnSource) {
+                return tryReturnSource(source, args);
+            }
+
             final String playerName = args.next();
             Optional<Player> ret;
             try {
@@ -85,12 +105,24 @@ protected Object parseValue(CommandSource source, CommandArgs args) throws Argum
                 ret = this.game.getServer().getPlayer(playerName);
             }
             if (!ret.isPresent()) {
-                throw args.createError(t("No matching players found!"));
+                if (this.returnSource) {
+                    return tryReturnSource(source, args);
+                } else {
+                    throw args.createError(t("No matching players found!"));
+                }
             } else {
                 return ret.get();
             }
         }
 
+        private Player tryReturnSource(CommandSource source, CommandArgs args) throws ArgumentParseException {
+            if (source instanceof Player) {
+                return ((Player) source);
+            } else {
+                throw args.createError(t("No players matched and source was not a player!"));
+            }
+        }
+
         @Override
         public List<String> complete(CommandSource src, CommandArgs args, CommandContext context) {
             Iterable<String> players = Iterables.transform(this.game.getServer().getOnlinePlayers(), new Function<Player, String>() {
@@ -110,6 +142,7 @@ public String apply(@Nullable Player input) {
 
     /**
      * Expect an argument to represent a world.
+     * Gives values of type {@link World}
      *
      * @param key The key to store under
      * @param game The game to find worlds from
@@ -129,15 +162,43 @@ protected WorldCommandElement(Text key, Game game) {
 
         @Override
         protected Object parseValue(CommandSource source, CommandArgs args) throws ArgumentParseException {
-            return null;
+            final String worldName = args.next();
+            Optional<World> ret = this.game.getServer().getWorld(worldName);
+            if (!ret.isPresent()) {
+                throw args.createError(t("Unable to find world for name %s", worldName));
+            }
+            return ret.get();
         }
 
         @Override
         public List<String> complete(CommandSource src, CommandArgs args, CommandContext context) {
-            return null;
+            final Optional<String> worldNameComponent = args.nextIfPresent();
+            Iterable<String> worldsList = Iterables.transform(this.game.getServer().getWorlds(), new Function<World, String>() {
+                @Nullable
+                @Override
+                public String apply(@Nullable World input) {
+                    return input == null ? null : input.getName();
+                }
+            });
+            if (worldNameComponent.isPresent()) {
+                worldsList = Iterables.filter(worldsList, new StartsWithPredicate(worldNameComponent.get()));
+            }
+            return ImmutableList.copyOf(worldsList);
         }
     }
 
+    /**
+     * Expect an argument to represent a dimension.
+     * Gives values of tye {@link DimensionType}
+     *
+     * @param key The key to store under
+     * @param game The game to find dimensions from
+     * @return the argument
+     */
+    public static CommandElement dimension(Text key, Game game) {
+        return catalogedElement(key, game, DimensionType.class);
+    }
+
     /**
      * Expect an argument to represent a {@link Vector3d}.
      *
@@ -166,7 +227,7 @@ public List<String> complete(CommandSource src, CommandArgs args, CommandContext
     }
 
     /**
-     * Expect an argument to represent a location.
+     * Expect an argument to represent a {@link Location}.
      *
      * @param key The key to store under
      * @param game The game to find worlds from
@@ -196,7 +257,7 @@ public List<String> complete(CommandSource src, CommandArgs args, CommandContext
     }
 
     /**
-     * Expect an argument that is a member of the specified catalog type.
+     * Expect an argument that is a member of the specified catalog type {@link T}.
      *
      * @param key The key to store the resolved value under
      * @param game The game to get the registry from

src/main/java/org/spongepowered/api/util/command/CommandMessageFormatting.java

@@ -33,6 +33,9 @@ public class CommandMessageFormatting {
     public static final Text SPACE_TEXT = Texts.of(" ");
     public static final Text PLUS_TEXT = Texts.of("*");
     public static final Text NEWLINE_TEXT = Texts.of('\n');
+    public static final Text LT_TEXT = Texts.of("<");
+    public static final Text GT_TEXT = Texts.of(">");
+    public static final Text ELIPSES_TEXT = Texts.of("…");
 
     /**
      * Format text to be output as an error directly to a sender. Not necessary when creating an exception to be thrown

src/main/java/org/spongepowered/api/util/command/args/ChildCommandElementExecutor.java

@@ -42,6 +42,7 @@
 import org.spongepowered.api.util.command.CommandSource;
 import org.spongepowered.api.util.command.dispatcher.SimpleDispatcher;
 import org.spongepowered.api.util.command.spec.CommandExecutor;
+import org.spongepowered.api.util.command.spec.CommandSpec;
 
 import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -68,12 +69,23 @@ public ChildCommandElementExecutor(@Nullable CommandExecutor fallbackExecutor) {
     /**
      * Register a child command for a given set of aliases.
      *
-     * @param value The command to register
-     * @param key The key to register it as
+     * @param callable The command to register
+     * @param aliases The aliases to register it as
      * @return The child command's mapping, if present
      */
-    public Optional<CommandMapping> register(CommandCallable value, List<String> key) {
-        return this.dispatcher.register(value, key);
+    public Optional<CommandMapping> register(CommandCallable callable, List<String> aliases) {
+        return this.dispatcher.register(callable, aliases);
+    }
+
+    /**
+     * Register a child command for a given set of aliases.
+     *
+     * @param callable The command to register
+     * @param aliases The aliases to register it as
+     * @return The child command's mapping, if present
+     */
+    public Optional<CommandMapping> register(CommandCallable callable, String... aliases) {
+        return this.dispatcher.register(callable, aliases);
     }
 
     @Override
@@ -85,19 +97,23 @@ public List<String> complete(final CommandSource src, CommandArgs args, CommandC
                 if (!child.isPresent()) {
                     return ImmutableList.of();
                 }
-                args.nextIfPresent();
-                final String arguments = args.getRaw().substring(args.getRawPosition());
-                while (args.hasNext()) {
+                if (child.get().getCallable() instanceof CommandSpec) {
+                    return ((CommandSpec) child.get().getCallable()).complete(src, args, context);
+                } else {
                     args.nextIfPresent();
-                }
-                try {
-                    return child.get().getCallable().getSuggestions(src, arguments);
-                } catch (CommandException e) {
-                    Text eText = e.getText();
-                    if (eText != null) {
-                        src.sendMessage(error(eText));
+                    final String arguments = args.getRaw().substring(args.getRawPosition());
+                    while (args.hasNext()) {
+                        args.nextIfPresent();
+                    }
+                    try {
+                        return child.get().getCallable().getSuggestions(src, arguments);
+                    } catch (CommandException e) {
+                        Text eText = e.getText();
+                        if (eText != null) {
+                            src.sendMessage(error(eText));
+                        }
+                        return ImmutableList.of();
                     }
-                    return ImmutableList.of();
                 }
             } else {
                 return ImmutableList.copyOf(Iterables.filter(filterCommands(src), new StartsWithPredicate(commandComponent.get())));
@@ -119,35 +135,55 @@ public boolean apply(@Nullable CommandMapping input) {
     @Override
     public void parse(CommandSource source, CommandArgs args, CommandContext context) throws ArgumentParseException {
         super.parse(source, args, context);
-        context.putArg(getUntranslatedKey() + "_args", args.getRaw().substring(args.getRawPosition()));
-        while (args.hasNext()) {
-            args.next();
+        final CommandMapping mapping = context.<CommandMapping>getOne(getUntranslatedKey()).get();
+        if ((mapping.getCallable() instanceof CommandSpec)) {
+            CommandSpec spec = ((CommandSpec) mapping.getCallable());
+            spec.populateContext(source, args, context);
+        } else {
+            if (args.hasNext()) {
+                args.next();
+            }
+
+            context.putArg(getUntranslatedKey() + "_args", args.getRaw().substring(args.getRawPosition()));
+            while (args.hasNext()) {
+                args.next();
+            }
         }
     }
 
     @Override
     protected Object parseValue(CommandSource source, CommandArgs args) throws ArgumentParseException {
         final String key = args.next();
-        if (!this.dispatcher.containsAlias(key)) {
+        final Optional<CommandMapping> mapping = this.dispatcher.get(key, source);
+        if (!mapping.isPresent()) {
             throw args.createError(t("Input command %s was not a valid subcommand!", key));
         }
 
-        return key;
+        return mapping.get();
     }
 
     @Override
     public CommandResult execute(CommandSource src, CommandContext args) throws CommandException {
-        final String arguments = args.<String>getOne(getUntranslatedKey() + "_args").get();
-        String alias = args.<String>getOne(getUntranslatedKey()).get();
-        CommandMapping mapping = this.dispatcher.get(alias, src).orNull();
+        CommandMapping mapping = args.<CommandMapping>getOne(getUntranslatedKey()).orNull();
         if (mapping == null) {
             if (this.fallbackExecutor != null) {
                 return this.fallbackExecutor.execute(src, args);
             } else {
                 throw new CommandException(t("Invalid subcommand state -- no more than one mapping may be provided for child arg %s", getKey()));
             }
         }
-        return mapping.getCallable().process(src, arguments).or(CommandResult.empty());
+        if (mapping.getCallable() instanceof CommandSpec) {
+            CommandSpec spec = ((CommandSpec) mapping.getCallable());
+            spec.checkPermission(src);
+            return spec.getExecutor().execute(src, args);
+        } else {
+            final String arguments = args.<String>getOne(getUntranslatedKey() + "_args").or("");
+            return mapping.getCallable().process(src, arguments).or(CommandResult.empty());
+        }
     }
 
+    @Override
+    public Text getUsage(CommandSource src) {
+        return this.dispatcher.getUsage(src);
+    }
 }

src/main/java/org/spongepowered/api/util/command/args/CommandElement.java

@@ -111,6 +111,6 @@ public void parse(CommandSource source, CommandArgs args, CommandContext context
      * @return The formatted usage
      */
     public Text getUsage(CommandSource src) {
-        return getKey() == null ? Texts.of() : getKey();
+        return getKey() == null ? Texts.of() : Texts.of("<", getKey(), ">");
     }
 }