Reduce coupling in the `MjResolve`

[volodya-lombrozo]

Currently MjResolve is hardly testable God class that does the following:

1. Serves as an entry point for Maven.
2. Handles logic with resolving dependencies

Moreover, logic in the MjResolve requires MavenPlugin in order to download and resolve dependencies. Thus it makes it hard to move internals of MjResolve to a separate class.

It would be nice to decouple the logic in MjResolve on two separate classes:

1. MjResolve - a thin maven endpoint for using resolving logic in a maven project.
2. Resolve - a core resolving logic.

Also, it's important to find out if it's possible to remove the dependency of Resolve on MavenProject. Most probably, without it, refactoring won't make any sense.

[yegor256]

@volodya-lombrozo using Resolve without Maven will be impossible -- this is one of the key reasons for keeping all features inside MjResolve

[volodya-lombrozo]

@yegor256 I'm trying to investigate it.

[yegor256]

@volodya-lombrozo take a look: https://github.com/jcabi/jcabi-aether

[volodya-lombrozo]

@yegor256 We have two components that use MavenSession, MavenProject, BuildPluginManager (exactly this components injected in mojo and require maven):

DpsDepgraph - a component that downloads transitive dependencies for a maven dependency.

Central - downloads and unpacks dependencies.

As for Central - it's pretty easy to rewrite it without using the maven components.

It will look something like that

/*
 * SPDX-FileCopyrightText: Copyright (c) 2016-2026 Objectionary.com
 * SPDX-License-Identifier: MIT
 */
package org.eolang.maven;

import com.jcabi.log.Logger;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.Collections;
import java.util.function.BiConsumer;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import org.apache.maven.model.Dependency;
import org.apache.maven.repository.internal.MavenRepositorySystemUtils;
import org.eclipse.aether.DefaultRepositorySystemSession;
import org.eclipse.aether.RepositorySystem;
import org.eclipse.aether.artifact.Artifact;
import org.eclipse.aether.artifact.DefaultArtifact;
import org.eclipse.aether.repository.LocalRepository;
import org.eclipse.aether.repository.RemoteRepository;
import org.eclipse.aether.resolution.ArtifactRequest;
import org.eclipse.aether.resolution.ArtifactResolutionException;
import org.eclipse.aether.supplier.RepositorySystemSupplier;

/**
 * Downloads and unpacks a Maven artifact directly via the Aether resolver API.
 *
 * <p>Unlike {@link Central}, this implementation does not require
 * {@code MavenProject}, {@code MavenSession}, or {@code MojoExecutor}.</p>
 *
 * @since 0.55
 */
final class CentralDirect implements BiConsumer<Dependency, Path> {

    /**
     * Default local Maven repository path.
     */
    private static final Path LOCAL = Paths.get(
        System.getProperty("user.home"), ".m2", "repository"
    );

    /**
     * Maven Central URL.
     */
    private static final String CENTRAL = "https://repo1.maven.org/maven2";

    /**
     * Local repository path.
     */
    private final Path local;

    /**
     * Ctor.
     * @param repo Local repository path
     */
    CentralDirect(final Path repo) {
        this.local = repo;
    }

    @Override
    public void accept(final Dependency dep, final Path dest) {
        final RepositorySystem system = new RepositorySystemSupplier().get();
        final DefaultRepositorySystemSession session = MavenRepositorySystemUtils.newSession();
        session.setLocalRepositoryManager(
            system.newLocalRepositoryManager(session, new LocalRepository(this.local.toFile()))
        );
        final String classifier = dep.getClassifier() == null ? "" : dep.getClassifier();
        final ArtifactRequest request = new ArtifactRequest(
            new DefaultArtifact(
                dep.getGroupId(), dep.getArtifactId(),
                classifier, "jar", dep.getVersion()
            ),
            Collections.singletonList(
                new RemoteRepository.Builder("central", "default", CentralDirect.CENTRAL).build()
            ),
            null
        );
        try {
            final Artifact artifact = system.resolveArtifact(session, request).getArtifact();
            CentralDirect.unpack(artifact.getFile().toPath(), dest);
        } catch (final ArtifactResolutionException ex) {
            throw new IllegalStateException(
                String.format(
                    "Failed to resolve %s:%s:%s",
                    dep.getGroupId(), dep.getArtifactId(), dep.getVersion()
                ),
                ex
            );
        } catch (final IOException ex) {
            throw new IllegalStateException(
                String.format(
                    "Failed to unpack %s:%s:%s to %s",
                    dep.getGroupId(), dep.getArtifactId(), dep.getVersion(), dest
                ),
                ex
            );
        }
        if (classifier.isEmpty()) {
            Logger.info(
                this, "%s:%s:%s unpacked to %[file]s",
                dep.getGroupId(), dep.getArtifactId(), dep.getVersion(), dest
            );
        } else {
            Logger.info(
                this, "%s:%s:%s:%s unpacked to %[file]s",
                dep.getGroupId(), dep.getArtifactId(), classifier, dep.getVersion(), dest
            );
        }
    }

    @Override
    public BiConsumer<Dependency, Path> andThen(
        final BiConsumer<? super Dependency, ? super Path> after
    ) {
        throw new UnsupportedOperationException("not implemented #andThen()");
    }

    /**
     * Unpacks a JAR (ZIP) file into the given directory.
     * @param jar Path to the JAR file
     * @param dest Destination directory
     * @throws IOException If unpacking fails
     */
    private static void unpack(final Path jar, final Path dest) throws IOException {
        Files.createDirectories(dest);
        try (ZipInputStream zis = new ZipInputStream(Files.newInputStream(jar))) {
            ZipEntry entry = zis.getNextEntry();
            while (entry != null) {
                final Path target = dest.resolve(entry.getName());
                if (entry.isDirectory()) {
                    Files.createDirectories(target);
                } else {
                    Files.createDirectories(target.getParent());
                    Files.copy(zis, target, StandardCopyOption.REPLACE_EXISTING);
                }
                zis.closeEntry();
                entry = zis.getNextEntry();
            }
        }
    }
}

As for DpsDephgraph - it's hard. I mean, really hard. I tried several approaches - using aeser, jcabi-aeser and maven-apache-resolver. All of the approaches failed to download transitive dependencies. It's extremely hard to configure them properly. Maybe it's possible to do, but I'm not sure whether it is worth it.

However, if we take a look on the usages of DpsDephgrap, we will find the only one:

        if (!this.ignoreTransitive) {
            deps = new DpsEachWithoutTransitive(
                deps,
                dependency -> new DpsDepgraph(
                    this.project,
                    this.session,
                    this.manager,
                    this.targetDir.toPath().resolve(MjResolve.DIR).resolve("dependencies-info"),
                    dependency
                )
            );
        }

In plain English, it means that we download transitive dependencies only to check that ... we shouldn't use transitive dependencies. Thus, I guess, we can just remove it.

[yegor256]

@volodya-lombrozo I agree