Pass in dependencies to ServerManager explicitly.

Avoid static/singleton references, and use a temporary Provider<>
implementation that will eventually be replaced by Dagger.

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

src/com/dmdirc/Main.java

 import java.util.Timer;
 import java.util.TimerTask;
 
+import javax.inject.Provider;
+
 /**
  * Main class, handles initialisation.
  */
     private final int FEEDBACK_DELAY = 30 * 60 * 1000;
 
     /** The UI to use for the client. */
-    private final Collection<UIController> CONTROLLERS = new HashSet<UIController>();
+    private final Collection<UIController> CONTROLLERS = new HashSet<>();
 
     /** The config dir to use for the client. */
     private String configdir;
         Thread.setDefaultUncaughtExceptionHandler(new DMDircExceptionHandler());
 
         IdentityManager.getIdentityManager().loadVersionIdentity();
-        serverManager = new ServerManager();
+        serverManager = new ServerManager(
+                new ParserFactoryProvider(),
+                IdentityManager.getIdentityManager());
         ActionManager.initActionManager(serverManager, IdentityManager.getIdentityManager());
 
         final CommandLineParser clp = new CommandLineParser(this, args);
         }
     }
 
+    /**
+     * Temporary class to lazily provide {@link ParserFactory}s.
+     */
+    private class ParserFactoryProvider implements Provider<ParserFactory> {
+
+        /** {@inheritDoc} */
+        @Override
+        public ParserFactory get() {
+            return new ParserFactory(pluginManager);
+        }
+    }
+
 }

src/com/dmdirc/ServerManager.java

 import com.dmdirc.commandparser.parsers.ServerCommandParser;
 import com.dmdirc.config.ConfigManager;
 import com.dmdirc.config.Identity;
-import com.dmdirc.config.IdentityManager;
+import com.dmdirc.interfaces.IdentityController;
 import com.dmdirc.interfaces.ServerFactory;
 import com.dmdirc.logger.ErrorLevel;
 import com.dmdirc.logger.Logger;
 import java.util.Set;
 import java.util.concurrent.CopyOnWriteArraySet;
 
+import javax.inject.Provider;
+
 /**
  * The ServerManager maintains a list of all servers, and provides methods to
  * search or iterate over them.
 public class ServerManager implements ServerFactory {
 
     /** All servers that currently exist. */
-    private final Set<Server> servers = new CopyOnWriteArraySet<Server>();
+    private final Set<Server> servers = new CopyOnWriteArraySet<>();
+
+    /** Provider of {@link ParserFactory}s for servers. */
+    private final Provider<ParserFactory> parserFactoryProvider;
+
+    /** The identity controller to use to find profiles. */
+    private final IdentityController identityController;
 
     /**
      * Creates a new instance of ServerManager.
+     *
+     * @param parserFactoryProvider The provider of {@link ParserFactory}s to give to servers.
+     * @param identityController The identity controller to use to find profiles.
      */
-    public ServerManager() {
+    public ServerManager(
+            final Provider<ParserFactory> parserFactoryProvider,
+            final IdentityController identityController) {
+        this.parserFactoryProvider = parserFactoryProvider;
+        this.identityController = identityController;
     }
 
     /** {@inheritDoc} */
                 this,
                 configManager,
                 new ServerCommandParser(configManager),
-                new ParserFactory(Main.mainInstance.getPluginManager()),
+                parserFactoryProvider.get(),
                 WindowManager.getWindowManager(),
                 AliasWrapper.getAliasWrapper(),
                 CommandManager.getCommandManager(),
      * @return A list of all servers
      */
     public List<Server> getServers() {
-        return new ArrayList<Server>(servers);
+        return new ArrayList<>(servers);
     }
 
     /**
      * @return A list of servers connected to the network
      */
     public List<Server> getServersByNetwork(final String network) {
-        final List<Server> res = new ArrayList<Server>();
+        final List<Server> res = new ArrayList<>();
 
         for (Server server : servers) {
             if (server.isNetwork(network)) {
      * @return A list of servers connected to the network
      */
     public List<Server> getServersByAddress(final String address) {
-        final List<Server> res = new ArrayList<Server>();
+        final List<Server> res = new ArrayList<>();
 
         for (Server server : servers) {
             if (server.getAddress().equalsIgnoreCase(address)) {
      * @since 0.6.3
      */
     public Server connectToAddress(final URI uri) {
-        return connectToAddress(uri, IdentityManager.getIdentityManager()
-                .getIdentitiesByType("profile").get(0));
+        return connectToAddress(uri,
+                identityController.getIdentitiesByType("profile").get(0));
     }
 
     /**
 
         if (connectedServer == null) {
             try {
-                connectToAddress(new URI("irc://irc.quakenet.org/DMDirc"),
-                        IdentityManager.getIdentityManager().getIdentitiesByType("profile").get(0));
+                connectToAddress(new URI("irc://irc.quakenet.org/DMDirc"));
             } catch (URISyntaxException ex) {
                 Logger.appError(ErrorLevel.MEDIUM, "Unable to construct new server", ex);
             }

test/com/dmdirc/ServerManagerTest.java

 
 package com.dmdirc;
 
+import com.dmdirc.interfaces.IdentityController;
 import com.dmdirc.parser.common.ChannelJoinRequest;
 
+import javax.inject.Provider;
+
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Ignore;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
 
 import static org.junit.Assert.*;
 import static org.mockito.Mockito.*;
 
+@RunWith(MockitoJUnitRunner.class)
 public class ServerManagerTest {
 
+    @Mock private IdentityController identityController;
+    @Mock private Provider<ParserFactory> parserFactoryProvider;
     private ServerManager serverManager;
 
     @Before
     public void setUp() throws Exception {
-        serverManager = new ServerManager();
+        serverManager = new ServerManager(parserFactoryProvider, identityController);
     }
 
     @After

test/com/dmdirc/TestMain.java

 import com.dmdirc.config.InvalidIdentityFileException;
 import com.dmdirc.plugins.PluginManager;
 
+import javax.inject.Provider;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
 /**
  * Main subclass to init things needed for testing.
  */
 public class TestMain extends Main {
     private static Main instance;
 
+    @Mock private Provider<ParserFactory> parserFactoryProvider;
+
     public TestMain() { }
 
     /** {@inheritDoc} */
     @Override
     public void init(final String[] args) {
+        MockitoAnnotations.initMocks(this);
+
         // TODO: Tests probably shouldn't rely on a config dir... Who knows
         //       what the user has done with their config.
         IdentityManager.getIdentityManager().loadVersionIdentity();
             // DON'T do anything to the user's configuration... (so no calls
             // to handleInvalidConfigFile(); here)
         }
-        serverManager = new ServerManager();
+        serverManager = new ServerManager(
+                parserFactoryProvider,
+                IdentityManager.getIdentityManager());
         ActionManager.initActionManager(serverManager, IdentityManager.getIdentityManager());
         pluginManager = new PluginManager(IdentityManager.getIdentityManager(), this);
         pluginManager.refreshPlugins();