org.gradle.plugins.ide.idea.model.internal.IdeaDependenciesOptimizer Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of gradle-api Show documentation
Gradle 6.9.1 API redistribution.
There is a newer version: 8.11.1
/*
 * Copyright 2017 the original author or authors.
 *
 * Licensed 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.
 */

package org.gradle.plugins.ide.idea.model.internal;

import com.google.common.collect.Multimap;
import com.google.common.collect.MultimapBuilder;
import org.gradle.plugins.ide.idea.model.Dependency;
import org.gradle.plugins.ide.idea.model.ModuleDependency;
import org.gradle.plugins.ide.idea.model.SingleEntryModuleLibrary;

import java.util.Collection;
import java.util.Iterator;
import java.util.Map;


/**
 * Minimizes a set of IDEA dependencies based on knowledge about how IDEA handles compilation and runtime of main and test classes:
 *
 * 
 *  COMPILE dependencies are visible everywhere. 
 *  PROVIDED dependencies are visible both when compiling main and test code as well as when running tests (but not when running main). 
 *  RUNTIME dependencies are visible when running main and test code.
 *  TEST dependencies are visible when compiling and running tests.
 * 
 *
 * This means we can do the following simplifications:
 *
 * 
 * If a dependency is in COMPILE, we can remove it everywhere else.
 * If a dependency is PROVIDED, we don't need it in TEST. 
 * If a dependency is in RUNTIME and PROVIDED, we can hoist it up to COMPILE.
 * 
 *
 * This results is much closer to what a user would do by hand. Having less dependencies also makes IntelliJ faster.
 */
class IdeaDependenciesOptimizer {
    public void optimizeDeps(Collection deps) {
        Multimap scopesByDependencyKey = collectScopesByDependency(deps);
        optimizeScopes(scopesByDependencyKey);
        applyScopesToDependencies(deps, scopesByDependencyKey);
    }

    private Multimap collectScopesByDependency(Collection deps) {
        Multimap scopesByDependencyKey = MultimapBuilder.hashKeys().enumSetValues(GeneratedIdeaScope.class).build();
        for (Dependency dep : deps) {
            scopesByDependencyKey.put(getKey(dep), GeneratedIdeaScope.nullSafeValueOf(dep.getScope()));
        }
        return scopesByDependencyKey;
    }

    private void optimizeScopes(Multimap scopesByDependencyKey) {
        for (Map.Entry> entry : scopesByDependencyKey.asMap().entrySet()) {
            optimizeScopes(entry.getValue());
        }
    }

    private void applyScopesToDependencies(Collection deps, Multimap scopesByDependencyKey) {
        for (Iterator iterator = deps.iterator(); iterator.hasNext();) {
            applyScopeToNextDependency(iterator, scopesByDependencyKey);
        }
    }

    private void applyScopeToNextDependency(Iterator iterator, Multimap scopesByDependencyKey) {
        Dependency dep = iterator.next();
        Object key = getKey(dep);
        Collection ideaScopes = scopesByDependencyKey.get(key);
        if (ideaScopes.isEmpty()) {
            iterator.remove();
        } else {
            GeneratedIdeaScope scope = ideaScopes.iterator().next();
            dep.setScope(scope.name());
            scopesByDependencyKey.remove(key, scope);
        }
    }

    private Object getKey(Dependency dep) {
        if (dep instanceof ModuleDependency) {
            return ((ModuleDependency) dep).getName();
        } else if (dep instanceof SingleEntryModuleLibrary) {
            return ((SingleEntryModuleLibrary) dep).getLibraryFile();
        } else {
            throw new IllegalArgumentException("Unsupported type: " + dep.getClass().getName());
        }
    }

    private void optimizeScopes(Collection ideaScopes) {
        boolean isRuntime = ideaScopes.contains(GeneratedIdeaScope.RUNTIME);
        boolean isProvided = ideaScopes.contains(GeneratedIdeaScope.PROVIDED);
        boolean isCompile = ideaScopes.contains(GeneratedIdeaScope.COMPILE);

        if (isProvided) {
            ideaScopes.remove(GeneratedIdeaScope.TEST);
        }

        if (isRuntime && isProvided) {
            ideaScopes.add(GeneratedIdeaScope.COMPILE);
            isCompile = true;
        }

        if (isCompile) {
            ideaScopes.remove(GeneratedIdeaScope.TEST);
            ideaScopes.remove(GeneratedIdeaScope.RUNTIME);
            ideaScopes.remove(GeneratedIdeaScope.PROVIDED);
        }
    }
}