Inject GlobalCommandParser, and tidying up.

Rename ActionFactory methods to be consistent with @Factory-generated ones.

Change-Id: Iafd20682f2fb0a166c6d7502443b56c3263da85d
Depends-On: Ifa75714ab3445634e61df3d99792cdef602d319e
Reviewed-on: http://gerrit.dmdirc.com/2899
Automatic-Compile: DMDirc Build Manager
Reviewed-by: Greg Holmes <greg@dmdirc.com>

ivy.xml

         <dependency org="ch.qos.logback" name="logback-classic" rev="1.+" conf="test->default" />
 
         <dependency org="org.projectlombok" name="lombok" rev="latest.integration" conf="main->default" />
-        <dependency org="com.dmdirc" name="annotations" rev="[0.3.2,)" conf="main->default" />
+        <dependency org="com.dmdirc" name="annotations" rev="[0.3.4,)" conf="main->default" />
 
         <dependency org="com.squareup.dagger" name="dagger" rev="1.1.+" conf="main->default" />
         <dependency org="com.squareup.dagger" name="dagger-compiler" rev="1.1.+" conf="main->default" />

src/com/dmdirc/GlobalWindow.java

 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.commandparser.parsers.CommandParser;
 import com.dmdirc.commandparser.parsers.GlobalCommandParser;
-import com.dmdirc.interfaces.CommandController;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.interfaces.config.ConfigChangeListener;
 import com.dmdirc.messages.MessageSinkManager;
         private final AggregateConfigProvider globalConfig;
         /** The factory to use to create tab completers. */
         private final TabCompleterFactory tabCompleterFactory;
