Initial work on moving to CommandArguments

src/com/dmdirc/commandparser/CommandArguments.java

@@ -22,9 +22,17 @@
 
 package com.dmdirc.commandparser;
 
+import java.util.Arrays;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
 /**
- * Represents a command and its arguments.
+ * Represents a command and its arguments. In this class, input is split into
+ * 'words' which are separated by any number of whitespace characters;
+ * 'arguments' are the same but exclude the first word, which will normally be
+ * the command name.
  *
+ * @since 0.6.3
  * @author chris
  */
 public class CommandArguments {
@@ -32,31 +40,140 @@ public class CommandArguments {
     /** The raw line that was input. */
     private final String line;
 
-    private String[] arguments;
+    /** The line split into whitespace-delimited words. */
+    private String[] words;
 
+    /**
+     * Creates a new command arguments parser for the specified line.
+     *
+     * @param line The line to be parsed
+     */
     public CommandArguments(final String line) {
         this.line = line;
     }
-    
-    public synchronized String[] getArguments() {
-        if (arguments == null) {
-            parse();
-        }
+
+    /**
+     * Retrieves the raw line that was input, including any command character(s)
+     * and names.
+     *
+     * @return The raw line entered
+     */
+    public String getLine() {
+        return line;
+    }
+
+    /**
+     * Retrieves the raw line that was input, including the command name but
+     * stripped of any command characters.
+     *
+     * @return The raw line entered, without command chars
+     */
+    public String getStrippedLine() {
+        final int offset = isCommand() ? isSilent() ? 2 : 1 : 0;
+
+        return line.substring(offset);
+    }
+
+    /**
+     * Retrieves the input split into distinct, whitespace-separated words. The
+     * first item in the array will be the command name complete with any
+     * command characters.
+     *
+     * @return An array of 'words' that make up the input
+     */
+    public String[] getWords() {
+        parse();
+        
+        return words;
+    }
+
+    /**
+     * Retrieves the arguments to the command split into disticnt,
+     * whitespace-separated words.
+     *
+     * @return An array of 'words' that make up the command's arguments
+     */
+    public String[] getArguments() {
+        parse();
+
+        return Arrays.copyOfRange(words, 1, words.length);
+    }
+
+    /**
+     * Retrieves all the arguments to the command (i.e., not including the
+     * command name) with their original whitespace separation preserved.
+     *
+     * @return A String representation of the command arguments
+     */
+    public String getArgumentsAsString() {
+        parse();
         
-        return arguments;
+        return getWordsAsString(1);
     }
 
-    protected void parse() {
-        arguments = line.split("\\s+");
+    /**
+     * Retrieves the specified words with their original whitespace separation
+     * preserved.
+     *
+     * @param start The index of the first word to include (starting at 0)
+     * @return A String representation of the requested words
+     */
+    public String getWordsAsString(final int start) {
+        return getWordsAsString(start, words.length);
+    }
+
+    /**
+     * Retrieves the specified words with their original whitespace separation
+     * preserved.
+     *
+     * @param start The index of the first word to include (starting at 0)
+     * @param end The index of the last word to include
+     * @return A String representation of the requested words
+     */
+    public String getWordsAsString(final int start, final int end) {
+        final Pattern pattern = Pattern.compile("(\\S+\\s*){" + (start) + "}"
+                + "((\\S+\\s*){" + (end - start) + "}).*?");
+        final Matcher matcher = pattern.matcher(line);
+
+        return matcher.matches() ? matcher.group(2) : "";
     }
 
+    /**
+     * Parses the input into a set of words, if it has not been done before.
+     */
+    protected synchronized void parse() {
+        if (words == null) {
+            words = line.split("\\s+");
+        }
+    }
+
+    /**
+     * Determines if the input was a command or not.
+     *
+     * @return True if the input was a command, false otherwise
+     */
     public boolean isCommand() {
         return !line.isEmpty() && line.charAt(0) == CommandManager.getCommandChar();
     }
 
+    /**
+     * Determines if the input was a silenced command or not.
+     *
+     * @return True if the input was a silenced command, false otherwise
+     */
     public boolean isSilent() {
         return isCommand() && line.length() >= 2 &&
                 line.charAt(1) == CommandManager.getSilenceChar();
     }
 
+    /**
+     * Retrieves the name of the command that was used.
+     *
+     * @return The command name used
+     */
+    public String getCommandName() {
+        final int offset = isCommand() ? isSilent() ? 2 : 1 : 0;
+        return getWords()[0].substring(offset);
+    }
+
 }

src/com/dmdirc/commandparser/commands/ChannelCommand.java

@@ -24,6 +24,7 @@ package com.dmdirc.commandparser.commands;
 
 import com.dmdirc.Channel;
 import com.dmdirc.Server;
+import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandInfo;
 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.ui.interfaces.InputWindow;
@@ -36,14 +37,16 @@ public abstract class ChannelCommand extends Command implements CommandInfo {
     
     /**
      * Executes this command.
+     *
      * @param origin The window in which the command was typed
      * @param server The server instance that this command is being executed on
      * @param channel The channel instance that this command is being executed on
      * @param isSilent Whether this command is silenced or not
      * @param args Arguments passed to this command
+     * @since 0.6.3
      */
     public abstract void execute(InputWindow origin, Server server, Channel channel,
-            boolean isSilent, String... args);
+            boolean isSilent, CommandArguments args);
 
     /** {@inheritDoc} */
     @Override

src/com/dmdirc/commandparser/commands/ChatCommand.java

@@ -24,6 +24,7 @@ package com.dmdirc.commandparser.commands;
 
 import com.dmdirc.MessageTarget;
 import com.dmdirc.Server;
+import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandInfo;
 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.ui.interfaces.InputWindow;
@@ -44,9 +45,10 @@ public abstract class ChatCommand extends Command implements CommandInfo {
      * @param target The target of this command
      * @param isSilent Whether this command is silenced or not
      * @param args Arguments passed to this command
+     * @since 0.6.3
      */
     public abstract void execute(InputWindow origin, Server server, MessageTarget target,
-            boolean isSilent, String... args);
+            boolean isSilent, CommandArguments args);
 
     /** {@inheritDoc} */
     @Override

src/com/dmdirc/commandparser/commands/Command.java

@@ -44,7 +44,9 @@ public abstract class Command {
      * @param offset The index to start at
      * @param args The arguments to implode
      * @return A string containing each argument seperated by a space
+     * @deprecated Should be no need for this now
      */
+    @Deprecated
     protected static final String implodeArgs(final int offset, final String... args) {
         String res = "";
         for (int i = offset; i < args.length; i++) {
@@ -61,7 +63,9 @@ public abstract class Command {
      * Implodes the given list of arguments.
      * @param args The arguments to implode
      * @return A string containing each argument seperated by a space
+     * @deprecated Should be no need for this now
      */
+    @Deprecated
     protected static final String implodeArgs(final String... args) {
         return implodeArgs(0, args);
     } 

src/com/dmdirc/commandparser/commands/ExternalCommand.java

@@ -22,6 +22,7 @@
 package com.dmdirc.commandparser.commands;
 
 import com.dmdirc.Server;
+import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.ui.interfaces.InputWindow;
 
 /**
@@ -40,8 +41,9 @@ public interface ExternalCommand {
      * @param channel The name of the channel the command is being executed for
      * @param isSilent Whether this command is silenced or not
      * @param args Arguments passed to this command
+     * @since 0.6.3
      */
     void execute(InputWindow origin, Server server, String channel,
-            boolean isSilent, String... args);    
+            boolean isSilent, CommandArguments args);
 
 }

src/com/dmdirc/commandparser/commands/GlobalCommand.java

@@ -22,6 +22,7 @@
 
 package com.dmdirc.commandparser.commands;
 
+import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandInfo;
 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.ui.interfaces.InputWindow;
@@ -29,6 +30,7 @@ import com.dmdirc.ui.interfaces.InputWindow;
 /**
  * Represents a generic global command. Global commands are associated with
  * no servers.
+ *
  * @author chris
  */
 public abstract class GlobalCommand extends Command implements CommandInfo {
@@ -36,11 +38,13 @@ public abstract class GlobalCommand extends Command implements CommandInfo {
     /**
      * Executes this command. Note that for global commands, origin may be
      * null.
+     *
      * @param origin The window in which the command was typed
      * @param isSilent Whether this command is silenced or not
      * @param args Arguments passed to this command
+     * @since 0.6.3
      */
-    public abstract void execute(InputWindow origin, boolean isSilent, String ... args);
+    public abstract void execute(InputWindow origin, boolean isSilent, CommandArguments args);
 
     /** {@inheritDoc} */
     @Override

src/com/dmdirc/commandparser/commands/QueryCommand.java

@@ -24,26 +24,30 @@ package com.dmdirc.commandparser.commands;
 
 import com.dmdirc.Query;
 import com.dmdirc.Server;
+import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandInfo;
 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.ui.interfaces.InputWindow;
 
 /**
  * Represents a command which can be performed only in the context of a query.
+ *
  * @author chris
  */
 public abstract class QueryCommand extends Command implements CommandInfo {
         
     /**
      * Executes this command.
+     *
      * @param origin The window in which the command was typed
      * @param server The server instance that this command is being executed on
      * @param query The query object that the commadparser is associated with
      * @param isSilent Whether this command is silenced or not
      * @param args Arguments passed to this command
+     * @since 0.6.3
      */
     public abstract void execute(InputWindow origin, Server server, Query query,
-            boolean isSilent, String... args);
+            boolean isSilent, CommandArguments args);
 
     /** {@inheritDoc} */
     @Override

src/com/dmdirc/commandparser/commands/ServerCommand.java

@@ -23,6 +23,7 @@
 package com.dmdirc.commandparser.commands;
 
 import com.dmdirc.Server;
+import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandInfo;
 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.ui.interfaces.InputWindow;
@@ -30,19 +31,22 @@ import com.dmdirc.ui.interfaces.InputWindow;
 /**
  * Represents a generic server command. Server commands are associated with
  * a server instance.
+ *
  * @author chris
  */
 public abstract class ServerCommand extends Command implements CommandInfo {
     
     /**
      * Executes this command.
+     *
      * @param origin The window in which the command was typed
      * @param server The server instance that this command is being executed on
      * @param isSilent Whether this command is silenced or not
      * @param args Arguments passed to this command
+     * @since 0.6.3
      */
     public abstract void execute(InputWindow origin, Server server,
-            boolean isSilent, String ... args);
+            boolean isSilent, CommandArguments args);
 
     /** {@inheritDoc} */
     @Override

src/com/dmdirc/commandparser/parsers/ChannelCommandParser.java

@@ -24,6 +24,7 @@ package com.dmdirc.commandparser.parsers;
 
 import com.dmdirc.Channel;
 import com.dmdirc.Server;
+import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandManager;
 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.commandparser.commands.ChannelCommand;
@@ -78,7 +79,7 @@ public final class ChannelCommandParser extends CommandParser {
     /** {@inheritDoc} */
     @Override
     protected void executeCommand(final InputWindow origin,
-            final boolean isSilent, final Command command, final String... args) {
+            final boolean isSilent, final Command command, final CommandArguments args) {
         if (command instanceof ChannelCommand) {
             ((ChannelCommand) command).execute(origin, server, channel, isSilent, args);
         } else if (command instanceof ChatCommand) {

src/com/dmdirc/commandparser/parsers/CommandParser.java

@@ -25,6 +25,7 @@ package com.dmdirc.commandparser.parsers;
 import com.dmdirc.Server;
 import com.dmdirc.actions.ActionManager;
 import com.dmdirc.actions.CoreActionType;
+import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandInfo;
 import com.dmdirc.commandparser.CommandManager;
 import com.dmdirc.commandparser.CommandType;
@@ -108,67 +109,42 @@ public abstract class CommandParser implements Serializable {
      */
     public final void parseCommand(final InputWindow origin,
             final String line, final boolean parseChannel) {
-        if (line.isEmpty()) {
-            return;
-        }
-
-        if (line.charAt(0) == CommandManager.getCommandChar()) {
-            int offset = 1;
-            boolean silent = false;
-
-            if (line.length() > offset && line.charAt(offset) == CommandManager.getSilenceChar()) {
-                silent = true;
-                offset++;
-            }
+        final CommandArguments args = new CommandArguments(line);
 
-            final String[] args = line.split(" ");
-            final String command = args[0].substring(offset);
-            String[] comargs;
+        if (args.isCommand()) {
+            final boolean silent = args.isSilent();
+            final String command = args.getCommandName();
+            final String[] cargs = args.getArguments();
 
-            if (args.length >= 2 && parseChannel && origin != null
+            if (args.getArguments().length > 0 && parseChannel && origin != null
                     && origin.getContainer() != null
                     && origin.getContainer().getServer() != null
-                    && origin.getContainer().getServer().isValidChannelName(args[1])
+                    && origin.getContainer().getServer().isValidChannelName(cargs[0])
                     && CommandManager.isChannelCommand(command)) {
                 final Server server = origin.getContainer().getServer();
 
-                if (server.hasChannel(args[1])) {
-
-                    final StringBuilder newLine = new StringBuilder();
-                    for (int i = 0; i < args.length; i++) {
-                        if (i == 1) { continue; }
-                        newLine.append(" ").append(args[i]);
-                    }
-
-                    server.getChannel(args[1]).getFrame().getCommandParser()
-                            .parseCommand(origin, newLine.substring(1), false);
-
+                if (server.hasChannel(cargs[0])) {
+                    server.getChannel(cargs[0]).getFrame().getCommandParser()
+                            .parseCommand(origin, args.getWordsAsString(2), false);
                     return;
                 } else {
                     final Command actCommand = CommandManager.getCommand(
                             CommandType.TYPE_CHANNEL, command);
 
                     if (actCommand instanceof ExternalCommand) {
-                        comargs = new String[args.length - 2];
-                        System.arraycopy(args, 2, comargs, 0, args.length - 2);
-
-                        ((ExternalCommand) actCommand).execute(origin, server,
-                                args[1], silent, comargs);
+                        ((ExternalCommand) actCommand).execute(
+                                origin, server, cargs[0], silent,
+                                new CommandArguments(args.getWordsAsString(2)));
                         return;
                     }
                 }
             }
 
-            comargs = new String[args.length - 1];
-            System.arraycopy(args, 1, comargs, 0, args.length - 1);
-
-            final String signature = command;
-
-            if (commands.containsKey(signature.toLowerCase())) {
-                addHistory(line.substring(offset));
-                executeCommand(origin, silent, commands.get(signature.toLowerCase()), comargs);
+            if (commands.containsKey(command.toLowerCase())) {
+                addHistory(args.getStrippedLine());
+                executeCommand(origin, silent, commands.get(command.toLowerCase()), args);
            } else {
-                handleInvalidCommand(origin, command, comargs);
+                handleInvalidCommand(origin, args);
             }
         } else {
             handleNonCommand(origin, line);
@@ -237,30 +213,32 @@ public abstract class CommandParser implements Serializable {
      * @param isSilent Whether the command is being silenced or not
      * @param command The command to be executed
      * @param args The arguments to the command
+     * @since 0.6.3
      */
     protected abstract void executeCommand(final InputWindow origin,
-            final boolean isSilent, final Command command, final String... args);
+            final boolean isSilent, final Command command, final CommandArguments args);
 
     /**
      * Called when the user attempted to issue a command (i.e., used the command
      * character) that wasn't found. It could be that the command has a different
      * arity, or that it plain doesn't exist.
+     *
      * @param origin The window in which the command was typed
-     * @param command The command the user tried to execute
      * @param args The arguments passed to the command
+     * @since 0.6.3
      */
     protected void handleInvalidCommand(final InputWindow origin,
-            final String command, final String... args) {
+            final CommandArguments args) {
         if (origin == null) {
             ActionManager.processEvent(CoreActionType.UNKNOWN_COMMAND, null,
-                    null, command, args);
+                    null, args.getCommandName(), args.getArguments());
         } else {
             final StringBuffer buff = new StringBuffer("unknownCommand");
 
             ActionManager.processEvent(CoreActionType.UNKNOWN_COMMAND, buff,
-                    origin.getContainer(), command, args);
+                    origin.getContainer(), args.getCommandName(), args.getArguments());
 
-            origin.addLine(buff, command);
+            origin.addLine(buff, args.getCommandName());
         }
     }
 

src/com/dmdirc/commandparser/parsers/GlobalCommandParser.java

@@ -22,6 +22,7 @@
 
 package com.dmdirc.commandparser.parsers;
 
+import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandManager;
 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.commandparser.commands.Command;
@@ -76,7 +77,7 @@ public final class GlobalCommandParser extends CommandParser {
     /** {@inheritDoc} */
     @Override
     protected void executeCommand(final InputWindow origin,
-            final boolean isSilent, final Command command, final String... args) {
+            final boolean isSilent, final Command command, final CommandArguments args) {
         ((GlobalCommand) command).execute(origin, isSilent, args);
     }
     

src/com/dmdirc/commandparser/parsers/QueryCommandParser.java

@@ -24,6 +24,7 @@ package com.dmdirc.commandparser.parsers;
 
 import com.dmdirc.Query;
 import com.dmdirc.Server;
+import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandManager;
 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.commandparser.commands.ChatCommand;
@@ -78,7 +79,7 @@ public final class QueryCommandParser extends CommandParser {
     /** {@inheritDoc} */
     @Override
     protected void executeCommand(final InputWindow origin,
-            final boolean isSilent, final Command command, final String... args) {
+            final boolean isSilent, final Command command, final CommandArguments args) {
         if (command instanceof QueryCommand) {
             ((QueryCommand) command).execute(origin, server, query, isSilent, args);
         } else if (command instanceof ChatCommand) {

src/com/dmdirc/commandparser/parsers/ServerCommandParser.java

@@ -23,6 +23,7 @@
 package com.dmdirc.commandparser.parsers;
 
 import com.dmdirc.Server;
+import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandManager;
 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.commandparser.commands.Command;
@@ -67,7 +68,7 @@ public final class ServerCommandParser extends CommandParser {
     /** {@inheritDoc} */
     @Override
     protected void executeCommand(final InputWindow origin,
-            final boolean isSilent, final Command command, final String... args) {
+            final boolean isSilent, final Command command, final CommandArguments args) {
         if (command instanceof ServerCommand) {
             ((ServerCommand) command).execute(origin, server, isSilent, args);
         } else {

test/com/dmdirc/commandparser/CommandArgumentsTest.java

@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.commandparser;
+
+import com.dmdirc.config.IdentityManager;
+
+import java.util.Arrays;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class CommandArgumentsTest {
+
+    @BeforeClass
+    public static void beforeClass() {
+        IdentityManager.load();
+    }
+
+    @Test
+    public void testIsCommand() {
+        assertTrue(new CommandArguments(CommandManager.getCommandChar() + "").isCommand());
+        assertTrue(new CommandArguments(CommandManager.getCommandChar() + "foo bar").isCommand());
+        assertFalse(new CommandArguments(" " + CommandManager.getCommandChar()).isCommand());
+        assertFalse(new CommandArguments("").isCommand());
+        assertFalse(new CommandArguments("foo").isCommand());
+    }
+
+    @Test
+    public void testIsSilent() {
+        final char c = CommandManager.getCommandChar();
+        final char s = CommandManager.getSilenceChar();
+
+        assertTrue(new CommandArguments(c + "" + s).isSilent());
+        assertFalse(new CommandArguments("f" + s).isSilent());
+        assertTrue(new CommandArguments(c + "" + s + "foo").isSilent());
+        assertFalse(new CommandArguments("").isSilent());
+        assertFalse(new CommandArguments("foo").isSilent());
+    }
+
+    @Test
+    public void testGetLine() {
+        assertEquals("foo", new CommandArguments("foo").getLine());
+        assertEquals("foo  bar", new CommandArguments("foo  bar").getLine());
+        assertEquals("", new CommandArguments("").getLine());
+    }
+
+    @Test
+    public void testGetWords() {
+        final CommandArguments args = new CommandArguments("a\tb    c d e");
+
+        assertEquals(5, args.getWords().length);
+        assertEquals("a", args.getWords()[0]);
+        assertEquals("b", args.getWords()[1]);
+        assertEquals("c", args.getWords()[2]);
+        assertEquals("d", args.getWords()[3]);
+        assertEquals("e", args.getWords()[4]);
+    }
+
+    @Test
+    public void testGetArguments() {
+        final CommandArguments args = new CommandArguments("a\tb    c d e");
+
+        assertEquals(4, args.getArguments().length);
+        assertEquals("b", args.getArguments()[0]);
+        assertEquals("c", args.getArguments()[1]);
+        assertEquals("d", args.getArguments()[2]);
+        assertEquals("e", args.getArguments()[3]);
+    }
+
+    @Test
+    public void testGetArgumentsAsString() {
+        assertEquals("b\tc  d", new CommandArguments("a b\tc  d").getArgumentsAsString());
+        assertEquals("", new CommandArguments("a").getArgumentsAsString());
+        assertEquals("", new CommandArguments("a\t  \t   \t").getArgumentsAsString());
+        assertEquals("b", new CommandArguments("a\t  \t   \tb").getArgumentsAsString());
+    }
+
+}