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