Tidy up suppliers

maven-resolver-supplier-mvn3/src/main/java/org/eclipse/aether/supplier/Maven3ScopeManagerConfiguration.java

@@ -33,6 +33,7 @@
 import org.eclipse.aether.internal.impl.scope.ScopeManagerDump;
 import org.eclipse.aether.scope.DependencyScope;
 import org.eclipse.aether.scope.ResolutionScope;
+import org.eclipse.aether.util.artifact.JavaScopes;
 
 import static org.eclipse.aether.impl.scope.BuildScopeQuery.all;
 import static org.eclipse.aether.impl.scope.BuildScopeQuery.byBuildPath;
@@ -44,22 +45,24 @@
 /**
  * Maven3 scope configurations. Configures scope manager to support Maven3 scopes.
  * <p>
- * This manager supports the old Maven 3 dependency scopes + new "compile-only".
+ * This manager supports the old Maven 3 dependency scopes + new scopes.
  * <p>
- * Note: Maven3 CANNOT support Maven 4 scopes "test-only" and "test-runtime", as it does not distinguish
+ * Note: Maven3 CANNOT support new scopes "test-only" and "test-runtime", as it does not distinguish
  * resolution scope (the class {@code ResolutionScope} has only "TEST", instead of "TEST_COMPILE" and "TEST_RUNTIME").
+ * <em>This scope manager configuration is not used in Maven 3!</em>
  *
  * @since 2.0.11
  */
 public final class Maven3ScopeManagerConfiguration implements ScopeManagerConfiguration {
     public static final Maven3ScopeManagerConfiguration INSTANCE = new Maven3ScopeManagerConfiguration();
     public static final String DS_NONE = "none";
-    public static final String DS_COMPILE = "compile"; // JavaScopes.COMPILE;
+    public static final String DS_COMPILE = JavaScopes.COMPILE;
+    public static final String DS_RUNTIME = JavaScopes.RUNTIME;
+    public static final String DS_PROVIDED = JavaScopes.PROVIDED;
+    public static final String DS_SYSTEM = JavaScopes.SYSTEM;
+    public static final String DS_TEST = JavaScopes.TEST;
+
     public static final String DS_COMPILE_ONLY = "compile-only";
-    public static final String DS_RUNTIME = "runtime"; // JavaScopes.RUNTIME;
-    public static final String DS_PROVIDED = "provided"; // JavaScopes.PROVIDED;
-    public static final String DS_SYSTEM = "system"; // JavaScopes.SYSTEM;
-    public static final String DS_TEST = "test"; // JavaScopes.TEST;
     public static final String DS_TEST_ONLY = "test-only";
     public static final String DS_TEST_RUNTIME = "test-runtime";
 

maven-resolver-supplier-mvn3/src/main/java/org/eclipse/aether/supplier/SessionBuilderSupplier.java

@@ -26,13 +26,13 @@
 import org.eclipse.aether.RepositorySystem;
 import org.eclipse.aether.RepositorySystemSession.CloseableSession;
 import org.eclipse.aether.RepositorySystemSession.SessionBuilder;
-import org.eclipse.aether.artifact.ArtifactTypeRegistry;
 import org.eclipse.aether.artifact.DefaultArtifactType;
 import org.eclipse.aether.collection.DependencyGraphTransformer;
 import org.eclipse.aether.collection.DependencyManager;
 import org.eclipse.aether.collection.DependencySelector;
 import org.eclipse.aether.collection.DependencyTraverser;
 import org.eclipse.aether.impl.scope.InternalScopeManager;
+import org.eclipse.aether.impl.scope.ScopeManagerConfiguration;
 import org.eclipse.aether.internal.impl.scope.ManagedDependencyContextRefiner;
 import org.eclipse.aether.internal.impl.scope.ManagedScopeDeriver;
 import org.eclipse.aether.internal.impl.scope.ManagedScopeSelector;
@@ -41,12 +41,17 @@
 import org.eclipse.aether.internal.impl.scope.ScopeManagerImpl;
 import org.eclipse.aether.resolution.ArtifactDescriptorPolicy;
 import org.eclipse.aether.util.artifact.DefaultArtifactTypeRegistry;
+import org.eclipse.aether.util.artifact.JavaScopes;
 import org.eclipse.aether.util.graph.manager.ClassicDependencyManager;
+import org.eclipse.aether.util.graph.manager.TransitiveDependencyManager;
 import org.eclipse.aether.util.graph.selector.AndDependencySelector;
 import org.eclipse.aether.util.graph.selector.ExclusionDependencySelector;
 import org.eclipse.aether.util.graph.transformer.ChainedDependencyGraphTransformer;
 import org.eclipse.aether.util.graph.transformer.ConfigurableVersionSelector;
 import org.eclipse.aether.util.graph.transformer.ConflictResolver;
+import org.eclipse.aether.util.graph.transformer.JavaDependencyContextRefiner;
+import org.eclipse.aether.util.graph.transformer.JavaScopeDeriver;
+import org.eclipse.aether.util.graph.transformer.JavaScopeSelector;
 import org.eclipse.aether.util.graph.transformer.SimpleOptionalitySelector;
 import org.eclipse.aether.util.graph.traverser.FatArtifactTraverser;
 import org.eclipse.aether.util.repository.SimpleArtifactDescriptorPolicy;
@@ -60,27 +65,41 @@
  * <p>
  * Extend this class and override methods to customize, if needed.
  * <p>
- * Resolver created as this is NOT using {@link org.eclipse.aether.scope.ScopeManager}!
+ * Resolver session created as this may or may not use {@link org.eclipse.aether.scope.ScopeManager}.
  *
  * @since 2.0.0
  */
 public class SessionBuilderSupplier implements Supplier<SessionBuilder> {
     protected final RepositorySystem repositorySystem;
     protected final InternalScopeManager scopeManager;
 
+    /**
+     * Creates Resolver 2 session using Maven 3 elements without {@link InternalScopeManager}.
+     */
     public SessionBuilderSupplier(RepositorySystem repositorySystem) {
+        this(repositorySystem, null);
+    }
+
+    /**
+     * Creates Resolver 2 session using Maven 3 elements with or without {@link InternalScopeManager}.
+     */
+    public SessionBuilderSupplier(
+            RepositorySystem repositorySystem, ScopeManagerConfiguration scopeManagerConfiguration) {
         this.repositorySystem = requireNonNull(repositorySystem);
-        this.scopeManager = new ScopeManagerImpl(Maven3ScopeManagerConfiguration.INSTANCE);
+        this.scopeManager =
+                scopeManagerConfiguration == null ? null : new ScopeManagerImpl(scopeManagerConfiguration); // nullable
     }
 
-    protected void configureSessionBuilder(SessionBuilder session) {
+    public void configureSessionBuilder(SessionBuilder session) {
         session.setSystemProperties(System.getProperties());
         boolean caseSensitive = !Os.IS_WINDOWS;
         System.getenv().forEach((key, value) -> {
             key = "env." + (caseSensitive ? key : key.toUpperCase(Locale.ENGLISH));
             session.setSystemProperty(key, value);
         });
-        session.setScopeManager(scopeManager);
+        if (getScopeManager() != null) {
+            session.setScopeManager(getScopeManager());
+        }
         session.setDependencyTraverser(getDependencyTraverser());
         session.setDependencyManager(getDependencyManager());
         session.setDependencySelector(getDependencySelector());
@@ -89,39 +108,67 @@ protected void configureSessionBuilder(SessionBuilder session) {
         session.setArtifactDescriptorPolicy(getArtifactDescriptorPolicy());
     }
 
-    protected InternalScopeManager getScopeManager() {
+    public InternalScopeManager getScopeManager() {
         return this.scopeManager;
     }
 
-    protected DependencyTraverser getDependencyTraverser() {
+    public DependencyTraverser getDependencyTraverser() {
         return new FatArtifactTraverser();
     }
 
-    protected DependencyManager getDependencyManager() {
-        return new ClassicDependencyManager(getScopeManager());
+    public DependencyManager getDependencyManager() {
+        return this.getDependencyManager(false);
+    }
+
+    public DependencyManager getDependencyManager(boolean transitive) {
+        if (getScopeManager() == null) {
+            return transitive ? new TransitiveDependencyManager() : new ClassicDependencyManager();
+        } else {
+            return transitive
+                    ? new TransitiveDependencyManager(getScopeManager())
+                    : new ClassicDependencyManager(getScopeManager());
+        }
     }
 
-    protected DependencySelector getDependencySelector() {
-        return new AndDependencySelector(
-                ScopeDependencySelector.legacy(
-                        null,
-                        Arrays.asList(
-                                Maven3ScopeManagerConfiguration.DS_TEST, Maven3ScopeManagerConfiguration.DS_PROVIDED)),
-                OptionalDependencySelector.fromDirect(),
-                new ExclusionDependencySelector());
+    public DependencySelector getDependencySelector() {
+        if (getScopeManager() == null) {
+            return new AndDependencySelector(
+                    ScopeDependencySelector.legacy(null, Arrays.asList(JavaScopes.TEST, JavaScopes.PROVIDED)),
+                    OptionalDependencySelector.fromDirect(),
+                    new ExclusionDependencySelector());
+        } else {
+            return new AndDependencySelector(
+                    ScopeDependencySelector.legacy(
+                            null,
+                            Arrays.asList(
+                                    Maven3ScopeManagerConfiguration.DS_TEST,
+                                    Maven3ScopeManagerConfiguration.DS_PROVIDED)),
+                    OptionalDependencySelector.fromDirect(),
+                    new ExclusionDependencySelector());
+        }
     }
 
-    protected DependencyGraphTransformer getDependencyGraphTransformer() {
-        return new ChainedDependencyGraphTransformer(
-                new ConflictResolver(
-                        new ConfigurableVersionSelector(),
-                        new ManagedScopeSelector(getScopeManager()),
-                        new SimpleOptionalitySelector(),
-                        new ManagedScopeDeriver(getScopeManager())),
-                new ManagedDependencyContextRefiner(getScopeManager()));
+    public DependencyGraphTransformer getDependencyGraphTransformer() {
+        if (getScopeManager() == null) {
+            return new ChainedDependencyGraphTransformer(
+                    new ConflictResolver(
+                            new ConfigurableVersionSelector(),
+                            new JavaScopeSelector(),
+                            new SimpleOptionalitySelector(),
+                            new JavaScopeDeriver()),
+                    new JavaDependencyContextRefiner());
+        } else {
+            return new ChainedDependencyGraphTransformer(
+                    new ConflictResolver(
+                            new ConfigurableVersionSelector(),
+                            new ManagedScopeSelector(getScopeManager()),
+                            new SimpleOptionalitySelector(),
+                            new ManagedScopeDeriver(getScopeManager())),
+                    new ManagedDependencyContextRefiner(getScopeManager()));
+        }
     }
 
-    protected ArtifactTypeRegistry getArtifactTypeRegistry() {
+    public DefaultArtifactTypeRegistry getArtifactTypeRegistry() {
         DefaultArtifactTypeRegistry stereotypes = new DefaultArtifactTypeRegistry();
         stereotypes.add(new DefaultArtifactType("pom"));
         stereotypes.add(new DefaultArtifactType("maven-plugin", "jar", "", "java"));
@@ -131,14 +178,15 @@ protected ArtifactTypeRegistry getArtifactTypeRegistry() {
         stereotypes.add(new DefaultArtifactType("test-jar", "jar", "tests", "java"));
         stereotypes.add(new DefaultArtifactType("javadoc", "jar", "javadoc", "java"));
         stereotypes.add(new DefaultArtifactType("java-source", "jar", "sources", "java", false, false));
+        stereotypes.add(new DefaultArtifactType("fatjar", "jar", "", "java", true, true));
         stereotypes.add(new DefaultArtifactType("war", "war", "", "java", false, true));
         stereotypes.add(new DefaultArtifactType("ear", "ear", "", "java", false, true));
         stereotypes.add(new DefaultArtifactType("rar", "rar", "", "java", false, true));
         stereotypes.add(new DefaultArtifactType("par", "par", "", "java", false, true));
         return stereotypes;
     }
 
-    protected ArtifactDescriptorPolicy getArtifactDescriptorPolicy() {
+    public ArtifactDescriptorPolicy getArtifactDescriptorPolicy() {
         return new SimpleArtifactDescriptorPolicy(true, true);
     }
 

maven-resolver-supplier-mvn3/src/test/java/org/eclipse/aether/supplier/RepositorySystemSupplierTest.java

@@ -44,7 +44,7 @@ public class RepositorySystemSupplierTest {
     @Test
     void smoke() throws Exception {
         try (RepositorySystem system = new RepositorySystemSupplier().get();
-                CloseableSession session = new SessionBuilderSupplier(system)
+                CloseableSession session = new SessionBuilderSupplier(system, Maven3ScopeManagerConfiguration.INSTANCE)
                         .get()
                         .withLocalRepositoryBaseDirectories(new File("target/local-repo").toPath())
                         .build()) {
@@ -66,7 +66,7 @@ void smoke() throws Exception {
     @Test
     void smokeV2Feature() throws Exception {
         try (RepositorySystem system = new RepositorySystemSupplier().get();
-                CloseableSession session = new SessionBuilderSupplier(system)
+                CloseableSession session = new SessionBuilderSupplier(system, Maven3ScopeManagerConfiguration.INSTANCE)
                         .get()
                         .withLocalRepositoryBaseDirectories(new File("target/local-repo").toPath())
                         .build()) {