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