Change some more files to paths.

The updater code is horrid. In most cases I've just bailed out by
converting to a file.

Issue #24

src/com/dmdirc/ui/core/feedback/CoreFeedbackDialogModel.java

 
 import com.google.common.base.Optional;
 
+import java.nio.file.Path;
+
 import javax.inject.Inject;
 
 /**
     private final ListenerList listeners;
     private final AggregateConfigProvider config;
     private final ConnectionManager connectionManager;
-    private final String configDirectory;
+    private final Path configDirectory;
     private Optional<String> name;
     private Optional<String> email;
     private Optional<String> feedback;
     @Inject
     public CoreFeedbackDialogModel(@ClientModule.GlobalConfig final AggregateConfigProvider config,
             final ConnectionManager connectionManager, final FeedbackSenderFactory feedbackSenderFactory,
-            @Directory(DirectoryType.BASE) final String configDirectory) {
+            @Directory(DirectoryType.BASE) final Path configDirectory) {
         this.connectionManager = connectionManager;
         this.configDirectory = configDirectory;
         this.feedbackSenderFactory = feedbackSenderFactory;

src/com/dmdirc/updater/UpdateComponent.java

 
 package com.dmdirc.updater;
 
+import java.nio.file.Path;
+
 /**
  * The update component interface defines the methods needed to be implemented by updatable
  * components. The components handle determining the current version and installing updated files.
 
     /**
      * Provisionally indicates if this component will require a client restart. The result of
-     * {@link #doInstall(java.lang.String)} ultimately decides if the client requires a restart.
+     * {@link #doInstall(Path)} ultimately decides if the client requires a restart.
      *
      * @return True if the client requires a restart
      *
      *
      * @since 0.6.4
      */
-    String getManualInstructions(final String path);
+    String getManualInstructions(final Path path);
 
     /**
      * Installs the updated version of this component. After the update has been installed, the
      *
      * @throws java.lang.Exception If any error occurred
      */
-    boolean doInstall(String path) throws Exception; //NOPMD
+    boolean doInstall(Path path) throws Exception; //NOPMD
 
 }

src/com/dmdirc/updater/components/ActionGroupComponent.java

 import com.dmdirc.updater.Version;
 
 import java.io.IOException;
-import java.nio.file.Paths;
+import java.nio.file.Path;
 
 /**
  * Update component for action groups.
     }
 
     @Override
-    public String getManualInstructions(final String path) {
+    public String getManualInstructions(final Path path) {
         return "";
     }
 
     @Override
-    public boolean doInstall(final String path) throws IOException {
-        ActionManager.installActionPack(Paths.get(path));
+    public boolean doInstall(final Path path) throws IOException {
+        ActionManager.installActionPack(path);
         return false;
     }
 

src/com/dmdirc/updater/components/ClientComponent.java

 package com.dmdirc.updater.components;
 
 import com.dmdirc.Main;
+import com.dmdirc.commandline.CommandLineOptionsModule.Directory;
+import com.dmdirc.commandline.CommandLineOptionsModule.DirectoryType;
 import com.dmdirc.interfaces.config.IdentityController;
 import com.dmdirc.ui.StatusMessage;
 import com.dmdirc.ui.core.components.StatusBarManager;
 import com.dmdirc.updater.Version;
 import com.dmdirc.util.io.FileUtils;
 
-import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
 
 import javax.inject.Inject;
 
     private final IdentityController identityController;
     /** The manager to add status bar messages to. */
     private final StatusBarManager statusBarManager;
