All Classes and Interfaces
Class
Description
Abstract mojo.
A
javac argfile materialised on disk.Method or constructor arguments.
Java sources split the way Maven compiles them: one batch per source
root, never two roots in one batch.
A file that is considered binary.
Checks node/closing brackets to be the last symbols on the line.
Make sure each line indentation is either:
the same as previous one or less
bigger than previous by exactly 4
Also, if the previous non-empty line consists only of closing brackets
(and optional trailing semicolon or comma), the current line indentation
must not be greater than that of the closing bracket line, since the
expression has been already terminated.
Check the project and find all possible violations.
Validator with Checkstyle.
Rule to flag
AutoCloseable expressions that are created inline and
then consumed by another expression instead of a resource boundary.Performs multiline regexp match only if a regexp condition passes.
Checks that constant, declared as private field of class is used more than
once.
Checks that constructors do not contain any method calls.
Checks the order of constructor declarations.
Checks node/closing curly brackets to be the last symbols on the line.
Environment, passed from MOJO to validators.
Checks if possible to use Diamond operator in generic instances creation.
Validate with maven-duplicate-finder-plugin.
Checks that a class, interface, enum or annotation declaration is followed
by an empty line before its first member.
Check for empty lines inside methods and constructors.
Validate with maven-enforcer-plugin.
Checks that enum constant names conform to the same naming convention
as
static final fields (i.e., the default Checkstyle
ConstantName pattern ^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$).Environment.
Mock of
Environment.Validates source code with Google ErrorProne.
Rule to check that a method does not take too many parameters.
Detects unnecessary semicolons placed after the closing brace
of a class, interface, record, method or constructor declaration.
Checks that try-with-resources does not end with a semicolon.
Prohibits a fully qualified type name where an import would do.
Forbids an
else branch when the then branch of an
if statement ends with a throw.A file Qulice leaves alone, wherever the project keeps it.
Prohibits an implicit constructor in a class that Javadoc documents.
Rule to flag an interface that is implicitly functional (declares exactly
one abstract method) but is not annotated with
@FunctionalInterface.Check if import lines are all together without any empty lines or comments.
Check for compact paragraph tags in Javadoc.
Check for the empty Javadoc line before the group of at-clauses.
Check for empty lines inside Javadoc.
Check for text on the first line of a multi-line Javadoc.
Checks that there is no empty line between a javadoc and it's subject,
and that no annotation is placed above the javadoc.
Checks that Javadoc body text is not over-indented.
Checks method parameters order to comply with what is defined in method
javadoc.
Check for a stray asterisk at the end of a Javadoc line.
Check that the class/interface javadoc does not contain prohibited
author or version tags and has a properly formatted
since tag.Prohibit a trailing dot in the description of
@param and
@return Javadoc tags.Checks that every
@throws (or @exception) tag in the
javadoc of a method or constructor refers to an exception actually
declared in the throws clause of that method/constructor.Check for a Javadoc paragraph that is never closed.
Represent a line range.
Represents a set of LineRange objects.
Checks method bodies for comments.
Checks that method and constructor declarations do not span multiple
lines when the entire signature can fit on one line within the limit.
Names of methods, tolerant to the methods of a JNA binding.
Checks the order of methods declaration.
Executor of plugins.
Multi line comment checker.
Check indents in multi line JavaDoc tags.
Forbids nested
switch statements.Checks that there is no Javadoc for inherited methods.
Checks that there is no Javadoc for private methods, both static
and non-static ones.
Checks that non static method must contain at least one reference to
this.Number of parameters, tolerant to constructors that only take attributes
and to private methods.
Abstract parameters.
Represents one PMD error (usually it will be violation).
PmdError backed by a ConfigError.
PmdError backed by a ProcessingError.
PmdError backed by a RuleViolation.
Validates source code with PMD.
Check pom.xml with XPath validation queries.
Checks that test classes do not declare instance fields, since
such fields couple tests together through shared state.
Rule to flag redundant
String.format(...) calls passed as
arguments to com.jcabi.log.Logger methods.Prohibits hard-coded line separator escape sequences inside string literals.
Checks that classes are declared as final.
Rule to check plain assertions in JUnit tests.
Checks that a class does not declare a static nested class, since a
static nested class is a self-contained abstraction and belongs in
a file of its own.
Forbids the
expected parameter on JUnit's @Test annotation.Forbids
@Test-annotated methods whose name starts with
test or should.Checks that constructor, declared as private class is used more than once.
Checks that final class doesn't contain protected methods unless they are
overriding protected methods from superclass.
Checks if inner classes are properly accessed using their qualified name
with the outer class.
Checks that constructors do not contain a redundant
super()
call when the enclosing class does not extend any class explicitly.Path of a file relative to a base directory.
Validator.
Checks that String.split is only invoked with regex arguments that the JDK
handles via its fastpath.
C++ style inline comment is not allowed.
Checks that a private static constant is mentioned more than once.
Check that the project has not SNAPSHOT dependencies if its own
status is stable.
Checks that static members are not accessed through an instance reference.
Checks for not using concatenation of string literals in any form.
Rule to check that a class does not declare too many fields.
Rule to check that a class does not expose too many methods.
Class, interface, constructor or method generic type parameters.
Rule to check that JUnit/TestNG test methods do not contain more than
one assertion.
Rule to check that JUnit/TestNG test methods contain at least one
assertion.
Checks that every
@checkstyle suppression names an enabled check.Prohibits the redundant
java.lang. prefix in front of a simple
class name.Rule to check unnecessary local variables.
Rule to flag
Arrays.asList invocations that are passed a single
non-array argument.Rule to prohibit use of String.length() when checking for empty string.
Exception thrown by a validator, if it fails.
Validator.
Validation result.
Default validation result.
The
-Xplugin argument that wires ErrorProne into a forked
javac, together with the bug patterns it leaves out.