Drop dependency to plexus-container-default - replace logging with slf4j

slachiewicz · slachiewicz · commit 2ed77f57ef2b · 2023-06-11T15:40:29.000+02:00
diff --git a/plexus-compiler-api/pom.xml b/plexus-compiler-api/pom.xml
@@ -18,6 +18,11 @@
       <groupId>org.codehaus.plexus</groupId>
       <artifactId>plexus-utils</artifactId>
     </dependency>
+    <dependency>
+      <groupId>org.slf4j</groupId>
+      <artifactId>slf4j-api</artifactId>
+      <version>1.7.36</version>
+    </dependency>
     <dependency>
       <groupId>org.junit.jupiter</groupId>
       <artifactId>junit-jupiter-api</artifactId>
diff --git a/plexus-compiler-api/src/main/java/org/codehaus/plexus/compiler/AbstractCompiler.java b/plexus-compiler-api/src/main/java/org/codehaus/plexus/compiler/AbstractCompiler.java
@@ -24,8 +24,9 @@
  * SOFTWARE.
  */
 
-import org.codehaus.plexus.logging.AbstractLogEnabled;
 import org.codehaus.plexus.util.DirectoryScanner;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.io.File;
 import java.io.IOException;
@@ -39,9 +40,9 @@
  * @author <a href="mailto:trygvis@inamo.no">Trygve Laugst&oslash;l</a>
  */
 public abstract class AbstractCompiler
