jdk-sandbox: comparison langtools/src/jdk.jdeps/share/classes/com/sun/tools/jdeps/JdepsTask.java

equal deleted inserted replaced

-:b6e87a8600a4
+:8e8b50c7491d
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.text.MessageFormat;
 import java.util.*;
+import java.util.function.Function;
+import java.util.function.ToIntFunction;
 import java.util.jar.JarFile;
 import java.util.regex.Pattern;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
 /**
 * Implementation for the jdeps tool for static class dependency analysis.
 */
 class JdepsTask {
 task.options.addmods.addAll(mods);
 }
 },
 new Option(true, "-m", "--module") {
 void process(JdepsTask task, String opt, String arg) throws BadArgs {
-task.options.rootModule = arg;
+if (!task.options.rootModules.isEmpty()) {
+throw new BadArgs("err.option.already.specified", opt);
+}
+task.options.rootModules.add(arg);
 task.options.addmods.add(arg);
 }
 },
 new Option(true, "--multi-release") {
 void process(JdepsTask task, String opt, String arg) throws BadArgs {
 }
 },
 new Option(true, "--require") {
 void process(JdepsTask task, String opt, String arg) {
 task.options.requires.add(arg);
+task.options.addmods.add(arg);
 }
 },
 new Option(true, "-f", "-filter") {
 void process(JdepsTask task, String opt, String arg) {
 task.options.filterRegex = Pattern.compile(arg);
 showVersion(options.fullVersion);
 }
 if (options.help || options.version || options.fullVersion) {
 return EXIT_OK;
 }
-if (!inputArgs.isEmpty() && options.rootModule != null) {
-reportError("err.invalid.arg.for.option", "-m");
-}
 if (options.numFilters() > 1) {
 reportError("err.invalid.filters");
 return EXIT_CMDERR;
 }
 .sorted(Map.Entry.comparingByKey())
 .forEach(e -> log.println(getMessage("split.package",
 e.getKey(),
 e.getValue().toString())));
-// check if any module specified in --require is missing
+// check if any module specified in --add-modules, --require, and -m is missing
-Stream.concat(options.addmods.stream(), options.requires.stream())
+options.addmods.stream()
 .filter(mn -> !config.isValidToken(mn))
 .forEach(mn -> config.findModule(mn).orElseThrow(() ->
 new UncheckedBadArgs(new BadArgs("err.module.not.found", mn))));
 return command.run(config);
 abstract class Command {
 final CommandOption option;
 protected Command(CommandOption option) {
 this.option = option;
 }
 /**
 * Returns true if the command-line options are all valid;
 * otherwise, returns false.
 */
 abstract boolean checkOptions();
 */
 abstract boolean run(JdepsConfiguration config) throws IOException;
 /**
 * Includes all modules on system module path and application module path
+*
+* When a named module is analyzed, it will analyze the dependences
+* only.  The method should be overridden when this command should
+* analyze all modules instead.
 */
 boolean allModules() {
 return false;
 }
 // -summary cannot use with -verbose option
 if (options.verbose != null) {
 reportError("err.invalid.options", "-v, -verbose", "-s, -summary");
 return false;
 }
+}
+if (!inputArgs.isEmpty() && !options.rootModules.isEmpty()) {
+reportError("err.invalid.arg.for.option", "-m");
 }
 if (inputArgs.isEmpty() && !options.hasSourcePath()) {
 showHelp();
 return false;
 }
 boolean ok = analyzer.run();
 log.println();
 if (!options.requires.isEmpty())
 log.println(getMessage("inverse.transitive.dependencies.on",
 options.requires));
 else
 log.println(getMessage("inverse.transitive.dependencies.matching",
 options.regex != null
 ? options.regex.toString()
 : "packages " + options.packageNames));
-analyzer.inverseDependences().stream()
+analyzer.inverseDependences()
-.sorted(Comparator.comparing(this::sortPath))
+.stream()
-.forEach(path -> log.println(path.stream()
+.sorted(comparator())
-.map(Archive::getName)
+.map(this::toInversePath)
-.collect(joining(" <- "))));
+.forEach(log::println);
 return ok;
 }
-private String sortPath(Deque<Archive> path) {
+private String toInversePath(Deque<Archive> path) {
-return path.peekFirst().getName();
+return path.stream()
+.map(Archive::getName)
+.collect(joining(" <- "));
+}
+/*
+* Returns a comparator for sorting the inversed path, grouped by
+* the first module name, then the shortest path and then sort by
+* the module names of each path
+*/
+private Comparator<Deque<Archive>> comparator() {
+return Comparator.<Deque<Archive>, String>
+comparing(deque -> deque.peekFirst().getName())
+.thenComparingInt(Deque::size)
+.thenComparing(this::toInversePath);
+}
+/*
+* Returns true if --require is specified so that all modules are
+* analyzed to find all modules that depend on the modules specified in the
+* --require option directly and indirectly
+*/
+public boolean allModules() {
+return options.requires.size() > 0;
 }
 }
 class GenModuleInfo extends Command {
 list, "--check"));
 }
 return new ModuleAnalyzer(config, log, modules).run();
 }
+/*
+* Returns true to analyze all modules
+*/
 public boolean allModules() {
 return true;
 }
 }
 if (options.findJDKInternals) {
 reportError("err.invalid.options", "-jdkinternals",
 option);
 return false;
 }
+if (!inputArgs.isEmpty() && !options.rootModules.isEmpty()) {
+reportError("err.invalid.arg.for.option", "-m");
+}
 if (inputArgs.isEmpty() && !options.hasSourcePath()) {
 showHelp();
 return false;
 }
 return true;
 boolean run(JdepsConfiguration config) throws IOException {
 return new ModuleExportsAnalyzer(config,
 dependencyFilter(config),
 reduced,
 log).run();
-}
-@Override
-boolean allModules() {
-return true;
 }
 }
 class GenDotFile extends AnalyzeDeps {
 boolean inverse = false;
 boolean compileTimeView = false;
 String systemModulePath = System.getProperty("java.home");
 String upgradeModulePath;
 String modulePath;
-String rootModule;
+Set<String> rootModules = new HashSet<>();
 Set<String> addmods = new HashSet<>();
 Runtime.Version multiRelease;
 boolean hasSourcePath() {
 return !addmods.isEmpty() || includePattern != null;

changeset 43026	8e8b50c7491d
parent 42840	dfe1a03d4db4
child 43873	705d732d3715