+    /** Base directory to move updates to. */
+    private final Path baseDirectory;
 
     /**
      * Creates a new instance of {@link ClientComponent}.
     @Inject
     public ClientComponent(
             final IdentityController identityController,
-            final StatusBarManager statusBarManager) {
+            final StatusBarManager statusBarManager,
+            @Directory(DirectoryType.BASE) final Path baseDirectory) {
         this.identityController = identityController;
         this.statusBarManager = statusBarManager;
+        this.baseDirectory = baseDirectory;
     }
 
     @Override
     }
 
     @Override
-    public String getManualInstructions(final String path) {
-        final File targetFile = new File(new File(path).getParent()
-                + File.separator + ".DMDirc.jar");
+    public String getManualInstructions(final Path path) {
+        final Path targetFile = baseDirectory.resolve(".DMDirc.jar");
 
         if (requiresManualInstall()) {
             if (FileUtils.isRunningFromJar(Main.class)) {
                         + "not be installed automatically.\n\n"
                         + "To install this update manually, please replace the\n"
                         + "existing DMDirc.jar file, located at:\n"
-                        + " " + FileUtils.getApplicationPath(Main.class)
+                        + ' ' + FileUtils.getApplicationPath(Main.class)
                         + "\n with the following file:\n "
-                        + targetFile.getAbsolutePath();
+                        + targetFile.toAbsolutePath();
             } else {
                 return "A new version of DMDirc has been downloaded, but as you\n"
                         + "do not seem to be using the DMDirc launcher, it will\n"
                         + "not be installed automatically.\n\n"
                         + "To install this update manually, please extract the\n"
                         + "new DMDirc.jar file, located at:\n"
-                        + " " + targetFile.getAbsolutePath() + "\n"
+                        + ' ' + targetFile.toAbsolutePath() + '\n'
                         + "over your existing DMDirc install located in:\n"
                         + "  " + FileUtils.getApplicationPath(Main.class);
             }
     }
 
     @Override
-    public boolean doInstall(final String path) {
-        final File tmpFile = new File(path);
-        final File targetFile = new File(tmpFile.getParent() + File.separator
-                + ".DMDirc.jar");
+    public boolean doInstall(final Path path) throws IOException {
+        final Path targetFile = baseDirectory.resolve(".DMDirc.jar");
 
-        if (targetFile.exists()) {
-            targetFile.delete();
-        }
-
-        tmpFile.renameTo(targetFile);
+        Files.deleteIfExists(targetFile);
+        Files.move(path, targetFile);
 
         if (requiresManualInstall()) {
             // @deprecated Should be removed when updater UI changes are
             // implemented.
-            final String message = this.getManualInstructions(path);
+            final String message = getManualInstructions(path);
             statusBarManager.setMessage(new StatusMessage(message,
                     identityController.getGlobalConfiguration()));
         }

src/com/dmdirc/updater/components/DefaultsComponent.java

 import com.dmdirc.updater.Version;
 import com.dmdirc.util.resourcemanager.ZipResourceManager;
 
-import java.io.File;
 import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
 
 import javax.inject.Inject;
 
     }
 
     @Override
-    public String getManualInstructions(final String path) {
+    public String getManualInstructions(final Path path) {
         return "";
     }
 
     @Override
-    public boolean doInstall(final String path) throws IOException {
-        final ZipResourceManager ziprm = ZipResourceManager.getInstance(path);
+    public boolean doInstall(final Path path) throws IOException {
+        final ZipResourceManager ziprm =
+                ZipResourceManager.getInstance(path.toAbsolutePath().toString());
 
         ziprm.extractResources("", directory);
 
         identityController.loadUserIdentities();
 
-        new File(path).delete();
+        Files.delete(path);
 
         return false;
     }

src/com/dmdirc/updater/components/LauncherComponent.java

 
 import java.io.File;
 import java.io.IOException;
+import java.nio.file.Path;
 
 /**
  * Component for updates of DMDirc's launcher.
     }
 
     @Override
-    public String getManualInstructions(final String path) {
+    public String getManualInstructions(final Path path) {
         return "";
     }
 
     @Override
-    public boolean doInstall(final String path) throws IOException {
-        final File tmpFile = new File(path);
+    public boolean doInstall(final Path path) throws IOException {
+        final File tmpFile = path.toFile();
         if (platform.equalsIgnoreCase("Linux")
                 || platform.equalsIgnoreCase("unix")) {
             final File targetFile = new File(tmpFile.getParent()
             targetFile.setExecutable(true);
 
         } else {
-            ZipResourceManager.getInstance(path).extractResources("",
-                    tmpFile.getParent() + File.separator);
-            new File(path).delete();
+            ZipResourceManager.getInstance(path.toAbsolutePath().toString())
+                    .extractResources("", tmpFile.getParent() + File.separator);
+            path.toFile().delete();
         }
         return true;
     }

src/com/dmdirc/updater/components/ModeAliasesComponent.java

 import com.dmdirc.updater.Version;
 import com.dmdirc.util.resourcemanager.ZipResourceManager;
 
-import java.io.File;
 import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
 
 import javax.inject.Inject;
 
     }
 
     @Override
-    public String getManualInstructions(final String path) {
+    public String getManualInstructions(final Path path) {
         return "";
     }
 
     @Override
-    public boolean doInstall(final String path) throws IOException {
-        final ZipResourceManager ziprm = ZipResourceManager.getInstance(path);
+    public boolean doInstall(final Path path) throws IOException {
+        final ZipResourceManager ziprm =
+                ZipResourceManager.getInstance(path.toAbsolutePath().toString());
 
         ziprm.extractResources("", directory);
 
         identityController.loadUserIdentities();
 
-        new File(path).delete();
+        Files.delete(path);
 
         return false;
     }

src/com/dmdirc/updater/components/PluginComponent.java

 
 import java.io.File;
 import java.io.IOException;
+import java.nio.file.Path;
 import java.util.zip.ZipFile;
 
 /**
     }
 
     @Override
-    public String getManualInstructions(final String path) {
+    public String getManualInstructions(final Path path) {
         return "";
     }
 
     @Override
-    public boolean doInstall(final String path) {
+    public boolean doInstall(final Path path) {
         final File target = new File(plugin.getMetaData().getPluginUrl().getPath());
 
         boolean returnCode = false;
         // Try and move the downloaded plugin to the new location.
         // If it doesn't work then keep the plugin in a .update file until the next restart.
         // If it does, update the metadata.
-        final File newPlugin = new File(path);
+        final File newPlugin = path.toFile();
         if (!isValid(newPlugin)) {
             return false;
         }
                 newTarget.delete();
             }
 
-            new File(path).renameTo(newTarget);
+            path.toFile().renameTo(newTarget);
             returnCode = true;
         } else {
             try {

src/com/dmdirc/updater/installing/LegacyInstallationStrategy.java

 
 import javax.inject.Inject;
 
+import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 /**
  * An {@link UpdateInstallationStrategy} which uses the old
- * {@link UpdateComponent#doInstall(java.lang.String)} methods to perform installation.
+ * {@link UpdateComponent#doInstall(java.nio.file.Path)} methods to perform installation.
  */
 public class LegacyInstallationStrategy extends TypeSensitiveInstallationStrategy<UpdateComponent, SingleFileRetrievalResult> {
 
-    private static final org.slf4j.Logger LOG = LoggerFactory.getLogger(
+    private static final Logger LOG = LoggerFactory.getLogger(
             LegacyInstallationStrategy.class);
     /** List of registered listeners. */
     private final ListenerList listenerList = new ListenerList();
                 retrievalResult.getFile(), component.getName());
 
         try {
-            component.doInstall(retrievalResult.getFile().getAbsolutePath());
+            component.doInstall(retrievalResult.getFile());
             listenerList.getCallable(UpdateInstallationListener.class).installCompleted(component);
         } catch (Exception ex) {
             LOG.warn("Error installing update for {}", component.getName(), ex);

src/com/dmdirc/updater/retrieving/BaseSingleFileResult.java

 
 import com.dmdirc.updater.checking.UpdateCheckResult;
 
-import java.io.File;
+import java.nio.file.Path;
 
 /**
  * Simple implementation of a {@link SingleFileRetrievalResult}.
         implements SingleFileRetrievalResult {
 
     /** The file where the update is located. */
-    private final File file;
+    private final Path file;
 
     /**
      * Creates a new instance of {@link BaseSingleFileResult}.
-     *
-     * @param checkResult The check result that triggered this retrieval
+     *  @param checkResult The check result that triggered this retrieval
      * @param file        The file containing the update
      */
-    public BaseSingleFileResult(final UpdateCheckResult checkResult, final File file) {
+    public BaseSingleFileResult(final UpdateCheckResult checkResult, final Path file) {
         super(checkResult, true);
 
         this.file = file;
     }
 
-    public File getFile() {
+    public Path getFile() {
         return file;
     }
 

src/com/dmdirc/updater/retrieving/DownloadRetrievalStrategy.java

 import com.dmdirc.util.collections.ListenerList;
 import com.dmdirc.util.io.DownloadListener;
 import com.dmdirc.util.io.Downloader;
-import org.slf4j.LoggerFactory;
 
-import javax.inject.Inject;
-import java.io.File;
 import java.io.IOException;
-import java.nio.file.Paths;
+import java.nio.file.Path;
+
+import javax.inject.Inject;
+
+import org.slf4j.LoggerFactory;
 
 /**
  * An {@link UpdateRetrievalStrategy} that downloads a file specified in a
     /** List of registered listeners. */
     private final ListenerList listenerList = new ListenerList();
     /** The directory to put temporary update files in. */
-    private final String directory;
+    private final Path directory;
     /** Downloader to download files. */
     private final Downloader downloader;
 
      * @param downloader Used to download files
      */
     @Inject
-    public DownloadRetrievalStrategy(@Directory(DirectoryType.BASE) final String directory,
+    public DownloadRetrievalStrategy(@Directory(DirectoryType.BASE) final Path directory,
             final Downloader downloader) {
         super(DownloadableUpdate.class);
 
     @Override
     protected UpdateRetrievalResult retrieveImpl(final DownloadableUpdate checkResult) {
         try {
-            final String file = getFileName();
+            final Path file = getFile();
 
             listenerList.getCallable(UpdateRetrievalListener.class)
                     .retrievalProgressChanged(checkResult.getComponent(), 0);
 
             LOG.debug("Downloading file from {} to {}", checkResult.getUrl(), file);
-            downloader.downloadPage(checkResult.getUrl().toString(), Paths.get(file),
+            downloader.downloadPage(checkResult.getUrl().toString(), file,
                     new DownloadProgressListener(checkResult.getComponent()));
 
             listenerList.getCallable(UpdateRetrievalListener.class)
                     .retrievalCompleted(checkResult.getComponent());
 
-            return new BaseSingleFileResult(checkResult, new File(file));
+            return new BaseSingleFileResult(checkResult, file);
         } catch (IOException ex) {
             LOG.warn("I/O exception downloading update from {}", checkResult.getUrl(), ex);
             listenerList.getCallable(UpdateRetrievalListener.class)
      *
      * @return The full, local path to download the remote file to
      */
-    private String getFileName() {
-        return directory + File.separator + "update."
-                + Math.round(10000 * Math.random()) + ".tmp";
+    private Path getFile() {
+        return directory.resolve("update." + Math.round(10000 * Math.random()) + ".tmp");
     }
 
     @Override

src/com/dmdirc/updater/retrieving/SingleFileRetrievalResult.java

      *
      * @return The file containing the retrieved update
      */
-    File getFile();
+    java.nio.file.Path getFile();
 
 }

test/com/dmdirc/ui/core/feedback/CoreFeedbackDialogModelTest.java

 
 import com.google.common.base.Optional;
 
+import java.nio.file.Path;
+
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
     @Mock private ConnectionManager connectionManager;
     @Mock private FeedbackSenderFactory feedbackSenderFactory;
     @Mock private FeedbackDialogModelListener listener;
+    @Mock private Path path;
     private static final String NAME = "Bob Dole";
     private static final String EMAIL = "bob@dole.com";
     private static final String FEEDBACK = "DMDirc Rocks.";
     public void testName() {
         final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
                 connectionManager,
-                feedbackSenderFactory, "configDirectory");
+                feedbackSenderFactory, path);
         assertEquals("testName", Optional.absent(), instance.getName());
         instance.setName(Optional.fromNullable(NAME));
         assertEquals("testName", Optional.fromNullable(NAME), instance.getName());
     public void testEmail() {
         final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
                 connectionManager,
-                feedbackSenderFactory, "configDirectory");
+                feedbackSenderFactory, path);
         assertEquals("testEmail", Optional.absent(), instance.getEmail());
         instance.setEmail(Optional.fromNullable(EMAIL));
         assertEquals("testEmail", Optional.fromNullable(EMAIL), instance.getEmail());
     public void testFeedback() {
         final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
                 connectionManager,
-                feedbackSenderFactory, "configDirectory");
+                feedbackSenderFactory, path);
         assertEquals("testFeedback", Optional.absent(), instance.getFeedback());
         instance.setFeedback(Optional.fromNullable(FEEDBACK));
         assertEquals("testFeedback", Optional.fromNullable(FEEDBACK), instance.getFeedback());
     public void testServerInfo() {
         final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
                 connectionManager,
-                feedbackSenderFactory, "configDirectory");
+                feedbackSenderFactory, path);
         assertEquals("testServerInfo", false, instance.getIncludeServerInfo());
         instance.setIncludeServerInfo(true);
         assertEquals("testServerInfo", true, instance.getIncludeServerInfo());
     public void testDMDircInfo() {
         final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
                 connectionManager,
-                feedbackSenderFactory, "configDirectory");
+                feedbackSenderFactory, path);
         assertEquals("testDMDircInfo", false, instance.getIncludeDMDircInfo());
         instance.setIncludeDMDircInfo(true);
         assertEquals("testDMDircInfo", true, instance.getIncludeDMDircInfo());
     public void testNameListener() {
         final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
                 connectionManager,
-                feedbackSenderFactory, "configDirectory");
+                feedbackSenderFactory, path);
         instance.addListener(listener);
         instance.setName(Optional.fromNullable("Bob Dole"));
         verify(listener).nameChanged(Optional.fromNullable("Bob Dole"));
     public void testEmailListener() {
         final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
                 connectionManager,
-                feedbackSenderFactory, "configDirectory");
+                feedbackSenderFactory, path);
         instance.addListener(listener);
         instance.setEmail(Optional.fromNullable("bob@dole.com"));
         verify(listener).emailChanged(Optional.fromNullable("bob@dole.com"));
     public void testFeedbackListener() {
         final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
                 connectionManager,
-                feedbackSenderFactory, "configDirectory");
+                feedbackSenderFactory, path);
         instance.addListener(listener);
         instance.setFeedback(Optional.fromNullable("DMDirc Rocks."));
         verify(listener).feedbackChanged(Optional.fromNullable("DMDirc Rocks."));
     public void testServerInfoListener() {
         final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
                 connectionManager,
-                feedbackSenderFactory, "configDirectory");
+                feedbackSenderFactory, path);
         instance.addListener(listener);
         instance.setIncludeServerInfo(true);
         verify(listener).includeServerInfoChanged(true);
     public void testDMDircInfoListener() {
         final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
                 connectionManager,
-                feedbackSenderFactory, "configDirectory");
+                feedbackSenderFactory, path);
         instance.addListener(listener);
         instance.setIncludeDMDircInfo(true);
         verify(listener).includeDMDircInfoChanged(true);