-    extends AbstractLogEnabled
     implements Compiler
 {
+    protected Logger log = LoggerFactory.getLogger ( getClass() );
     protected static final String EOL = System.lineSeparator();
 
     protected static final String PS = System.getProperty( "path.separator" );
@@ -280,11 +281,11 @@ private static String getCanonicalPath( File origFile )
 
     protected void logCompiling( String[] sourceFiles, CompilerConfiguration config )
     {
-        if ( ( getLogger() != null ) && getLogger().isInfoEnabled() )
+        if ( log.isInfoEnabled() )
         {
             String to = ( config.getWorkingDirectory() == null ) ? config.getOutputLocation() :
                 config.getWorkingDirectory().toPath().relativize( new File( config.getOutputLocation() ).toPath() ).toString();
-            getLogger().info( "Compiling " +
+            log.info( "Compiling " +
                                   ( sourceFiles == null ? "" : ( sourceFiles.length + " source file" + ( sourceFiles.length == 1 ? " " : "s " ) ) ) +
                                   "with " + getCompilerId() + " [" + config.describe() + "]" +
                                   " to " + to );
diff --git a/plexus-compiler-manager/src/main/java/org/codehaus/plexus/compiler/manager/DefaultCompilerManager.java b/plexus-compiler-manager/src/main/java/org/codehaus/plexus/compiler/manager/DefaultCompilerManager.java
@@ -27,7 +27,6 @@
 import org.codehaus.plexus.compiler.Compiler;
 import org.codehaus.plexus.component.annotations.Component;
 import org.codehaus.plexus.component.annotations.Requirement;
-import org.codehaus.plexus.logging.AbstractLogEnabled;
 
 import java.util.Map;
 
@@ -36,7 +35,6 @@
  */
 @Component( role = CompilerManager.class )
 public class DefaultCompilerManager
-    extends AbstractLogEnabled
     implements CompilerManager
 {
     @Requirement
diff --git a/plexus-compilers/plexus-compiler-eclipse/src/main/java/org/codehaus/plexus/compiler/eclipse/EclipseJavaCompiler.java b/plexus-compilers/plexus-compiler-eclipse/src/main/java/org/codehaus/plexus/compiler/eclipse/EclipseJavaCompiler.java
@@ -268,13 +268,13 @@ public CompilerResult performCompile( CompilerConfiguration config )
             boolean success = false;
             if ( compiler != null )
             {
-                getLogger().debug( "Using JSR-199 EclipseCompiler" );
+                log.debug( "Using JSR-199 EclipseCompiler" );
                 // ECJ JSR-199 compiles against the latest Java version it supports if no source
                 // version is given explicitly. BatchCompiler uses 1.3 as default. So check
                 // whether a source version is specified, and if not supply 1.3 explicitly.
                 if ( !haveSourceOrReleaseArgument( args ) )
                 {
-                    getLogger().debug( "ecj: no source level nor release specified, defaulting to Java 1.3" );
+                    log.debug( "ecj: no source level nor release specified, defaulting to Java 1.3" );
                     args.add( "-source" );
                     args.add( "1.3" );
                 }
@@ -336,7 +336,7 @@ public void report( Diagnostic<? extends JavaFileObject> diagnostic )
                     }
                     catch ( IllegalCharsetNameException | UnsupportedCharsetException e )
                     {
-                        getLogger().warn(
+                        log.warn(
                             "ecj: invalid or unsupported character set '" + encoding + "', using default" );
                         // charset remains null
                     }
@@ -345,11 +345,11 @@ public void report( Diagnostic<? extends JavaFileObject> diagnostic )
                 {
                     charset = Charset.defaultCharset();
                 }
-                if ( getLogger().isDebugEnabled() )
+                if ( log.isDebugEnabled() )
                 {
-                    getLogger().debug( "ecj: using character set " + charset.displayName() );
-                    getLogger().debug( "ecj command line: " + args );
-                    getLogger().debug( "ecj input source files: " + allSources );
+                    log.debug( "ecj: using character set " + charset.displayName() );
+                    log.debug( "ecj command line: " + args );
+                    log.debug( "ecj input source files: " + allSources );
                 }
 
                 try ( StandardJavaFileManager manager =
@@ -362,7 +362,7 @@ public void report( Diagnostic<? extends JavaFileObject> diagnostic )
                 {
                     throw new EcjFailureException( e.getLocalizedMessage() );
                 }
-                getLogger().debug( sw.toString() );
+                log.debug( sw.toString() );
             }
             else
             {
@@ -371,13 +371,13 @@ public void report( Diagnostic<? extends JavaFileObject> diagnostic )
                 try
                 {
                     errorF = File.createTempFile( "ecjerr-", ".xml" );
-                    getLogger().debug( "Using legacy BatchCompiler; error file " + errorF );
+                    log.debug( "Using legacy BatchCompiler; error file " + errorF );
 
                     args.add( "-log" );
                     args.add( errorF.toString() );
                     args.addAll( allSources );
 
-                    getLogger().debug( "ecj command line: " + args );
+                    log.debug( "ecj command line: " + args );
 
                     success = BatchCompiler.compile( args.toArray( new String[args.size()] ), devNull, devNull,
                                                      new CompilationProgress()
@@ -408,7 +408,7 @@ public void worked( int i, int i1 )
                                                          {
                                                          }
                                                      } );
-                    getLogger().debug( sw.toString() );
+                    log.debug( sw.toString() );
 
                     if ( errorF.length() < 80 )
                     {
@@ -635,7 +635,7 @@ private JavaCompiler getEcj()
                 }
             }
         }
-        getLogger().debug( "Cannot find org.eclipse.jdt.internal.compiler.tool.EclipseCompiler" );
+        log.debug( "Cannot find org.eclipse.jdt.internal.compiler.tool.EclipseCompiler" );
         return null;
     }
 
@@ -743,7 +743,7 @@ private String decodeVersion( String versionSpec )
 
         if ( versionSpec.equals( "1.9" ) )
         {
-            getLogger().warn( "Version 9 should be specified as 9, not 1.9" );
+            log.warn( "Version 9 should be specified as 9, not 1.9" );
             return "9";
         }
         return versionSpec;
diff --git a/plexus-compilers/plexus-compiler-javac/src/main/java/org/codehaus/plexus/compiler/javac/InProcessCompiler.java b/plexus-compilers/plexus-compiler-javac/src/main/java/org/codehaus/plexus/compiler/javac/InProcessCompiler.java
@@ -3,9 +3,8 @@
 import org.codehaus.plexus.compiler.CompilerConfiguration;
 import org.codehaus.plexus.compiler.CompilerException;
 import org.codehaus.plexus.compiler.CompilerResult;
-import org.codehaus.plexus.logging.LogEnabled;
 
-public interface InProcessCompiler extends LogEnabled {
+public interface InProcessCompiler {
 
 	CompilerResult compileInProcess(String[] args, final CompilerConfiguration config, String[] sourceFiles)
 			throws CompilerException;
diff --git a/plexus-compilers/plexus-compiler-javac/src/main/java/org/codehaus/plexus/compiler/javac/JavacCompiler.java b/plexus-compilers/plexus-compiler-javac/src/main/java/org/codehaus/plexus/compiler/javac/JavacCompiler.java
@@ -165,8 +165,8 @@ public CompilerResult performCompile( CompilerConfiguration config )
                 }
                 catch ( IOException e )
                 {
-                    if ( (getLogger() != null ) && getLogger().isWarnEnabled()) {
-                        getLogger().warn( "Unable to autodetect 'javac' path, using 'javac' from the environment." );
+                    if ( log.isWarnEnabled()) {
+                        log.warn( "Unable to autodetect 'javac' path, using 'javac' from the environment." );
                     }
                     executable = "javac";
                 }
@@ -607,7 +607,7 @@ protected CompilerResult compileOutOfProcess( CompilerConfiguration config, Stri
 
         List<CompilerMessage> messages;
 
-        if ( ( getLogger() != null ) && getLogger().isDebugEnabled() )
+        if ( log.isDebugEnabled() )
         {
             String debugFileName = StringUtils.isEmpty(config.getDebugFileName()) ? "javac" : config.getDebugFileName();
 
@@ -624,9 +624,9 @@ protected CompilerResult compileOutOfProcess( CompilerConfiguration config, Stri
             }
             catch ( IOException e )
             {
-                if ( ( getLogger() != null ) && getLogger().isWarnEnabled() )
+                if ( log.isWarnEnabled() )
                 {
-                    getLogger().warn( "Unable to write '" + commandLineFile.getName() + "' debug script file", e );
+                    log.warn( "Unable to write '" + commandLineFile.getName() + "' debug script file", e );
                 }
             }
         }
@@ -662,8 +662,8 @@ CompilerResult compileInProcess( String[] args, CompilerConfiguration config )
         final Thread thread = Thread.currentThread();
         final ClassLoader contextClassLoader = thread.getContextClassLoader();
         thread.setContextClassLoader( javacClass.getClassLoader() );
-        if ( (getLogger() != null ) && getLogger().isDebugEnabled()) {
-            getLogger().debug("ttcl changed run compileInProcessWithProperClassloader");
+        if ( log.isDebugEnabled()) {
+            log.debug("ttcl changed run compileInProcessWithProperClassloader");
         }
         try
         {
@@ -1024,7 +1024,7 @@ private File createFileWithArguments( String[] args, String outputDirectory )
         try
         {
             File tempFile;
-            if ( ( getLogger() != null ) && getLogger().isDebugEnabled() )
+            if ( log.isDebugEnabled() )
             {
                 tempFile =
                     File.createTempFile( JavacCompiler.class.getName(), "arguments", new File( outputDirectory ) );
diff --git a/plexus-compilers/plexus-compiler-javac/src/main/java/org/codehaus/plexus/compiler/javac/JavaxToolsCompiler.java b/plexus-compilers/plexus-compiler-javac/src/main/java/org/codehaus/plexus/compiler/javac/JavaxToolsCompiler.java
@@ -23,7 +23,8 @@
 import org.codehaus.plexus.compiler.CompilerException;
 import org.codehaus.plexus.compiler.CompilerResult;
 import org.codehaus.plexus.component.annotations.Component;
-import org.codehaus.plexus.logging.AbstractLogEnabled;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import javax.tools.Diagnostic;
 import javax.tools.DiagnosticCollector;
@@ -45,8 +46,9 @@
  * @since 2.0
  */
 @Component( role = InProcessCompiler.class )
-public class JavaxToolsCompiler extends AbstractLogEnabled implements InProcessCompiler
+public class JavaxToolsCompiler implements InProcessCompiler
 {
+    private final Logger log = LoggerFactory.getLogger( getClass() );
     /**
      * is that thread safe ???
      */
@@ -149,7 +151,7 @@ public CompilerResult compileInProcess( String[] args, final CompilerConfigurati
                     {
                         // workaround for https://bugs.openjdk.java.net/browse/JDK-8210649
                         // workaround for https://bugs.openjdk.java.net/browse/JDK-8216202
-                        getLogger().debug( "Ignore Issue get JavaCompiler Diagnostic message (see https://bugs.openjdk.java.net/browse/JDK-8210649):" + e.getMessage(), e );
+                        log.debug( "Ignore Issue get JavaCompiler Diagnostic message (see https://bugs.openjdk.java.net/browse/JDK-8210649):" + e.getMessage(), e );
                         // in this case we try to replace the baseMessage with toString (hoping this does not throw a new exception..
                         baseMessage = diagnostic.toString();
                     }
diff --git a/pom.xml b/pom.xml
@@ -107,13 +107,6 @@
       </dependency>
     </dependencies>
   </dependencyManagement>
-  <dependencies>
-    <dependency>
-      <groupId>org.codehaus.plexus</groupId>
-      <artifactId>plexus-container-default</artifactId>
-      <scope>provided</scope>
-    </dependency>
-  </dependencies>
 
   <build>
     <pluginManagement>

Original file line number	Diff line number	Diff line change
`@@ -268,13 +268,13 @@ public CompilerResult performCompile( CompilerConfiguration config )`
`268`	`268`	`boolean success = false;`
`269`	`269`	`if ( compiler != null )`
`270`	`270`	`{`
`271`		`- getLogger().debug( "Using JSR-199 EclipseCompiler" );`
	`271`	`+ log.debug( "Using JSR-199 EclipseCompiler" );`
`272`	`272`	`// ECJ JSR-199 compiles against the latest Java version it supports if no source`
`273`	`273`	`// version is given explicitly. BatchCompiler uses 1.3 as default. So check`
`274`	`274`	`// whether a source version is specified, and if not supply 1.3 explicitly.`
`275`	`275`	`if ( !haveSourceOrReleaseArgument( args ) )`
`276`	`276`	`{`
`277`		`- getLogger().debug( "ecj: no source level nor release specified, defaulting to Java 1.3" );`
	`277`	`+ log.debug( "ecj: no source level nor release specified, defaulting to Java 1.3" );`
`278`	`278`	`args.add( "-source" );`
`279`	`279`	`args.add( "1.3" );`
`280`	`280`	`}`
`@@ -336,7 +336,7 @@ public void report( Diagnostic<? extends JavaFileObject> diagnostic )`
`336`	`336`	`}`
`337`	`337`	`catch ( IllegalCharsetNameException \| UnsupportedCharsetException e )`
`338`	`338`	`{`
`339`		`- getLogger().warn(`
	`339`	`+ log.warn(`
`340`	`340`	`"ecj: invalid or unsupported character set '" + encoding + "', using default" );`
`341`	`341`	`// charset remains null`
`342`	`342`	`}`
`@@ -345,11 +345,11 @@ public void report( Diagnostic<? extends JavaFileObject> diagnostic )`
`345`	`345`	`{`
`346`	`346`	`charset = Charset.defaultCharset();`
`347`	`347`	`}`
`348`		`- if ( getLogger().isDebugEnabled() )`
	`348`	`+ if ( log.isDebugEnabled() )`
`349`	`349`	`{`
`350`		`- getLogger().debug( "ecj: using character set " + charset.displayName() );`
`351`		`- getLogger().debug( "ecj command line: " + args );`
`352`		`- getLogger().debug( "ecj input source files: " + allSources );`
	`350`	`+ log.debug( "ecj: using character set " + charset.displayName() );`
	`351`	`+ log.debug( "ecj command line: " + args );`
	`352`	`+ log.debug( "ecj input source files: " + allSources );`
`353`	`353`	`}`
`354`	`354`
`355`	`355`	`try ( StandardJavaFileManager manager =`
`@@ -362,7 +362,7 @@ public void report( Diagnostic<? extends JavaFileObject> diagnostic )`
`362`	`362`	`{`
`363`	`363`	`throw new EcjFailureException( e.getLocalizedMessage() );`
`364`	`364`	`}`
`365`		`- getLogger().debug( sw.toString() );`
	`365`	`+ log.debug( sw.toString() );`
`366`	`366`	`}`
`367`	`367`	`else`
`368`	`368`	`{`
`@@ -371,13 +371,13 @@ public void report( Diagnostic<? extends JavaFileObject> diagnostic )`
`371`	`371`	`try`
`372`	`372`	`{`
`373`	`373`	`errorF = File.createTempFile( "ecjerr-", ".xml" );`
`374`		`- getLogger().debug( "Using legacy BatchCompiler; error file " + errorF );`
	`374`	`+ log.debug( "Using legacy BatchCompiler; error file " + errorF );`
`375`	`375`
`376`	`376`	`args.add( "-log" );`
`377`	`377`	`args.add( errorF.toString() );`
`378`	`378`	`args.addAll( allSources );`
`379`	`379`
`380`		`- getLogger().debug( "ecj command line: " + args );`
	`380`	`+ log.debug( "ecj command line: " + args );`
`381`	`381`
`382`	`382`	`success = BatchCompiler.compile( args.toArray( new String[args.size()] ), devNull, devNull,`
`383`	`383`	`new CompilationProgress()`
`@@ -408,7 +408,7 @@ public void worked( int i, int i1 )`
`408`	`408`	`{`
`409`	`409`	`}`
`410`	`410`	`} );`
`411`		`- getLogger().debug( sw.toString() );`
	`411`	`+ log.debug( sw.toString() );`
`412`	`412`
`413`	`413`	`if ( errorF.length() < 80 )`
`414`	`414`	`{`
`@@ -635,7 +635,7 @@ private JavaCompiler getEcj()`
`635`	`635`	`}`
`636`	`636`	`}`
`637`	`637`	`}`
`638`		`- getLogger().debug( "Cannot find org.eclipse.jdt.internal.compiler.tool.EclipseCompiler" );`
	`638`	`+ log.debug( "Cannot find org.eclipse.jdt.internal.compiler.tool.EclipseCompiler" );`
`639`	`639`	`return null;`
`640`	`640`	`}`
`641`	`641`
`@@ -743,7 +743,7 @@ private String decodeVersion( String versionSpec )`
`743`	`743`
`744`	`744`	`if ( versionSpec.equals( "1.9" ) )`
`745`	`745`	`{`
`746`		`- getLogger().warn( "Version 9 should be specified as 9, not 1.9" );`
	`746`	`+ log.warn( "Version 9 should be specified as 9, not 1.9" );`
`747`	`747`	`return "9";`
`748`	`748`	`}`
`749`	`749`	`return versionSpec;`
Original file line number	Diff line number	Diff line change
`@@ -165,8 +165,8 @@ public CompilerResult performCompile( CompilerConfiguration config )`
`165`	`165`	`}`
`166`	`166`	`catch ( IOException e )`
`167`	`167`	`{`
`168`		`- if ( (getLogger() != null ) && getLogger().isWarnEnabled()) {`
`169`		`- getLogger().warn( "Unable to autodetect 'javac' path, using 'javac' from the environment." );`
	`168`	`+ if ( log.isWarnEnabled()) {`
	`169`	`+ log.warn( "Unable to autodetect 'javac' path, using 'javac' from the environment." );`
`170`	`170`	`}`
`171`	`171`	`executable = "javac";`
`172`	`172`	`}`
`@@ -607,7 +607,7 @@ protected CompilerResult compileOutOfProcess( CompilerConfiguration config, Stri`
`607`	`607`
`608`	`608`	`List<CompilerMessage> messages;`
`609`	`609`
`610`		`- if ( ( getLogger() != null ) && getLogger().isDebugEnabled() )`
	`610`	`+ if ( log.isDebugEnabled() )`
`611`	`611`	`{`
`612`	`612`	`String debugFileName = StringUtils.isEmpty(config.getDebugFileName()) ? "javac" : config.getDebugFileName();`
`613`	`613`
`@@ -624,9 +624,9 @@ protected CompilerResult compileOutOfProcess( CompilerConfiguration config, Stri`
`624`	`624`	`}`
`625`	`625`	`catch ( IOException e )`
`626`	`626`	`{`
`627`		`- if ( ( getLogger() != null ) && getLogger().isWarnEnabled() )`
	`627`	`+ if ( log.isWarnEnabled() )`
`628`	`628`	`{`
`629`		`- getLogger().warn( "Unable to write '" + commandLineFile.getName() + "' debug script file", e );`
	`629`	`+ log.warn( "Unable to write '" + commandLineFile.getName() + "' debug script file", e );`
`630`	`630`	`}`
`631`	`631`	`}`
`632`	`632`	`}`
`@@ -662,8 +662,8 @@ CompilerResult compileInProcess( String[] args, CompilerConfiguration config )`
`662`	`662`	`final Thread thread = Thread.currentThread();`
`663`	`663`	`final ClassLoader contextClassLoader = thread.getContextClassLoader();`
`664`	`664`	`thread.setContextClassLoader( javacClass.getClassLoader() );`
`665`		`- if ( (getLogger() != null ) && getLogger().isDebugEnabled()) {`
`666`		`- getLogger().debug("ttcl changed run compileInProcessWithProperClassloader");`
	`665`	`+ if ( log.isDebugEnabled()) {`
	`666`	`+ log.debug("ttcl changed run compileInProcessWithProperClassloader");`
`667`	`667`	`}`
`668`	`668`	`try`
`669`	`669`	`{`
`@@ -1024,7 +1024,7 @@ private File createFileWithArguments( String[] args, String outputDirectory )`
`1024`	`1024`	`try`
`1025`	`1025`	`{`
`1026`	`1026`	`File tempFile;`
`1027`		`- if ( ( getLogger() != null ) && getLogger().isDebugEnabled() )`
	`1027`	`+ if ( log.isDebugEnabled() )`
`1028`	`1028`	`{`
`1029`	`1029`	`tempFile =`
`1030`	`1030`	`File.createTempFile( JavacCompiler.class.getName(), "arguments", new File( outputDirectory ) );`