-        /** The provider to use to retrieve a command controller. */
-        private final Provider<CommandController> commandControllerProvider;
         /** 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;
 
         /**
          * 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 commandControllerProvider The provider to use to retrieve a command controller.
          * @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.
          */
         @Inject
         public GlobalWindowManager(
                 @GlobalConfig final AggregateConfigProvider globalConfig,
                 final TabCompleterFactory tabCompleterFactory,
-                final Provider<CommandController> commandControllerProvider,
                 final Provider<WindowManager> windowManagerProvider,
-                final Provider<MessageSinkManager> messageSinkManagerProvider) {
+                final Provider<MessageSinkManager> messageSinkManagerProvider,
+                final Provider<GlobalCommandParser> globalCommandParserProvider) {
             this.globalConfig = globalConfig;
             this.tabCompleterFactory = tabCompleterFactory;
-            this.commandControllerProvider = commandControllerProvider;
             this.windowManagerProvider = windowManagerProvider;
             this.messageSinkManagerProvider = messageSinkManagerProvider;
+            this.globalCommandParserProvider = globalCommandParserProvider;
         }
 
         /** {@inheritDoc} */
                 if (globalConfig.getOptionBool("general", "showglobalwindow")) {
                     if (globalWindow == null) {
                         globalWindow = new GlobalWindow(globalConfig,
-                                new GlobalCommandParser(globalConfig,
-                                commandControllerProvider.get()),
+                                globalCommandParserProvider.get(),
                                 tabCompleterFactory,
                                 messageSinkManagerProvider.get());
                         windowManagerProvider.get().addWindow(globalWindow);

src/com/dmdirc/actions/Action.java

 
 package com.dmdirc.actions;
 
+import com.dmdirc.commandparser.parsers.GlobalCommandParser;
 import com.dmdirc.config.prefs.PreferencesSetting;
 import com.dmdirc.config.prefs.PreferencesType;
 import com.dmdirc.interfaces.ActionController;
 import java.util.List;
 import java.util.Map;
 
+import javax.inject.Provider;
+
 /**
  * Describes a single action.
  */
      * Creates a new instance of Action. The group and name specified must
      * be the group and name of a valid action already saved to disk.
      *
+     * @param globalCommandParserProvider Provider of global command parsers for triggering actions.
      * @param actionController The controller that owns this action.
      * @param identityController The controller to use to retrieve and update settings.
      * @param actionsDirectory The base directory to store actions in.
      * @param name The name of the action
      */
     public Action(
+            final Provider<GlobalCommandParser> globalCommandParserProvider,
             final ActionController actionController,
             final IdentityController identityController,
             final String actionsDirectory,
             final String group,
             final String name) {
-        super(group, name);
+        super(globalCommandParserProvider, 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 actionController The controller that owns this action.
      * @param identityController The controller to use to retrieve and update settings.
      * @param actionsDirectory The base directory to store actions in.
      * @param newFormat The new formatter to use
      */
     public Action(
+            final Provider<GlobalCommandParser> globalCommandParserProvider,
             final ActionController actionController,
             final IdentityController identityController,
             final String actionsDirectory,
             final List<ActionCondition> conditions,
             final ConditionTree conditionTree,
             final String newFormat) {
-        super(group, name, triggers, response, conditions, conditionTree, newFormat);
+        super(globalCommandParserProvider, group, name, triggers, response, conditions, conditionTree, newFormat);
 
         this.actionController = actionController;
         this.identityController = identityController;

src/com/dmdirc/actions/ActionFactory.java

 
 import com.dmdirc.commandline.CommandLineOptionsModule.Directory;
 import com.dmdirc.commandline.CommandLineOptionsModule.DirectoryType;
+import com.dmdirc.commandparser.parsers.GlobalCommandParser;
 import com.dmdirc.interfaces.ActionController;
 import com.dmdirc.interfaces.actions.ActionType;
 import com.dmdirc.interfaces.config.IdentityController;
 @Singleton
 public class ActionFactory {
 
+    /** Provider of global command parsers. */
+    private final Provider<GlobalCommandParser> globalCommandParserProvider;
     /** The controller that will own actions. */
     private final Provider<ActionController> actionController;
     /** The controller to use to retrieve and update settings. */
      *
      * @param actionController The controller that will own actions.
      * @param identityController The controller to use to retrieve and update settings.
+     * @param globalCommandParserProvider The global command parser to use for actions without windows.
      * @param actionsDirectory The base directory to store actions in.
      */
     @Inject
     public ActionFactory(
             final Provider<ActionController> actionController,
             final Provider<IdentityController> identityController,
+            final Provider<GlobalCommandParser> globalCommandParserProvider,
             @Directory(DirectoryType.ACTIONS) final String actionsDirectory) {
         this.actionController = actionController;
         this.identityController = identityController;
+        this.globalCommandParserProvider = globalCommandParserProvider;
         this.actionsDirectory = actionsDirectory;
     }
 
      * @param name The name of the action
      * @return A relevant action.
      */
-    public Action create(final String group, final String name) {
-        return new Action(actionController.get(), identityController.get(), actionsDirectory, group, name);
-    }
-
-    /**
-     * Creates a new instance of Action with the specified properties and saves
-     * it to disk.
-     *
-     * @param group The group the action belongs to
-     * @param name The name of the action
-     * @param triggers The triggers to use
-     * @param response The response to use
-     * @param conditions The conditions to use
-     * @param newFormat The new formatter to use
-     * @return A relevant action.
-     */
-    public Action create(final String group, final String name,
-            final ActionType[] triggers, final String[] response,
-            final List<ActionCondition> conditions, final String newFormat) {
-        return create(group, name, triggers, response, conditions,
-                ConditionTree.createConjunction(conditions.size()), newFormat);
+    public Action getAction(final String group, final String name) {
+        return new Action(globalCommandParserProvider, actionController.get(),
+                identityController.get(), actionsDirectory, group, name);
     }
 
     /**
      * @param newFormat The new formatter to use
      * @return A relevant action.
      */
-    public Action create(final String group, final String name,
+    public Action getAction(final String group, final String name,
             final ActionType[] triggers, final String[] response,
             final List<ActionCondition> conditions,
             final ConditionTree conditionTree, final String newFormat) {
-        return new Action(actionController.get(), identityController.get(), actionsDirectory, group,
+        return new Action(globalCommandParserProvider, actionController.get(),
+                identityController.get(), actionsDirectory, group,
                 name, triggers, response, conditions, conditionTree, newFormat);
     }
 

src/com/dmdirc/actions/ActionManager.java

         }
 
         for (File file : dir.listFiles()) {
-            factory.create(dir.getName(), file.getName());
+            factory.getAction(dir.getName(), file.getName());
         }
     }
 

src/com/dmdirc/actions/ActionModel.java

 import com.dmdirc.Precondition;
 import com.dmdirc.ServerManager;
 import com.dmdirc.WritableFrameContainer;
-import com.dmdirc.commandparser.CommandManager;
 import com.dmdirc.commandparser.parsers.CommandParser;
 import com.dmdirc.commandparser.parsers.GlobalCommandParser;
-import com.dmdirc.config.IdentityManager;
 import com.dmdirc.interfaces.actions.ActionType;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
+import javax.inject.Provider;
+
 /**
  * Represents the basic model of an action, and its triggering mechanism.
  * Saving and loading are handled by the Action class.
  */
 public class ActionModel {
 
+    /** Provider of global command parsers, for use when triggering window-less actions. */
+    private final Provider<GlobalCommandParser> globalCommandParserProvider;
+
     /** The group this action belongs to. */
     protected String group;
 
     /**
      * Creates a new instance of ActionModel with the specified properties.
      *
+     * @param globalCommandParserProvider Provider of global command parsers for triggering actions.
      * @param group The group the action belongs to
      * @param name The name of the action
      */
-    public ActionModel(final String group, final String name) {
+    public ActionModel(
+            final Provider<GlobalCommandParser> globalCommandParserProvider,
+            final String group,
+            final String name) {
+        this.globalCommandParserProvider = globalCommandParserProvider;
         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 group The group the action belongs to
      * @param name The name of the action
      * @param triggers The triggers to use
      * @param conditionTree The condition tree to use
      * @param newFormat The new formatter to use
      */
-    public ActionModel(final String group, final String name,
+    public ActionModel(
+            final Provider<GlobalCommandParser> globalCommandParserProvider,
+            final String group, final String name,
             final ActionType[] triggers, final String[] response,
             final List<ActionCondition> conditions,
             final ConditionTree conditionTree, final String newFormat) {
-        this(group, name);
+        this(globalCommandParserProvider, group, name);
         this.triggers = triggers.clone();
         this.response = response.clone();
         this.conditions = conditions;
         }
 
         if (container == null) {
-            cp = new GlobalCommandParser(IdentityManager.getIdentityManager()
-                    .getGlobalConfiguration(), CommandManager.getCommandManager());
+            cp = globalCommandParserProvider.get();
         } else {
             cp = container.getCommandParser();
         }

src/com/dmdirc/actions/wrappers/Alias.java

 import com.dmdirc.actions.Action;
 import com.dmdirc.actions.ActionCondition;
 import com.dmdirc.actions.ActionFactory;
+import com.dmdirc.actions.ConditionTree;
 import com.dmdirc.actions.CoreActionComparison;
 import com.dmdirc.actions.CoreActionComponent;
 import com.dmdirc.actions.CoreActionType;
      * @return A new action for this alias.
      */
     public Action createAction() {
-        return actionFactory.create(
+        return actionFactory.getAction(
                 AliasWrapper.GROUP_NAME,
                 getName(),
                 new ActionType[] {CoreActionType.UNKNOWN_COMMAND, },
                 getResponse(),
                 getArguments(),
+                ConditionTree.createConjunction(getArguments().size()),
                 "");
     }
 

src/com/dmdirc/actions/wrappers/PerformWrapper.java

 import com.dmdirc.actions.ActionFactory;
 import com.dmdirc.actions.ActionGroup;
 import com.dmdirc.actions.ActionManager;
+import com.dmdirc.actions.ConditionTree;
 import com.dmdirc.actions.CoreActionComparison;
 import com.dmdirc.actions.CoreActionComponent;
 import com.dmdirc.actions.CoreActionType;
                     CoreActionComparison.STRING_EQUALS, profile));
         }
 
-        return actionFactory.create(getName(), server + network
+        return actionFactory.getAction(getName(), server + network
                 + (profile == null ? "" : " - " + profile),
                 new ActionType[]{CoreActionType.SERVER_CONNECTED},
-                new String[0], conditions, null);
+                new String[0], conditions,
+                ConditionTree.createConjunction(conditions.size()), null);
     }
 
     /**

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

 import com.dmdirc.ui.input.TabCompleter;
 
 import javax.inject.Inject;
+import javax.inject.Provider;
 
 /**
  * The if plugin command allows the user to execute commands based on whether
     /** The plugin manager to use to query plugins. */
     private final PluginManager pluginManager;
 
+    /** Provider of global command parsers. */
+    private final Provider<GlobalCommandParser> globalCommandParserProvider;
+
     /**
      * 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.
      */
     @Inject
-    public Ifplugin(final CommandController controller, final PluginManager pluginManager) {
+    public Ifplugin(
+            final CommandController controller,
+            final PluginManager pluginManager,
+            final Provider<GlobalCommandParser> globalCommandParserProvider) {
         super(controller);
         this.pluginManager = pluginManager;
+        this.globalCommandParserProvider = globalCommandParserProvider;
     }
 
     /** {@inheritDoc} */
 
         if (result != negative) {
             if (origin == null) {
-                new GlobalCommandParser(origin.getConfigManager(), getController())
+                globalCommandParserProvider.get()
                         .parseCommand(null, args.getArgumentsAsString(1));
             } else {
                 ((WritableFrameContainer) origin).getCommandParser()

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

 
 package com.dmdirc.commandparser.parsers;
 
+import com.dmdirc.ClientModule;
 import com.dmdirc.FrameContainer;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandInfo;
 import com.dmdirc.logger.ErrorLevel;
 import com.dmdirc.logger.Logger;
 
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
 /**
  * The command parser used for global commands.
  */
+@Singleton
 public class GlobalCommandParser extends CommandParser {
 
     /**
      * @param configManager Config manager to read settings from
      * @param commandManager Command manager to load commands from
      */
-    public GlobalCommandParser(final AggregateConfigProvider configManager,
+    @Inject
+    public GlobalCommandParser(
+            @ClientModule.GlobalConfig final AggregateConfigProvider configManager,
             final CommandController commandManager) {
         super(configManager, commandManager);
     }

test/com/dmdirc/actions/ActionModelTest.java

 
 package com.dmdirc.actions;
 
+import com.dmdirc.commandparser.parsers.GlobalCommandParser;
 import com.dmdirc.interfaces.ActionController;
 import com.dmdirc.interfaces.actions.ActionType;
 
 import java.util.Arrays;
 import java.util.List;
 
+import javax.inject.Provider;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 @RunWith(MockitoJUnitRunner.class)
 public class ActionModelTest {
 
+    @Mock private Provider<GlobalCommandParser> gcpProvider;
     @Mock private ActionController actionController;
 
     @Test
     public void testConditions() {
-        final ActionModel model = new ActionModel("group", "name");
+        final ActionModel model = new ActionModel(gcpProvider, "group", "name");
 
         assertTrue("ActionModel must start with no conditions",
                 model.getConditions().isEmpty());
 
     @Test
     public void testTriggers() {
-        final ActionModel model = new ActionModel("group", "name");
+        final ActionModel model = new ActionModel(gcpProvider, "group", "name");
 
         assertNull("ActionModel must start with null triggers",
                 model.getTriggers());
 
     @Test
     public void testNewFormat() {
-        final ActionModel model = new ActionModel("group", "name");
+        final ActionModel model = new ActionModel(gcpProvider, "group", "name");
 
         assertNull("ActionModel must start with null format",
                 model.getNewFormat());
 
     @Test
     public void testResponse() {
-        final ActionModel model = new ActionModel("group", "name");
+        final ActionModel model = new ActionModel(gcpProvider, "group", "name");
 
         assertNull("ActionModel must start with null response",
                 model.getResponse());
 
     @Test
     public void testGroup() {
-        final ActionModel model = new ActionModel("group", "name");
+        final ActionModel model = new ActionModel(gcpProvider, "group", "name");
 
         assertEquals("ActionModel constructor must set group",
                 "group", model.getGroup());
 
     @Test
     public void testName() {
-        final ActionModel model = new ActionModel("group", "name");
+        final ActionModel model = new ActionModel(gcpProvider, "group", "name");
 
         assertEquals("ActionModel constructor must set name",
                 "name", model.getName());
 
     @Test
     public void testTest() {
-        final ActionModel model = new ActionModel("group", "name",
+        final ActionModel model = new ActionModel(gcpProvider, "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("group", "name",
+        final ActionModel model = new ActionModel(gcpProvider, "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.commandparser.parsers.GlobalCommandParser;
 import com.dmdirc.config.prefs.PreferencesSetting;
 import com.dmdirc.config.prefs.PreferencesType;
 import com.dmdirc.interfaces.ActionController;
 import java.util.HashMap;
 import java.util.Map;
 
+import javax.inject.Provider;
+
 import org.junit.After;
 import org.junit.Before;
 import org.junit.BeforeClass;
 @RunWith(MockitoJUnitRunner.class)
 public class ActionTest {
 
+    @Mock private Provider<GlobalCommandParser> gcpProvider;
     @Mock private ActionController actionController;
     @Mock private ActionGroup actionGroup;
     @Mock private IdentityController identityController;
 
     @Test
     public void testSave() {
-        new Action(actionController, identityController, testDirectory,
+        new Action(gcpProvider, actionController, identityController, testDirectory,
                 "unit-test", "test1", new ActionType[0],
                 new String[0], new ArrayList<ActionCondition>(),
                 ConditionTree.createConjunction(0), null);
 
     @Test
     public void testSetGroup() {
-        Action action = new Action(actionController, identityController, testDirectory,
+        Action action = new Action(gcpProvider, actionController, identityController, testDirectory,
                 "unit-test", "test1", new ActionType[0],
                 new String[0], new ArrayList<ActionCondition>(),
                 ConditionTree.createConjunction(0), null);
 
     @Test
     public void testSetName() {
-        Action action = new Action(actionController, identityController, testDirectory,
+        Action action = new Action(gcpProvider, actionController, identityController, testDirectory,
                 "unit-test", "test1", new ActionType[0],
                 new String[0], new ArrayList<ActionCondition>(),
                 ConditionTree.createConjunction(0), null);
 
     @Test
     public void testDelete() {
-        Action action = new Action(actionController, identityController, testDirectory,
+        Action action = new Action(gcpProvider, actionController, identityController, testDirectory,
                 "unit-test", "test1", new ActionType[0],
                 new String[0], new ArrayList<ActionCondition>(),
                 ConditionTree.createConjunction(0), null);
 
     @Test
     public void testRead() throws IOException, InvalidConfigFileException {
-        Action action = new Action(actionController, identityController, testDirectory,
+        Action action = new Action(gcpProvider, actionController, identityController, testDirectory,
                 "unit-test", "doesn't_exist");
         action.config = new ConfigFile(getClass().getResourceAsStream("action1"));
         action.config.read();
 
     @Test
     public void testMultipleGroups() throws IOException, InvalidConfigFileException {
-        Action action = new Action(actionController, identityController, testDirectory,
+        Action action = new Action(gcpProvider, actionController, identityController, testDirectory,
                 "unit-test", "doesn't_exist");
         action.config = new ConfigFile(getClass().getResourceAsStream("action_multisettings"));
         action.config.read();

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

 import com.dmdirc.FrameContainer;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.commands.context.CommandContext;
+import com.dmdirc.commandparser.parsers.GlobalCommandParser;
 import com.dmdirc.interfaces.CommandController;
 import com.dmdirc.plugins.PluginManager;
 
+import javax.inject.Provider;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 @RunWith(MockitoJUnitRunner.class)
 public class IfpluginTest {
 
+    @Mock private Provider<GlobalCommandParser> gcpProvider;
     @Mock private CommandController controller;
     @Mock private PluginManager pluginManager;
     @Mock private FrameContainer tiw;
 
     @Before
     public void setUp() {
-        command = new Ifplugin(controller, pluginManager);
+        command = new Ifplugin(controller, pluginManager, gcpProvider);
     }
 
     @Test