Rename PluginRepository.getPluginPaths to getPluginsPaths

pf4j/src/main/java/org/pf4j/AbstractPluginManager.java

             return;
         }
 
-        // get all plugin paths from repository
-        List<Path> pluginPaths = pluginRepository.getPluginPaths();
+        // get all plugins paths from repository
+        List<Path> pluginsPaths = pluginRepository.getPluginsPaths();
 
         // check for no plugins
-        if (pluginPaths.isEmpty()) {
+        if (pluginsPaths.isEmpty()) {
             log.info("No plugins");
             return;
         }
 
-        log.debug("Found {} possible plugins: {}", pluginPaths.size(), pluginPaths);
+        log.debug("Found {} possible plugins: {}", pluginsPaths.size(), pluginsPaths);
 
         // load plugins from plugin paths
-        for (Path pluginPath : pluginPaths) {
+        for (Path pluginPath : pluginsPaths) {
             try {
                 loadPluginFromPath(pluginPath);
             } catch (PluginException e) {

pf4j/src/main/java/org/pf4j/BasePluginRepository.java

 
     /**
      * Set a {@link File} {@link Comparator} used to sort the listed files from {@code pluginsRoot}.
-     * This comparator is used in {@link #getPluginPaths()} method.
+     * This comparator is used in {@link #getPluginsPaths()} method.
      * By default is used a file comparator that returns the last modified files first.
      * If you don't want a file comparator, then call this method with {@code null}.
      */
     }
 
     @Override
-    public List<Path> getPluginPaths() {
+    public List<Path> getPluginsPaths() {
         File[] files = pluginsRoot.toFile().listFiles(filter);
 
         if ((files == null) || files.length == 0) {

pf4j/src/main/java/org/pf4j/CompoundPluginRepository.java

     }
 
     @Override
-    public List<Path> getPluginPaths() {
+    public List<Path> getPluginsPaths() {
         List<Path> paths = new ArrayList<>();
         for (PluginRepository repository : repositories) {
-            paths.addAll(repository.getPluginPaths());
+            paths.addAll(repository.getPluginsPaths());
         }
 
         return paths;

pf4j/src/main/java/org/pf4j/DefaultPluginRepository.java

     }
 
     @Override
-    public List<Path> getPluginPaths() {
+    public List<Path> getPluginsPaths() {
         // expand plugins zip files
         File[] pluginZips = pluginsRoot.toFile().listFiles(new ZipFileFilter());
         if ((pluginZips != null) && pluginZips.length > 0) {
             }
         }
 
-        return super.getPluginPaths();
+        return super.getPluginsPaths();
     }
 
     @Override

pf4j/src/main/java/org/pf4j/PluginRepository.java

 import java.util.List;
 
 /**
- * Directory that contains plugins. A plugin could be a zip file.
+ * Directory that contains plugins. A plugin could be a {@code directory}, @code zip} or {@code jar} file.
  *
  * @author Decebal Suiu
  * @author Mário Franco
 public interface PluginRepository {
 
     /**
-     * List all plugin paths.
+     * List all plugins paths.
      *
-     * @return a list of files
+     * @return a list with paths
      */
-    List<Path> getPluginPaths();
+    List<Path> getPluginsPaths();
 
     /**
      * Removes a plugin from the repository.

pf4j/src/test/java/org/pf4j/DefaultPluginRepositoryTest.java

     }
 
     /**
-     * Test of {@link DefaultPluginRepository#getPluginPaths()} method.
+     * Test of {@link DefaultPluginRepository#getPluginsPaths()} method.
      */
     @Test
     public void testGetPluginArchives() {
         PluginRepository repository = new DefaultPluginRepository(pluginsPath, false);
 
-        List<Path> pluginPaths = repository.getPluginPaths();
+        List<Path> pluginsPaths = repository.getPluginsPaths();
 
-        assertEquals(5, pluginPaths.size());
-        assertPathExists(pluginPaths, pluginsPath.resolve("plugin-1"));
-        assertPathExists(pluginPaths, pluginsPath.resolve("plugin-2"));
-        assertPathExists(pluginPaths, pluginsPath.resolve("plugin-3"));
+        assertEquals(5, pluginsPaths.size());
+        assertPathExists(pluginsPaths, pluginsPath.resolve("plugin-1"));
+        assertPathExists(pluginsPaths, pluginsPath.resolve("plugin-2"));
+        assertPathExists(pluginsPaths, pluginsPath.resolve("plugin-3"));
         // when not in development mode we will honor these folders
-        assertPathExists(pluginPaths, pluginsPath.resolve("target"));
-        assertPathExists(pluginPaths, pluginsPath.resolve("build"));
+        assertPathExists(pluginsPaths, pluginsPath.resolve("target"));
+        assertPathExists(pluginsPaths, pluginsPath.resolve("build"));
     }
 
     @Test
     public void testGetPluginArchivesInDevelopmentMode() {
         PluginRepository repository = new DefaultPluginRepository(pluginsPath, true);
 
-        List<Path> pluginPaths = repository.getPluginPaths();
+        List<Path> pluginsPaths = repository.getPluginsPaths();
 
         // target and build should be ignored
-        assertEquals(3, pluginPaths.size());
-        assertPathDoesNotExists(pluginPaths, pluginsPath.resolve("target"));
-        assertPathDoesNotExists(pluginPaths, pluginsPath.resolve("build"));
+        assertEquals(3, pluginsPaths.size());
+        assertPathDoesNotExists(pluginsPaths, pluginsPath.resolve("target"));
+        assertPathDoesNotExists(pluginsPaths, pluginsPath.resolve("build"));
     }
 
     /**
         assertTrue(repository.deletePluginPath(pluginsPath.resolve("target")));
         assertTrue(repository.deletePluginPath(pluginsPath.resolve("build")));
 
-        List<Path> pluginPaths = repository.getPluginPaths();
+        List<Path> pluginsPaths = repository.getPluginsPaths();
 
-        assertEquals(1, pluginPaths.size());
-        assertEquals(pluginsPath.relativize(pluginPaths.get(0)).toString(), "plugin-2");
+        assertEquals(1, pluginsPaths.size());
+        assertEquals(pluginsPath.relativize(pluginsPaths.get(0)).toString(), "plugin-2");
     }
 
     private void assertPathExists(List<Path> paths, Path path) {