jdk-sandbox: comparison jdk/src/java.base/share/classes/java/lang/module/ModulePath.java

equal deleted inserted replaced

-:ec60c3290242
+:7c84df693837
 import java.nio.file.NoSuchFileException;
 import java.nio.file.Path;
 import java.nio.file.attribute.BasicFileAttributes;
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.HashSet;
+import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.jar.Attributes;
 import java.util.jar.JarFile;
 import java.util.jar.Manifest;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
-import java.util.stream.Stream;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipFile;
 import jdk.internal.module.Checks;
 import jdk.internal.module.ConfigurableModuleFinder;
 // directory of modules
 return scanDirectory(entry);
 }
 }
-if (attrs.isRegularFile() || attrs.isDirectory()) {
+// packaged or exploded module
-// packaged or exploded module
+ModuleReference mref = readModule(entry, attrs);
-ModuleReference mref = readModule(entry, attrs);
+if (mref != null) {
-if (mref != null) {
+String name = mref.descriptor().name();
-String name = mref.descriptor().name();
+return Collections.singletonMap(name, mref);
-return Collections.singletonMap(name, mref);
+} else {
-}
+// skipped
-}
+return Collections.emptyMap();
+}
-// not recognized
-throw new FindException("Unrecognized module: " + entry);
 } catch (IOException ioe) {
 throw new FindException(ioe);
 }
 }
 ModuleReference mref = readModule(entry, attrs);
 // module found
 if (mref != null) {
 // can have at most one version of a module in the directory
 String name = mref.descriptor().name();
 if (nameToReference.put(name, mref) != null) {
 throw new FindException("Two versions of module "
 + name + " found in " + dir);
 }
 }
 }
 }
 return nameToReference;
 }
 /**
 * Locates a packaged or exploded module, returning a {@code ModuleReference}
-* to the module. Returns {@code null} if the module is not recognized
+* to the module. Returns {@code null} if the entry is skipped because it is
-* as a packaged or exploded module.
+* to a directory that does not contain a module-info.class or it's a hidden
+* file.
 *
 * @throws IOException if an I/O error occurs
-* @throws FindException if an error occurs parsing the module descriptor
+* @throws FindException if the file is not recognized as a module or an
+*         error occurs parsing its module descriptor
 */
 private ModuleReference readModule(Path entry, BasicFileAttributes attrs)
 throws IOException
 {
 try {
-ModuleReference mref = null;
 if (attrs.isDirectory()) {
-mref = readExplodedModule(entry);
+return readExplodedModule(entry); // may return null
-} if (attrs.isRegularFile()) {
+}
-if (entry.toString().endsWith(".jar")) {
-mref = readJar(entry);
+String fn = entry.getFileName().toString();
-} else if (isLinkPhase && entry.toString().endsWith(".jmod")) {
+if (attrs.isRegularFile()) {
-mref = readJMod(entry);
+if (fn.endsWith(".jar")) {
+return readJar(entry);
+} else if (fn.endsWith(".jmod")) {
+if (isLinkPhase)
+return readJMod(entry);
+throw new FindException("JMOD files not supported: " + entry);
 }
 }
-return mref;
+// skip hidden files
+if (fn.startsWith(".") || Files.isHidden(entry)) {
+return null;
+} else {
+throw new FindException("Unrecognized module: " + entry);
+}
 } catch (InvalidModuleDescriptorException e) {
 throw new FindException("Error reading module: " + entry, e);
 }
 }
 private Set<String> jmodPackages(ZipFile zf) {
 return zf.stream()
 .filter(e -> e.getName().startsWith("classes/") &&
 e.getName().endsWith(".class"))
-.map(e -> toPackageName(e))
+.map(e -> toPackageName(e.getName().substring(8)))
 .filter(pkg -> pkg.length() > 0) // module-info
-.distinct()
 .collect(Collectors.toSet());
 }
 /**
 * Returns a {@code ModuleReference} to a module in jmod file on the
 * file system.
+*
+* @throws IOException
+* @throws InvalidModuleDescriptorException
 */
 private ModuleReference readJMod(Path file) throws IOException {
 try (ZipFile zf = new ZipFile(file.toString())) {
 ZipEntry ze = zf.getEntry("classes/" + MODULE_INFO);
 if (ze == null) {
 if (vs != null)
 builder.version(vs);
 // scan the entries in the JAR file to locate the .class and service
 // configuration file
-Stream<String> stream = jf.stream()
+Map<Boolean, Set<String>> map =
-.map(e -> e.getName())
+jf.stream()
-.filter(e -> (e.endsWith(".class") || e.startsWith(SERVICES_PREFIX)))
+.map(JarEntry::getName)
-.distinct();
+.filter(s -> (s.endsWith(".class") ^ s.startsWith(SERVICES_PREFIX)))
-Map<Boolean, Set<String>> map
+.collect(Collectors.partitioningBy(s -> s.endsWith(".class"),
-= stream.collect(Collectors.partitioningBy(s -> s.endsWith(".class"),
+Collectors.toSet()));
-Collectors.toSet()));
 Set<String> classFiles = map.get(Boolean.TRUE);
 Set<String> configFiles = map.get(Boolean.FALSE);
 // all packages are exported
 classFiles.stream()
 .map(c -> toPackageName(c))
 .distinct()
-.forEach(p -> builder.exports(p));
+.forEach(builder::exports);
 // map names of service configuration files to service names
 Set<String> serviceNames = configFiles.stream()
 .map(this::toServiceName)
-.filter(Optional::isPresent)
+.flatMap(Optional::stream)
-.map(Optional::get)
 .collect(Collectors.toSet());
 // parse each service configuration file
 for (String sn : serviceNames) {
 JarEntry entry = jf.getJarEntry(SERVICES_PREFIX + sn);
-Set<String> providerClasses = new HashSet<>();
+Set<String> providerClasses = new LinkedHashSet<>();
 try (InputStream in = jf.getInputStream(entry)) {
 BufferedReader reader
 = new BufferedReader(new InputStreamReader(in, "UTF-8"));
 String cn;
 while ((cn = nextLine(reader)) != null) {
 }
 private Set<String> jarPackages(JarFile jf) {
 return jf.stream()
 .filter(e -> e.getName().endsWith(".class"))
-.map(e -> toPackageName(e))
+.map(e -> toPackageName(e.getName()))
 .filter(pkg -> pkg.length() > 0)   // module-info
-.distinct()
 .collect(Collectors.toSet());
 }
 /**
 * Returns a {@code ModuleReference} to a module in modular JAR file on
 * the file system.
+*
+* @throws IOException
+* @throws FindException
+* @throws InvalidModuleDescriptorException
 */
 private ModuleReference readJar(Path file) throws IOException {
-try (JarFile jf = new JarFile(file.toString())) {
+try (JarFile jf = new JarFile(file.toFile(),
+true,               // verify
+ZipFile.OPEN_READ,
+JarFile.Release.RUNTIME))
+{
 ModuleDescriptor md;
 JarEntry entry = jf.getJarEntry(MODULE_INFO);
 if (entry == null) {
 // no module-info.class so treat it as automatic module
 return Files.find(dir, Integer.MAX_VALUE,
 ((path, attrs) -> attrs.isRegularFile() &&
 path.toString().endsWith(".class")))
 .map(path -> toPackageName(dir.relativize(path)))
 .filter(pkg -> pkg.length() > 0)   // module-info
-.distinct()
 .collect(Collectors.toSet());
 } catch (IOException x) {
 throw new UncheckedIOException(x);
 }
 }
 /**
 * Returns a {@code ModuleReference} to an exploded module on the file
 * system or {@code null} if {@code module-info.class} not found.
+*
+* @throws IOException
+* @throws InvalidModuleDescriptorException
 */
 private ModuleReference readExplodedModule(Path dir) throws IOException {
 Path mi = dir.resolve(MODULE_INFO);
 ModuleDescriptor md;
 try (InputStream in = Files.newInputStream(mi)) {
 } else {
 return "";
 }
 }
-private String toPackageName(ZipEntry entry) {
-String name = entry.getName();
-assert name.endsWith(".class");
-// jmod classes in classes/, jar in /
-int start = name.startsWith("classes/") ? 8 : 0;
-int index = name.lastIndexOf("/");
-if (index > start) {
-return name.substring(start, index).replace('/', '.');
-} else {
-return "";
-}
-}
 private String toPackageName(Path path) {
 String name = path.toString();
 assert name.endsWith(".class");
 int index = name.lastIndexOf(File.separatorChar);
 if (index != -1) {

changeset 37779	7c84df693837
parent 36511	9d0388c6b336
child 39050	9de41b79ec7e