Support LocationManager.resolvePath for single jar

Author: rfscholte

plexus-java/pom.xml

@@ -55,6 +55,7 @@
         <configuration>
           <includes>
               <include>**/*Test.java</include>
+              <include>**/*IT.java</include>
           </includes>      
         </configuration>
       </plugin>

plexus-java/src/main/java/org/codehaus/plexus/languages/java/jpms/CmdModuleNameExtractor.java

@@ -0,0 +1,41 @@
+package org.codehaus.plexus.languages.java.jpms;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import java.nio.file.Path;
+
+/**
+ * This is just a placeholder class
+ * 
+ * @author Robert Scholte
+ * @since 1.0.0
+ */
+public class CmdModuleNameExtractor
+{
+    /**
+     * 
+     * @param modulePath
+     * @return
+     */
+    public static String getModuleName( Path modulePath )
+    {
+        throw new UnsupportedOperationException();
+    }
+}

plexus-java/src/main/java/org/codehaus/plexus/languages/java/jpms/JavaModuleDescriptor.java

@@ -72,6 +72,48 @@ public static Builder newAutomaticModule( String name )
         return new Builder( name ).setAutomatic( true );
     }  
 
+    @Override
+    public int hashCode()
+    {
+        return Objects.hash( name, automatic, requires, exports );
+    }
+    
+    @Override
+    public boolean equals( Object obj )
+    {
+        if ( this == obj )
+        {
+            return true;
+        }
+        if ( obj == null )
+        {
+            return false;
+        }
+        if ( getClass() != obj.getClass() )
+        {
+            return false;
+        }
+
+        JavaModuleDescriptor other = (JavaModuleDescriptor) obj;
+        if ( automatic != other.automatic )
+        {
+            return false;
+        }
+        if ( !Objects.equals( name, other.name ) )
+        {
+            return false;
+        }
+        if ( !Objects.equals( requires, other.requires ) )
+        {
+            return false;
+        }
+        if ( !Objects.equals( exports, other.exports ) )
+        {
+            return false;
+        }
+        return true;
+    }
+    
     /**
      * A JavaModuleDescriptor Builder
      * 
@@ -306,7 +348,5 @@ public boolean equals( Object obj )
             }
             return true;
         }
-        
-        
     }
 }

plexus-java/src/main/java/org/codehaus/plexus/languages/java/jpms/LocationManager.java

@@ -33,7 +33,6 @@
 import javax.inject.Singleton;
 
 import org.codehaus.plexus.component.annotations.Component;
-import org.codehaus.plexus.languages.java.jpms.ResolvePathsResult.ModuleNameSource;
 
 /**
  * Maps artifacts to modules and analyzes the type of required modules
@@ -49,18 +48,46 @@ public class LocationManager
 
     private SourceModuleInfoParser sourceParser;
 
+    private ManifestModuleNameExtractor manifestModuleNameExtractor;
+    
     public LocationManager()
     {
         this.binaryParser = new BinaryModuleInfoParser();
         this.sourceParser = new SourceModuleInfoParser();
+        this.manifestModuleNameExtractor = new ManifestModuleNameExtractor();
     }
 
     LocationManager( ModuleInfoParser binaryParser, SourceModuleInfoParser sourceParser )
     {
         this.binaryParser = binaryParser;
         this.sourceParser = sourceParser;
+        this.manifestModuleNameExtractor = new ManifestModuleNameExtractor();
     }
 
+    public <T> ResolvePathResult resolvePath( final ResolvePathRequest<T> request  ) throws Exception
+    {
+        ModuleNameExtractor filenameExtractor = new ModuleNameExtractor()
+        {
+            MainClassModuleNameExtractor extractor = new MainClassModuleNameExtractor( request.getJdkHome() );
+            
+            @Override
+            public String extract( Path file )
+                throws IOException
+            {
+                if ( request.getJdkHome() != null )
+                {
+                    return extractor.extract( Collections.singletonMap( file, file ) ).get( file );
+                }
+                else
+                {
+                    return CmdModuleNameExtractor.getModuleName( file );
+                }
+            }
+        };
+        
+        return resolvePath( request.toPath( request.getPathElement() ), filenameExtractor );
+    }
+    
     /**
      * Decide for every {@code request.getPathElements()} if it belongs to the modulePath or classPath, based on the
      * {@code request.getMainModuleDescriptor()}.
@@ -69,10 +96,10 @@ public LocationManager()
      * @return the result of the resolution
      * @throws IOException if a critical IOException occurs
      */
