Add command flag utility classes and make /echo and /set use them.

Fixes CLIENT-119
Fixes CLIENT-120

Change-Id: I2e7ad2c3b8f0db591031fc281a24aa6627331a6e
Reviewed-on: http://gerrit.dmdirc.com/1680
Reviewed-by: Greg Holmes <greg@dmdirc.com>
Automatic-Compile: DMDirc Local Commits <dmdirc@googlemail.com>

src/com/dmdirc/commandparser/CommandArguments.java

@@ -122,7 +122,7 @@ public class CommandArguments {
     public String[] getArguments() {
         parse();
 
-        return Arrays.copyOfRange(words, 1, words.length);
+        return Arrays.copyOfRange(words, Math.min(1, words.length), words.length);
     }
 
     /**
@@ -132,8 +132,6 @@ public class CommandArguments {
      * @return A String representation of the command arguments
      */
     public String getArgumentsAsString() {
-        parse();
-
         return getArgumentsAsString(0);
     }
 
@@ -147,8 +145,21 @@ public class CommandArguments {
      */
     public String getArgumentsAsString(final int start) {
         parse();
+        
+        return getArgumentsAsString(start, words.length - 2);
+    }
 
-        return getWordsAsString(start + 1);
+    /**
+     * Retrieves arguments to the command (i.e., not including the
+     * command name) starting with the specified argument, with their original
+     * whitespace separation preserved.
+     *
+     * @param start The index of the first argument to include
+     * @param end The index of the last argument to include
+     * @return A String representation of the command arguments
+     */
+    public String getArgumentsAsString(final int start, final int end) {
+        return getWordsAsString(start + 1, end + 1);
     }
 
     /**

src/com/dmdirc/commandparser/commands/flags/CommandFlag.java

@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) 2006-2010 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.commands.flags;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * Describes a flag that may be used in a command. Each flag may be enabled
+ * or disabled initially, can specify a number of immediate arguments (which
+ * must follow the flag directly), a number of delayed arguments (which
+ * are specified after any other flags), and a list of other flags that
+ * the use of this one causes to be enabled or disabled.
+ *
+ * @since 0.6.5
+ * @see CommandFlagHandler
+ */
+public class CommandFlag {
+
+    /** The name of the flag. */
+    private final String name;
+    /** The list of flags that become enabled if this one is used. */
+    private final List<CommandFlag> enables = new LinkedList<CommandFlag>();
+    /** The list of flags that become disabled if this one is used. */
+    private final List<CommandFlag> disables = new LinkedList<CommandFlag>();
+    /** The number of args expected following this flag. */
+    private final int immediateArgs;
+    /** The number of args expected after flags are finished. */
+    private final int delayedArgs;
+    /** The initial state of this flag. */
+    private final boolean enabled;
+
+    /**
+     * Creates a new enabled flag with the specified name and no arguments.
+     *
+     * @param name The name of this flag
+     */
+    public CommandFlag(final String name) {
+        this(name, true);
+    }
+
+    /**
+     * Creates a new flag with the specified name and no arguments.
+     *
+     * @param name The name of this flag
+     * @param enabled Whether or not this flag is initially enabled
+     */
+    public CommandFlag(final String name, final boolean enabled) {
+        this(name, enabled, 0, 0);
+    }
+
+    /**
+     * Creates a new flag with the specified name and the specified number
+     * of arguments. Flags may only use immediate OR delayed arguments, not
+     * both.
+     *
+     * @param name The name of this flag
+     * @param enabled Whether or not this flag is initially enabled
+     * @param immediateArgs The number of immediate arguments
+     * @param delayedArgs The number of delayed arguments
+     */
+    public CommandFlag(final String name, final boolean enabled,
+            final int immediateArgs, final int delayedArgs) {
+        this.name = name;
+        this.immediateArgs = immediateArgs;
+        this.delayedArgs = delayedArgs;
+        this.enabled = enabled;
+
+        if (delayedArgs > 0 && immediateArgs > 0) {
+            throw new IllegalArgumentException("May not use both delayed and immediate arguments");
+        }
+    }
+
+    /**
+     * Indicates that the specified flags will be enabled if this flag
+     * is used.
+     *
+     * @param enabled The flags which will be enabled
+     */
+    public void addEnabled(final CommandFlag ... enabled) {
+        this.enables.addAll(Arrays.asList(enabled));
+    }
+
+    /**
+     * Indicates that the specified flags will be disabled if this flag
+     * is used.
+     *
+     * @param disabled The flags which will be disabled
+     */
+    public void addDisabled(final CommandFlag ... disabled) {
+        this.disables.addAll(Arrays.asList(disabled));
+    }
+
+    /**
+     * Retrieves the number of delayed arguments required by this flag.
+     *
+     * @return The number of delayed arguments
+     */
+    public int getDelayedArgs() {
+        return delayedArgs;
+    }
+
+    /**
+     * Retrieves the set of flags which become disabled if this one is used.
+     *
+     * @return A set of flags disabled by the use of this one
+     */
+    public Collection<CommandFlag> getDisables() {
+        return Collections.unmodifiableCollection(disables);
+    }
+
+    /**
+     * Determines whether or not this flag is enabled initially.
+     *
+     * @return The initial enabled/disabled state of this action
+     */
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    /**
+     * Retrieves the set of flags which become enabled if this one is used.
+     *
+     * @return A set of flags enabled by the use of this one
+     */
+    public Collection<CommandFlag> getEnables() {
+        return Collections.unmodifiableCollection(enables);
+    }
+
+    /**
+     * Retrieves the number of immediate arguments required by this flag.
+     *
+     * @return The number of immediate arguments
+     */
+    public int getImmediateArgs() {
+        return immediateArgs;
+    }
+
+    /**
+     * Retrieves the name of this flag.
+     *
+     * @return This flag's name
+     */
+    public String getName() {
+        return name;
+    }
+    
+}

src/com/dmdirc/commandparser/commands/flags/CommandFlagHandler.java

@@ -0,0 +1,260 @@
+/*
+ * Copyright (c) 2006-2010 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.commands.flags;
+
+import com.dmdirc.FrameContainer;
+import com.dmdirc.commandparser.CommandArguments;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Utility class for commands which allow the user to specify shell-like
+ * flags (<code>--foo</code>).
+ *
+ * @since 0.6.5
+ */
+public class CommandFlagHandler {
+
+    /** A map of all known flag names to their flag objects. */
+    private final Map<String, CommandFlag> flags = new HashMap<String, CommandFlag>();
+    /** A map of currently enabled flag names to their flag objects. */
+    private final Map<String, CommandFlag> enabledFlags = new HashMap<String, CommandFlag>();
+    /** A map of currently disabled flag names to their flag objects. */
+    private final Map<String, CommandFlag> disabledFlags = new HashMap<String, CommandFlag>();
+    /** A map of disabled flag names to the flag objects that caused them to be disabled. */
+    private final Map<String, CommandFlag> disabledBy = new HashMap<String, CommandFlag>();
+
+    /**
+     * Creates a new command flag handler which will handle all of the specified
+     * flags.
+     *
+     * @param flags The flags that will be handled
+     */
+    public CommandFlagHandler(final CommandFlag ... flags) {
+        for (CommandFlag flag : flags) {
+            this.flags.put(flag.getName(), flag);
+        }
+    }
+
+    /**
+     * Processes the specified arguments and parses out command flags. If
+     * the specified arguments aren't valid given the flags belonging to
+     * this command flag handler, an error message is sent to the origin and
+     * <code>null</code> is returned from this method.
+     *
+     * @param origin The container where the command was entered
+     * @param arguments The arguments passed to the command
+     * @return A corresponding {@link CommandFlagResult} object, or null
+     * if some problem was encountered.
+     */
+    public CommandFlagResult process(final FrameContainer<?> origin,
+            final CommandArguments arguments) {
+        final Map<CommandFlag, Integer> results = parse(origin, arguments);
+
+        return results == null ? null : new CommandFlagResult(arguments, results);
+    }
+
+    /**
+     * Parses the specified arguments and returns the offsets of the arguments
+     * for each found command flag.
+     *
+     * @param origin The container where the command was entered
+     * @param arguments The arguments passed to the command
+     * @return A map of discovered command flags to the offset of the flag's
+     * first argument within the <code>arguments</code> object. If an error
+     * occurs, null is returned.
+     */
+    protected Map<CommandFlag, Integer> parse(final FrameContainer<?> origin,
+            final CommandArguments arguments) {
+        enabledFlags.clear();
+        disabledBy.clear();
+        disabledFlags.clear();
+
+        for (CommandFlag flag : flags.values()) {
+            (flag.isEnabled() ? enabledFlags : disabledFlags).put(flag.getName(), flag);
+        }
+
+        final Map<CommandFlag, Integer> results = new HashMap<CommandFlag, Integer>();
+        final List<CommandFlag> delayedFlags = new ArrayList<CommandFlag>(flags.size());
+
+        int offset;
+        for (offset = 0; offset < arguments.getArguments().length; offset++) {
+            final String arg = arguments.getArguments()[offset];
+            String name;
+
+            if (arg.startsWith("--")
+                    && flags.containsKey(name = arg.substring(2).toLowerCase())) {
+                final CommandFlag flag = flags.get(name);
+
+                if (enabledFlags.containsKey(name)) {
+                    // It's enabled!
+                    handleEnable(flag);
+
+                    // Handle any immediate arguments
+                    if ((offset = readArguments(flag, arguments, offset + 1,
+                            flag.getImmediateArgs(), origin, results)) == -1) {
+                        return null;
+                    }
+
+                    // Handle delayed arguments (if any)
+                    if (flag.getDelayedArgs() > 0) {
+                        delayedFlags.add(flag);
+                    }
+                } else if (disabledBy.containsKey(name)) {
+                    // Disabled by another flag
+                    sendLine(origin, arguments.isSilent(), "commandError",
+                            "Cannot use flag --" + name
+                            + " in conjunction with --" + disabledBy.get(name).getName());
+                    return null;
+                } else {
+                    // Disabled because not yet enabled
+                    sendLine(origin, arguments.isSilent(), "commandError",
+                            "Cannot use flag --" + name
+                            + " without " + getEnablers(flag));
+                    return null;
+                }
+            } else {
+                break;
+            }
+        }
+
+        // Handle any stored delayed arguments
+        for (CommandFlag flag : delayedFlags) {
+            if ((offset = readArguments(flag, arguments, offset,
+                    flag.getDelayedArgs(), origin, results)) == -1) {
+                return null;
+            }
+
+            offset++;
+        }
+
+        results.put(null, offset);
+        
+        return results;
+    }
+
+    /**
+     * Reads the arguments for the specified flag.
+     *
+     * @param flag The flag that is being read
+     * @param arguments The raw arguments for the command
+     * @param offset The index that the first argument will be at
+     * @param argCount The number of arguments that need to be read
+     * @param origin The source of the command (for error messages)
+     * @param results The map to place results into
+     * @return The index of the last argument that was handled, or -1 if
+     * there were insufficient arguments for the flag
+     */
+    protected int readArguments(final CommandFlag flag,
+            final CommandArguments arguments, final int offset, final int argCount,
+            final FrameContainer<?> origin, final Map<CommandFlag, Integer> results) {
+        final int lastArg = argCount + offset - 1;
+
+        if (arguments.getArguments().length <= lastArg) {
+            sendLine(origin, arguments.isSilent(),
+                    "commandError", "Flag --" + flag.getName() + " expects "
+                    + argCount + " argument"
+                    + (argCount == 1 ? "" : "s"));
+            return -1;
+        }
+
+        results.put(flag, offset);
+
+        return lastArg;
+    }
+
+    /**
+     * Processes the enabled and disabled lists for the specified flag, and
+     * adds them to the relevant properties.
+     *
+     * @param flag The flag whose enables/disables lists should be processed
+     */
+    protected void handleEnable(final CommandFlag flag) {
+        for (CommandFlag target : flag.getDisables()) {
+            if (enabledFlags.containsKey(target.getName())) {
+                enabledFlags.remove(target.getName());
+                disabledFlags.put(target.getName(), target);
+                disabledBy.put(target.getName(), flag);
+            }
+        }
+
+        for (CommandFlag target : flag.getEnables()) {
+            if (disabledFlags.containsKey(target.getName())) {
+                disabledFlags.remove(target.getName());
+                enabledFlags.put(target.getName(), target);
+                disabledBy.remove(target.getName());
+            }
+        }
+    }
+
+    /**
+     * Constructs a user-friendly string describing the flag(s) which must
+     * be used in order to enable the specified flag. This is useful for
+     * error messages when the user tries to use a disabled flag.
+     *
+     * @param flag The flag to find enablers for
+     * @return A user-friendly string describing flags which enable the
+     * specified flag.
+     */
+    protected String getEnablers(final CommandFlag flag) {
+        final List<CommandFlag> enablers = new LinkedList<CommandFlag>();
+
+        for (CommandFlag target : flags.values()) {
+            if (target.getEnables().contains(flag)) {
+                enablers.add(target);
+            }
+        }
+
+        if (enablers.size() == 1) {
+            return "--" + enablers.get(0).getName();
+        }
+
+        final StringBuilder res = new StringBuilder("one of ");
+        for (CommandFlag enabler : enablers) {
+            res.append("--");
+            res.append(enabler.getName());
+            res.append(", ");
+        }
+
+        return res.substring(0, res.length() - 2);
+    }
+
+    /**
+     * Convenience method to send a line to the specified frame container.
+     *
+     * @param origin The container to send the line to
+     * @param isSilent Whether the command is silenced or not
+     * @param messageType The type of the line to be sent
+     * @param args The arguments for the specified messageType
+     */
+    protected static void sendLine(final FrameContainer<?> origin, final boolean isSilent,
+            final String messageType, final Object ... args) {
+        if (origin != null && !isSilent) {
+            origin.addLine(messageType, args);
+        }
+    }
+}

src/com/dmdirc/commandparser/commands/flags/CommandFlagResult.java

@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2006-2010 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.commands.flags;
+
+import com.dmdirc.commandparser.CommandArguments;
+
+import java.util.Map;
+
+/**
+ * Convenient wrapper around the results of a {@link CommandFlagHandler}'s
+ * parsing routines.
+ */
+public class CommandFlagResult {
+
+    /** The original arguments for the command. */
+    private final CommandArguments arguments;
+
+    /** The offsets of the first argument for each flag. */
+    private final Map<CommandFlag, Integer> offsets;
+
+    /**
+     * Creates a new CommandFlagResult with the specified results.
+     *
+     * @param arguments The original arguments for the command
+     * @param offsets The offsets for each flag's arguments
+     */
+    public CommandFlagResult(final CommandArguments arguments,
+            final Map<CommandFlag, Integer> offsets) {
+        this.arguments = arguments;
+        this.offsets = offsets;
+    }
+
+    /**
+     * Determines if the specified command flag has been used when the command
+     * was executed.
+     *
+     * @param flag The flag to be checked
+     * @return True iff the flag was specified legally, false otherwise
+     */
+    public boolean hasFlag(final CommandFlag flag) {
+        return offsets.containsKey(flag);
+    }
+
+    /**
+     * Retrieves all of the arguments passed for the specified flag as a string.
+     *
+     * @param flag The flag to retrieve arguments for
+     * @return The arguments passed with the specified flag
+     * @see #getArguments(com.dmdirc.commandparser.commands.flags.CommandFlag)
+     */
+    public String getArgumentsAsString(final CommandFlag flag) {
+        return flag == null ? (offsets.get(flag) > arguments.getArguments().length
+                ? "" : arguments.getArgumentsAsString(offsets.get(flag))) :
+                arguments.getArgumentsAsString(offsets.get(flag),
+                offsets.get(flag) + flag.getDelayedArgs() + flag.getImmediateArgs() - 1);
+    }
+
+    /**
+     * Retrieves all arguments not associated with any flags as a string.
+     *
+     * @see CommandArguments#getArgumentsAsString()
+     * @see #getArguments()
+     * @return All arguments that aren't associated with a flag, as a string
+     */
+    public String getArgumentsAsString() {
+        return getArgumentsAsString(null);
+    }
+
+    /**
+     * Retrieves a subset of the arguments not associated with any flags,
+     * starting at the specified offset.
+     *
+     * @see CommandArguments#getArgumentsAsString(int)
+     * @param offset The offset of the argument to start at
+     * @return All arguments that aren't associated with a flag, as a string,
+     * starting with the argument at the specified offset
+     */
+    public String getArgumentsAsString(final int offset) {
+        return arguments.getArgumentsAsString(offsets.get(null) + offset);
+    }
+
+    /**
+     * Retrieves the arguments passed with the specified flag as an array.
+     *
+     * @param flag The flag to be checked
+     * @return The arguments passed with the specified flag
+     * @see #getArgumentsAsString(com.dmdirc.commandparser.commands.flags.CommandFlag)
+     */
+    public String[] getArguments(final CommandFlag flag) {
+        final String[] args = arguments.getArguments();
+        final int end = flag == null ? args.length
+                : offsets.get(flag) + flag.getDelayedArgs() + flag.getImmediateArgs();
+        final int offset = offsets.get(flag);
+        final int size = end - offset;
+
+        final String[] result = new String[size];
+        System.arraycopy(args, offset, result, 0, size);
+
+        return result;
+    }
+
+    /**
+     * Retrieves all arguments not associated with any flags.
+     *
+     * @see CommandArguments#getArguments()
+     * @see #getArgumentsAsString()
+     * @return All arguments that aren't associated with a flag
+     */
+    public String[] getArguments() {
+        return getArguments(null);
+    }
+
+}

src/com/dmdirc/commandparser/commands/global/Echo.java

@@ -31,6 +31,9 @@ import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.commandparser.commands.Command;
 import com.dmdirc.commandparser.commands.IntelligentCommand;
 import com.dmdirc.commandparser.commands.context.CommandContext;
+import com.dmdirc.commandparser.commands.flags.CommandFlag;
+import com.dmdirc.commandparser.commands.flags.CommandFlagHandler;
+import com.dmdirc.commandparser.commands.flags.CommandFlagResult;
 import com.dmdirc.ui.WindowManager;
 import com.dmdirc.ui.input.AdditionalTabTargets;
 
@@ -46,60 +49,74 @@ import java.util.List;
 public final class Echo extends Command implements IntelligentCommand,
         CommandInfo {
 
+    /** The flag used to specify a timestamp for the echo command. */
+    private final CommandFlag timeStampFlag = new CommandFlag("ts", true, 1, 0);
+    /** The flag used to specify the echo command should use the active window. */
+    private final CommandFlag activeFlag = new CommandFlag("active");
+    /** The flag used to specify a target for the echo command. */
+    private final CommandFlag targetFlag = new CommandFlag("target", true, 1, 0);
+    /** The command flag handler for this command. */
+    private final CommandFlagHandler handler;
+
     /**
      * Creates a new instance of Echo.
      */
     public Echo() {
         super();
+
+        activeFlag.addDisabled(targetFlag);
+        targetFlag.addDisabled(activeFlag);
+
+        handler = new CommandFlagHandler(timeStampFlag, activeFlag, targetFlag);
     }
 
     /** {@inheritDoc} */
     @Override
     public void execute(final FrameContainer<?> origin,
             final CommandArguments args, final CommandContext context) {
-        int offset = 0;
-        Date time = new Date();
+        final CommandFlagResult results = handler.process(origin, args);
 
-        if (args.getArguments().length > 1
-                && args.getArguments()[offset].equalsIgnoreCase("--ts")) {
+        if (results == null) {
+            return;
+        }
+
+        Date time = new Date();
+        if (results.hasFlag(timeStampFlag)) {
             try {
-                time = new Date(Long.parseLong(args.getWordsAsString(2, 2)));
+                time = new Date(Long.parseLong(results.getArgumentsAsString(timeStampFlag)));
             } catch (NumberFormatException ex) {
                 sendLine(origin, args.isSilent(), FORMAT_ERROR, "Unable to process timestamp");
                 return;
             }
-
-            offset = 2;
         }
 
-        if (args.getArguments().length > offset
-                && args.getArguments()[offset].equalsIgnoreCase("--active")) {
+        if (results.hasFlag(activeFlag)) {
             if (!args.isSilent()) {
                 final FrameContainer<?> frame = WindowManager.getActiveWindow();
-                frame.addLine(FORMAT_OUTPUT, time, args.getArgumentsAsString(offset + 1));
+                frame.addLine(FORMAT_OUTPUT, time, results.getArgumentsAsString());
             }
-        } else if (args.getArguments().length > offset + 1
-                && args.getArguments()[offset].equalsIgnoreCase("--target")) {
+        } else if (results.hasFlag(targetFlag)) {
             FrameContainer<?> frame = null;
             FrameContainer<?> target = origin;
 
             while (frame == null && target != null) {
-                frame = WindowManager.findCustomWindow(target, args.getArguments()[offset + 1]);
+                frame = WindowManager.findCustomWindow(target,
+                        results.getArgumentsAsString(targetFlag));
+                target = target.getParent();
             }
 
             if (frame == null) {
-                frame = WindowManager.findCustomWindow(args.getArguments()[offset + 1]);
+                frame = WindowManager.findCustomWindow(results.getArgumentsAsString(targetFlag));
             }
 
             if (frame == null) {
                 sendLine(origin, args.isSilent(), FORMAT_ERROR,
                         "Unable to find target window");
             } else if (!args.isSilent()) {
-                frame.addLine(FORMAT_OUTPUT, time, args.getArgumentsAsString(offset + 2));
+                frame.addLine(FORMAT_OUTPUT, time, results.getArgumentsAsString());
             }
-
         } else if (origin != null && !args.isSilent()) {
-            origin.addLine(FORMAT_OUTPUT, time, args.getArgumentsAsString(offset));
+            origin.addLine(FORMAT_OUTPUT, time, results.getArgumentsAsString());
         }
     }
 

src/com/dmdirc/commandparser/commands/global/Set.java

@@ -22,6 +22,7 @@
 
 package com.dmdirc.commandparser.commands.global;
 
+import com.dmdirc.Channel;
 import com.dmdirc.FrameContainer;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandInfo;
@@ -29,7 +30,11 @@ import com.dmdirc.commandparser.CommandManager;
 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.commandparser.commands.Command;
 import com.dmdirc.commandparser.commands.IntelligentCommand;
+import com.dmdirc.commandparser.commands.context.ChannelCommandContext;
 import com.dmdirc.commandparser.commands.context.CommandContext;
+import com.dmdirc.commandparser.commands.flags.CommandFlag;
+import com.dmdirc.commandparser.commands.flags.CommandFlagHandler;
+import com.dmdirc.commandparser.commands.flags.CommandFlagResult;
 import com.dmdirc.config.ConfigManager;
 import com.dmdirc.config.Identity;
 import com.dmdirc.config.IdentityManager;
@@ -44,54 +49,98 @@ import java.util.List;
  */
 public final class Set extends Command implements IntelligentCommand, CommandInfo {
 
+    /** The flag to indicate the set command should apply to a server's settings. */
+    private final CommandFlag serverFlag = new CommandFlag("server");
+    /** The flag to indicate the set command should apply to a channel's settings. */
+    private final CommandFlag channelFlag = new CommandFlag("channel");
+    /** The flag to indicate that the specified setting should be unset. */
+    private final CommandFlag unsetFlag = new CommandFlag("unset", true, 0, 2);
+    /** The flag to indicate that the specified setting should be appended to. */
+    private final CommandFlag appendFlag = new CommandFlag("append", true, 0, 2);
+    /** The command flag handler for this command. */
+    private final CommandFlagHandler handler;
+
     /**
      * Creates a new instance of Set.
      */
     public Set() {
         super();
+        
+        unsetFlag.addDisabled(appendFlag);
+        appendFlag.addDisabled(unsetFlag);
+        
+        channelFlag.addDisabled(serverFlag);
+        serverFlag.addDisabled(channelFlag);
+
+        handler = new CommandFlagHandler(serverFlag, channelFlag, unsetFlag, appendFlag);
     }
 
     /** {@inheritDoc} */
     @Override
     public void execute(final FrameContainer<?> origin,
             final CommandArguments args, final CommandContext context) {
-        int i = 0;
+        final CommandFlagResult res = handler.process(origin, args);
+
+        if (res == null) {
+            return;
+        }
 
         Identity identity = IdentityManager.getConfigIdentity();
         ConfigManager manager = IdentityManager.getGlobalConfig();
 
-        if (args.getArguments().length > 0
-                && "--server".equalsIgnoreCase(args.getArguments()[0]) && origin != null
-                && origin.getServer() != null) {
-            i = 1;
+        if (res.hasFlag(serverFlag)) {
+            if (origin.getServer() == null) {
+                sendLine(origin, args.isSilent(), FORMAT_ERROR,
+                        "Cannot use --server in this context");
+                return;
+            }
+
             identity = origin.getServer().getServerIdentity();
             manager = origin.getServer().getConfigManager();
         }
 
-        switch (args.getArguments().length - i) {
+        if (res.hasFlag(channelFlag)) {
+            if (!(context instanceof ChannelCommandContext)) {
+                sendLine(origin, args.isSilent(), FORMAT_ERROR,
+                        "Cannot use --channel in this context");
+                return;
+            }
+
+            final Channel channel = ((ChannelCommandContext) context).getChannel();
+            identity = IdentityManager.getChannelConfig(origin.getServer().getNetwork(),
+                    channel.getName());
+            manager = channel.getConfigManager();
+        }
+
+        if (res.hasFlag(unsetFlag)) {
+            final String[] arguments = res.getArguments(unsetFlag);
+            doUnsetOption(origin, args.isSilent(), identity, arguments[0], arguments[1]);
+            return;
+        }
+        
+        if (res.hasFlag(appendFlag)) {
+            final String[] arguments = res.getArguments(appendFlag);
+            doAppendOption(origin, args.isSilent(), identity, manager,
+                    arguments[0], arguments[1], res.getArgumentsAsString());
+            return;
+        }
+        
+        final String[] arguments = res.getArguments();
+
+        switch (arguments.length) {
         case 0:
             doDomainList(origin, args.isSilent(), manager);
             break;
         case 1:
-            doOptionsList(origin, args.isSilent(), manager, args.getArguments()[i]);
+            doOptionsList(origin, args.isSilent(), manager, arguments[0]);
             break;
         case 2:
-            doShowOption(origin, args.isSilent(), manager, args.getArguments()[i],
-                    args.getArguments()[1 + i]);
+            doShowOption(origin, args.isSilent(), manager, arguments[0],
+                    arguments[1]);
             break;
         default:
-            if (args.getArguments()[i].equalsIgnoreCase("--unset")) {
-                doUnsetOption(origin, args.isSilent(), identity, args.getArguments()[1 + i],
-                        args.getArguments()[2 + i]);
-            } else if (args.getArguments()[i].equalsIgnoreCase("--append")
-                    && args.getArguments().length > 3 + i) {
-                doAppendOption(origin, args.isSilent(), identity, manager,
-                        args.getArguments()[1 + i], args.getArguments()[2 + i],
-                        args.getArgumentsAsString(3 + i));
-            } else {
-                doSetOption(origin, args.isSilent(), identity, args.getArguments()[i],
-                        args.getArguments()[1 + i], args.getArgumentsAsString(2 + i));
-            }
+            doSetOption(origin, args.isSilent(), identity, arguments[0],
+                    arguments[1], res.getArgumentsAsString(2));
             break;
         }
     }
@@ -247,9 +296,9 @@ public final class Set extends Command implements IntelligentCommand, CommandInf
     /** {@inheritDoc} */
     @Override
     public String getHelp() {
-        return "set [--server] [domain [option [newvalue]]] - inspect or change configuration settings"
-                + "\nset [--server] --append <domain> <option> <data> - appends data to the specified option"
-                + "\nset [--server] --unset <domain> <option> - unsets the specified option";
+        return "set [--server|--channel] [domain [option [newvalue]]] - inspect or change configuration settings"
+                + "\nset [--server|--channel] --append <domain> <option> <data> - appends data to the specified option"
+                + "\nset [--server|--channel] --unset <domain> <option> - unsets the specified option";
     }
 
     /** {@inheritDoc} */
@@ -265,11 +314,13 @@ public final class Set extends Command implements IntelligentCommand, CommandInf
             res.add("--unset");
             res.add("--append");
             res.add("--server");
+            res.add("--channel");
             res.excludeAll();
         } else if (arg == 1 && previousArgs.size() >= 1) {
             if (previousArgs.get(0).equalsIgnoreCase("--unset")
                     || previousArgs.get(0).equalsIgnoreCase("--append")
-                    || previousArgs.get(0).equalsIgnoreCase("--server")) {
+                    || previousArgs.get(0).equalsIgnoreCase("--server")
+                    || previousArgs.get(0).equalsIgnoreCase("--channel")) {
                 res.addAll(context.getWindow().getContainer().getConfigManager()
                         .getDomains());
             } else {
@@ -279,7 +330,8 @@ public final class Set extends Command implements IntelligentCommand, CommandInf
             res.excludeAll();
         } else if (arg == 2 && (previousArgs.get(0).equalsIgnoreCase("--unset")
                 || previousArgs.get(0).equalsIgnoreCase("--append")
-                || previousArgs.get(0).equalsIgnoreCase("--server"))) {
+                || previousArgs.get(0).equalsIgnoreCase("--server")
+                || previousArgs.get(0).equalsIgnoreCase("--channel"))) {
             res.addAll(context.getWindow().getContainer().getConfigManager()
                     .getOptions(previousArgs.get(1)).keySet());
             res.excludeAll();

test/com/dmdirc/commandparser/commands/flags/CommandFlagHandlerTest.java

@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2006-2010 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.commands.flags;
+
+import com.dmdirc.config.InvalidIdentityFileException;
+import java.util.Map;
+import com.dmdirc.FrameContainer;
+import com.dmdirc.commandparser.CommandArguments;
+import com.dmdirc.config.IdentityManager;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+@RunWith(Parameterized.class)
+public class CommandFlagHandlerTest {
+    
+    private static final CommandFlag noArgsFlag1 = new CommandFlag("noargs1");
+    private static final CommandFlag noArgsFlag2 = new CommandFlag("noargs2", false);
+    private static final CommandFlag noArgsFlag3 = new CommandFlag("noargs3");
+    private static final CommandFlag noArgsFlag4 = new CommandFlag("noargs4", false);
+    private static final CommandFlag immArgsFlag1 = new CommandFlag("immargs1", true, 1, 0);
+    private static final CommandFlag immArgsFlag2 = new CommandFlag("immargs2", true, 2, 0);
+    private static final CommandFlag defArgsFlag1 = new CommandFlag("defargs1", true, 0, 1);
+    private static final CommandFlag defArgsFlag2 = new CommandFlag("defargs2", true, 0, 2);
+    private final CommandFlagHandler handler;
+    
+    private final String input;
+    private final CommandFlag[] flags;
+    private final int[] offsets;
+    
+    @BeforeClass
+    public static void setupClass() throws InvalidIdentityFileException {
+        IdentityManager.load();
+    }
+    
+    public CommandFlagHandlerTest(String input, CommandFlag[] flags, int[] offsets) {
+        noArgsFlag3.addEnabled(noArgsFlag4);
+        noArgsFlag3.addDisabled(noArgsFlag1);
+
+        handler = new CommandFlagHandler(noArgsFlag1, noArgsFlag2, noArgsFlag3,
+                noArgsFlag4, immArgsFlag1, immArgsFlag2, defArgsFlag1, defArgsFlag2);
+        
+        this.input = input;
+        this.flags = flags;
+        this.offsets = offsets;
+    }
+    
+    @Test
+    public void testParse() {
+        final FrameContainer<?> container = mock(FrameContainer.class);
+        
+        final Map<CommandFlag, Integer> results
+                = handler.parse(container, new CommandArguments(input));
+        
+        if (flags == null) {
+            assertNull("Command should fail: " + input, results);
+        } else {
+            assertNotNull("Command should NOT fail: " + input, results);
+            assertTrue("Result must contain a null element: " + input,
+                    results.containsKey(null));
+
+            int i = 0;
+            for (CommandFlag flag : flags) {
+                assertTrue("Result must contain flag: " + flag.getName()
+                        + ": " + input, results.containsKey(flag));
+                assertEquals("Offset for flag " + flag.getName()
+                        + " should be " + offsets[i] + ": " + input,
+                        offsets[i++], (int) results.get(flag));
+            }
+
+            assertEquals("Global offset should be " + offsets[i],
+                    offsets[i], (int) results.get(null));
+
+            assertEquals("Result should contain " + (flags.length + 1)
+                    + " elements: " + input, flags.length + 1, results.size());
+        }
+    }
+
+    @Parameterized.Parameters
+    public static List<Object[]> data() {
+        final Object[][] tests = {
+            {"/foo", new CommandFlag[0], new int[]{0}},
+            {"/foo --noargs1", new CommandFlag[]{noArgsFlag1}, new int[]{1, 1}},
+            {"/foo --noargs2", null, null},
+            {"/foo --noargs3", new CommandFlag[]{noArgsFlag3}, new int[]{1, 1}},
+            {"/foo --noargs4", null, null},
+            {"/foo --noargs5", new CommandFlag[0], new int[]{0}},
+            {"/foo --noargs3 --noargs4", new CommandFlag[]{noArgsFlag3, noArgsFlag4}, new int[]{1, 2, 2}},
+            {"/foo --noargs3 --noargs1", null, null},
+            {"/foo --noargs1 --noargs3", new CommandFlag[]{noArgsFlag1, noArgsFlag3}, new int[]{1, 2, 2}},
+            {"/foo --noargs3 --noargs4 --noargs1", null, null},
+            {"/foo --noargs3 --noargs4 --noargs2", null, null},
+
+            {"/foo --immargs1", null, null},
+            {"/foo --noargs1 --immargs1", null, null},
+            {"/foo --immargs2", null, null},
+            {"/foo --immargs2 xxx", null, null},
+            {"/foo --immargs1 arg1", new CommandFlag[]{immArgsFlag1}, new int[]{1, 2}},
+            {"/foo --noargs1 --immargs1 arg1", new CommandFlag[]{immArgsFlag1, noArgsFlag1},
+                    new int[]{2, 1, 3}},
+            {"/foo --immargs1 arg1 --noargs1", new CommandFlag[]{immArgsFlag1, noArgsFlag1},
+                    new int[]{1, 3, 3}},
+
+            {"/foo --defargs1", null, null},
+            {"/foo --noargs1 --defargs1", null, null},
+            {"/foo --defargs2", null, null},
+            {"/foo --defargs2 xxx", null, null},
+            {"/foo --defargs1 arg1", new CommandFlag[]{defArgsFlag1}, new int[]{1, 2}},
+            {"/foo --noargs1 --defargs1 arg1", new CommandFlag[]{defArgsFlag1, noArgsFlag1},
+                    new int[]{2, 1, 3}},
+            {"/foo --defargs1 --noargs1 arg1", new CommandFlag[]{defArgsFlag1, noArgsFlag1},
+                    new int[]{2, 2, 3}},
+        };
+
+        return Arrays.asList(tests);
+    }    
+
+}