Ignore JPMS when all modules are automatic

Author: mizdebsk

xmvn-mojo/src/main/java/org/fedoraproject/xmvn/mojo/JavadocModule.java

@@ -25,15 +25,22 @@
  */
 class JavadocModule
 {
-    private final String moduleName;
+    private String moduleName;
+
+    private boolean isAutomatic;
+
+    private final Path artifactPath;
 
     private final List<Path> sourcePaths;
 
     private final List<Path> binaryPaths;
 
-    public JavadocModule( String moduleName, Path artifactPath, List<Path> sourcePaths, List<Path> dependencies )
+    public JavadocModule( String moduleName, boolean isAutomatic, Path artifactPath, List<Path> sourcePaths,
+                          List<Path> dependencies )
     {
         this.moduleName = moduleName;
+        this.isAutomatic = isAutomatic;
+        this.artifactPath = artifactPath;
         this.sourcePaths = sourcePaths;
         binaryPaths = new ArrayList<>( Collections.singleton( artifactPath ) );
         binaryPaths.addAll( dependencies );
@@ -54,6 +61,11 @@ public boolean isNotModular()
         return moduleName == null;
     }
 
+    public boolean isAutomatic()
+    {
+        return isAutomatic;
+    }
+
     public List<Path> getSourcePaths()
     {
         return sourcePaths;
@@ -63,4 +75,17 @@ public List<Path> getClassPaths()
     {
         return binaryPaths;
     }
+
+    public JavadocModule demodularize()
+    {
+        return new JavadocModule( null, false, artifactPath, sourcePaths, binaryPaths );
+    }
+
+    @Override
+    public String toString()
+    {
+        String name = moduleName != null ? moduleName : "UNNAMED";
+        String automatic = isAutomatic ? "automatic" : "non-automatic";
+        return automatic + " module " + name + " at " + artifactPath;
+    }
 }

xmvn-mojo/src/main/java/org/fedoraproject/xmvn/mojo/JavadocMojo.java

@@ -181,8 +181,6 @@ else if ( project.getBuild().getOutputDirectory() != null )
             // Ignore dependency resolution errors
         }
 
-        String moduleName = ignoreJPMS ? null : moduleGleaner.glean( artifactPath );
-
         List<Path> sourcePaths = project.getCompileSourceRoots().stream() //
                                         .filter( Objects::nonNull ) //
                                         .map( Paths::get ) //
@@ -191,7 +189,9 @@ else if ( project.getBuild().getOutputDirectory() != null )
                                         .filter( Files::isDirectory ) //
                                         .collect( Collectors.toList() );
 
-        modules.add( new JavadocModule( moduleName, artifactPath, sourcePaths, dependencies ) );
+        JavadocModule module = moduleGleaner.glean( artifactPath, sourcePaths, dependencies, ignoreJPMS );
+        modules.add( module );
+        logger.debug( "Gleaner found " + module );
     }
 
     private List<JavadocModule> discoverModules()
@@ -212,6 +212,21 @@ private List<JavadocModule> discoverModules()
             }
         }
 
+        long nModular = modules.stream().filter( JavadocModule::isModular ).count();
+        long nAutomatic = modules.stream().filter( JavadocModule::isAutomatic ).count();
+        long nNonAutomatic = nModular - nAutomatic;
+        if ( nAutomatic > 0 && nNonAutomatic > 0 )
+        {
+            logger.warn( "Found " + nNonAutomatic + " non-automacit modules (with module-info) and " + nAutomatic
+                + " automatic modules. Mixing automatic and non-automatic modules is not supported."
+                + " Javadoc is likely to fail. For more info see debug output." );
+        }
+        if ( nAutomatic == nModular )
+        {
+            logger.info( "All discovered modules are automatic modules, thus ignoring JPMS" );
+            modules = modules.stream().map( JavadocModule::demodularize ).collect( Collectors.toList() );
+        }
+
         return modules;
     }
 

