De-singleton + unit test

Change-Id: Iadcf92d4390034828d005a9c9e92d9a8ba189c99
Depends-On: I17790a0e71a6c004a088a6eb51332293b23062a4
Reviewed-on: http://gerrit.dmdirc.com/2455
Automatic-Compile: DMDirc Build Manager
Reviewed-by: Chris Smith <chris@dmdirc.com>

src/com/dmdirc/GlobalWindow.java

             if (configManager.getOptionBool("general", "showglobalwindow")) {
                 if (globalWindow == null) {
                     globalWindow = new GlobalWindow(configManager,
-                            GlobalCommandParser.getGlobalCommandParser());
+                            new GlobalCommandParser(configManager,
+                            CommandManager.getCommandManager()));
                 }
             } else {
                 if (globalWindow != null) {

src/com/dmdirc/Raw.java

      */
     public Raw(final Server newServer) {
         super("raw", "Raw", "(Raw log)", newServer.getConfigManager(),
-                new ServerCommandParser(),
+                new ServerCommandParser(newServer.getConfigManager()),
                 Arrays.asList(WindowComponent.TEXTAREA.getIdentifier(),
                 WindowComponent.INPUTFIELD.getIdentifier()));
 

src/com/dmdirc/Server.java

     public Server(final URI uri, final Identity profile) {
         super("server-disconnected", getHost(uri), getHost(uri),
                 new ConfigManager(uri.getScheme(), "", "", uri.getHost()),
-                new ServerCommandParser(),
+                new ServerCommandParser(
+                new ConfigManager(uri.getScheme(), "", "", uri.getHost())),
                 Arrays.asList(WindowComponent.TEXTAREA.getIdentifier(),
                 WindowComponent.INPUTFIELD.getIdentifier(),
                 WindowComponent.CERTIFICATE_VIEWER.getIdentifier()));

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;
         }
 
         WritableFrameContainer container = null;
-        CommandParser cp = null;
+        CommandParser cp;
 
         if (arguments.length > 0
                 && arguments[0] instanceof WritableFrameContainer) {
         }
 
         if (container == null) {
-            cp = GlobalCommandParser.getGlobalCommandParser();
+            cp = new GlobalCommandParser(IdentityManager.getIdentityManager()
+                    .getGlobalConfiguration(), CommandManager.getCommandManager());
         } else {
             cp = container.getCommandParser();
         }

src/com/dmdirc/commandparser/CommandArguments.java

         this.line = line;
     }
 
-   /**
+    /**
      * Creates a new command arguments parser for the specified words.
      *
      * @param words The words which form the line ot be parsed

src/com/dmdirc/commandparser/CommandManager.java

 public class CommandManager implements CommandController {
 
     /** A singleton instance of the command manager. */
-    private static final CommandManager INSTANCE
-            = new CommandManager(IdentityManager.getIdentityManager().getGlobalConfiguration());
+    private static CommandManager instance;
 
     /** A list of commands that have been instantiated. */
     private final Map<CommandInfo, Command> commands
      *
      * @return A singleton instance of the CommandManager.
      */
-    public static CommandManager getCommandManager() {
-        return INSTANCE;
+    public static synchronized CommandManager getCommandManager() {
+        if (instance == null) {
+            instance = new CommandManager(IdentityManager.getIdentityManager()
+                    .getGlobalConfiguration());
+        }
+        return instance;
     }
 
 }

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

 import com.dmdirc.commandparser.commands.flags.CommandFlag;
 import com.dmdirc.commandparser.commands.flags.CommandFlagHandler;
 import com.dmdirc.commandparser.commands.flags.CommandFlagResult;
+import com.dmdirc.interfaces.CommandController;
 import com.dmdirc.ui.WindowManager;
 import com.dmdirc.ui.input.AdditionalTabTargets;
 
         handler = new CommandFlagHandler(timeStampFlag, targetFlag);
     }
 
+    /**
+     * Creates a new instance of Echo.
+     *
+     * @param controller Command controller
+     */
+    public Echo(final CommandController controller) {
+        super(controller);
+
+        handler = new CommandFlagHandler(timeStampFlag, targetFlag);
+    }
+
     /** {@inheritDoc} */
     @Override
     public void execute(final FrameContainer origin,

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

 import com.dmdirc.commandparser.BaseCommandInfo;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandInfo;
+import com.dmdirc.commandparser.CommandManager;
 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.commandparser.commands.Command;
 import com.dmdirc.commandparser.commands.IntelligentCommand;
 
         if (result != negative) {
             if (origin == null) {
-                GlobalCommandParser.getGlobalCommandParser().parseCommand(null,
-                        args.getArgumentsAsString(1));
+                new GlobalCommandParser(origin.getConfigManager(),
+                        CommandManager.getCommandManager()).parseCommand(
+                        null, args.getArgumentsAsString(1));
             } else {
                 ((WritableFrameContainer) origin).getCommandParser()
                         .parseCommand(origin, args.getArgumentsAsString(1));

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

      * @param server The server which owns this parser's container
      */
     public ChatCommandParser(final Server server) {
+        super(server.getConfigManager());
         super.setOwner(server);
     }
 

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

 import com.dmdirc.commandparser.commands.CommandOptions;
 import com.dmdirc.commandparser.commands.ExternalCommand;
 import com.dmdirc.commandparser.commands.PreviousCommand;
-import com.dmdirc.config.IdentityManager;
+import com.dmdirc.config.ConfigManager;
 import com.dmdirc.util.collections.RollingList;
 
 import java.io.Serializable;
 import java.util.HashMap;
 import java.util.Map;
 
+import lombok.Getter;
+
 /**
  * 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
     private final RollingList<PreviousCommand> history;
 
     /** Command manager to use. */
-    protected final CommandManager commandManager = CommandManager.getCommandManager();
+    @Getter
+    protected final CommandManager commandManager;
 
     /** Creates a new instance of CommandParser. */
-    protected CommandParser() {
+    protected CommandParser(final ConfigManager configManager,
+            final CommandManager commandManager) {
         commands = new HashMap<String, CommandInfoPair>();
-        history = new RollingList<PreviousCommand>(IdentityManager
-                .getIdentityManager().getGlobalConfiguration()
+        history = new RollingList<PreviousCommand>(configManager
                 .getOptionInt("general", "commandhistory"));
+        this.commandManager = commandManager;
         loadCommands();
     }
 
      */
     public final void parseCommand(final FrameContainer origin,
             final String line, final boolean parseChannel) {
-        final CommandArguments args = new CommandArguments(line);
+        final CommandArguments args = new CommandArguments(getCommandManager(), line);
 
         if (args.isCommand()) {
             if (handleChannelCommand(origin, args, parseChannel)) {

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

 import com.dmdirc.FrameContainer;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandInfo;
+import com.dmdirc.commandparser.CommandManager;
 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.commandparser.commands.Command;
 import com.dmdirc.commandparser.commands.context.CommandContext;
+import com.dmdirc.config.ConfigManager;
 import com.dmdirc.logger.ErrorLevel;
 import com.dmdirc.logger.Logger;
 
     private static final long serialVersionUID = 1;
 
     /**
-     * The singleton instance of this command parser.
+     * Creates a new command parser for global commands.
+     *
+     * @param configManager Config manager to read settings from
+     * @param commandManager Command manager to load commands from
      */
-    private static GlobalCommandParser me;
+    public GlobalCommandParser(final ConfigManager configManager,
+            final CommandManager commandManager) {
+        super(configManager, commandManager);
+    }
 
     /** {@inheritDoc} */
     @Override
         // Don't care
     }
 
-    /**
-     * Retrieves a singleton instance of the global command parser.
-     * @return A GlobalCommandParser
-     */
-    public static synchronized GlobalCommandParser getGlobalCommandParser() {
-        if (me == null) {
-            me = new GlobalCommandParser();
-        }
-
-        return me;
-    }
-
     /** Loads the relevant commands into the parser. */
     @Override
     protected void loadCommands() {

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

 import com.dmdirc.ServerState;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandInfo;
+import com.dmdirc.commandparser.CommandManager;
 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.commandparser.commands.Command;
 import com.dmdirc.commandparser.commands.context.ServerCommandContext;
+import com.dmdirc.config.ConfigManager;
 
 /**
  * A command parser used in the context of a server.
      */
     private static final long serialVersionUID = 1;
 
+    /**
+     * Creates a new command parser for server commands.
+     *
+     * @param configManager Config manager to read settings from
+     */
+    public ServerCommandParser(final ConfigManager configManager) {
+        super(configManager, CommandManager.getCommandManager());
+    }
+
     /**
      * The server instance that this parser is attached to.
      */

test/com/dmdirc/WritableFrameContainerTest.java

 
 package com.dmdirc;
 
-import com.dmdirc.config.IdentityManager;
+import com.dmdirc.commandparser.CommandManager;
+import com.dmdirc.config.ConfigBinder;
+import com.dmdirc.config.ConfigManager;
 import com.dmdirc.config.InvalidIdentityFileException;
 import com.dmdirc.harness.TestWritableFrameContainer;
 
 import java.util.Arrays;
 
-import org.junit.BeforeClass;
+import org.junit.Before;
 import org.junit.Test;
 
 import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
 
 public class WritableFrameContainerTest {
 
-    @BeforeClass
-    public static void setupClass() throws InvalidIdentityFileException {
-        IdentityManager.getIdentityManager().initialise();
+    private ConfigManager cm;
+    private CommandManager commands;
+
+    @Before
+    public void setup() throws InvalidIdentityFileException {
+        cm = mock(ConfigManager.class);
+        when(cm.getOption("general", "silencechar")).thenReturn(".");
+        when(cm.getOption("general", "commandchar")).thenReturn("/");
+        final ConfigBinder binder = new ConfigBinder(cm);
+        when(cm.getBinder()).thenReturn(binder);
+        commands = new CommandManager(cm);
     }
 
     @Test
     public void testGetNumLines() {
         final WritableFrameContainer container10
-                = new TestWritableFrameContainer(10);
+                = new TestWritableFrameContainer(10, cm, commands);
 
         final int res0a = container10.getNumLines("");
         final int res0b = container10.getNumLines("\r");
     @Test
     public void testSplitLine() {
         final WritableFrameContainer container10
-                = new TestWritableFrameContainer(10);
+                = new TestWritableFrameContainer(10, cm, commands);
         final String[][][] tests = new String[][][]{
             {{""}, {""}},
             {{"0123456789"}, {"0123456789"}},

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

 
 import com.dmdirc.commandparser.CommandManager;
 import com.dmdirc.commandparser.commands.global.Echo;
-import com.dmdirc.config.IdentityManager;
+import com.dmdirc.config.ConfigBinder;
+import com.dmdirc.config.ConfigManager;
+import com.dmdirc.config.InvalidIdentityFileException;
 import com.dmdirc.harness.TestCommandParser;
 
-import org.junit.BeforeClass;
+import org.junit.Before;
 import org.junit.Test;
 
 import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
 
 public class CommandParserTest {
 
-    @BeforeClass
-    public static void setUpClass() throws Exception {
-        IdentityManager.getIdentityManager().initialise();
-        CommandManager.getCommandManager().registerCommand(new Echo(), Echo.INFO);
+    private ConfigManager cm;
+    private CommandManager commands;
+
+    @Before
+    public void setup() throws InvalidIdentityFileException {
+        cm = mock(ConfigManager.class);
+        when(cm.getOptionChar("general", "silencechar")).thenReturn('.');
+        when(cm.getOptionInt("general", "commandhistory")).thenReturn(10);
+        when(cm.getOptionChar("general", "commandchar")).thenReturn('/');
+        final ConfigBinder binder = new ConfigBinder(cm);
+        when(cm.getBinder()).thenReturn(binder);
+        commands = new CommandManager(cm);
+        commands.registerCommand(new Echo(commands), Echo.INFO);
     }
 
     @Test
     public void testBasicCommand() {
-        final TestCommandParser tcp = new TestCommandParser();
+        final TestCommandParser tcp = new TestCommandParser(cm, commands);
         tcp.parseCommand(null, "/echo this is a test");
 
         assertNull(tcp.nonCommandLine);
 
     @Test
     public void testBasicNoArgs() {
-        final TestCommandParser tcp = new TestCommandParser();
+        final TestCommandParser tcp = new TestCommandParser(cm, commands);
         tcp.parseCommand(null, "/echo");
 
         assertNull(tcp.nonCommandLine);
 
     @Test
     public void testSilentNoArgs() {
-        final TestCommandParser tcp = new TestCommandParser();
+        final TestCommandParser tcp = new TestCommandParser(cm, commands);
         tcp.parseCommand(null, "/.echo");
 
         assertNull(tcp.nonCommandLine);
 
     @Test
     public void testSilentCommand() {
-        final TestCommandParser tcp = new TestCommandParser();
+        final TestCommandParser tcp = new TestCommandParser(cm, commands);
         tcp.parseCommand(null, "/.echo this is a test");
 
         assertNull(tcp.nonCommandLine);
 
     @Test
     public void testNonExistantCommand() {
-        final TestCommandParser tcp = new TestCommandParser();
+        final TestCommandParser tcp = new TestCommandParser(cm, commands);
         tcp.parseCommand(null, "/foobar moo bar");
 
         assertNull(tcp.nonCommandLine);
 
     @Test
     public void testEmptyCommand() {
-        final TestCommandParser tcp = new TestCommandParser();
+        final TestCommandParser tcp = new TestCommandParser(cm, commands);
         tcp.parseCommand(null, "/ moo bar");
 
         assertNull(tcp.nonCommandLine);
 
     @Test
     public void testEmptySilentCommand() {
-        final TestCommandParser tcp = new TestCommandParser();
+        final TestCommandParser tcp = new TestCommandParser(cm, commands);
         tcp.parseCommand(null, "/. moo bar");
 
         assertNull(tcp.nonCommandLine);
 
     @Test
     public void testNonCommand() {
-        final TestCommandParser tcp = new TestCommandParser();
+        final TestCommandParser tcp = new TestCommandParser(cm, commands);
         tcp.parseCommand(null, "Foobar baz");
 
         assertNotNull(tcp.nonCommandLine);
 
     @Test
     public void testCommandHistory() {
-        final TestCommandParser tcp = new TestCommandParser();
+        final TestCommandParser tcp = new TestCommandParser(cm, commands);
         tcp.parseCommand(null, "/echo this is a test");
 
         final long time1 = tcp.getCommandTime("echo this is a test");

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

-/*
- * Copyright (c) 2006-2012 DMDirc Developers
- *
- * 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.parsers;
-
-import com.dmdirc.config.IdentityManager;
-
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class GlobalCommandParserTest {
-
-    @BeforeClass
-    public static void setUp() throws Exception {
-        IdentityManager.getIdentityManager().initialise();
-    }
-
-    @Test
-    public void testGetGlobalCommandParser() {
-        final GlobalCommandParser p1 = GlobalCommandParser.getGlobalCommandParser();
-
-        final GlobalCommandParser p2 = GlobalCommandParser.getGlobalCommandParser();
-
-        assertSame(p1, p2);
-    }
-
-}

test/com/dmdirc/harness/TestCommandParser.java

 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.commandparser.commands.Command;
 import com.dmdirc.commandparser.parsers.*;
+import com.dmdirc.config.ConfigManager;
+
+import lombok.ToString;
 
 public class TestCommandParser extends CommandParser {
     private static final long serialVersionUID = 7073002401375438532L;
 
+    private final ConfigManager configManager;
+
     public String nonCommandLine;
 
     public Command executedCommand;
 
     public String invalidCommand;
 
+    public TestCommandParser(final ConfigManager configManager,
+            final CommandManager commandManager) {
+        super(configManager, commandManager);
+        this.configManager = configManager;
+    }
+
     @Override
     protected void loadCommands() {
-        CommandManager.getCommandManager().loadCommands(this, CommandType.TYPE_GLOBAL);
+        commandManager.loadCommands(this, CommandType.TYPE_GLOBAL);
     }
 
     @Override

test/com/dmdirc/harness/TestWritableFrameContainer.java

 
 import com.dmdirc.Server;
 import com.dmdirc.WritableFrameContainer;
+import com.dmdirc.commandparser.CommandManager;
 import com.dmdirc.commandparser.parsers.GlobalCommandParser;
 import com.dmdirc.config.ConfigManager;
-import com.dmdirc.config.IdentityManager;
 import com.dmdirc.ui.input.TabCompleter;
 
 import java.util.Collections;
     private final int lineLength;
 
     public TestWritableFrameContainer(final int lineLength,
-            final ConfigManager cm) {
+            final ConfigManager cm, final CommandManager commandManager) {
         super("raw", "Raw", "(Raw)", cm,
-                GlobalCommandParser.getGlobalCommandParser(),
+                new GlobalCommandParser(cm, commandManager),
                 Collections.<String>emptySet());
 
         this.lineLength = lineLength;
     }
 
-    public TestWritableFrameContainer(final int lineLength) {
-        this(lineLength, IdentityManager.getIdentityManager().getGlobalConfiguration());
-    }
-
     @Override
     public void sendLine(final String line) {
         // Do nothing
 
     @Override
     public void windowClosing() {
-        System.out.println("windowClosing");
+        // Do nothing
     }
 
     @Override
     public void windowClosed() {
-        // DO nothing
+        // Do nothing
     }
 
     @Override

test/com/dmdirc/ui/WindowManagerTest.java

 import com.dmdirc.CustomWindow;
 import com.dmdirc.FrameContainer;
 import com.dmdirc.addons.ui_dummy.DummyInputWindow;
-import com.dmdirc.config.IdentityManager;
+import com.dmdirc.commandparser.CommandManager;
+import com.dmdirc.config.ConfigBinder;
+import com.dmdirc.config.ConfigManager;
 import com.dmdirc.config.InvalidIdentityFileException;
 import com.dmdirc.harness.TestWritableFrameContainer;
 import com.dmdirc.interfaces.ui.FrameListener;
 import java.util.Arrays;
 import java.util.Collection;
 
-import org.junit.BeforeClass;
+import org.junit.Before;
 import org.junit.Test;
 
 import static org.junit.Assert.*;
 
 public class WindowManagerTest {
 
-    @BeforeClass
-    public static void setupClass() throws InvalidIdentityFileException {
-        IdentityManager.getIdentityManager().initialise();
+    private ConfigManager cm;
+    private CommandManager commands;
+
+    @Before
+    public void setup() throws InvalidIdentityFileException {
+        cm = mock(ConfigManager.class);
+        final ConfigBinder binder = new ConfigBinder(cm);
+        when(cm.getBinder()).thenReturn(binder);
+        commands = new CommandManager(cm);
     }
 
     @Test
     public void testAddRoot() {
         final WindowManager manager = new WindowManager();
         final FrameListener tfm = mock(FrameListener.class);
-        final Window parent = new DummyInputWindow(new TestWritableFrameContainer(512));
+        final Window parent = new DummyInputWindow(new TestWritableFrameContainer(512, cm, commands));
 
         manager.addListener(tfm);
 
     public void testAddChild() {
         final WindowManager manager = new WindowManager();
         final FrameListener tfm = mock(FrameListener.class);
-        final Window parent = new DummyInputWindow(new TestWritableFrameContainer(512));
-        final Window child = new DummyInputWindow(new TestWritableFrameContainer(512));
+        final Window parent = new DummyInputWindow(new TestWritableFrameContainer(512, cm, commands));
+        final Window child = new DummyInputWindow(new TestWritableFrameContainer(512, cm, commands));
         manager.addWindow(parent.getContainer());
         manager.addListener(tfm);
 
     public void testRemoveRoot() {
         final WindowManager manager = new WindowManager();
         final FrameListener tfm = mock(FrameListener.class);
-        final Window parent = new DummyInputWindow(new TestWritableFrameContainer(512));
+        final Window parent = new DummyInputWindow(new TestWritableFrameContainer(512, cm, commands));
         manager.addWindow(parent.getContainer());
         manager.addListener(tfm);
 
     public void testRemoveChild() {
         final WindowManager manager = new WindowManager();
         final FrameListener tfm = mock(FrameListener.class);
-        final Window parent = new DummyInputWindow(new TestWritableFrameContainer(512));
-        final Window child = new DummyInputWindow(new TestWritableFrameContainer(512));
+        final Window parent = new DummyInputWindow(new TestWritableFrameContainer(512, cm, commands));
+        final Window child = new DummyInputWindow(new TestWritableFrameContainer(512, cm, commands));
         manager.addWindow(parent.getContainer());
         manager.addWindow(parent.getContainer(), child.getContainer());
         manager.addListener(tfm);
     public void testRemoveFrameManager() {
         final WindowManager manager = new WindowManager();
         final FrameListener tfm = mock(FrameListener.class);
-        final Window parent = new DummyInputWindow(new TestWritableFrameContainer(512));
-        final Window child = new DummyInputWindow(new TestWritableFrameContainer(512));
+        final Window parent = new DummyInputWindow(new TestWritableFrameContainer(512, cm, commands));
+        final Window child = new DummyInputWindow(new TestWritableFrameContainer(512, cm, commands));
         manager.addWindow(parent.getContainer());
 
         manager.addListener(tfm);