Always specify an origin when parsing commands.

Where commands are executed globally, pass in a GlobalWindow.

Make the GlobalWindow a singleton that persists, and is simply
added/removed from the WindowManager when the user wants to
show/hide it.

Change-Id: Iac94848487442509bdbf8ec98f67983e313ed743
Reviewed-on: http://gerrit.dmdirc.com/3451
Automatic-Compile: DMDirc Build Manager
Reviewed-by: Greg Holmes <greg@dmdirc.com>

src/com/dmdirc/FrameContainer.java

     }
 
     /**
-     * Closes this container (and it's associated frame).
+     * Closes this container (and its associated frame).
      */
     public void close() {
         for (FrameCloseListener listener : listeners.get(FrameCloseListener.class)) {
             listener.windowClosing(this);
+            listeners.remove(FrameCloseListener.class, listener);
         }
     }
 
     }
 
     /**
-     * Adds a close listener for this frame container.
+     * Adds a close listener for this frame container. Close listeners will only be called once,
+     * even if the container is closed, re-added, and closed again.
      *
-     * @since 0.6.5
      * @param listener The listener to be added
      */
     public void addCloseListener(final FrameCloseListener listener) {

src/com/dmdirc/GlobalWindow.java

 
 import com.dmdirc.ClientModule.GlobalConfig;
 import com.dmdirc.commandparser.CommandType;
-import com.dmdirc.commandparser.parsers.CommandParser;
 import com.dmdirc.commandparser.parsers.GlobalCommandParser;
 import com.dmdirc.interfaces.Connection;
 import com.dmdirc.interfaces.FrameCloseListener;
 /**
  * A window which can be used to execute global commands.
  */
+@Singleton
 public class GlobalWindow extends FrameContainer {
 
     /**
      * @param urlBuilder          The URL builder to use when finding icons.
      * @param eventBus            The bus to despatch events on.
      */
+    @Inject
     public GlobalWindow(
-            final AggregateConfigProvider config,
-            final CommandParser parser,
+            @GlobalConfig final AggregateConfigProvider config,
+            final GlobalCommandParser parser,
             final TabCompleterFactory tabCompleterFactory,
             final MessageSinkManager messageSinkManager,
             final URLBuilder urlBuilder,
     @Singleton
     public static class GlobalWindowManager implements ConfigChangeListener {
 
+        /** Provider to use to obtain global window instances. */
+        private final Provider<GlobalWindow> globalWindowProvider;
         /** The global configuration to read settings from. */
         private final AggregateConfigProvider globalConfig;
-        /** The factory to use to create tab completers. */
-        private final TabCompleterFactory tabCompleterFactory;
         /** The provider to use to retrieve a window manager. */
         private final Provider<WindowManager> windowManagerProvider;
-        /** The provider to use to retrieve message sink managers. */
-        private final Provider<MessageSinkManager> messageSinkManagerProvider;
-        /** The provider to use to retrieve a global command parser. */
-        private final Provider<GlobalCommandParser> globalCommandParserProvider;
-        /** The URL builder to use when finding icons. */
-        private final URLBuilder urlBuilder;
-        /** The bus to despatch events on. */
-        private final EventBus eventBus;
-        /** The global window that's in use, if any. */
-        private GlobalWindow globalWindow;
 
         /**
          * Creates a new instance of {@link GlobalWindowManager}.
          *
-         * @param globalConfig                Configuration provider to read settings from.
-         * @param tabCompleterFactory         Factory to use to create tab completers.
-         * @param windowManagerProvider       The provider to use to retrieve a window manager.
-         * @param messageSinkManagerProvider  The provider to use to retrieve a sink manager.
-         * @param globalCommandParserProvider The provider to use to retrieve a global command
-         *                                    parser.
-         * @param urlBuilder                  The URL builder to use when finding icons.
-         * @param eventBus                    The bus to despatch events on.
+         * @param globalWindowProvider  The provider to use to obtain global windows.
+         * @param globalConfig          Configuration provider to read settings from.
+         * @param windowManagerProvider The provider to use to retrieve a window manager.
          */
         @Inject
         public GlobalWindowManager(
+                final Provider<GlobalWindow> globalWindowProvider,
                 @GlobalConfig final AggregateConfigProvider globalConfig,
-                final TabCompleterFactory tabCompleterFactory,
-                final Provider<WindowManager> windowManagerProvider,
-                final Provider<MessageSinkManager> messageSinkManagerProvider,
-                final Provider<GlobalCommandParser> globalCommandParserProvider,
-                final URLBuilder urlBuilder,
-                final EventBus eventBus) {
+                final Provider<WindowManager> windowManagerProvider) {
+            this.globalWindowProvider = globalWindowProvider;
             this.globalConfig = globalConfig;
-            this.tabCompleterFactory = tabCompleterFactory;
             this.windowManagerProvider = windowManagerProvider;
-            this.messageSinkManagerProvider = messageSinkManagerProvider;
-            this.globalCommandParserProvider = globalCommandParserProvider;
-            this.urlBuilder = urlBuilder;
-            this.eventBus = eventBus;
         }
 
         @Override
          * setting.
          */
         protected void updateWindowState() {
-            synchronized (GlobalWindow.class) {
-                if (globalConfig.getOptionBool("general", "showglobalwindow")) {
-                    if (globalWindow == null) {
-                        globalWindow = new GlobalWindow(globalConfig,
-                                globalCommandParserProvider.get(),
-                                tabCompleterFactory,
-                                messageSinkManagerProvider.get(),
-                                urlBuilder,
-                                eventBus);
-                        addCloseListener(globalWindow);
-                        windowManagerProvider.get().addWindow(globalWindow);
-                    }
-                } else {
-                    if (globalWindow != null) {
-                        globalWindow.close();
-                    }
+            final WindowManager windowManager = windowManagerProvider.get();
+            final GlobalWindow globalWindow = globalWindowProvider.get();
+            final boolean globalWindowExists = windowManager.getRootWindows()
+                    .contains(globalWindow);
+
+            if (globalConfig.getOptionBool("general", "showglobalwindow")) {
+                if (!globalWindowExists) {
+                    addCloseListener(globalWindow);
+                    windowManager.addWindow(globalWindow);
+                }
+            } else {
+                if (globalWindowExists) {
+                    globalWindow.close();
                 }
             }
         }
         /**
          * Adds a {@link FrameCloseListener} to the specified window to update the global window
          * state if the user closes it from the UI.
+         *
+         * @param window The window to add a listener to.
          */
         private void addCloseListener(final GlobalWindow window) {
             window.addCloseListener(new FrameCloseListener() {
                 @Override
                 public void windowClosing(final FrameContainer container) {
-                    synchronized (GlobalWindow.class) {
-                        globalWindow = null;
-                    }
+                    container.removeCloseListener(this);
                 }
             });
         }

src/com/dmdirc/actions/Action.java

 
 package com.dmdirc.actions;
 
+import com.dmdirc.GlobalWindow;
 import com.dmdirc.commandparser.parsers.GlobalCommandParser;
 import com.dmdirc.config.prefs.PreferencesSetting;
 import com.dmdirc.config.prefs.PreferencesType;
      * a valid action already saved to disk.
      *
      * @param globalCommandParserProvider Provider of global command parsers for triggering actions.
+     * @param globalWindowProvider        Provider of global windows for triggering actions.
      * @param substitutorFactory          Factory to use to create action substitutors.
      * @param actionController            The controller that owns this action.
      * @param identityController          The controller to use to retrieve and update settings.
      */
     public Action(
             final Provider<GlobalCommandParser> globalCommandParserProvider,
+            final Provider<GlobalWindow> globalWindowProvider,
             final ActionSubstitutorFactory substitutorFactory,
             final ActionController actionController,
             final IdentityController identityController,
             final String actionsDirectory,
             final String group,
             final String name) {
-        super(globalCommandParserProvider, substitutorFactory, group, name);
+        super(globalCommandParserProvider, globalWindowProvider, substitutorFactory, group, name);
 
         this.actionController = actionController;
         this.identityController = identityController;
      * Creates a new instance of Action with the specified properties and saves it to disk.
      *
      * @param globalCommandParserProvider Provider of global command parsers for triggering actions.
+     * @param globalWindowProvider        Provider of global windows for triggering actions.
      * @param substitutorFactory          Factory to use to create action substitutors.
      * @param actionController            The controller that owns this action.
      * @param identityController          The controller to use to retrieve and update settings.
      */
     public Action(
             final Provider<GlobalCommandParser> globalCommandParserProvider,
+            final Provider<GlobalWindow> globalWindowProvider,
             final ActionSubstitutorFactory substitutorFactory,
             final ActionController actionController,
             final IdentityController identityController,
             final List<ActionCondition> conditions,
             final ConditionTree conditionTree,
             final String newFormat) {
-        super(globalCommandParserProvider, substitutorFactory, group, name, triggers, response,
-                conditions, conditionTree, newFormat);
+        super(globalCommandParserProvider, globalWindowProvider, substitutorFactory, group, name,
+                triggers, response, conditions, conditionTree, newFormat);
 
         this.actionController = actionController;
         this.identityController = identityController;

src/com/dmdirc/actions/ActionFactory.java

 
 package com.dmdirc.actions;
 
+import com.dmdirc.GlobalWindow;
 import com.dmdirc.commandline.CommandLineOptionsModule.Directory;
 import com.dmdirc.commandline.CommandLineOptionsModule.DirectoryType;
 import com.dmdirc.commandparser.parsers.GlobalCommandParser;
     private final Provider<ActionController> actionController;
     /** The controller to use to retrieve and update settings. */
     private final Provider<IdentityController> identityController;
+    /** The global window to use for actions without windows. */
+    private final Provider<GlobalWindow> globalWindowProvider;
     /** The factory to use to create substitutors. */
     private final ActionSubstitutorFactory substitutorFactory;
     /** The base directory to store actions in. */
      * @param identityController          The controller to use to retrieve and update settings.
      * @param globalCommandParserProvider The global command parser to use for actions without
      *                                    windows.
+     * @param globalWindowProvider        The global window to use for actions without windows.
      * @param substitutorFactory          The factory to use to create substitutors.
      * @param actionsDirectory            The base directory to store actions in.
      */
             final Provider<ActionController> actionController,
             final Provider<IdentityController> identityController,
             final Provider<GlobalCommandParser> globalCommandParserProvider,
+            final Provider<GlobalWindow> globalWindowProvider,
             final ActionSubstitutorFactory substitutorFactory,
             @Directory(DirectoryType.ACTIONS) final String actionsDirectory) {
         this.actionController = actionController;
         this.identityController = identityController;
         this.globalCommandParserProvider = globalCommandParserProvider;
+        this.globalWindowProvider = globalWindowProvider;
         this.substitutorFactory = substitutorFactory;
         this.actionsDirectory = actionsDirectory;
     }
      * @return A relevant action.
      */
     public Action getAction(final String group, final String name) {
-        return new Action(globalCommandParserProvider, substitutorFactory, actionController.get(),
-                identityController.get(), actionsDirectory, group, name);
+        return new Action(
+                globalCommandParserProvider,
+                globalWindowProvider,
+                substitutorFactory,
+                actionController.get(),
+                identityController.get(),
+                actionsDirectory,
+                group,
+                name);
     }
 
     /**
             final ActionType[] triggers, final String[] response,
             final List<ActionCondition> conditions,
             final ConditionTree conditionTree, final String newFormat) {
-        return new Action(globalCommandParserProvider, substitutorFactory, actionController.get(),
-                identityController.get(), actionsDirectory, group,
-                name, triggers, response, conditions, conditionTree, newFormat);
+        return new Action(
+                globalCommandParserProvider,
+                globalWindowProvider,
+                substitutorFactory,
+                actionController.get(),
+                identityController.get(),
+                actionsDirectory,
+                group,
+                name,
+                triggers,
+                response,
+                conditions,
+                conditionTree,
+                newFormat);
     }
 
 }

src/com/dmdirc/actions/ActionModel.java

 package com.dmdirc.actions;
 
 import com.dmdirc.FrameContainer;
+import com.dmdirc.GlobalWindow;
 import com.dmdirc.Precondition;
 import com.dmdirc.ServerManager;
 import com.dmdirc.commandparser.parsers.CommandParser;
  */
 public class ActionModel {
 
+    // TODO: Sort out the mess of protected fields here.
+
     /** Provider of global command parsers, for use when triggering window-less actions. */
     private final Provider<GlobalCommandParser> globalCommandParserProvider;
+    /** Provider of global windows for global actions. */
+    private final Provider<GlobalWindow> globalWindowProvider;
     /** Factory to use to creator substitutors. */
     private final ActionSubstitutorFactory substitutorFactory;
     /** The group this action belongs to. */
     /**
      * Creates a new instance of ActionModel with the specified properties.
      *
-     * @param globalCommandParserProvider Provider of global command parsers for triggering actions.
+     * @param globalCommandParserProvider Provider of global command parsers for global actions.
+     * @param globalWindowProvider        Provider of global windows for global actions.
      * @param substitutorFactory          Factory to use to create action substitutors.
      * @param group                       The group the action belongs to
      * @param name                        The name of the action
      */
     public ActionModel(
             final Provider<GlobalCommandParser> globalCommandParserProvider,
+            final Provider<GlobalWindow> globalWindowProvider,
             final ActionSubstitutorFactory substitutorFactory,
             final String group,
             final String name) {
         this.globalCommandParserProvider = globalCommandParserProvider;
+        this.globalWindowProvider = globalWindowProvider;
         this.substitutorFactory = substitutorFactory;
         this.group = group;
         this.name = name;
      * Creates a new instance of ActionModel with the specified properties.
      *
      * @param globalCommandParserProvider Provider of global command parsers for triggering actions.
+     * @param globalWindowProvider        Provider of global windows for global actions.
      * @param substitutorFactory          Factory to use to create action substitutors.
      * @param group                       The group the action belongs to
      * @param name                        The name of the action
      */
     public ActionModel(
             final Provider<GlobalCommandParser> globalCommandParserProvider,
+            final Provider<GlobalWindow> globalWindowProvider,
             final ActionSubstitutorFactory substitutorFactory,
             final String group, final String name,
             final ActionType[] triggers, final String[] response,
             final List<ActionCondition> conditions,
             final ConditionTree conditionTree, final String newFormat) {
-        this(globalCommandParserProvider, substitutorFactory, group, name);
+        this(globalCommandParserProvider, globalWindowProvider, substitutorFactory, group, name);
         this.triggers = triggers.clone();
         this.response = response.clone();
         this.conditions = conditions;
             return false;
         }
 
-        FrameContainer container = null;
-        CommandParser cp;
-
+        final FrameContainer container;
         if (arguments.length > 0 && arguments[0] instanceof FrameContainer
                 && ((FrameContainer) arguments[0]).isWritable()) {
             container = (FrameContainer) arguments[0];
-        } else if (serverManager.numServers() > 0) {
-            container = serverManager.getServers().get(0);
-        }
-
-        if (container == null) {
-            cp = globalCommandParserProvider.get();
         } else {
-            cp = container.getCommandParser();
+            container = globalWindowProvider.get();
         }
 
+        final CommandParser cp = container.getCommandParser();
         for (String command : response) {
             cp.parseCommand(container, sub.doSubstitution(command, arguments));
         }

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

 package com.dmdirc.commandparser.commands.global;
 
 import com.dmdirc.FrameContainer;
+import com.dmdirc.GlobalWindow;
 import com.dmdirc.commandparser.BaseCommandInfo;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandInfo;
     private final PluginManager pluginManager;
     /** Provider of global command parsers. */
     private final Provider<GlobalCommandParser> globalCommandParserProvider;
+    /** Proivder of global windows. */
+    private final Provider<GlobalWindow> globalWindowProvider;
 
     /**
      * Creates a new instance of the {@link Ifplugin} command.
      * @param controller                  The controller to use for command information.
      * @param pluginManager               The plugin manager to use to query plugins.
      * @param globalCommandParserProvider Provider to use to retrieve a global command parser.
+     * @param globalWindowProvider        Provider to use to retrieve a global window.
      */
     @Inject
     public Ifplugin(
             final CommandController controller,
             final PluginManager pluginManager,
-            final Provider<GlobalCommandParser> globalCommandParserProvider) {
+            final Provider<GlobalCommandParser> globalCommandParserProvider,
+            final Provider<GlobalWindow> globalWindowProvider) {
         super(controller);
         this.pluginManager = pluginManager;
         this.globalCommandParserProvider = globalCommandParserProvider;
+        this.globalWindowProvider = globalWindowProvider;
     }
 
     @Override
         if (result != negative) {
             if (origin == null || !origin.isWritable()) {
                 globalCommandParserProvider.get()
-                        .parseCommand(null, args.getArgumentsAsString(1));
+                        .parseCommand(globalWindowProvider.get(), args.getArgumentsAsString(1));
             } else {
                 origin.getCommandParser().parseCommand(origin, args.getArgumentsAsString(1));
             }

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

 import java.util.HashMap;
 import java.util.Map;
 
+import javax.annotation.Nonnull;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
 /**
  * Represents a generic command parser. A command parser takes a line of input from the user,
  * determines if it is an attempt at executing a command (based on the character at the start of the
      *
      * @since 0.6.4
      */
-    public final void parseCommand(final FrameContainer origin,
-            final String line, final boolean parseChannel) {
-        final CommandArguments args = new CommandArguments(commandManager, line);
+    public final void parseCommand(@Nonnull final FrameContainer origin, final String line,
+            final boolean parseChannel) {
+        checkNotNull(origin);
 
+        final CommandArguments args = new CommandArguments(commandManager, line);
         if (args.isCommand()) {
             if (handleChannelCommand(origin, args, parseChannel)) {
                 return;
      *
      * @return True iff the command was handled, false otherwise
      */
-    protected boolean handleChannelCommand(final FrameContainer origin,
+    protected boolean handleChannelCommand(@Nonnull final FrameContainer origin,
             final CommandArguments args, final boolean parseChannel) {
         final boolean silent = args.isSilent();
         final String command = args.getCommandName();
         final String[] cargs = args.getArguments();
 
-        if (cargs.length == 0 || !parseChannel || origin == null
+        if (cargs.length == 0 || !parseChannel
                 || origin.getConnection() == null
                 || !commandManager.isChannelCommand(command)) {
             return false;
      *
      * @since 0.6.4
      */
-    public void parseCommand(final FrameContainer origin, final String line) {
+    public void parseCommand(@Nonnull final FrameContainer origin, final String line) {
         parseCommand(origin, line, true);
     }
 

test/com/dmdirc/actions/ActionModelTest.java

 
 package com.dmdirc.actions;
 
+import com.dmdirc.GlobalWindow;
 import com.dmdirc.commandparser.parsers.GlobalCommandParser;
 import com.dmdirc.interfaces.ActionController;
 import com.dmdirc.interfaces.CommandController;
 import org.mockito.Mock;
 import org.mockito.runners.MockitoJUnitRunner;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
 
 @RunWith(MockitoJUnitRunner.class)
 public class ActionModelTest {
 
     @Mock private Provider<GlobalCommandParser> gcpProvider;
+    @Mock private Provider<GlobalWindow> gwProvider;
     @Mock private ActionSubstitutorFactory substitutorFactory;
     @Mock private ActionController actionController;
     @Mock private CommandController commandController;
 
     @Test
     public void testConditions() {
-        final ActionModel model = new ActionModel(gcpProvider, substitutorFactory, "group", "name");
+        final ActionModel model = new ActionModel(gcpProvider, gwProvider, substitutorFactory,
+                "group", "name");
 
         assertTrue("ActionModel must start with no conditions",
                 model.getConditions().isEmpty());
 
     @Test
     public void testTriggers() {
-        final ActionModel model = new ActionModel(gcpProvider, substitutorFactory, "group", "name");
+        final ActionModel model = new ActionModel(gcpProvider, gwProvider, substitutorFactory,
+                "group", "name");
 
         assertNull("ActionModel must start with null triggers",
                 model.getTriggers());
 
     @Test
     public void testNewFormat() {
-        final ActionModel model = new ActionModel(gcpProvider, substitutorFactory, "group", "name");
+        final ActionModel model = new ActionModel(gcpProvider, gwProvider, substitutorFactory,
+                "group", "name");
 
         assertNull("ActionModel must start with null format",
                 model.getNewFormat());
 
     @Test
     public void testResponse() {
-        final ActionModel model = new ActionModel(gcpProvider, substitutorFactory, "group", "name");
+        final ActionModel model = new ActionModel(gcpProvider, gwProvider, substitutorFactory,
+                "group", "name");
 
         assertNull("ActionModel must start with null response",
                 model.getResponse());
 
     @Test
     public void testGroup() {
-        final ActionModel model = new ActionModel(gcpProvider, substitutorFactory, "group", "name");
+        final ActionModel model = new ActionModel(gcpProvider, gwProvider, substitutorFactory,
+                "group", "name");
 
         assertEquals("ActionModel constructor must set group",
                 "group", model.getGroup());
 
     @Test
     public void testName() {
-        final ActionModel model = new ActionModel(gcpProvider, substitutorFactory, "group", "name");
+        final ActionModel model = new ActionModel(gcpProvider, gwProvider, substitutorFactory,
+                "group", "name");
 
         assertEquals("ActionModel constructor must set name",
                 "name", model.getName());
 
     @Test
     public void testTest() {
-        final ActionModel model = new ActionModel(gcpProvider, substitutorFactory, "group", "name",
+        final ActionModel model = new ActionModel(gcpProvider, gwProvider, substitutorFactory,
+                "group", "name",
                 new ActionType[]{CoreActionType.CHANNEL_ACTION},
                 new String[0], Arrays.asList(new ActionCondition[]{
                     new ActionCondition(2, CoreActionComponent.STRING_STRING,
 
     @Test
     public void testTestNoCondTree() {
-        final ActionModel model = new ActionModel(gcpProvider, substitutorFactory, "group", "name",
+        final ActionModel model = new ActionModel(gcpProvider, gwProvider, substitutorFactory,
+                "group", "name",
                 new ActionType[]{CoreActionType.CHANNEL_ACTION},
                 new String[0], Arrays.asList(new ActionCondition[]{
                     new ActionCondition(2, CoreActionComponent.STRING_STRING,

test/com/dmdirc/actions/ActionTest.java

 
 package com.dmdirc.actions;
 
+import com.dmdirc.GlobalWindow;
 import com.dmdirc.commandparser.parsers.GlobalCommandParser;
 import com.dmdirc.config.prefs.PreferencesSetting;
 import com.dmdirc.config.prefs.PreferencesType;
     @Rule public final TemporaryFolder folder = new TemporaryFolder();
 
     @Mock private Provider<GlobalCommandParser> gcpProvider;
+    @Mock private Provider<GlobalWindow> gwProvider;
     @Mock private ActionSubstitutorFactory substitutorFactory;
     @Mock private ActionController actionController;
     @Mock private ActionGroup actionGroup;
 
     @Test
     public void testSave() {
-        new Action(gcpProvider, substitutorFactory, actionController, identityController,
-                getTempDirectory(), "unit-test", "test1", new ActionType[0],
+        new Action(gcpProvider, gwProvider, substitutorFactory, actionController,
+                identityController, getTempDirectory(), "unit-test", "test1", new ActionType[0],
                 new String[0], new ArrayList<ActionCondition>(),
                 ConditionTree.createConjunction(0), null);
         assertTrue("Action constructor must create new file",
 
     @Test
     public void testSetGroup() {
-        Action action = new Action(gcpProvider, substitutorFactory, actionController,
+        Action action = new Action(gcpProvider, gwProvider, substitutorFactory, actionController,
                 identityController, getTempDirectory(),
                 "unit-test", "test1", new ActionType[0],
                 new String[0], new ArrayList<ActionCondition>(),
 
     @Test
     public void testSetName() {
-        Action action = new Action(gcpProvider, substitutorFactory, actionController,
+        Action action = new Action(gcpProvider, gwProvider, substitutorFactory, actionController,
                 identityController, getTempDirectory(),
                 "unit-test", "test1", new ActionType[0],
                 new String[0], new ArrayList<ActionCondition>(),
 
     @Test
     public void testDelete() {
-        Action action = new Action(gcpProvider, substitutorFactory, actionController,
+        Action action = new Action(gcpProvider, gwProvider, substitutorFactory, actionController,
                 identityController, getTempDirectory(),
                 "unit-test", "test1", new ActionType[0],
                 new String[0], new ArrayList<ActionCondition>(),
 
     @Test
     public void testRead() throws IOException, InvalidConfigFileException {
-        Action action = new Action(gcpProvider, substitutorFactory, actionController,
+        Action action = new Action(gcpProvider, gwProvider, substitutorFactory, actionController,
                 identityController, getTempDirectory(),
                 "unit-test", "doesn't_exist");
         action.config = new ConfigFile(getClass().getResourceAsStream("action1"));
 
     @Test
     public void testMultipleGroups() throws IOException, InvalidConfigFileException {
-        Action action = new Action(gcpProvider, substitutorFactory, actionController,
+        Action action = new Action(gcpProvider, gwProvider, substitutorFactory, actionController,
                 identityController, getTempDirectory(),
                 "unit-test", "doesn't_exist");
         action.config = new ConfigFile(getClass().getResourceAsStream("action_multisettings"));

test/com/dmdirc/commandparser/commands/global/IfpluginTest.java

 package com.dmdirc.commandparser.commands.global;
 
 import com.dmdirc.FrameContainer;
+import com.dmdirc.GlobalWindow;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.commands.context.CommandContext;
 import com.dmdirc.commandparser.parsers.GlobalCommandParser;
 import com.dmdirc.plugins.PluginManager;
 
 import javax.inject.Provider;
+
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.runners.MockitoJUnitRunner;
 
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.anyChar;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.verify;
 
 @RunWith(MockitoJUnitRunner.class)
 public class IfpluginTest {
 
+    @Mock private Provider<GlobalWindow> gwProvider;
     @Mock private Provider<GlobalCommandParser> gcpProvider;
     @Mock private CommandController controller;
     @Mock private PluginManager pluginManager;
 
     @Before
     public void setUp() {
-        command = new Ifplugin(controller, pluginManager, gcpProvider);
+        command = new Ifplugin(controller, pluginManager, gcpProvider, gwProvider);
     }
 
     @Test

test/com/dmdirc/commandparser/parsers/CommandParserTest.java

 
     @Test
     public void testParseCommandWithArguments() {
-        commandParser.parseCommand(null, "/command this is a test");
+        commandParser.parseCommand(container, "/command this is a test");
 
         assertNull(commandParser.nonCommandLine);
         assertNull(commandParser.invalidCommand);
 
     @Test
     public void testParseCommandWithoutArguments() {
-        commandParser.parseCommand(null, "/command");
+        commandParser.parseCommand(container, "/command");
 
         assertNull(commandParser.nonCommandLine);
         assertNull(commandParser.invalidCommand);
 
     @Test
     public void testParseSilentCommandWithoutArguments() {
-        commandParser.parseCommand(null, "/.command");
+        commandParser.parseCommand(container, "/.command");
 
         assertNull(commandParser.nonCommandLine);
         assertNull(commandParser.invalidCommand);
 
     @Test
     public void testParseSilentCommandWithArguments() {
-        commandParser.parseCommand(null, "/.command this is a test");
+        commandParser.parseCommand(container, "/.command this is a test");
 
         assertNull(commandParser.nonCommandLine);
         assertNull(commandParser.invalidCommand);
 
     @Test
     public void testParseUnknownCommand() {
-        commandParser.parseCommand(null, "/foobar moo bar");
+        commandParser.parseCommand(container, "/foobar moo bar");
 
         assertNull(commandParser.nonCommandLine);
         assertEquals("foobar", commandParser.invalidCommand);
 
     @Test
     public void testParseEmptyCommand() {
-        commandParser.parseCommand(null, "/ moo bar");
+        commandParser.parseCommand(container, "/ moo bar");
 
         assertNull(commandParser.nonCommandLine);
         assertEquals("", commandParser.invalidCommand);
 
     @Test
     public void testParseEmptySilenceCommand() {
-        commandParser.parseCommand(null, "/. moo bar");
+        commandParser.parseCommand(container, "/. moo bar");
 
         assertNull(commandParser.nonCommandLine);
         assertEquals("", commandParser.invalidCommand);
 
     @Test
     public void testParseNonCommand() {
-        commandParser.parseCommand(null, "Foobar baz");
+        commandParser.parseCommand(container, "Foobar baz");
 
         assertEquals("Foobar baz", commandParser.nonCommandLine);
         assertNull(commandParser.invalidCommand);
 
     @Test
     public void testGetCommandTime() {
-        commandParser.parseCommand(null, "/command this is a test");
+        commandParser.parseCommand(container, "/command this is a test");
 
         final long time1 = commandParser.getCommandTime("command this is a test");
         assertTrue(time1 > 0);
 
-        commandParser.parseCommand(null, "/command this is a test");
+        commandParser.parseCommand(container, "/command this is a test");
         final long time2 = commandParser.getCommandTime("command this is a test");
         assertTrue(time2 > 0);
         assertTrue(time2 >= time1);
     @Test
     public void testParseUnregisterCommand() {
         commandParser.unregisterCommand(commandInfo);
-        commandParser.parseCommand(null, "/command test 123");
+        commandParser.parseCommand(container, "/command test 123");
 
         assertNull(commandParser.nonCommandLine);
         assertEquals("command", commandParser.invalidCommand);