All Classes and Interfaces
Class
Description
A utility for validating the shape of ASTs and filtering them to retrieve.
A type for querying and filtering expression statements.
A type for querying and filtering name expressions.
A type for querying and filtering a single variable declaration.
A type for querying and filtering method call expressions.
A type for querying and filtering name expressions.
A type for querying and filtering generic AST nodes.
A type for querying and filtering string literals.
A type for querying and filtering variable declaration(s).
A static library for querying and returning patterns over AST nodes.
A
Node iterator iterating over all the nodes that precedes a given node in the
pre-order of its AST.Builder for
CallReplacer.Represents the result of changes made during parsing.
The base of a codemod type.
Holds a code directory (e.g., a repository root).
Used to mark types providing codemod functionality and provide the necessary metadata.
Represents a change made to the code.
A description of how important it is that a codemod execute in the list of codemods being run.
A type responsible for executing a codemod on a set of files.
Represents the result of scanning a file for changes.
A codemod and its ID.
The context we provide to each codemod.
This type is responsible for loading codemods and the surrounding subsystem.
A
Describes a codemod parameter.
A type that helps provide functionality codemods.
A type that is relied on to inform our in-flight analysis on whether codemods are allowed.
A type responsible for reporting codemod changes.
A utility class for accessing a codemod's resources in it's "default location" the classpath.
Type responsible for running a codemod on a single file, performing the analysis and file
changes.
A type that plugins can implement to enrich or modify CodeTF results.
A type that allows composing multiple
JavaParserChanger instances are under the same
umbrella.During analysis, this will be the default setting for every rule.
A type that describes a new dependency being added to a project.
Models a Java dependency we might want to add.
The license, if known, of a dependency.
Represents the result of a dependency update operation.
An implementation of the Either monad.
Detects the encoding of a file.
Holds the nodes in the AST that represents a local variable declaration statement.
A cache for file contents.
A codemod that only fixes issues and does not perform its own detection, instead relying on
external analysis from other tools.
Holds the nodes in the AST that represents a variable declaration in an enhanced for statement .
Holds the nodes in the AST that represents a variable declaration in a for statement init
expression.
Represents the importance of a codemod.
This is the main interaction point with types for detecting if a path should be included.
Uses JavaParser to change Java source files.
Responsible for parsing Java files and maintaining the compilation units across different
accesses.
Responsible for generating
JavaParser instances.A utility for making it easy to transform JavaParser ASTs.
Represents a line of code.
Linearizes a string expression
For a given file, this type provides an API for callers to understand if certain line numbers are
allowed.
Given a set of lines to exclude, determine if we should allow changes to this line.
Given a set of lines to include, determine if we should allow changes to this line.
Utilities related to line numbers.
A local declaration.
Contains the expressions and statements that span the scope of a local declaration.
Holds the nodes in the AST that represents several types of local declaration of a variable.
A configurator for the log levels that defaults to "quiet" mode.
A type that can collect specific types of nodes from a
CompilationUnit.A parameter for a codemod, capable of retrieving the right value for a given path and line.
Represents the declaration of a parameter in a method, constructor, lambda expression, and catch
clause.
This type is used in include/exclude logic for matching paths.
Represents a position in a source file.
A type that plugins can implement to provide a project management functions to codemods.
Gives access to raw files for performing arbitrary changes.
This type does the heavy lifting for many protections that can work in a simple
"search-and-replace" pattern for non-Java code.
A type that can match a
Region to a Range for determining if we should change the
node at this location.Represents a codemod author's confidence that changes wll be safe and effective.
Defines a model for interacting with SARIF.
An empty implementation of
RuleSarif for binding codemods with no SARIF results.Builds
RuleSarifs.Provides an entrypoint for CLIs built with the codemodder framework.
Utility class for working with SARIF model objects.
Utility class for building keys for SARIF findings.
SarifPluginJavaParserChanger<T extends com.github.javaparser.ast.Node>
Provides base functionality for making JavaParser-based changes based on results found by a sarif
file.
A
RawFileChanger bundled with a RuleSarif.Describes a region of source code.
A type responsible for extracting a region from a result
Represent a normally-structured Java source code directory and all its files underneath it.
Represents a worker class that reads a list of repository roots and captures the Java source
directories.
Holds the nodes in the AST that represents a variable declaration as a try resource.
Type that gets used to modify an XML stream.
A handler for
XMLEvents that match an XPath expression.Represents the results when an XML file is transformed using
XPathStreamProcessor.Performs configurable actions on nodes that match XPath expressions.