Merge branch '3.1.x' into 3.2.x

Author: graemerocher

grails-core/src/main/groovy/grails/boot/config/GrailsAutoConfiguration.groovy

@@ -1,31 +1,36 @@
+/*
+ * Copyright 2015 original authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package grails.boot.config
 
 import grails.config.Config
-import grails.config.Settings
 import grails.core.GrailsApplication
+import grails.boot.config.tools.ClassPathScanner
 import grails.core.GrailsApplicationClass
-import grails.io.IOUtils
 import groovy.transform.CompileStatic
-import groovy.transform.InheritConstructors
-import groovy.transform.Memoized
 import groovy.util.logging.Slf4j
-import org.grails.asm.AnnotationMetadataReader
 import org.grails.compiler.injection.AbstractGrailsArtefactTransformer
 import org.grails.spring.aop.autoproxy.GroovyAwareAspectJAwareAdvisorAutoProxyCreator
 import org.springframework.aop.config.AopConfigUtils
 import org.springframework.context.ApplicationContext
 import org.springframework.context.ApplicationContextAware
-import org.springframework.context.ResourceLoaderAware
 import org.springframework.context.annotation.Bean
-import org.springframework.core.io.DefaultResourceLoader
-import org.springframework.core.io.Resource
-import org.springframework.core.io.UrlResource
 import org.springframework.core.io.support.PathMatchingResourcePatternResolver
-import org.springframework.core.io.support.ResourcePatternResolver
-import org.springframework.core.type.classreading.CachingMetadataReaderFactory
-import org.springframework.util.ClassUtils
 
 import java.lang.reflect.Field
+
 /**
  * A base class for configurations that bootstrap a Grails application
  *
@@ -38,7 +43,6 @@ import java.lang.reflect.Field
 class GrailsAutoConfiguration implements GrailsApplicationClass, ApplicationContextAware {
 
     private static final String APC_PRIORITY_LIST_FIELD = "APC_PRIORITY_LIST";
-    private static final List DEFAULT_IGNORED_ROOT_PACKAGES = ['com', 'org', 'net', 'co', 'java', 'javax', 'groovy']
 
     static {
         try {
@@ -55,8 +59,6 @@ class GrailsAutoConfiguration implements GrailsApplicationClass, ApplicationCont
         }
     }
 
-    ResourcePatternResolver resourcePatternResolver = new GrailsClasspathIgnoringResourceResolver(getClass())
-
     ApplicationContext applicationContext
 
     /**
@@ -71,34 +73,17 @@ class GrailsAutoConfiguration implements GrailsApplicationClass, ApplicationCont
      * @return The classes that constitute the Grails application
      */
     Collection<Class> classes() {
-        def readerFactory = new CachingMetadataReaderFactory(resourcePatternResolver)
-        def packages = packageNames().unique()
         Collection<Class> classes = new HashSet()
-        for (pkg in packages) {
-            if(pkg == null) continue
-            if(ignoredRootPackages().contains(pkg)) {
-               continue
-            }
-            // if it is the default package
-            if(pkg == "") {
-                // try the default package in case of a script without recursing into subpackages
-                log.error("The application defines a Groovy source using the default package. Please move all Groovy sources into a package.")
-                String pattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +  "*.class"
-                classes.addAll scanUsingPattern(pattern, readerFactory)
-            }
-            else {
-
-                String pattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
-                        ClassUtils.convertClassNameToResourcePath(pkg) + Settings.CLASS_RESOURCE_PATTERN;
-
-
-                classes.addAll scanUsingPattern(pattern, readerFactory)
-            }
 
+        ClassPathScanner scanner = new ClassPathScanner()
+        if(limitScanningToApplication()) {
+            classes.addAll scanner.scan(getClass(), packageNames())
+        }
+        else {
+            classes.addAll scanner.scan(new PathMatchingResourcePatternResolver(applicationContext), packageNames())
         }
 
-
-        def classLoader = Thread.currentThread().contextClassLoader
+        ClassLoader classLoader = getClass().getClassLoader()
         for(cls in AbstractGrailsArtefactTransformer.transformedClassNames) {
             try {
                 classes << classLoader.loadClass(cls)
@@ -110,12 +95,6 @@ class GrailsAutoConfiguration implements GrailsApplicationClass, ApplicationCont
         return classes
     }
 
-    /**
-     * @return The root packages to ignore by default
-     */
-    protected List ignoredRootPackages() {
-        DEFAULT_IGNORED_ROOT_PACKAGES
-    }
 
     /**
      * Whether classpath scanning should be limited to the application and not dependent JAR files. Users can override this method to enable more broad scanning
@@ -143,23 +122,6 @@ class GrailsAutoConfiguration implements GrailsApplicationClass, ApplicationCont
     }
 
 
-    private Collection<Class> scanUsingPattern(String pattern, CachingMetadataReaderFactory readerFactory) {
-        def resources = limitScanningToApplication() ?  this.resourcePatternResolver.getResources(pattern) : new PathMatchingResourcePatternResolver(applicationContext).getResources(pattern)
-        def classLoader = Thread.currentThread().contextClassLoader
-        Collection<Class> classes = []
-        for (Resource res in resources) {
-            // ignore closures / inner classes
-            if(!res.filename.contains('$') && !res.filename.startsWith("gsp_")) {
-                def reader = new AnnotationMetadataReader(res, classLoader)
-                def metadata = reader.annotationMetadata
-                if (metadata.annotationTypes.any() { String annotation -> annotation.startsWith('grails.') }) {
-                    classes << classLoader.loadClass(reader.classMetadata.className)
-                }
-            }
-        }
-        return classes
-    }
-
     @Override
     Closure doWithSpring() { null }
 
@@ -196,87 +158,5 @@ class GrailsAutoConfiguration implements GrailsApplicationClass, ApplicationCont
         grailsApplication.config
     }
 
-    @CompileStatic
-    @InheritConstructors
-    @Slf4j
-    private static class GrailsClasspathIgnoringResourceResolver extends PathMatchingResourcePatternResolver {
-
-        GrailsClasspathIgnoringResourceResolver(Class applicationClass) {
-            super(new DefaultResourceLoader(new ApplicationRelativeClassLoader(applicationClass)))
-        }
-
-        @Memoized(maxCacheSize = 20)
-        protected Set<Resource> doFindAllClassPathResources(String path) throws IOException {
-            Set<Resource> result = new LinkedHashSet<Resource>(16)
-            ClassLoader cl = getClassLoader()
-            Enumeration<URL> resourceUrls = (cl != null ? cl.getResources(path) : ClassLoader.getSystemResources(path))
-            while (resourceUrls.hasMoreElements()) {
-
-                URL url = resourceUrls.nextElement()
-                // if the path is from a JAR file ignore, plugins inside JAR files will have their own mechanism for loading
-                if(!url.path.contains('jar!/grails/')) {
-                    result.add(convertClassLoaderURL(url))
-                }
-
-            }
-            return result
-        }
-
-        @Memoized
-        protected Resource[] findAllClassPathResources(String location) throws IOException {
-            return super.findAllClassPathResources(location)
-        }
-
-        @Memoized
-        protected Resource[] findPathMatchingResources(String locationPattern) throws IOException {
-            return super.findPathMatchingResources(locationPattern)
-        }
-
-    }
-
-    private static class ApplicationRelativeClassLoader extends URLClassLoader {
-
-        final URL rootResource
-        final Class applicationClass
-        final boolean jarDeployed
-
-        ApplicationRelativeClassLoader(Class applicationClass) {
-            super([ IOUtils.findRootResource(applicationClass)] as URL[])
-
-            this.rootResource = getURLs()[0]
-            this.applicationClass = applicationClass
-            String urlStr = rootResource.toString()
-            jarDeployed = urlStr.startsWith("jar:")
-            try {
-                URL withoutBang = new URL("${urlStr.substring(0, urlStr.length() - 2)}/")
-                addURL(withoutBang)
-
-            } catch (MalformedURLException e) {
-                // ignore, running as a WAR
-            }
-        }
-
-        @Override
-        Enumeration<URL> getResources(String name) throws IOException {
-            if(jarDeployed && name == '') {
-                return applicationClass.getClassLoader().getResources(name)
-            }
-            else {
-                return super.findResources(name)
-            }
-        }
-
-                @Override
-        protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
-            try {
-                return super.loadClass(name, resolve)
-            } catch (ClassNotFoundException cnfe) {
-                return applicationClass.getClassLoader().loadClass(name)
-            }
-        }
-    }
-
-
-
 }