Merge pull request #595 from csmith/plugins

Tidy up plugin refreshing.

src/com/dmdirc/plugins/PluginFileHandler.java

 import java.nio.file.FileVisitOption;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.function.Function;
 import java.util.stream.Collectors;
      * @param manager The plugin manager to pass to new metadata instances.
      * @return Collection of valid plugins.
      */
-    public Collection<PluginMetaData> refresh(final PluginManager manager) {
+    public Set<PluginMetaData> refresh(final PluginManager manager) {
         applyUpdates();
 
-        final Collection<PluginMetaData> metadata = findAllPlugins(manager);
+        final Set<PluginMetaData> metadata = findAllPlugins(manager);
 
         // Deal with plugins that had errors
         metadata.stream().filter(PluginMetaData::hasErrors).forEach(this::reportErrors);
         metadata.removeIf(PluginMetaData::hasErrors);
 
-        final Collection<PluginMetaData> newPlugins = getValidPlugins(metadata);
+        final Set<PluginMetaData> newPlugins = getValidPlugins(metadata);
 
         knownPlugins.clear();
         knownPlugins.addAll(newPlugins);
      * @param manager The plugin manager to pass to new metadata instances.
      * @return Collection of all plugins with loadable metadata.
      */
-    private Collection<PluginMetaData> findAllPlugins(final PluginManager manager) {
+    private Set<PluginMetaData> findAllPlugins(final PluginManager manager) {
         try {
             return Files.walk(directory, FileVisitOption.FOLLOW_LINKS)
                     .filter(p -> p.getFileName().toString().endsWith(".jar"))
                     .map(Path::toAbsolutePath)
                     .map(path -> getMetaData(path, manager))
-                    .collect(Collectors.toList());
+                    .collect(Collectors.toSet());
         } catch (IOException ex) {
             LOG.error(USER_ERROR, "Unable to read plugin directory.", ex);
-            return Collections.emptyList();
+            return Collections.emptySet();
         }
     }
 
      * @param metadata The collection of metadata to validate.
      * @return The collection of metadata that passed validation.
      */
-    private Collection<PluginMetaData> getValidPlugins(
-            final Collection<PluginMetaData> metadata) {
+    private Set<PluginMetaData> getValidPlugins(final Collection<PluginMetaData> metadata) {
         // Collect a map by name
         final Map<String, PluginMetaData> metaDataByName = metadata.stream()
                 .collect(Collectors.toMap(PluginMetaData::getName, Function.identity()));
         final Multimap<String, String> services = getServices(metadata);
 
         // Validate each in turn
-        final Collection<PluginMetaData> res = new ArrayList<>();
+        final Set<PluginMetaData> res = new HashSet<>();
         for (PluginMetaData target : metadata) {
             final PluginMetaDataValidator validator = new PluginMetaDataValidator(target);
             final Collection<String> results = validator.validate(metaDataByName, services);

src/com/dmdirc/plugins/PluginManager.java

 import com.dmdirc.updater.components.PluginComponent;
 import com.dmdirc.updater.manager.UpdateManager;
 
+import com.google.common.collect.Sets;
+
 import java.io.File;
 import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 public class PluginManager {
 
     private static final Logger LOG = LoggerFactory.getLogger(PluginManager.class);
+
     /** List of known plugins' file names to their corresponding {@link PluginInfo} objects. */
     private final Map<String, PluginInfo> knownPlugins = new HashMap<>();
     /** Set of known plugins' metadata. */
-    private final Collection<PluginMetaData> plugins = new HashSet<>();
+    private final Set<PluginMetaData> plugins = new HashSet<>();
+    /** File handler to use for disk-based functions. */
     private final PluginFileHandler fileHandler;
     /** Directory where plugins are stored. */
     private final String directory;
      * Refreshes the list of known plugins.
      */
     public void refreshPlugins() {
-        final Collection<PluginMetaData> newPlugins = fileHandler.refresh(this);
-
-        for (PluginMetaData plugin : newPlugins) {
-            addPlugin(plugin.getRelativeFilename());
-        }
+        final Set<PluginMetaData> newPlugins = fileHandler.refresh(this);
 
-        // Update our list of plugins
-        synchronized (plugins) {
-            plugins.removeAll(newPlugins);
+        Sets.difference(plugins, newPlugins).forEach(this::handlePluginDeleted);
+        Sets.difference(newPlugins, plugins).forEach(this::handleNewPluginFound);
 
-            for (PluginMetaData oldPlugin : new HashSet<>(plugins)) {
-                delPlugin(oldPlugin.getRelativeFilename());
-            }
+        eventBus.publishAsync(new PluginRefreshEvent());
+    }
 
-            plugins.clear();
-            plugins.addAll(newPlugins);
-        }
+    /**
+     * Called when a new plugin has been located on disk.
+     *
+     * @param metaData The metadata of the new plugin.
+     */
+    private void handleNewPluginFound(final PluginMetaData metaData) {
+        plugins.add(metaData);
+        addPlugin(metaData.getRelativeFilename());
+    }
 
-        eventBus.publishAsync(new PluginRefreshEvent());
+    /**
+     * Called when an existing plugin has gone missing from disk.
+     *
+     * @param metaData The metadata of the deleted plugin.
+     */
+    private void handlePluginDeleted(final PluginMetaData metaData) {
+        plugins.remove(metaData);
+        delPlugin(metaData.getRelativeFilename());
     }
 
     /**