All Classes and Interfaces
Class
Description
Determines which IntelliJ `.iml` file should be synced when there are
two `.iml` files present:
One for
jeka-src
One for the project
The SyncFocus specifies which of these `.iml` files will be prioritized
for synchronization.Utility class that allows formatting text into two columns.
Utility class that allows formatting text into many column.
Provides a view on files and sub-folders contained in a given directory or zip file.
The JkProcess class represents a process that can be executed on the system.
Template class for performing actions on application to be deployed and undeployed.
Artifacts are files produced by projects in order to be published and reused by other projects.
Defines methods for enumerating and locating artifacts files likely to be produced.
Container for artifact files to publish.
Definition for Jeka class option.
Definition of method in a given class that can be called by Jeka.
Adapter for both JkProject an BaseKBean that can be used as an abstraction
on this two classes.
Wrapper class around
ClassLoader providing convenient methods.Utility class for formatting text into columns.
Folder layout for a project output.
Specifies the options of the Jeka compiler for jeka-src classes.
Repeatable container.
Dependency on computed resource.
Holds constants about project structures
A mutable container for
Consumer.Represents a set of identifiers for binary artifacts.
When declaring a module dependency, we implicitly request for the main artifact of this module.
A dependency on an external module supposed to be located in a binary repository.
Class behaving as a file supplier for a given dependency.
Consumer behaving like
JkIndentLogDecorator but displaying the source line where each log occurs.Adds an element to jeka-src classpath.
Repeatable container.
Interface standing for a dependency.
A piece of information aiming at excluding transitive dependencies.
Class to resolve dependencies to files or dependency tree.
A set of
JkDependency generally standing for a given purpose (compile, test, runtime) in a project build.Result of merging two
JkDependencySet.This class allows modifying a JkDependencySet using a series of method calls.
Tag to let IDE recognise that the value can be suggested with dependency coordinate
Documents the annotated element so that Jeka can display some information
when 'help' is invoked from command line.
Class providing utility methods for executing Docker commands.
Docker Builder assistant for defining and creating Docker images.
Defines the modes for creating a nonroot user in a Docker image.
Docker Builder assistant for creating Docker images that run JVM applications.
Provides functionality tailored to JVM programs, such as setting classes, classpaths, agents, and Maven repositories for fetching tools.
Provides functionality tailored to JVM programs, such as setting classes, classpaths, agents, and Maven repositories for fetching tools.
Docker Builder assistant for creating Docker images that run native applications compiled with GraalVM.
Provides a default Docker build configuration using a multi-stage build process: The first stage is the build image, which compiles the JVM application into a native executable. The native executable is then copied into the production image to serve as the entrypoint.
Provides a default Docker build configuration using a multi-stage build process: The first stage is the build image, which compiles the JVM application into a native executable. The native executable is then copied into the production image to serve as the entrypoint.
Indicates that the annotated KBean has documentation accessible at the specified value.
Borrowed from VincerDom https://github.com/djeang/vincer-dom
Wrapper for
Document offering a Parent-Chaining fluent interface.Borrowed from VincerDom https://github.com/djeang/vincer-dom
Wrapper for
Element offering a Parent-Chaining fluent interface.Borrowed from VincerDom https://github.com/djeang/vincer-dom
Utility class to create
XPathExpression avoiding checked exceptions.Provides method to generate Eclipse .classpath metadata files.
Memory model of Eclipse .project file.
Marker exception to notice a misconfiguration from the user or an infrastructure problem.
Exported methods to integrate with external tools.
Dependencies that can directly provide files without passing by an external medium.
A dependency on files located on file system.
This decorator shows minimalist task decoration...
A utility class for executing Git commands within a specific directory.
Provides methods for signing data with GnuPG.
Provides methods for verifying signature with GnuPG.
A utility class for constructing and executing HTTP requests using
HttpURLConnection.Information necessary to generate metadata project file for IDE.
Object model for IntelliJ iml files.
Provides method to generate and read Eclipse metadata files.
This decorator adds indentation for logs nested within a task.
Provides information about Jeka running instance.
Class for instantiating builds while displaying meaningful information about environment on console.
Adds an entry to the jeka-src classpath where this annotation is declared.
Deprecated.
Use @JkDep instead
Repeatable container.
Deprecated.
Use @JkCompileOption instead
Repeatable container.
Deprecated.
Use
JkPropValue insteadDeprecated.
Use @
JkInject insteadNot part of public API
Not part of public api
Not part of the public API.
Not part of the public API
Not part of the public API
Not part of the public API.
Information required to publish a module in an Ivy repository.
Utilities class to produce Jar files.
Writes JAR content, ensuring valid directory entries are always created and
duplicated items are ignored.
Compiler for Java source code.
Stands for a compilation settings as source and target version, encoding, annotation processing
or any option supported by the compileRunner.
Provides fluent interface for producing Javadoc.
Offers fluent interface for launching Java processes.
Java specification version
A utility class to check if the Jeka related classes imported in Jeka classpath are compatible with
the running Jeka version.
Interface representing a utility for JSON serialization and deserialization.
Represents a Kotlin compiler.
Represents the possible target platforms for the Kotlin compiler.
Stands for a compilation settings as source and target version, encoding, annotation processing
or any option supported by the compileRunner.
Provides location related to the running Jeka instance.
Provides static methods for logging events.
Available style of logging displaying.
Type of events emitted by logs.
Levels of logging
Wrapper class on
Manifest providing utility methods.Object representation of the maven-metadata.xml file found in Maven
repositories for describing available timestamped snapshot available for a
given version.
Represents a Maven project with various utility methods for performing common tasks.
Publication specific information to include in POM file in order to be published of a Maven repository.
Utility class for working with IntelliJ IDEA's `misc.xml` configuration file.
Information about problem when resolving dependencies
Identify a module (such as Google Guava).
A type-safe container that maps String keys to values while maintaining natural key ordering,
with special handling for both numeric and non-numeric keys.
Convenient class wrapping maven process.
Handles native compilation to produce executables from a list of JAR files.
This decorator adds task numbering
s: 1
s: 1.1
s: 1.1.1
e:
s: 1.1.2
A path standing for a file (not a directory).
A collection of pre-defined
PathMatchers, each associated with a label for human-readable identification.A sequence of file path (folder or archive).
Provides a view on files and sub-folders contained in a given directory or zip file.
Immutable collection of
JkPathTree instances representing multiple
directory trees or zip file trees.Wraps a POM file (Ideally an effective POM file) and provides convenient methods to extract
information on.
These are extra information required to publish on Maven central.
Information about a developer.
Information about a license.
Constants on popular modules used in Java ecosystem.
Marks an instance KBean method to run KBean initialization phase.
Marks a static KBean method to run during KBean initialization.
The JkProcess class represents a process that can be executed on the system.
Represents a handler for a running process.
Represents the result of a process execution.
Stands for the whole project model for building purpose.
Flag to indicate if we need to include, or not, runtime dependencies in some scenario.
This class handles the compilation phase for a project, including source generation, resource
processing, dependency resolution, and Java source compilation.
A simplified facade over
JkProject to access its configuration
through a single entry point.Responsible to create binary, Javadoc and Source jars.
Provides factory methods to create different types of publications for a JkProject.
Provides features to scaffold projects.
Handles project testing step.
A set of name-value pairs.
Injects the environment variable value if such a one exists and an option as not been already injected on.
Many tools as Maven, Ivy, Gradle or Intellij qualify dependencies according their purpose and how
they should be used for resolution or publication.
Represents a set of qualified dependencies.
Hold configuration necessary to instantiate download or upload repository
Configuration specific to publishing.
Configuration specific to Ivy.
Provides static methods for creating repositories from standard properties.
A set of
JkRepoMarks a method that dynamically computes a required KBean for a KBean declaring the method.
This class provides a configurable set of parameters for controlling dependency resolution behavior.
Strategy for resolving version conflict
A representation of a node in a dependency tree.
Result of a module dependency resolution for a given scope.
When resolving a module dependencies for a given scope, we expect to get The list of files constituting the resolved dependencies (the jar files for instance) The
When resolving a module dependencies for a given scope, we expect to get The list of files constituting the resolved dependencies (the jar files for instance) The
JkVersionProvider that specify which static version has been
taken in account when a module dependency is declared using dynamic versions
(as 1.0.+)
This processor basically copies some resource files to a target folder
(generally the class folder).
Execution context associated with a base directory.
A mutable container for
Runnable.Object that process scaffolding.
Provides method to generate a project skeleton (folder structure, configuration files, ....)
Functional interface for signing data.
A generic abstract class that decorates a
Stream.Tag to let IDE recognise that the value can be suggested with specified values
Processor executing a given bunch of tests existing in compiled Java classes.
Style of progress mark to display on console while the tests are running.
Mutable object to specify a set of test to run according class root dirs, file patterns and tags.
In Maven repositories, modules are published along a pom.xml metadata containing
the transitive dependencies of the module.
A serializable
UnaryOperatorWrapper around
URLClassLoader offering convenient methods and fluent
interface to deal with URLClassLoader.Utility class for dealing with assertions.
Utility class for dealing with Inputs/Outputs.
Runs a thread copying all data from the specified input stream to specified output streams.
Utility class for dealing with
Iterable.Convenient methods to deal with running JDK.
Deprecated.
Use
JkHttpResponse insteadUtility class for dealing with generic Object class instances.
Utility class providing convenient methods to deal with
Path.A container object representing both a zip file and its content.
Utility class for dealing with reflection
Proxy Invocation handler, that delegate to target instance via reflection
Utility class for dealing with strings.
Utility class to deal with the underlying ofSystem.
The
JkUtilsSystem.Processor.Arch enum defines the architecture of
a microprocessor.The
JkUtilsSystem.Processor.Type enum defines types of a microprocessor.Utility class to deal with
ThrowableUtility class to deal with time.
Utilities methods to ease XML api of the JDK
Low level utility method to deal with zip files.
Used to specify a module version.
Version calculator from git info.
Association between getModuleIds and version.
A
JkPathTree for zip path tree located in a zip file.Base class for KBean.
Standard options for packaging java projects.
Options about tests