View Javadoc
1   ////////////////////////////////////////////////////////////////////////////////
2   // checkstyle: Checks Java source code for adherence to a set of rules.
3   // Copyright (C) 2001-2018 the original author or authors.
4   //
5   // This library is free software; you can redistribute it and/or
6   // modify it under the terms of the GNU Lesser General Public
7   // License as published by the Free Software Foundation; either
8   // version 2.1 of the License, or (at your option) any later version.
9   //
10  // This library is distributed in the hope that it will be useful,
11  // but WITHOUT ANY WARRANTY; without even the implied warranty of
12  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  // Lesser General Public License for more details.
14  //
15  // You should have received a copy of the GNU Lesser General Public
16  // License along with this library; if not, write to the Free Software
17  // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  ////////////////////////////////////////////////////////////////////////////////
19  
20  package com.puppycrawl.tools.checkstyle.utils;
21  
22  import java.io.IOException;
23  import java.lang.reflect.Constructor;
24  import java.lang.reflect.Modifier;
25  import java.util.Collection;
26  import java.util.Set;
27  import java.util.stream.Collectors;
28  
29  import com.google.common.reflect.ClassPath;
30  import com.puppycrawl.tools.checkstyle.TreeWalkerFilter;
31  import com.puppycrawl.tools.checkstyle.api.AbstractCheck;
32  import com.puppycrawl.tools.checkstyle.api.AbstractFileSetCheck;
33  import com.puppycrawl.tools.checkstyle.api.AuditListener;
34  import com.puppycrawl.tools.checkstyle.api.AutomaticBean;
35  import com.puppycrawl.tools.checkstyle.api.BeforeExecutionFileFilter;
36  import com.puppycrawl.tools.checkstyle.api.Filter;
37  import com.puppycrawl.tools.checkstyle.api.RootModule;
38  
39  /**
40   * Contains utility methods for module reflection.
41   */
42  public final class ModuleReflectionUtils {
43  
44      /** Prevent instantiation. */
45      private ModuleReflectionUtils() {
46      }
47  
48      /**
49       * Gets checkstyle's modules (directly, not recursively) in the given packages.
50       * @param packages the collection of package names to use
51       * @param loader the class loader used to load Checkstyle package names
52       * @return the set of checkstyle's module classes
53       * @throws IOException if the attempt to read class path resources failed
54       * @see #isCheckstyleModule(Class)
55       */
56      public static Set<Class<?>> getCheckstyleModules(
57              Collection<String> packages, ClassLoader loader) throws IOException {
58          final ClassPath classPath = ClassPath.from(loader);
59          return packages.stream()
60                  .flatMap(pkg -> classPath.getTopLevelClasses(pkg).stream())
61                  .map(ClassPath.ClassInfo::load)
62                  .filter(ModuleReflectionUtils::isCheckstyleModule)
63                  .collect(Collectors.toSet());
64      }
65  
66      /**
67       * Checks whether a class may be considered as a checkstyle module. Checkstyle's modules are
68       * non-abstract classes, which are either checkstyle's checks, file sets, filters, file filters,
69       * {@code TreeWalker} filters, audit listener, or root module.
70       * @param clazz class to check.
71       * @return true if the class may be considered as the checkstyle module.
72       */
73      public static boolean isCheckstyleModule(Class<?> clazz) {
74          return isValidCheckstyleClass(clazz)
75              && (isCheckstyleTreeWalkerCheck(clazz)
76                      || isFileSetModule(clazz)
77                      || isFilterModule(clazz)
78                      || isFileFilterModule(clazz)
79                      || isTreeWalkerFilterModule(clazz)
80                      || isAuditListener(clazz)
81                      || isRootModule(clazz));
82      }
83  
84      /**
85       * Checks whether a class extends 'AutomaticBean', is non-abstract, and has a default
86       * constructor.
87       * @param clazz class to check.
88       * @return true if a class may be considered a valid production class.
89       */
90      public static boolean isValidCheckstyleClass(Class<?> clazz) {
91          return AutomaticBean.class.isAssignableFrom(clazz)
92                  && !Modifier.isAbstract(clazz.getModifiers())
93                  && hasDefaultConstructor(clazz);
94      }
95  
96      /**
97       * Checks if the class has a default constructor.
98       * @param clazz class to check
99       * @return true if the class has a default constructor.
100      */
101     private static boolean hasDefaultConstructor(Class<?> clazz) {
102         boolean result = false;
103         for (Constructor<?> constructor : clazz.getDeclaredConstructors()) {
104             if (constructor.getParameterCount() == 0) {
105                 result = true;
106                 break;
107             }
108         }
109         return result;
110     }
111 
112     /**
113      * Checks whether a class may be considered as the checkstyle check
114      * which has TreeWalker as a parent.
115      * Checkstyle's checks are classes which implement 'AbstractCheck' interface.
116      * @param clazz class to check.
117      * @return true if a class may be considered as the checkstyle check.
118      */
119     public static boolean isCheckstyleTreeWalkerCheck(Class<?> clazz) {
120         return AbstractCheck.class.isAssignableFrom(clazz);
121     }
122 
123     /**
124      * Checks whether a class may be considered as the checkstyle file set.
125      * Checkstyle's file sets are classes which implement 'AbstractFileSetCheck' interface.
126      * @param clazz class to check.
127      * @return true if a class may be considered as the checkstyle file set.
128      */
129     public static boolean isFileSetModule(Class<?> clazz) {
130         return AbstractFileSetCheck.class.isAssignableFrom(clazz);
131     }
132 
133     /**
134      * Checks whether a class may be considered as the checkstyle filter.
135      * Checkstyle's filters are classes which implement 'Filter' interface.
136      * @param clazz class to check.
137      * @return true if a class may be considered as the checkstyle filter.
138      */
139     public static boolean isFilterModule(Class<?> clazz) {
140         return Filter.class.isAssignableFrom(clazz);
141     }
142 
143     /**
144      * Checks whether a class may be considered as the checkstyle file filter.
145      * Checkstyle's file filters are classes which implement 'BeforeExecutionFileFilter' interface.
146      * @param clazz class to check.
147      * @return true if a class may be considered as the checkstyle file filter.
148      */
149     public static boolean isFileFilterModule(Class<?> clazz) {
150         return BeforeExecutionFileFilter.class.isAssignableFrom(clazz);
151     }
152 
153     /**
154      * Checks whether a class may be considered as the checkstyle audit listener module.
155      * Checkstyle's audit listener modules are classes which implement 'AuditListener' interface.
156      * @param clazz class to check.
157      * @return true if a class may be considered as the checkstyle audit listener module.
158      */
159     public static boolean isAuditListener(Class<?> clazz) {
160         return AuditListener.class.isAssignableFrom(clazz);
161     }
162 
163     /**
164      * Checks whether a class may be considered as the checkstyle root module.
165      * Checkstyle's root modules are classes which implement 'RootModule' interface.
166      * @param clazz class to check.
167      * @return true if a class may be considered as the checkstyle root module.
168      */
169     public static boolean isRootModule(Class<?> clazz) {
170         return RootModule.class.isAssignableFrom(clazz);
171     }
172 
173     /**
174      * Checks whether a class may be considered as the checkstyle {@code TreeWalker} filter.
175      * Checkstyle's {@code TreeWalker} filters are classes which implement 'TreeWalkerFilter'
176      * interface.
177      * @param clazz class to check.
178      * @return true if a class may be considered as the checkstyle {@code TreeWalker} filter.
179      */
180     public static boolean isTreeWalkerFilterModule(Class<?> clazz) {
181         return TreeWalkerFilter.class.isAssignableFrom(clazz);
182     }
183 
184 }