-    public <T> ResolvePathsResult<T> resolvePaths( ResolvePathsRequest<T> request )
+    public <T> ResolvePathsResult<T> resolvePaths( final ResolvePathsRequest<T> request )
         throws IOException
     {
-        ResolvePathsResult<T> result = request.createResult();
+        final ResolvePathsResult<T> result = request.createResult();
 
         Map<T, JavaModuleDescriptor> pathElements = new LinkedHashMap<>( request.getPathElements().size() );
 
@@ -107,72 +134,44 @@ else if ( descriptorPath.endsWith( "module-info.class" ) )
         // start from root
         result.setMainModuleDescriptor( mainModuleDescriptor );
 
-        Map<T, Path> filenameAutoModules = new HashMap<>();
+        final Map<T, Path> filenameAutoModules = new HashMap<>();
 
-        ManifestModuleNameExtractor manifestModuleNameExtractor = new ManifestModuleNameExtractor();
-
         // collect all modules from path
-        for ( T t : request.getPathElements() )
+        for ( final T t : request.getPathElements() )
         {
-            Path path = request.toPath( t );
+            JavaModuleDescriptor moduleDescriptor;
+            ModuleNameSource source;
 
-            JavaModuleDescriptor moduleDescriptor = null;
-            ModuleNameSource source = null;
-            
-            // either jar or outputDirectory
-            if ( Files.isRegularFile( path ) || Files.exists( path.resolve( "module-info.class" ) ) )
+            ModuleNameExtractor nameExtractor = new ModuleNameExtractor()
             {
-                try
+                @Override
+                public String extract( Path path )
+                    throws IOException
                 {
-                    moduleDescriptor = binaryParser.getModuleDescriptor( path );
-                }
-                catch( IOException e )
-                {
-                    result.getPathExceptions().put( t, e );
-                    continue;
-                }
-            }
-
-            if ( moduleDescriptor != null ) 
-            {
-                source = ModuleNameSource.MODULEDESCRIPTOR;
-            }
-            else
-            {
-                String moduleName = manifestModuleNameExtractor.extract( path );
-
-                if ( moduleName != null )
-                {
-                    source = ModuleNameSource.MANIFEST;
-                }
-                else if ( request.getJdkHome() != null )
-                {
-                    // Will require external JVM, which is considered slow(er)
-                    // Collect first, next resolve all at once
-                    filenameAutoModules.put( t, path );
-                }
-                else 
-                {
-                    try
+                    if ( request.getJdkHome() != null )
                     {
-                        moduleName = MainClassModuleNameExtractor.getModuleName( path );
+                        filenameAutoModules.put( t, path );
                     }
-                    catch ( Exception e )
+                    else
                     {
-                        result.getPathExceptions().put( t, e );
-                        continue;
-                    }
-                    
-                    if ( moduleName != null )
-                    {
-                        source = ModuleNameSource.FILENAME;
+                        return CmdModuleNameExtractor.getModuleName( path );
                     }
+                    return null;
                 }
+            };
+           
+            try
+            {
+                ResolvePathResult resolvedPath = resolvePath( request.toPath( t ), nameExtractor );
+                
+                moduleDescriptor = resolvedPath.getModuleDescriptor();
 
-                if ( moduleName != null )
-                {
-                    moduleDescriptor = JavaModuleDescriptor.newAutomaticModule( moduleName ).build();
-                }
+                source = resolvedPath.getModuleNameSource();
+            }
+            catch ( Exception e )
+            {
+                result.getPathExceptions().put( t, e );
+                continue;
             }
 
             if ( moduleDescriptor != null )
@@ -243,6 +242,49 @@ else if ( request.getJdkHome() != null )
         return result;
     }
 
+    private ResolvePathResult resolvePath( Path path, ModuleNameExtractor fileModulenameExtractor ) throws Exception
+    {
+        ResolvePathResult result = new ResolvePathResult();
+        JavaModuleDescriptor moduleDescriptor = null;
+        
+        // either jar or outputDirectory
+        if ( Files.isRegularFile( path ) || Files.exists( path.resolve( "module-info.class" ) ) )
+        {
+            moduleDescriptor = binaryParser.getModuleDescriptor( path );
+        }
+
+        if ( moduleDescriptor != null ) 
+        {
+            result.setModuleNameSource( ModuleNameSource.MODULEDESCRIPTOR );
+        }
+        else
+        {
+            String moduleName = manifestModuleNameExtractor.extract( path );
+
+            if ( moduleName != null )
+            {
+                result.setModuleNameSource( ModuleNameSource.MANIFEST );
+            }
+            else 
+            {
+                moduleName = fileModulenameExtractor.extract( path );
+                
+                if ( moduleName != null )
+                {
+                    result.setModuleNameSource( ModuleNameSource.FILENAME );
+                }
+            }
+
+            if ( moduleName != null )
+            {
+                moduleDescriptor = JavaModuleDescriptor.newAutomaticModule( moduleName ).build();
+            }
+        }
+        
+        result.setModuleDescriptor( moduleDescriptor );
+        return result;
+    }
+    
     private void select( JavaModuleDescriptor module, Map<String, JavaModuleDescriptor> availableModules,
                          Set<String> namedModules )
     {