wip fix'em ~all

.travis.yml

@@ -2,4 +2,5 @@ language: java
 
 jdk:
   - openjdk8
+  - openjdk9
   - openjdk11

pom.xml

@@ -62,8 +62,7 @@
             <groupId>org.javassist</groupId>
             <artifactId>javassist</artifactId>
             <version>${javassist.version}</version>
-            <optional>false
-            </optional> <!-- case: when not actually scanning with javassist or if using {@link Reflections.collect()} -->
+            <optional>false</optional> <!-- case: when not actually scanning with javassist or if using {@link Reflections.collect()} -->
         </dependency>
 
         <dependency>
@@ -103,6 +102,14 @@
             <optional>true</optional> <!-- case: when other logging implementation used or logging is not needed -->
         </dependency>
 
+        <dependency>
+            <groupId>org.jboss</groupId>
+            <artifactId>jboss-vfs</artifactId>
+            <version>3.2.12.Final</version>
+            <scope>provided</scope>
+            <optional>true</optional><!-- case: when using jboss-vfs -->
+        </dependency>
+
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
@@ -112,26 +119,34 @@
 
     </dependencies>
 
+    <!-- Release -->
     <profiles>
         <profile>
-            <id>build</id>
+            <id>release</id>
             <build>
                 <plugins>
+                    <plugin>
+                        <groupId>org.apache.maven.plugins</groupId>
+                        <artifactId>maven-release-plugin</artifactId>
+                        <version>2.5.3</version>
+                    </plugin>
                     <plugin>
                         <groupId>org.apache.maven.plugins</groupId>
                         <artifactId>maven-source-plugin</artifactId>
+                        <version>3.1.0</version>
                         <executions>
                             <execution>
                                 <id>attach-sources</id>
                                 <goals>
-                                    <goal>jar</goal>
+                                    <goal>jar-no-fork</goal>
                                 </goals>
                             </execution>
                         </executions>
                     </plugin>
                     <plugin>
                         <groupId>org.apache.maven.plugins</groupId>
                         <artifactId>maven-javadoc-plugin</artifactId>
+                        <version>3.1.1</version>
                         <executions>
                             <execution>
                                 <id>attach-javadocs</id>
@@ -140,40 +155,11 @@
                                 </goals>
                             </execution>
                         </executions>
-                        <configuration>
-                            <doclint>none</doclint>
-                        </configuration>
-                    </plugin>
-                    <plugin>
-                        <artifactId>maven-enforcer-plugin</artifactId>
-                        <executions>
-                            <execution>
-                                <goals>
-                                    <goal>enforce</goal>
-                                </goals>
-                                <configuration>
-                                    <rules>
-                                        <requireProperty>
-                                            <property>gpg.keyname</property>
-                                            <message>gpg.keyname must be supplied using -D.
-                                                create a key using gpg --gen-key or use existing one.
-                                            </message>
-                                        </requireProperty>
-                                        <requireProperty>
-                                            <property>gpg.passphrase</property>
-                                            <message>gpg.passphrase must be supplied using -D.
-                                                create a key using gpg --gen-key or use existing one.
-                                            </message>
-                                        </requireProperty>
-                                    </rules>
-                                    <fail>true</fail>
-                                </configuration>
-                            </execution>
-                        </executions>
                     </plugin>
                     <plugin>
                         <groupId>org.apache.maven.plugins</groupId>
                         <artifactId>maven-gpg-plugin</artifactId>
+                        <version>1.6</version>
                         <executions>
                             <execution>
                                 <id>sign-artifacts</id>
@@ -184,6 +170,17 @@
                             </execution>
                         </executions>
                     </plugin>
+                    <plugin>
+                        <groupId>org.sonatype.plugins</groupId>
+                        <artifactId>nexus-staging-maven-plugin</artifactId>
+                        <version>1.6.8</version>
+                        <extensions>true</extensions>
+                        <configuration>
+                            <serverId>ossrh</serverId>
+                            <nexusUrl>https://oss.sonatype.org/</nexusUrl>
+                            <autoReleaseAfterClose>true</autoReleaseAfterClose>
+                        </configuration>
+                    </plugin>
                 </plugins>
             </build>
         </profile>