xmvn-mojo/src/main/java/org/fedoraproject/xmvn/mojo/ModuleGleaner.java

@@ -21,6 +21,7 @@
 import java.io.InputStream;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.List;
 import java.util.jar.JarEntry;
 import java.util.jar.JarInputStream;
 import java.util.jar.Manifest;
@@ -34,7 +35,7 @@
  */
 class ModuleGleaner
 {
-    private String gleanFromManifest( Manifest mf )
+    private String gleanAutomaticFromManifest( Manifest mf )
     {
         if ( mf != null )
         {
@@ -47,7 +48,28 @@ private String gleanFromManifest( Manifest mf )
         return null;
     }
 
-    private String gleanFromModuleInfo( InputStream inputStream )
+    private String gleanAutomaticFromJar( Path jarPath )
+    {
+        try ( JarInputStream jis = new JarInputStream( Files.newInputStream( jarPath ) ) )
+        {
+            return gleanAutomaticFromManifest( jis.getManifest() );
+        }
+        catch ( IOException e )
+        {
+            return null;
+        }
+    }
+
+    private String gleanAutomatic( Path path )
+    {
+        if ( path.getFileName().toString().endsWith( ".jar" ) )
+        {
+            return gleanAutomaticFromJar( path );
+        }
+        return null;
+    }
+
+    private String gleanFromModuleInfoClass( InputStream inputStream )
         throws IOException
     {
         String[] moduleName = new String[1];
@@ -64,37 +86,37 @@ public ModuleVisitor visitModule( String modName, int modAccess, String modVersi
         return moduleName[0];
     }
 
-    private String gleanFromJar( Path jarPath )
+    private String gleanModuleInfoFromJar( Path jarPath )
     {
         try ( JarInputStream jis = new JarInputStream( Files.newInputStream( jarPath ) ) )
         {
             for ( JarEntry entry; ( entry = jis.getNextJarEntry() ) != null; )
             {
                 if ( "module-info.class".equals( entry.getName() ) )
                 {
-                    String moduleName = gleanFromModuleInfo( jis );
+                    String moduleName = gleanFromModuleInfoClass( jis );
                     if ( moduleName != null )
                     {
                         return moduleName;
                     }
                 }
             }
-            return gleanFromManifest( jis.getManifest() );
+            return null;
         }
         catch ( IOException e )
         {
             return null;
         }
     }
 
-    private String gleanFromClasses( Path classesPath )
+    private String gleanModuleInfoFromClasses( Path classesPath )
     {
         Path moduleInfoPath = classesPath.resolve( "module-info.class" );
         if ( Files.isRegularFile( moduleInfoPath ) )
         {
             try ( InputStream is = Files.newInputStream( moduleInfoPath ) )
             {
-                return gleanFromModuleInfo( is );
+                return gleanFromModuleInfoClass( is );
             }
             catch ( IOException e )
             {
@@ -103,16 +125,32 @@ private String gleanFromClasses( Path classesPath )
         return null;
     }
 
-    public String glean( Path path )
+    private String gleanModuleInfo( Path path )
     {
         if ( Files.isDirectory( path ) )
         {
-            return gleanFromClasses( path );
+            return gleanModuleInfoFromClasses( path );
         }
         if ( path.getFileName().toString().endsWith( ".jar" ) )
         {
-            return gleanFromJar( path );
+            return gleanModuleInfoFromJar( path );
         }
         return null;
     }
+
+    public JavadocModule glean( Path artifactPath, List<Path> sourcePaths, List<Path> dependencies, boolean ignoreJPMS )
+    {
+        String moduleName = null;
+        boolean isAutomatic = false;
+        if ( !ignoreJPMS )
+        {
+            moduleName = gleanModuleInfo( artifactPath );
+            if ( moduleName == null )
+            {
+                moduleName = gleanAutomatic( artifactPath );
+                isAutomatic = moduleName != null;
+            }
+        }
+        return new JavadocModule( moduleName, isAutomatic, artifactPath, sourcePaths, dependencies );
+    }
 }