001//////////////////////////////////////////////////////////////////////////////// 002// checkstyle: Checks Java source code for adherence to a set of rules. 003// Copyright (C) 2001-2017 the original author or authors. 004// 005// This library is free software; you can redistribute it and/or 006// modify it under the terms of the GNU Lesser General Public 007// License as published by the Free Software Foundation; either 008// version 2.1 of the License, or (at your option) any later version. 009// 010// This library is distributed in the hope that it will be useful, 011// but WITHOUT ANY WARRANTY; without even the implied warranty of 012// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 013// Lesser General Public License for more details. 014// 015// You should have received a copy of the GNU Lesser General Public 016// License along with this library; if not, write to the Free Software 017// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 018//////////////////////////////////////////////////////////////////////////////// 019 020package com.puppycrawl.tools.checkstyle; 021 022import java.io.IOException; 023import java.lang.reflect.Constructor; 024import java.util.Collections; 025import java.util.HashMap; 026import java.util.LinkedHashSet; 027import java.util.Map; 028import java.util.Set; 029import java.util.stream.Collectors; 030 031import com.puppycrawl.tools.checkstyle.api.CheckstyleException; 032import com.puppycrawl.tools.checkstyle.api.LocalizedMessage; 033import com.puppycrawl.tools.checkstyle.utils.ModuleReflectionUtils; 034 035/** 036 * A factory for creating objects from package names and names. 037 * Consider the below example for better understanding. 038 * <ul> 039 * <li>module name - name of java class that represents module;</li> 040 * <li>module full name - fully qualifies name of java class that represents module;</li> 041 * <li>check module short name - name of Check without 'Check' suffix;</li> 042 * <li>check module name - name of java class that represents Check (with 'Check' suffix);</li> 043 * <li> 044 * check module full name - fully qualifies name of java class 045 * that represents Check (with 'Check' suffix). 046 * </li> 047 * </ul> 048 * @author Rick Giles 049 * @author lkuehne 050 */ 051public class PackageObjectFactory implements ModuleFactory { 052 /** Base package of checkstyle modules checks. */ 053 public static final String BASE_PACKAGE = "com.puppycrawl.tools.checkstyle"; 054 055 /** Exception message when it is unable to create a class instance. */ 056 public static final String UNABLE_TO_INSTANTIATE_EXCEPTION_MESSAGE = 057 "PackageObjectFactory.unableToInstantiateExceptionMessage"; 058 059 /** Exception message when there is ambigugous module name in config file. */ 060 public static final String AMBIGUOUS_MODULE_NAME_EXCEPTION_MESSAGE = 061 "PackageObjectFactory.ambiguousModuleNameExceptionMessage"; 062 063 /** Suffix of checks. */ 064 public static final String CHECK_SUFFIX = "Check"; 065 066 /** Character separate package names in qualified name of java class. */ 067 public static final String PACKAGE_SEPARATOR = "."; 068 069 /** Exception message when null class loader is given. */ 070 public static final String NULL_LOADER_MESSAGE = "moduleClassLoader must not be null"; 071 072 /** Exception message when null package name is given. */ 073 public static final String NULL_PACKAGE_MESSAGE = "package name must not be null"; 074 075 /** Separator to use in strings. */ 076 public static final String STRING_SEPARATOR = ", "; 077 078 /** Map of Checkstyle module names to their fully qualified names. */ 079 private static final Map<String, String> NAME_TO_FULL_MODULE_NAME = new HashMap<>(); 080 081 /** A list of package names to prepend to class names. */ 082 private final Set<String> packages; 083 084 /** The class loader used to load Checkstyle core and custom modules. */ 085 private final ClassLoader moduleClassLoader; 086 087 /** Map of third party Checkstyle module names to the set of their fully qualified names. */ 088 private Map<String, Set<String>> thirdPartyNameToFullModuleNames; 089 090 static { 091 fillShortToFullModuleNamesMap(); 092 } 093 094 /** 095 * Creates a new {@code PackageObjectFactory} instance. 096 * @param packageNames the list of package names to use 097 * @param moduleClassLoader class loader used to load Checkstyle 098 * core and custom modules 099 */ 100 public PackageObjectFactory(Set<String> packageNames, ClassLoader moduleClassLoader) { 101 if (moduleClassLoader == null) { 102 throw new IllegalArgumentException(NULL_LOADER_MESSAGE); 103 } 104 if (packageNames.contains(null)) { 105 throw new IllegalArgumentException(NULL_PACKAGE_MESSAGE); 106 } 107 108 //create a copy of the given set, but retain ordering 109 packages = new LinkedHashSet<>(packageNames); 110 this.moduleClassLoader = moduleClassLoader; 111 } 112 113 /** 114 * Creates a new {@code PackageObjectFactory} instance. 115 * @param packageName The package name to use 116 * @param moduleClassLoader class loader used to load Checkstyle 117 * core and custom modules 118 */ 119 public PackageObjectFactory(String packageName, ClassLoader moduleClassLoader) { 120 if (moduleClassLoader == null) { 121 throw new IllegalArgumentException(NULL_LOADER_MESSAGE); 122 } 123 if (packageName == null) { 124 throw new IllegalArgumentException(NULL_PACKAGE_MESSAGE); 125 } 126 127 packages = new LinkedHashSet<>(1); 128 packages.add(packageName); 129 this.moduleClassLoader = moduleClassLoader; 130 } 131 132 /** 133 * Creates a new instance of a class from a given name, or that name 134 * concatenated with "Check". If the name is 135 * a class name, creates an instance of the named class. Otherwise, creates 136 * an instance of a class name obtained by concatenating the given name 137 * to a package name from a given list of package names. 138 * @param name the name of a class. 139 * @return the {@code Object} created by loader. 140 * @throws CheckstyleException if an error occurs. 141 */ 142 @Override 143 public Object createModule(String name) throws CheckstyleException { 144 Object instance = null; 145 // if the name is a simple class name, try to find it in maps at first 146 if (!name.contains(PACKAGE_SEPARATOR)) { 147 // find the name in hardcode map 148 final String fullModuleName = NAME_TO_FULL_MODULE_NAME.get(name); 149 if (fullModuleName == null) { 150 final String fullCheckModuleName = 151 NAME_TO_FULL_MODULE_NAME.get(name + CHECK_SUFFIX); 152 if (fullCheckModuleName != null) { 153 instance = createObject(fullCheckModuleName); 154 } 155 } 156 else { 157 instance = createObject(fullModuleName); 158 } 159 160 // find the name in third party map 161 if (instance == null) { 162 if (thirdPartyNameToFullModuleNames == null) { 163 thirdPartyNameToFullModuleNames = 164 generateThirdPartyNameToFullModuleName(moduleClassLoader); 165 } 166 instance = createObjectFromMap(name, thirdPartyNameToFullModuleNames); 167 } 168 } 169 170 if (instance == null) { 171 instance = createObject(name); 172 } 173 final String nameCheck = name + CHECK_SUFFIX; 174 if (instance == null) { 175 instance = createObject(nameCheck); 176 } 177 if (instance == null) { 178 final String attemptedNames = joinPackageNamesWithClassName(name, packages) 179 + STRING_SEPARATOR + nameCheck + STRING_SEPARATOR 180 + joinPackageNamesWithClassName(nameCheck, packages); 181 final LocalizedMessage exceptionMessage = new LocalizedMessage(0, 182 Definitions.CHECKSTYLE_BUNDLE, UNABLE_TO_INSTANTIATE_EXCEPTION_MESSAGE, 183 new String[] {name, attemptedNames}, null, getClass(), null); 184 throw new CheckstyleException(exceptionMessage.getMessage()); 185 } 186 return instance; 187 } 188 189 /** 190 * Create object with the help of the supplied map. 191 * @param name name of module. 192 * @param map the supplied map. 193 * @return instance of module if it is found in modules map and no ambiguous classes exist. 194 * @throws CheckstyleException if the class fails to instantiate or there are ambiguous classes. 195 */ 196 private Object createObjectFromMap(String name, Map<String, Set<String>> map) 197 throws CheckstyleException { 198 final Set<String> fullModuleNames = map.get(name); 199 Object instance = null; 200 if (fullModuleNames == null) { 201 final Set<String> fullCheckModuleNames = map.get(name + CHECK_SUFFIX); 202 if (fullCheckModuleNames != null) { 203 instance = createObjectFromFullModuleNames(name, fullCheckModuleNames); 204 } 205 } 206 else { 207 instance = createObjectFromFullModuleNames(name, fullModuleNames); 208 } 209 return instance; 210 } 211 212 /** 213 * Create Object from optional full module names. 214 * In most case, there should be only one element in {@code fullModuleName}, otherwise 215 * an exception would be thrown. 216 * @param name name of module 217 * @param fullModuleNames the supplied full module names set 218 * @return instance of module if there is only one element in {@code fullModuleName} 219 * @throws CheckstyleException if the class fails to instantiate or there are more than one 220 * element in {@code fullModuleName} 221 */ 222 private Object createObjectFromFullModuleNames(String name, Set<String> fullModuleNames) 223 throws CheckstyleException { 224 final Object returnValue; 225 if (fullModuleNames.size() == 1) { 226 returnValue = createObject(fullModuleNames.iterator().next()); 227 } 228 else { 229 final String optionalNames = fullModuleNames.stream() 230 .sorted() 231 .collect(Collectors.joining(STRING_SEPARATOR)); 232 final LocalizedMessage exceptionMessage = new LocalizedMessage(0, 233 Definitions.CHECKSTYLE_BUNDLE, AMBIGUOUS_MODULE_NAME_EXCEPTION_MESSAGE, 234 new String[] {name, optionalNames}, null, getClass(), null); 235 throw new CheckstyleException(exceptionMessage.getMessage()); 236 } 237 return returnValue; 238 } 239 240 /** 241 * Generate the map of third party Checkstyle module names to the set of their fully qualified 242 * names. 243 * @param loader the class loader used to load Checkstyle package names 244 * @return the map of third party Checkstyle module names to the set of their fully qualified 245 * names 246 */ 247 private Map<String, Set<String>> generateThirdPartyNameToFullModuleName(ClassLoader loader) { 248 Map<String, Set<String>> returnValue; 249 try { 250 returnValue = ModuleReflectionUtils.getCheckstyleModules(packages, loader).stream() 251 .collect(Collectors.toMap( 252 Class::getSimpleName, 253 cls -> Collections.singleton(cls.getCanonicalName()), 254 (fullNames1, fullNames2) -> { 255 final Set<String> mergedNames = new LinkedHashSet<>(fullNames1); 256 mergedNames.addAll(fullNames2); 257 return mergedNames; 258 })); 259 } 260 catch (IOException ignore) { 261 returnValue = new HashMap<>(); 262 } 263 return returnValue; 264 } 265 266 /** 267 * Creates a string by joining package names with a class name. 268 * @param className name of the class for joining. 269 * @param packages packages names. 270 * @return a string which is obtained by joining package names with a class name. 271 */ 272 private static String joinPackageNamesWithClassName(String className, Set<String> packages) { 273 return packages.stream().collect( 274 Collectors.joining(PACKAGE_SEPARATOR + className + STRING_SEPARATOR, "", 275 PACKAGE_SEPARATOR + className)); 276 } 277 278 /** 279 * Creates a new instance of a named class. 280 * @param className the name of the class to instantiate. 281 * @return the {@code Object} created by loader or null. 282 * @throws CheckstyleException if the class fails to instantiate. 283 */ 284 private Object createObject(String className) throws CheckstyleException { 285 Class<?> clazz = null; 286 287 try { 288 clazz = Class.forName(className, true, moduleClassLoader); 289 } 290 catch (final ReflectiveOperationException | NoClassDefFoundError ignored) { 291 // ignore the exception 292 } 293 294 Object instance = null; 295 296 if (clazz != null) { 297 try { 298 final Constructor<?> declaredConstructor = clazz.getDeclaredConstructor(); 299 declaredConstructor.setAccessible(true); 300 instance = declaredConstructor.newInstance(); 301 } 302 catch (final ReflectiveOperationException ex) { 303 throw new CheckstyleException("Unable to instantiate " + className, ex); 304 } 305 } 306 307 return instance; 308 } 309 310 /** 311 * Fill short-to-full module names map. 312 */ 313 private static void fillShortToFullModuleNamesMap() { 314 fillChecksFromAnnotationPackage(); 315 fillChecksFromBlocksPackage(); 316 fillChecksFromCodingPackage(); 317 fillChecksFromDesignPackage(); 318 fillChecksFromHeaderPackage(); 319 fillChecksFromImportsPackage(); 320 fillChecksFromIndentationPackage(); 321 fillChecksFromJavadocPackage(); 322 fillChecksFromMetricsPackage(); 323 fillChecksFromModifierPackage(); 324 fillChecksFromNamingPackage(); 325 fillChecksFromRegexpPackage(); 326 fillChecksFromSizesPackage(); 327 fillChecksFromWhitespacePackage(); 328 fillModulesFromChecksPackage(); 329 fillModulesFromFilefiltersPackage(); 330 fillModulesFromFiltersPackage(); 331 fillModulesFromCheckstylePackage(); 332 } 333 334 /** 335 * Fill short-to-full module names map with Checks from annotation package. 336 */ 337 private static void fillChecksFromAnnotationPackage() { 338 NAME_TO_FULL_MODULE_NAME.put("AnnotationLocationCheck", 339 BASE_PACKAGE + ".checks.annotation.AnnotationLocationCheck"); 340 NAME_TO_FULL_MODULE_NAME.put("AnnotationOnSameLineCheck", 341 BASE_PACKAGE + ".checks.annotation.AnnotationOnSameLineCheck"); 342 NAME_TO_FULL_MODULE_NAME.put("AnnotationUseStyleCheck", 343 BASE_PACKAGE + ".checks.annotation.AnnotationUseStyleCheck"); 344 NAME_TO_FULL_MODULE_NAME.put("MissingDeprecatedCheck", 345 BASE_PACKAGE + ".checks.annotation.MissingDeprecatedCheck"); 346 NAME_TO_FULL_MODULE_NAME.put("MissingOverrideCheck", 347 BASE_PACKAGE + ".checks.annotation.MissingOverrideCheck"); 348 NAME_TO_FULL_MODULE_NAME.put("PackageAnnotationCheck", 349 BASE_PACKAGE + ".checks.annotation.PackageAnnotationCheck"); 350 NAME_TO_FULL_MODULE_NAME.put("SuppressWarningsCheck", 351 BASE_PACKAGE + ".checks.annotation.SuppressWarningsCheck"); 352 } 353 354 /** 355 * Fill short-to-full module names map with Checks from blocks package. 356 */ 357 private static void fillChecksFromBlocksPackage() { 358 NAME_TO_FULL_MODULE_NAME.put("AvoidNestedBlocksCheck", 359 BASE_PACKAGE + ".checks.blocks.AvoidNestedBlocksCheck"); 360 NAME_TO_FULL_MODULE_NAME.put("EmptyBlockCheck", 361 BASE_PACKAGE + ".checks.blocks.EmptyBlockCheck"); 362 NAME_TO_FULL_MODULE_NAME.put("EmptyCatchBlockCheck", 363 BASE_PACKAGE + ".checks.blocks.EmptyCatchBlockCheck"); 364 NAME_TO_FULL_MODULE_NAME.put("LeftCurlyCheck", 365 BASE_PACKAGE + ".checks.blocks.LeftCurlyCheck"); 366 NAME_TO_FULL_MODULE_NAME.put("NeedBracesCheck", 367 BASE_PACKAGE + ".checks.blocks.NeedBracesCheck"); 368 NAME_TO_FULL_MODULE_NAME.put("RightCurlyCheck", 369 BASE_PACKAGE + ".checks.blocks.RightCurlyCheck"); 370 } 371 372 /** 373 * Fill short-to-full module names map with Checks from coding package. 374 */ 375 // -@cs[ExecutableStatementCount] splitting this method is not reasonable. 376 private static void fillChecksFromCodingPackage() { 377 NAME_TO_FULL_MODULE_NAME.put("ArrayTrailingCommaCheck", 378 BASE_PACKAGE + ".checks.coding.ArrayTrailingCommaCheck"); 379 NAME_TO_FULL_MODULE_NAME.put("AvoidInlineConditionalsCheck", 380 BASE_PACKAGE + ".checks.coding.AvoidInlineConditionalsCheck"); 381 NAME_TO_FULL_MODULE_NAME.put("CovariantEqualsCheck", 382 BASE_PACKAGE + ".checks.coding.CovariantEqualsCheck"); 383 NAME_TO_FULL_MODULE_NAME.put("DeclarationOrderCheck", 384 BASE_PACKAGE + ".checks.coding.DeclarationOrderCheck"); 385 NAME_TO_FULL_MODULE_NAME.put("DefaultComesLastCheck", 386 BASE_PACKAGE + ".checks.coding.DefaultComesLastCheck"); 387 NAME_TO_FULL_MODULE_NAME.put("EmptyStatementCheck", 388 BASE_PACKAGE + ".checks.coding.EmptyStatementCheck"); 389 NAME_TO_FULL_MODULE_NAME.put("EqualsAvoidNullCheck", 390 BASE_PACKAGE + ".checks.coding.EqualsAvoidNullCheck"); 391 NAME_TO_FULL_MODULE_NAME.put("EqualsHashCodeCheck", 392 BASE_PACKAGE + ".checks.coding.EqualsHashCodeCheck"); 393 NAME_TO_FULL_MODULE_NAME.put("ExplicitInitializationCheck", 394 BASE_PACKAGE + ".checks.coding.ExplicitInitializationCheck"); 395 NAME_TO_FULL_MODULE_NAME.put("FallThroughCheck", 396 BASE_PACKAGE + ".checks.coding.FallThroughCheck"); 397 NAME_TO_FULL_MODULE_NAME.put("FinalLocalVariableCheck", 398 BASE_PACKAGE + ".checks.coding.FinalLocalVariableCheck"); 399 NAME_TO_FULL_MODULE_NAME.put("HiddenFieldCheck", 400 BASE_PACKAGE + ".checks.coding.HiddenFieldCheck"); 401 NAME_TO_FULL_MODULE_NAME.put("IllegalCatchCheck", 402 BASE_PACKAGE + ".checks.coding.IllegalCatchCheck"); 403 NAME_TO_FULL_MODULE_NAME.put("IllegalInstantiationCheck", 404 BASE_PACKAGE + ".checks.coding.IllegalInstantiationCheck"); 405 NAME_TO_FULL_MODULE_NAME.put("IllegalThrowsCheck", 406 BASE_PACKAGE + ".checks.coding.IllegalThrowsCheck"); 407 NAME_TO_FULL_MODULE_NAME.put("IllegalTokenCheck", 408 BASE_PACKAGE + ".checks.coding.IllegalTokenCheck"); 409 NAME_TO_FULL_MODULE_NAME.put("IllegalTokenTextCheck", 410 BASE_PACKAGE + ".checks.coding.IllegalTokenTextCheck"); 411 NAME_TO_FULL_MODULE_NAME.put("IllegalTypeCheck", 412 BASE_PACKAGE + ".checks.coding.IllegalTypeCheck"); 413 NAME_TO_FULL_MODULE_NAME.put("InnerAssignmentCheck", 414 BASE_PACKAGE + ".checks.coding.InnerAssignmentCheck"); 415 NAME_TO_FULL_MODULE_NAME.put("MagicNumberCheck", 416 BASE_PACKAGE + ".checks.coding.MagicNumberCheck"); 417 NAME_TO_FULL_MODULE_NAME.put("MissingCtorCheck", 418 BASE_PACKAGE + ".checks.coding.MissingCtorCheck"); 419 NAME_TO_FULL_MODULE_NAME.put("MissingSwitchDefaultCheck", 420 BASE_PACKAGE + ".checks.coding.MissingSwitchDefaultCheck"); 421 NAME_TO_FULL_MODULE_NAME.put("ModifiedControlVariableCheck", 422 BASE_PACKAGE + ".checks.coding.ModifiedControlVariableCheck"); 423 NAME_TO_FULL_MODULE_NAME.put("MultipleStringLiteralsCheck", 424 BASE_PACKAGE + ".checks.coding.MultipleStringLiteralsCheck"); 425 NAME_TO_FULL_MODULE_NAME.put("MultipleVariableDeclarationsCheck", 426 BASE_PACKAGE + ".checks.coding.MultipleVariableDeclarationsCheck"); 427 NAME_TO_FULL_MODULE_NAME.put("NestedForDepthCheck", 428 BASE_PACKAGE + ".checks.coding.NestedForDepthCheck"); 429 NAME_TO_FULL_MODULE_NAME.put("NestedIfDepthCheck", 430 BASE_PACKAGE + ".checks.coding.NestedIfDepthCheck"); 431 NAME_TO_FULL_MODULE_NAME.put("NestedTryDepthCheck", 432 BASE_PACKAGE + ".checks.coding.NestedTryDepthCheck"); 433 NAME_TO_FULL_MODULE_NAME.put("NoCloneCheck", 434 BASE_PACKAGE + ".checks.coding.NoCloneCheck"); 435 NAME_TO_FULL_MODULE_NAME.put("NoFinalizerCheck", 436 BASE_PACKAGE + ".checks.coding.NoFinalizerCheck"); 437 NAME_TO_FULL_MODULE_NAME.put("OneStatementPerLineCheck", 438 BASE_PACKAGE + ".checks.coding.OneStatementPerLineCheck"); 439 NAME_TO_FULL_MODULE_NAME.put("OverloadMethodsDeclarationOrderCheck", 440 BASE_PACKAGE + ".checks.coding.OverloadMethodsDeclarationOrderCheck"); 441 NAME_TO_FULL_MODULE_NAME.put("PackageDeclarationCheck", 442 BASE_PACKAGE + ".checks.coding.PackageDeclarationCheck"); 443 NAME_TO_FULL_MODULE_NAME.put("ParameterAssignmentCheck", 444 BASE_PACKAGE + ".checks.coding.ParameterAssignmentCheck"); 445 NAME_TO_FULL_MODULE_NAME.put("RequireThisCheck", 446 BASE_PACKAGE + ".checks.coding.RequireThisCheck"); 447 NAME_TO_FULL_MODULE_NAME.put("ReturnCountCheck", 448 BASE_PACKAGE + ".checks.coding.ReturnCountCheck"); 449 NAME_TO_FULL_MODULE_NAME.put("SimplifyBooleanExpressionCheck", 450 BASE_PACKAGE + ".checks.coding.SimplifyBooleanExpressionCheck"); 451 NAME_TO_FULL_MODULE_NAME.put("SimplifyBooleanReturnCheck", 452 BASE_PACKAGE + ".checks.coding.SimplifyBooleanReturnCheck"); 453 NAME_TO_FULL_MODULE_NAME.put("StringLiteralEqualityCheck", 454 BASE_PACKAGE + ".checks.coding.StringLiteralEqualityCheck"); 455 NAME_TO_FULL_MODULE_NAME.put("SuperCloneCheck", 456 BASE_PACKAGE + ".checks.coding.SuperCloneCheck"); 457 NAME_TO_FULL_MODULE_NAME.put("SuperFinalizeCheck", 458 BASE_PACKAGE + ".checks.coding.SuperFinalizeCheck"); 459 NAME_TO_FULL_MODULE_NAME.put("UnnecessaryParenthesesCheck", 460 BASE_PACKAGE + ".checks.coding.UnnecessaryParenthesesCheck"); 461 NAME_TO_FULL_MODULE_NAME.put("VariableDeclarationUsageDistanceCheck", 462 BASE_PACKAGE + ".checks.coding.VariableDeclarationUsageDistanceCheck"); 463 } 464 465 /** 466 * Fill short-to-full module names map with Checks from design package. 467 */ 468 private static void fillChecksFromDesignPackage() { 469 NAME_TO_FULL_MODULE_NAME.put("DesignForExtensionCheck", 470 BASE_PACKAGE + ".checks.design.DesignForExtensionCheck"); 471 NAME_TO_FULL_MODULE_NAME.put("FinalClassCheck", 472 BASE_PACKAGE + ".checks.design.FinalClassCheck"); 473 NAME_TO_FULL_MODULE_NAME.put("HideUtilityClassConstructorCheck", 474 BASE_PACKAGE + ".checks.design.HideUtilityClassConstructorCheck"); 475 NAME_TO_FULL_MODULE_NAME.put("InnerTypeLastCheck", 476 BASE_PACKAGE + ".checks.design.InnerTypeLastCheck"); 477 NAME_TO_FULL_MODULE_NAME.put("InterfaceIsTypeCheck", 478 BASE_PACKAGE + ".checks.design.InterfaceIsTypeCheck"); 479 NAME_TO_FULL_MODULE_NAME.put("MutableExceptionCheck", 480 BASE_PACKAGE + ".checks.design.MutableExceptionCheck"); 481 NAME_TO_FULL_MODULE_NAME.put("OneTopLevelClassCheck", 482 BASE_PACKAGE + ".checks.design.OneTopLevelClassCheck"); 483 NAME_TO_FULL_MODULE_NAME.put("ThrowsCountCheck", 484 BASE_PACKAGE + ".checks.design.ThrowsCountCheck"); 485 NAME_TO_FULL_MODULE_NAME.put("VisibilityModifierCheck", 486 BASE_PACKAGE + ".checks.design.VisibilityModifierCheck"); 487 } 488 489 /** 490 * Fill short-to-full module names map with Checks from header package. 491 */ 492 private static void fillChecksFromHeaderPackage() { 493 NAME_TO_FULL_MODULE_NAME.put("HeaderCheck", 494 BASE_PACKAGE + ".checks.header.HeaderCheck"); 495 NAME_TO_FULL_MODULE_NAME.put("RegexpHeaderCheck", 496 BASE_PACKAGE + ".checks.header.RegexpHeaderCheck"); 497 } 498 499 /** 500 * Fill short-to-full module names map with Checks from imports package. 501 */ 502 private static void fillChecksFromImportsPackage() { 503 NAME_TO_FULL_MODULE_NAME.put("AvoidStarImportCheck", 504 BASE_PACKAGE + ".checks.imports.AvoidStarImportCheck"); 505 NAME_TO_FULL_MODULE_NAME.put("AvoidStaticImportCheck", 506 BASE_PACKAGE + ".checks.imports.AvoidStaticImportCheck"); 507 NAME_TO_FULL_MODULE_NAME.put("CustomImportOrderCheck", 508 BASE_PACKAGE + ".checks.imports.CustomImportOrderCheck"); 509 NAME_TO_FULL_MODULE_NAME.put("IllegalImportCheck", 510 BASE_PACKAGE + ".checks.imports.IllegalImportCheck"); 511 NAME_TO_FULL_MODULE_NAME.put("ImportControlCheck", 512 BASE_PACKAGE + ".checks.imports.ImportControlCheck"); 513 NAME_TO_FULL_MODULE_NAME.put("ImportOrderCheck", 514 BASE_PACKAGE + ".checks.imports.ImportOrderCheck"); 515 NAME_TO_FULL_MODULE_NAME.put("RedundantImportCheck", 516 BASE_PACKAGE + ".checks.imports.RedundantImportCheck"); 517 NAME_TO_FULL_MODULE_NAME.put("UnusedImportsCheck", 518 BASE_PACKAGE + ".checks.imports.UnusedImportsCheck"); 519 } 520 521 /** 522 * Fill short-to-full module names map with Checks from indentation package. 523 */ 524 private static void fillChecksFromIndentationPackage() { 525 NAME_TO_FULL_MODULE_NAME.put("CommentsIndentationCheck", 526 BASE_PACKAGE + ".checks.indentation.CommentsIndentationCheck"); 527 NAME_TO_FULL_MODULE_NAME.put("IndentationCheck", 528 BASE_PACKAGE + ".checks.indentation.IndentationCheck"); 529 } 530 531 /** 532 * Fill short-to-full module names map with Checks from javadoc package. 533 */ 534 private static void fillChecksFromJavadocPackage() { 535 NAME_TO_FULL_MODULE_NAME.put("AtclauseOrderCheck", 536 BASE_PACKAGE + ".checks.javadoc.AtclauseOrderCheck"); 537 NAME_TO_FULL_MODULE_NAME.put("JavadocMethodCheck", 538 BASE_PACKAGE + ".checks.javadoc.JavadocMethodCheck"); 539 NAME_TO_FULL_MODULE_NAME.put("JavadocPackageCheck", 540 BASE_PACKAGE + ".checks.javadoc.JavadocPackageCheck"); 541 NAME_TO_FULL_MODULE_NAME.put("JavadocParagraphCheck", 542 BASE_PACKAGE + ".checks.javadoc.JavadocParagraphCheck"); 543 NAME_TO_FULL_MODULE_NAME.put("JavadocStyleCheck", 544 BASE_PACKAGE + ".checks.javadoc.JavadocStyleCheck"); 545 NAME_TO_FULL_MODULE_NAME.put("JavadocTagContinuationIndentationCheck", 546 BASE_PACKAGE + ".checks.javadoc.JavadocTagContinuationIndentationCheck"); 547 NAME_TO_FULL_MODULE_NAME.put("JavadocTypeCheck", 548 BASE_PACKAGE + ".checks.javadoc.JavadocTypeCheck"); 549 NAME_TO_FULL_MODULE_NAME.put("JavadocVariableCheck", 550 BASE_PACKAGE + ".checks.javadoc.JavadocVariableCheck"); 551 NAME_TO_FULL_MODULE_NAME.put("NonEmptyAtclauseDescriptionCheck", 552 BASE_PACKAGE + ".checks.javadoc.NonEmptyAtclauseDescriptionCheck"); 553 NAME_TO_FULL_MODULE_NAME.put("SingleLineJavadocCheck", 554 BASE_PACKAGE + ".checks.javadoc.SingleLineJavadocCheck"); 555 NAME_TO_FULL_MODULE_NAME.put("SummaryJavadocCheck", 556 BASE_PACKAGE + ".checks.javadoc.SummaryJavadocCheck"); 557 NAME_TO_FULL_MODULE_NAME.put("WriteTagCheck", 558 BASE_PACKAGE + ".checks.javadoc.WriteTagCheck"); 559 } 560 561 /** 562 * Fill short-to-full module names map with Checks from metrics package. 563 */ 564 private static void fillChecksFromMetricsPackage() { 565 NAME_TO_FULL_MODULE_NAME.put("BooleanExpressionComplexityCheck", 566 BASE_PACKAGE + ".checks.metrics.BooleanExpressionComplexityCheck"); 567 NAME_TO_FULL_MODULE_NAME.put("ClassDataAbstractionCouplingCheck", 568 BASE_PACKAGE + ".checks.metrics.ClassDataAbstractionCouplingCheck"); 569 NAME_TO_FULL_MODULE_NAME.put("ClassFanOutComplexityCheck", 570 BASE_PACKAGE + ".checks.metrics.ClassFanOutComplexityCheck"); 571 NAME_TO_FULL_MODULE_NAME.put("CyclomaticComplexityCheck", 572 BASE_PACKAGE + ".checks.metrics.CyclomaticComplexityCheck"); 573 NAME_TO_FULL_MODULE_NAME.put("JavaNCSSCheck", 574 BASE_PACKAGE + ".checks.metrics.JavaNCSSCheck"); 575 NAME_TO_FULL_MODULE_NAME.put("NPathComplexityCheck", 576 BASE_PACKAGE + ".checks.metrics.NPathComplexityCheck"); 577 } 578 579 /** 580 * Fill short-to-full module names map with Checks from modifier package. 581 */ 582 private static void fillChecksFromModifierPackage() { 583 NAME_TO_FULL_MODULE_NAME.put("ModifierOrderCheck", 584 BASE_PACKAGE + ".checks.modifier.ModifierOrderCheck"); 585 NAME_TO_FULL_MODULE_NAME.put("RedundantModifierCheck", 586 BASE_PACKAGE + ".checks.modifier.RedundantModifierCheck"); 587 } 588 589 /** 590 * Fill short-to-full module names map with Checks from naming package. 591 */ 592 private static void fillChecksFromNamingPackage() { 593 NAME_TO_FULL_MODULE_NAME.put("AbbreviationAsWordInNameCheck", 594 BASE_PACKAGE + ".checks.naming.AbbreviationAsWordInNameCheck"); 595 NAME_TO_FULL_MODULE_NAME.put("AbstractClassNameCheck", 596 BASE_PACKAGE + ".checks.naming.AbstractClassNameCheck"); 597 NAME_TO_FULL_MODULE_NAME.put("CatchParameterNameCheck", 598 BASE_PACKAGE + ".checks.naming.CatchParameterNameCheck"); 599 NAME_TO_FULL_MODULE_NAME.put("ClassTypeParameterNameCheck", 600 BASE_PACKAGE + ".checks.naming.ClassTypeParameterNameCheck"); 601 NAME_TO_FULL_MODULE_NAME.put("ConstantNameCheck", 602 BASE_PACKAGE + ".checks.naming.ConstantNameCheck"); 603 NAME_TO_FULL_MODULE_NAME.put("InterfaceTypeParameterNameCheck", 604 BASE_PACKAGE + ".checks.naming.InterfaceTypeParameterNameCheck"); 605 NAME_TO_FULL_MODULE_NAME.put("LocalFinalVariableNameCheck", 606 BASE_PACKAGE + ".checks.naming.LocalFinalVariableNameCheck"); 607 NAME_TO_FULL_MODULE_NAME.put("LocalVariableNameCheck", 608 BASE_PACKAGE + ".checks.naming.LocalVariableNameCheck"); 609 NAME_TO_FULL_MODULE_NAME.put("MemberNameCheck", 610 BASE_PACKAGE + ".checks.naming.MemberNameCheck"); 611 NAME_TO_FULL_MODULE_NAME.put("MethodNameCheck", 612 BASE_PACKAGE + ".checks.naming.MethodNameCheck"); 613 NAME_TO_FULL_MODULE_NAME.put("MethodTypeParameterNameCheck", 614 BASE_PACKAGE + ".checks.naming.MethodTypeParameterNameCheck"); 615 NAME_TO_FULL_MODULE_NAME.put("PackageNameCheck", 616 BASE_PACKAGE + ".checks.naming.PackageNameCheck"); 617 NAME_TO_FULL_MODULE_NAME.put("ParameterNameCheck", 618 BASE_PACKAGE + ".checks.naming.ParameterNameCheck"); 619 NAME_TO_FULL_MODULE_NAME.put("StaticVariableNameCheck", 620 BASE_PACKAGE + ".checks.naming.StaticVariableNameCheck"); 621 NAME_TO_FULL_MODULE_NAME.put("TypeNameCheck", 622 BASE_PACKAGE + ".checks.naming.TypeNameCheck"); 623 } 624 625 /** 626 * Fill short-to-full module names map with Checks from regexp package. 627 */ 628 private static void fillChecksFromRegexpPackage() { 629 NAME_TO_FULL_MODULE_NAME.put("RegexpCheck", 630 BASE_PACKAGE + ".checks.regexp.RegexpCheck"); 631 NAME_TO_FULL_MODULE_NAME.put("RegexpMultilineCheck", 632 BASE_PACKAGE + ".checks.regexp.RegexpMultilineCheck"); 633 NAME_TO_FULL_MODULE_NAME.put("RegexpOnFilenameCheck", 634 BASE_PACKAGE + ".checks.regexp.RegexpOnFilenameCheck"); 635 NAME_TO_FULL_MODULE_NAME.put("RegexpSinglelineCheck", 636 BASE_PACKAGE + ".checks.regexp.RegexpSinglelineCheck"); 637 NAME_TO_FULL_MODULE_NAME.put("RegexpSinglelineJavaCheck", 638 BASE_PACKAGE + ".checks.regexp.RegexpSinglelineJavaCheck"); 639 } 640 641 /** 642 * Fill short-to-full module names map with Checks from sizes package. 643 */ 644 private static void fillChecksFromSizesPackage() { 645 NAME_TO_FULL_MODULE_NAME.put("AnonInnerLengthCheck", 646 BASE_PACKAGE + ".checks.sizes.AnonInnerLengthCheck"); 647 NAME_TO_FULL_MODULE_NAME.put("ExecutableStatementCountCheck", 648 BASE_PACKAGE + ".checks.sizes.ExecutableStatementCountCheck"); 649 NAME_TO_FULL_MODULE_NAME.put("FileLengthCheck", 650 BASE_PACKAGE + ".checks.sizes.FileLengthCheck"); 651 NAME_TO_FULL_MODULE_NAME.put("LineLengthCheck", 652 BASE_PACKAGE + ".checks.sizes.LineLengthCheck"); 653 NAME_TO_FULL_MODULE_NAME.put("MethodCountCheck", 654 BASE_PACKAGE + ".checks.sizes.MethodCountCheck"); 655 NAME_TO_FULL_MODULE_NAME.put("MethodLengthCheck", 656 BASE_PACKAGE + ".checks.sizes.MethodLengthCheck"); 657 NAME_TO_FULL_MODULE_NAME.put("OuterTypeNumberCheck", 658 BASE_PACKAGE + ".checks.sizes.OuterTypeNumberCheck"); 659 NAME_TO_FULL_MODULE_NAME.put("ParameterNumberCheck", 660 BASE_PACKAGE + ".checks.sizes.ParameterNumberCheck"); 661 } 662 663 /** 664 * Fill short-to-full module names map with Checks from whitespace package. 665 */ 666 private static void fillChecksFromWhitespacePackage() { 667 NAME_TO_FULL_MODULE_NAME.put("EmptyForInitializerPadCheck", 668 BASE_PACKAGE + ".checks.whitespace.EmptyForInitializerPadCheck"); 669 NAME_TO_FULL_MODULE_NAME.put("EmptyForIteratorPadCheck", 670 BASE_PACKAGE + ".checks.whitespace.EmptyForIteratorPadCheck"); 671 NAME_TO_FULL_MODULE_NAME.put("EmptyLineSeparatorCheck", 672 BASE_PACKAGE + ".checks.whitespace.EmptyLineSeparatorCheck"); 673 NAME_TO_FULL_MODULE_NAME.put("FileTabCharacterCheck", 674 BASE_PACKAGE + ".checks.whitespace.FileTabCharacterCheck"); 675 NAME_TO_FULL_MODULE_NAME.put("GenericWhitespaceCheck", 676 BASE_PACKAGE + ".checks.whitespace.GenericWhitespaceCheck"); 677 NAME_TO_FULL_MODULE_NAME.put("MethodParamPadCheck", 678 BASE_PACKAGE + ".checks.whitespace.MethodParamPadCheck"); 679 NAME_TO_FULL_MODULE_NAME.put("NoLineWrapCheck", 680 BASE_PACKAGE + ".checks.whitespace.NoLineWrapCheck"); 681 NAME_TO_FULL_MODULE_NAME.put("NoWhitespaceAfterCheck", 682 BASE_PACKAGE + ".checks.whitespace.NoWhitespaceAfterCheck"); 683 NAME_TO_FULL_MODULE_NAME.put("NoWhitespaceBeforeCheck", 684 BASE_PACKAGE + ".checks.whitespace.NoWhitespaceBeforeCheck"); 685 NAME_TO_FULL_MODULE_NAME.put("OperatorWrapCheck", 686 BASE_PACKAGE + ".checks.whitespace.OperatorWrapCheck"); 687 NAME_TO_FULL_MODULE_NAME.put("ParenPadCheck", 688 BASE_PACKAGE + ".checks.whitespace.ParenPadCheck"); 689 NAME_TO_FULL_MODULE_NAME.put("SeparatorWrapCheck", 690 BASE_PACKAGE + ".checks.whitespace.SeparatorWrapCheck"); 691 NAME_TO_FULL_MODULE_NAME.put("SingleSpaceSeparatorCheck", 692 BASE_PACKAGE + ".checks.whitespace.SingleSpaceSeparatorCheck"); 693 NAME_TO_FULL_MODULE_NAME.put("TypecastParenPadCheck", 694 BASE_PACKAGE + ".checks.whitespace.TypecastParenPadCheck"); 695 NAME_TO_FULL_MODULE_NAME.put("WhitespaceAfterCheck", 696 BASE_PACKAGE + ".checks.whitespace.WhitespaceAfterCheck"); 697 NAME_TO_FULL_MODULE_NAME.put("WhitespaceAroundCheck", 698 BASE_PACKAGE + ".checks.whitespace.WhitespaceAroundCheck"); 699 } 700 701 /** 702 * Fill short-to-full module names map with modules from checks package. 703 */ 704 private static void fillModulesFromChecksPackage() { 705 NAME_TO_FULL_MODULE_NAME.put("ArrayTypeStyleCheck", 706 BASE_PACKAGE + ".checks.ArrayTypeStyleCheck"); 707 NAME_TO_FULL_MODULE_NAME.put("AvoidEscapedUnicodeCharactersCheck", 708 BASE_PACKAGE + ".checks.AvoidEscapedUnicodeCharactersCheck"); 709 NAME_TO_FULL_MODULE_NAME.put("DescendantTokenCheck", 710 BASE_PACKAGE + ".checks.DescendantTokenCheck"); 711 NAME_TO_FULL_MODULE_NAME.put("FinalParametersCheck", 712 BASE_PACKAGE + ".checks.FinalParametersCheck"); 713 NAME_TO_FULL_MODULE_NAME.put("NewlineAtEndOfFileCheck", 714 BASE_PACKAGE + ".checks.NewlineAtEndOfFileCheck"); 715 NAME_TO_FULL_MODULE_NAME.put("OuterTypeFilenameCheck", 716 BASE_PACKAGE + ".checks.OuterTypeFilenameCheck"); 717 NAME_TO_FULL_MODULE_NAME.put("SuppressWarningsHolder", 718 BASE_PACKAGE + ".checks.SuppressWarningsHolder"); 719 NAME_TO_FULL_MODULE_NAME.put("TodoCommentCheck", 720 BASE_PACKAGE + ".checks.TodoCommentCheck"); 721 NAME_TO_FULL_MODULE_NAME.put("TrailingCommentCheck", 722 BASE_PACKAGE + ".checks.TrailingCommentCheck"); 723 NAME_TO_FULL_MODULE_NAME.put("TranslationCheck", 724 BASE_PACKAGE + ".checks.TranslationCheck"); 725 NAME_TO_FULL_MODULE_NAME.put("UncommentedMainCheck", 726 BASE_PACKAGE + ".checks.UncommentedMainCheck"); 727 NAME_TO_FULL_MODULE_NAME.put("UniquePropertiesCheck", 728 BASE_PACKAGE + ".checks.UniquePropertiesCheck"); 729 NAME_TO_FULL_MODULE_NAME.put("UpperEllCheck", 730 BASE_PACKAGE + ".checks.UpperEllCheck"); 731 } 732 733 /** 734 * Fill short-to-full module names map with modules from filefilters package. 735 */ 736 private static void fillModulesFromFilefiltersPackage() { 737 NAME_TO_FULL_MODULE_NAME.put("BeforeExecutionExclusionFileFilter", 738 BASE_PACKAGE + ".filefilters.BeforeExecutionExclusionFileFilter"); 739 } 740 741 /** 742 * Fill short-to-full module names map with modules from filters package. 743 */ 744 private static void fillModulesFromFiltersPackage() { 745 NAME_TO_FULL_MODULE_NAME.put("CsvFilter", 746 BASE_PACKAGE + ".filters.CsvFilter"); 747 NAME_TO_FULL_MODULE_NAME.put("IntMatchFilter", 748 BASE_PACKAGE + ".filters.IntMatchFilter"); 749 NAME_TO_FULL_MODULE_NAME.put("IntRangeFilter", 750 BASE_PACKAGE + ".filters.IntRangeFilter"); 751 NAME_TO_FULL_MODULE_NAME.put("SeverityMatchFilter", 752 BASE_PACKAGE + ".filters.SeverityMatchFilter"); 753 NAME_TO_FULL_MODULE_NAME.put("SuppressionCommentFilter", 754 BASE_PACKAGE + ".filters.SuppressionCommentFilter"); 755 NAME_TO_FULL_MODULE_NAME.put("SuppressionFilter", 756 BASE_PACKAGE + ".filters.SuppressionFilter"); 757 NAME_TO_FULL_MODULE_NAME.put("SuppressionXpathFilter", 758 BASE_PACKAGE + ".filters.SuppressionXpathFilter"); 759 NAME_TO_FULL_MODULE_NAME.put("SuppressWarningsFilter", 760 BASE_PACKAGE + ".filters.SuppressWarningsFilter"); 761 NAME_TO_FULL_MODULE_NAME.put("SuppressWithNearbyCommentFilter", 762 BASE_PACKAGE + ".filters.SuppressWithNearbyCommentFilter"); 763 } 764 765 /** 766 * Fill short-to-full module names map with modules from checkstyle package. 767 */ 768 private static void fillModulesFromCheckstylePackage() { 769 NAME_TO_FULL_MODULE_NAME.put("Checker", BASE_PACKAGE + ".Checker"); 770 NAME_TO_FULL_MODULE_NAME.put("TreeWalker", BASE_PACKAGE + ".TreeWalker"); 771 } 772}