* Helper method to simplify null processing
     *
     * @param scope a scope or {@code null}
     * @return the provided scope or DEFAULT_SCOPE
     */
    public static ArtifactScopeEnum checkScope(ArtifactScopeEnum scope) {
        return scope == null ? DEFAULT_SCOPE : scope;
    }

    /**
     *
     * @return unsafe String representation of this scope.
     */
    public String getScope() {
        if (id == 1) {

        return classpathTransformation.transform(dirtyGraph, scope, false);
    }

    // ----------------------------------------------------------------------------
    public MetadataTreeNode getClasspathTree(ArtifactScopeEnum scope)
            throws MetadataGraphTransformationException, MetadataResolutionException {
        ClasspathContainer cpc = getClasspath(scope);
        if (cpc == null) {
            return null;

import org.apache.maven.api.annotations.Immutable;
import org.apache.maven.api.annotations.Nonnull;

import static org.apache.maven.api.ExtensibleEnums.pathScope;

/**
 * Path scope.
 * A path scope is used to determine the kind of build or class path that will be built when resolving
 * dependencies using the {@link org.apache.maven.api.services.DependencyResolver} service.
 * <p>

        new ProjectBuilder( project ).addDependency( "org.apache.maven.its", "b", "0.1", Artifact.SCOPE_RUNTIME,
                                                     exclusion );

        Set<Artifact> artifactDependencies =
            resolver.resolve( project, Collections.singleton( Artifact.SCOPE_COMPILE ), session );
        assertEquals( 0, artifactDependencies.size() );

    }

    @Override
    public void setDependencyTrail(List<String> dependencyTrail) {
        this.dependencyTrail = dependencyTrail;
    }

    @Override
    public void setScope(String scope) {
        this.scope = scope;
    }

    @Override
    public VersionRange getVersionRange() {
        return versionRange;
    }

    @Override
    public void setVersionRange(VersionRange versionRange) {

        if (inheritedScope == null) {
            desiredScope = scope;
        } else if (Artifact.SCOPE_TEST.equals(scope) || Artifact.SCOPE_PROVIDED.equals(scope)) {
            return null;
        } else if (Artifact.SCOPE_COMPILE.equals(scope) && Artifact.SCOPE_COMPILE.equals(inheritedScope)) {
            // added to retain compile artifactScope. Remove if you want compile inherited as runtime

import org.apache.maven.execution.MavenSession;
import org.apache.maven.execution.scope.internal.MojoExecutionScope;
import org.apache.maven.repository.internal.MavenSessionBuilderSupplier;
import org.apache.maven.rtinfo.RuntimeInformation;
import org.apache.maven.session.scope.internal.SessionScope;
import org.apache.maven.toolchain.DefaultToolchainManagerPrivate;

    public ClasspathContainer transform(MetadataGraph dirtyGraph, ArtifactScopeEnum scope, boolean resolve)
            throws MetadataGraphTransformationException {
        try {
            if (dirtyGraph == null || dirtyGraph.isEmpty()) {
                return null;
            }

            MetadataGraph cleanGraph = conflictResolver.resolveConflicts(dirtyGraph, scope);

            if (cleanGraph == null || cleanGraph.isEmpty()) {

    protected final MojoExecutionScope scope;

    public MojoExecutionScopeModule(MojoExecutionScope scope) {
        this.scope = scope;
    }

    @Override
    protected void configure() {
        bindScope(MojoExecutionScoped.class, scope);
        // bindScope(org.apache.maven.api.di.MojoExecutionScoped.class, scope);
        bind(MojoExecutionScope.class).toInstance(scope);
        bind(MavenProject.class)

    }

    private static DependencyFilter getScopeDependencyFilter(PathScope scope) {
        Set<String> scopes =
                scope.dependencyScopes().stream().map(DependencyScope::id).collect(Collectors.toSet());
        return (n, p) -> {
            org.eclipse.aether.graph.Dependency d = n.getDependency();
            return d == null || scopes.contains(d.getScope());
        };
    }

    /**