Jadecy stands for Java Dependencies and Cycles computer.
Jadecy provides treatments to compute dependencies, strongly connected components (SCCs), and cycles, in classes or packages dependencies graphs parsed from class files, either through API or through command line. Lower level treatments, such as graph related computations, are also publicly available.
It's an evolution of http://sourceforge.net/projects/jcycles.
Apache License V2.0
-
src/main, src/build, src/samples:
- Java 5+, except net.jadecy.comp.JavacHelper which uses JavaCompiler and thus requires Java 6+
-
src/test:
- Java 16+ (for records)
- JUnit 3.8.1 (under lib/junit.jar)
-
Jadecy: The entry point.
-
JadecyUtils: Utilities for dealing with Jadecy, in particular its results.
-
DepUnit: For cycles and dependencies unit tests.
-
JadecyMain: Allows for a simple usage of Jadecy from command line, or from code with either main(...) or runArgs(...) methods.
-
Handles class files of major version <= 64 (Java 20), and does best effort if major version is higher.
-
Cannot parse .jimage files, which would require dependency to jrt-fs.jar, which itself requires Java 8, and is not trivial to use (FileSystemNotFoundException is easy to get), but their content can easily be extracted into class files using jimage executable.
-
Uses Tarjan's algorithm for SCCs computation, and Johnson's algorithm for cycles computation, with continuations instead of recursion, which allows to handle large graphs (< 2^31 vertices).
-
To avoid spam due to dependencies within a same top level class and its recursively nested classes, cycles and SCCs only involving such classes are always ignored by Jadecy class treatments.
-
Lower level APIs such as for class files parsing, classes and packages trees and graphs manipulation, or graph related computations, are also publicly available (cf. overview below), and can easily be extracted (sources contain no cyclic dependencies, except deliberate ones in tests).
-
As a general rule, for convenience, these treatments ensure determinism and when possible some ordering in their result.
-
Sample Jadecy class usage can be found in src/samples/java, and more use cases in tests.
-
Sample command line usages with .bat files (based on that, UX or MAC users should easily be able to do their own scripts) can be found in src/samples/scripts, and more use cases in tests.
-
Javadoc: Code Javadoc is done in plain text, not using HTML, for simplicity and easier writing and reading when working with source code.
-
net.jadecy: Contains treatments to compute dependencies, strongly connected components, and cycles, in classes or packages dependencies graphs parsed from class files. Principal classes:
- Jadecy: The entry point.
- JadecyUtils: Utilities for dealing with Jadecy, in particular its results.
- DepUnit: To check dependencies and cycles in unit tests.
-
net.jadecy.cmd: Contains classes for Jadecy usage through command line. Principal classes:
- JadecyMain: Allows for a simple usage of Jadecy from command line, or from code with either main(...) or runArgs(...) methods.
-
net.jadecy.code: Contains classes for modeling classes and packages trees and dependencies, and related utilities. Principal classes:
- ClassData: Represents a class.
- PackageData: Represents a package.
-
net.jadecy.comp: Contains classes to make it easy to compile Java code programmatically, so as to be able to use Jadecy or DepUnit on the resulting class files, or to build this library.
-
net.jadecy.graph: Contains classes for graphs representations and computations. Principal classes:
- InterfaceVertex: Interface for representing a vertex and its successors, a graph being a collection of vertices.
- ReachabilityComputer: Computes dependencies.
- OneShortestPathComputer: Computes one shortest path.
- PathsGraphComputer: Computes a graph containing all paths from a set of vertices to another.
- SccsComputer: Computes strongly connected components.
- CyclesComputer: Computes cycles (all of them).
- ShortestCyclesComputer: Computes shortest cycles (covering all the edges involved in cycles, i.e. of each SCC).
- SomeCyclesComputer: Computes some cycles (if any, finds at least one).
-
net.jadecy.names: Contains classes for dealing with packages or classes names. Principal classes:
- NameFilters: Filters for defining sets of classes or packages.
- NameUtils: Utilities for packages or classes names.
-
net.jadecy.parsing: Classes for parsing classes and packages dependencies from file system or memory. Principal classes:
- ClassDepsParser: Computes direct dependencies of a class.
- FsDepsParser: Parses dependencies from file system.
Comparison done in 2015, so with an early version of jdeps.
- Doesn't necessarily compute the same dependencies with -apionly option (but generally the same ones without it).
- Has no feature related to modules, or origin source or jar files.
- Does not by default discriminate between JDK internals and other classes, not to be tied to JDK structure (but that can be done using custom parsing filters, and the filter used to define the set of classes which dependencies must be computed among parsed classes).
- Does not indicate in which file or archive classes were found.
- The set of files which dependencies must be computed is not given as a list, but by a regular expression used against parsed elements.
- Can compute on graphs of packages dependencies (in addition to class dependencies), in which case classes causing each dependency can be indicated.
- Allows to compute depending elements (in addition to elements depended on), using inverse dependencies graph.
- Allows to compute differential dependencies, i.e. the additional dependencies caused by a set of elements over those caused by another set of elements.
- Allows to compute step-by-step dependencies, up to a max amount of steps.
- Allows to compute byte size of dependencies, for example as a rough measure of the associated conceptual weight.
- Allows to compute one shortest path between two sets of elements, or a graph containing all paths up to a max length.
- Allows to compute strongly connected components (of size > 1).
- Allows to compute (shortest) cycles covering all edges of each SCC, or all cycles (might take a long time), or some cycles (at least one if any).
- Allows to output into a file, whether or not DOT format is used.
- Considers dependencies of nested classes, but allows to merge them into top level class, which is the default.
- Doesn't by default filter out classes of same package.
- Is more likely not to be silent, and to output error messages, when inputs are broken or things go wrong.