src/main/java/org/reflections/ReflectionUtils.java

@@ -131,14 +131,18 @@ public static Set<Field> getFields(Class<?> type, Predicate<? super Field>... pr
     }
 
     /** get all annotations of given {@code type}, up the super class hierarchy, optionally filtered by {@code predicates} */
-    public static <T extends AnnotatedElement> Set<Annotation>  getAllAnnotations(T type, Predicate<Annotation>... predicates) {
-        Set<Annotation> result = new HashSet<>();
+    public static <T extends AnnotatedElement> Set<Annotation> getAllAnnotations(T type, Predicate<Annotation>... predicates) {
+        Set<Annotation> result = new LinkedHashSet<>();
+        List<AnnotatedElement> keys = new ArrayList();
         if (type instanceof Class) {
-            for (Class<?> t : getAllSuperTypes((Class<?>) type)) {
-                result.addAll(getAnnotations(t, predicates));
+            keys.addAll(getAllSuperTypes((Class<?>) type));
+        }
+        for (int i = 0; i < keys.size(); i++) {
+            for (Annotation annotation : getAnnotations(keys.get(i), predicates)) {
+                if (result.add(annotation)) {
+                    keys.add(annotation.annotationType());
+                }
             }
-        } else {
-            result.addAll(getAnnotations(type, predicates));
         }
         return result;
     }
@@ -313,10 +317,9 @@ public static Class<?> forName(String typeName, ClassLoader... classLoaders) {
                 }
             }
 
-            if (Reflections.log != null) {
+            if (Reflections.log != null && Reflections.log.isTraceEnabled()) {
                 for (ReflectionsException reflectionsException : reflectionsExceptions) {
-                    Reflections.log.warn("could not get type for name " + typeName + " from any class loader",
-                            reflectionsException);
+                    Reflections.log.trace("could not get type for name " + typeName + " from any class loader", reflectionsException);
                 }
             }
 

src/main/java/org/reflections/Reflections.java

@@ -37,6 +37,7 @@
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
 import java.util.concurrent.ThreadPoolExecutor;
@@ -126,7 +127,7 @@ public class Reflections {
      */
     public Reflections(final Configuration configuration) {
         this.configuration = configuration;
-        store = new Store();
+        store = new Store(configuration);
 
         if (configuration.getScanners() != null && !configuration.getScanners().isEmpty()) {
             //inject to scanners
@@ -184,18 +185,20 @@ public Reflections(final Object... params) {
 
     protected Reflections() {
         configuration = new ConfigurationBuilder();
-        store = new Store();
+        store = new Store(configuration);
     }
 
     //
     protected void scan() {
         if (configuration.getUrls() == null || configuration.getUrls().isEmpty()) {
-            if (log != null) log.warn("given scan urls are empty. set urls in the configuration");
+            if (log != null) {
+                log.warn("given scan urls are empty. set urls in the configuration");
+            }
             return;
         }
 
-        if (log != null && log.isDebugEnabled()) {
-            log.debug("going to scan these urls: {}", configuration.getUrls());
+        if (log != null && log.isTraceEnabled()) {
+            log.trace("going to scan these urls: {}", configuration.getUrls());
         }
 
         long time = System.currentTimeMillis();
@@ -207,8 +210,8 @@ protected void scan() {
             try {
                 if (executorService != null) {
                     futures.add(executorService.submit(() -> {
-                        if (log != null) {
-                            log.debug("[{}] scanning {}", Thread.currentThread().toString(), url);
+                        if (log != null && log.isTraceEnabled()) {
+                            log.trace("[{}] scanning {}", Thread.currentThread().toString(), url);
                         }
                         scan(url);
                     }));
@@ -223,10 +226,13 @@ protected void scan() {
             }
         }
 
-        //todo use CompletionService
         if (executorService != null) {
             for (Future future : futures) {
-                try { future.get(); } catch (Exception e) { throw new RuntimeException(e); }
+                try {
+                    future.get();
+                } catch (InterruptedException | ExecutionException e) {
+                    throw new RuntimeException(e);
+                }
             }
         }
 
@@ -270,9 +276,9 @@ protected void scan(URL url) {
                                 classObject = scanner.scan(file, classObject, store);
                             }
                         } catch (Exception e) {
-                            if (log != null) {
+                            if (log != null && log.isTraceEnabled()) {
                                 // SLF4J will filter out Throwables from the format string arguments.
-                                log.debug("could not scan file {} in url {} with scanner {}", file.getRelativePath(), url.toExternalForm(), scanner.getClass().getSimpleName(), e);
+                                log.trace("could not scan file {} in url {} with scanner {}", file.getRelativePath(), url.toExternalForm(), scanner.getClass().getSimpleName(), e);
                             }
                         }
                     }
@@ -332,7 +338,6 @@ public static Reflections collect(final String packagePrefix, final Predicate<St
     public Reflections collect(final InputStream inputStream) {
         try {
             merge(configuration.getSerializer().read(inputStream));
-            if (log != null) log.info("Reflections collected metadata from input stream using serializer " + configuration.getSerializer().getClass().getName());
         } catch (Exception ex) {
             throw new ReflectionsException("could not merge input stream", ex);
         }
@@ -389,7 +394,9 @@ public void expandSuperTypes() {
     private void expandSupertypes(Store store, String key, Class<?> type) {
         for (Class<?> supertype : ReflectionUtils.getSuperTypes(type)) {
             if (store.put(SubTypesScanner.class, supertype.getName(), key)) {
-                if (log != null) log.debug("expanded subtype {} -> {}", supertype.getName(), key);
+                if (log != null && log.isTraceEnabled()) {
+                    log.trace("expanded subtype {} -> {}", supertype.getName(), key);
+                }
                 expandSupertypes(store, supertype.getName(), supertype);
             }
         }
@@ -650,10 +657,7 @@ public File save(final String filename) {
      * so that it could be found later much faster using the load method
      */
     public File save(final String filename, final Serializer serializer) {
-        File file = serializer.save(this, filename);
-        if (log != null)
-            log.info("Reflections successfully saved in " + file.getAbsolutePath() + " using " + serializer.getClass().getSimpleName());
-        return file;
+        return serializer.save(this, filename);
     }
 
     private ClassLoader[] loaders() { return configuration.getClassLoaders(); }

src/main/java/org/reflections/Store.java

@@ -1,5 +1,7 @@
 package org.reflections;
 
+import org.reflections.scanners.Scanner;
+
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -23,8 +25,12 @@ public class Store {
 
     private final ConcurrentHashMap<String, Map<String, Collection<String>>> storeMap;
 
-    protected Store() {
+    protected Store(Configuration configuration) {
         storeMap = new ConcurrentHashMap<>();
+        for (Scanner scanner : configuration.getScanners()) {
+            String index = index(scanner.getClass());
+            storeMap.computeIfAbsent(index, s -> new ConcurrentHashMap<>());
+        }
     }
 
     /** return all indices */
@@ -115,7 +121,7 @@ public boolean put(Class<?> scannerClass, String key, String value) {
 
     public boolean put(String index, String key, String value) {
         return storeMap.computeIfAbsent(index, s -> new ConcurrentHashMap<>())
-                .computeIfAbsent(key, s -> new ArrayList<>())
+                .computeIfAbsent(key, s -> Collections.synchronizedList(new ArrayList<>()))
                 .add(value);
     }
 

src/main/java/org/reflections/scanners/MethodParameterNamesScanner.java

@@ -7,10 +7,8 @@
 import org.reflections.adapters.MetadataAdapter;
 
 import java.lang.reflect.Modifier;
-import java.util.ArrayList;
-import java.util.List;
-
-import static org.reflections.util.Utils.join;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 
 /** scans methods/constructors and indexes parameter names */
 @SuppressWarnings("unchecked")
@@ -25,12 +23,16 @@ public void scan(Object cls, Store store) {
             if (acceptResult(key)) {
                 CodeAttribute codeAttribute = ((MethodInfo) method).getCodeAttribute();
                 LocalVariableAttribute table = codeAttribute != null ? (LocalVariableAttribute) codeAttribute.getAttribute(LocalVariableAttribute.tag) : null;
-                int length = table != null ? table.tableLength() : 0;
-                int i = Modifier.isStatic(((MethodInfo) method).getAccessFlags()) ? 0 : 1; //skip this
-                if (i < length) {
-                    List<String> names = new ArrayList<>(length - i);
-                    while (i < length) names.add(((MethodInfo) method).getConstPool().getUtf8Info(table.nameIndex(i++)));
-                    put(store, key, join(names, ", "));
+                int length = md.getParameterNames(method).size();
+                if (length > 0) {
+                    int shift = Modifier.isStatic(((MethodInfo) method).getAccessFlags()) ? 0 : 1; //skip this
+                    String join = IntStream.range(shift, length + shift)
+                            .mapToObj(i -> ((MethodInfo) method).getConstPool().getUtf8Info(table.nameIndex(i)))
+                            .filter(name -> !name.startsWith("this$"))
+                            .collect(Collectors.joining(", "));
+                    if (!join.isEmpty()) {
+                        put(store, key, join);
+                    }
                 }
             }
         }

src/main/java/org/reflections/scanners/ResourcesScanner.java

@@ -7,7 +7,7 @@
  * <p>key: value - {web.xml: WEB-INF/web.xml} */
 public class ResourcesScanner extends AbstractScanner {
     public boolean acceptsInput(String file) {
-        return !file.endsWith(".class"); //not a class
+        return !file.endsWith(".class") && !file.endsWith(".groovy") && !file.endsWith(".scala") && !file.endsWith(".kt"); //not a class
     }
 
     @Override public Object scan(Vfs.File file, Object classObject, Store store) {

src/main/java/org/reflections/util/ConfigurationBuilder.java

@@ -110,7 +110,7 @@ else if (param instanceof Class) {
             else if (param instanceof ClassLoader) { /* already taken care */ }
             else if (param instanceof Predicate) { filter.add((Predicate<String>) param); }
             else if (param instanceof ExecutorService) { builder.setExecutorService((ExecutorService) param); }
-            else if (Reflections.log != null) { throw new ReflectionsException("could not use param " + param); }
+            else throw new ReflectionsException("could not use param " + param);
         }
 
         if (builder.getUrls().isEmpty()) {
@@ -119,6 +119,9 @@ else if (param instanceof ClassLoader) { /* already taken care */ }
             } else {
                 builder.addUrls(ClasspathHelper.forClassLoader()); //default urls getResources("")
             }
+            if (builder.urls.isEmpty()) {
+                builder.addUrls(ClasspathHelper.forJavaClassPath());
+            }
         }
 
         builder.filterInputsBy(filter);
@@ -290,8 +293,9 @@ public ConfigurationBuilder setExpandSuperTypes(boolean expandSuperTypes) {
     }
 
     /** set class loader, might be used for resolving methods/fields */
-    public void setClassLoaders(ClassLoader[] classLoaders) {
+    public ConfigurationBuilder setClassLoaders(ClassLoader[] classLoaders) {
         this.classLoaders = classLoaders;
+        return this;
     }
 
     /** add class loader, might be used for resolving methods/fields */
@@ -301,9 +305,9 @@ public ConfigurationBuilder addClassLoader(ClassLoader classLoader) {
 
     /** add class loader, might be used for resolving methods/fields */
     public ConfigurationBuilder addClassLoaders(ClassLoader... classLoaders) {
-        this.classLoaders = this.classLoaders == null ? classLoaders :
-                Stream.concat(Stream.concat(Arrays.stream(this.classLoaders), Arrays.stream(classLoaders)), Stream.of(ClassLoader.class))
-                        .distinct().toArray(ClassLoader[]::new);
+        this.classLoaders = this.classLoaders == null
+                            ? classLoaders
+                            : Stream.concat(Arrays.stream(this.classLoaders), Arrays.stream(classLoaders)).toArray(ClassLoader[]::new);
         return this;
     }