name.remal.gradle_plugins.dsl.extensions.org.gradle.api.artifacts.Configuration.kt Maven / Gradle / Ivy

Go to download
package name.remal.gradle_plugins.dsl.extensions

import name.remal.buildSet
import name.remal.default
import name.remal.gradle_plugins.dsl.DSL_DEPENDENCIES
import org.gradle.api.Project
import org.gradle.api.artifacts.*
import org.gradle.api.artifacts.ExcludeRule.GROUP_KEY
import org.gradle.api.artifacts.ExcludeRule.MODULE_KEY
import org.gradle.api.artifacts.component.ComponentSelector
import org.gradle.api.artifacts.result.ResolvedComponentResult
import org.gradle.api.artifacts.result.ResolvedDependencyResult

fun Configuration.hasDependency(group: String, name: String) = allDependencies.any { group == it.group && name == it.name }

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

val LOGGING_TRANSITIVE_DEPENDENCIES_EXCLUDES = buildSet> {
    add(mapOf(GROUP_KEY to "org.slf4j"))
    add(mapOf(GROUP_KEY to "ch.qos.logback"))
    add(mapOf(GROUP_KEY to "org.apache.logging.log4j"))
    add(mapOf(GROUP_KEY to "log4j"))
    add(mapOf(GROUP_KEY to "commons-logging"))
}

fun Configuration.applyLoggingTransitiveDependenciesExcludes() = apply {
    dependencies.all { dep ->
        if (dep is ModuleDependency) {
            LOGGING_TRANSITIVE_DEPENDENCIES_EXCLUDES.forEach { dep.exclude(it) }
        }
    }
}

val GRADLE_TRANSITIVE_DEPENDENCIES_EXCLUDES = buildSet> {
    add(mapOf(GROUP_KEY to "org.codehaus.groovy"))
    add(mapOf(GROUP_KEY to "org.apache.ant", MODULE_KEY to "ant"))
    add(mapOf(GROUP_KEY to "org.apache.ant", MODULE_KEY to "ant-launcher"))
    LOGGING_TRANSITIVE_DEPENDENCIES_EXCLUDES.forEach { add(it) }
}

fun Configuration.applyGradleTransitiveDependenciesExcludes() = apply {
    dependencies.all { dep ->
        if (dep is ModuleDependency) {
            GRADLE_TRANSITIVE_DEPENDENCIES_EXCLUDES.forEach { dep.exclude(it) }
        }
    }
}

fun Configuration.applyDSLTransitiveDependenciesExcludes() = apply {
    dependencies.all { dep ->
        if (dep is ModuleDependency) {
            DSL_DEPENDENCIES.forEach { dep.exclude(mapOf(GROUP_KEY to it.first, MODULE_KEY to it.second)) }
        }
    }
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

data class ResolvedDependencyMapping(
    val resolvedArtifact: ResolvedArtifact,
    val resolvedDependency: ResolvedDependency,
    val requested: ComponentSelector,
    val selected: ResolvedComponentResult,
    val dependency: Dependency,
    val isFirstLevel: Boolean,
    val configuration: Configuration,
    val project: Project
) {

    val isNotFirstLevel: Boolean get() = !isFirstLevel

    val moduleGroup: String = resolvedDependency.moduleGroup.default()
    val moduleName: String = resolvedDependency.moduleName.default()
    val moduleVersion: String = resolvedDependency.moduleVersion.default()

    val requestedGroup: String? by lazy { requested.calculateGroup(project) }
    val requestedModule: String? by lazy { requested.calculateModule(project) }
    val requestedVersion: String? by lazy { requested.calculateVersion(project) }

    val selectedGroup: String? by lazy { selected.id.calculateGroup(project) }
    val selectedModule: String? by lazy { selected.id.calculateModule(project) }
    val selectedVersion: String? by lazy { selected.id.calculateVersion(project) }

    val isShouldBeExplicitlyDefined: Boolean
        get() {
            if (isFirstLevel) return true
            if (selected.selectionReason.isForced || selected.selectionReason.isSelectedByRule) return true
            if (requestedGroup != selectedGroup || requestedModule != selectedModule || requestedVersion != selectedVersion) return true
            return false
        }

    val isShouldNotBeExplicitlyDefined: Boolean get() = !isShouldBeExplicitlyDefined

    val isSubstituted: Boolean
        get() {
            if (requestedGroup != selectedGroup || requestedModule != selectedModule) return true
            return false
        }

    val isNotSubstituted: Boolean get() = !isSubstituted

}

fun Configuration.getResolvedDependencyMappings(project: Project): Set {
    val configurationResolvedDependencyMappings: Set = mutableSetOf().also { mappings ->
        val resolvedConfiguration = this.resolvedConfiguration
        allDependencies.forEach { dependency ->
            val dependencyConf = hierarchy.firstOrNull { dependency in it.dependencies } ?: this
            resolvedConfiguration.getFirstLevelModuleDependencies(dependency).forEach { resolvedDependency ->
                mappings.add(ConfigurationResolvedDependencyMapping(
                    dependencyConf,
                    dependency,
                    resolvedDependency,
                    true
                ))
                resolvedDependency.allChildren.forEach {
                    mappings.add(ConfigurationResolvedDependencyMapping(
                        dependencyConf,
                        dependency,
                        it,
                        false
                    ))
                }
            }
        }
    }

    return mutableSetOf().apply {
        val dependencyResults = incoming.resolutionResult.allDependencies.filterIsInstance(ResolvedDependencyResult::class.java)
        for (artifact in incoming.artifacts) {
            val mapping = configurationResolvedDependencyMappings.firstOrNull { it.resolvedDependency.moduleArtifacts.any { it.file == artifact.file } } ?: continue
            val dependencyResult = dependencyResults.firstOrNull { dep -> mapping.resolvedDependency.moduleArtifacts.any { it.id.componentIdentifier == dep.selected.id } } ?: continue
            mapping.resolvedDependency.moduleArtifacts.forEach { resolvedArtifact ->
                add(ResolvedDependencyMapping(
                    resolvedArtifact,
                    mapping.resolvedDependency,
                    dependencyResult.requested,
                    dependencyResult.selected,
                    mapping.dependency,
                    mapping.isFirstLevel,
                    mapping.configuration,
                    project
                ))
            }
        }
    }
}

private data class ConfigurationResolvedDependencyMapping(
    val configuration: Configuration,
    val dependency: Dependency,
    val resolvedDependency: ResolvedDependency,
    val isFirstLevel: Boolean
)