test/com/dmdirc/updater/installing/LegacyInstallationStrategyTest.java

 import com.dmdirc.updater.UpdateComponent;
 import com.dmdirc.updater.retrieving.SingleFileRetrievalResult;
 
-import java.io.File;
 import java.io.IOException;
+import java.nio.file.Path;
 
 import org.junit.Before;
 import org.junit.Test;
+import org.mockito.Matchers;
 
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 public class LegacyInstallationStrategyTest {
 
 
     @Test
     public void testCallsInstallWithCorrectPath() throws Exception { // NOPMD
-        final File file = mock(File.class);
-        when(file.getAbsolutePath()).thenReturn("/my/path");
+        final Path file = mock(Path.class);
+        final Path absoluteFile = mock(Path.class);
+        when(file.toString()).thenReturn("path");
+        when(file.toAbsolutePath()).thenReturn(absoluteFile);
+        when(absoluteFile.toString()).thenReturn("/my/path");
         when(result.getFile()).thenReturn(file);
         strategy.installImpl(component, result);
-        verify(component).doInstall("/my/path");
+        verify(component).doInstall(file);
     }
 
     @Test
     public void testRaisesCompletedEvent() throws Exception { // NOPMD
-        final File file = mock(File.class);
-        when(result.getFile()).thenReturn(file);
+        final Path file = mock(Path.class);
+        final Path absoluteFile = mock(Path.class);
+        when(file.toString()).thenReturn("path");
+        when(file.toAbsolutePath()).thenReturn(absoluteFile);
+        when(absoluteFile.toString()).thenReturn("/my/path");
         strategy.addUpdateInstallationListener(listener);
         strategy.installImpl(component, result);
         verify(listener).installCompleted(component);
 
     @Test
     public void testRaisesFailedEvent() throws Exception { // NOPMD
-        final File file = mock(File.class);
-        when(result.getFile()).thenReturn(file);
-        when(component.doInstall(anyString())).thenThrow(new IOException());
+        final Path file = mock(Path.class);
+        final Path absoluteFile = mock(Path.class);
+        when(file.toString()).thenReturn("path");
+        when(file.toAbsolutePath()).thenReturn(absoluteFile);
+        when(absoluteFile.toString()).thenReturn("/my/path");
+        when(component.doInstall(Matchers.<Path>anyObject())).thenThrow(new IOException());
         strategy.addUpdateInstallationListener(listener);
         strategy.installImpl(component, result);
         verify(listener).installFailed(component);