In Gradle, how programmatically to exclude then force a dependency? - gradle

Question

The end goal is to replace versions of transitive dependencies with a different version. The caveat is that the replacement should be picked up by those dependent upon the library being built (I don't know if it's a standard Gradle or a plugin but if we exclude a transitive dependency, the produced ivy.xml file will have that information).
One possible way to achieve the end goal is to exclude the dependency in question then force that dependency later on.
The way to exclude a dependency is with something like:
dependencies {
compile 'org:name:version' {
exclude(group: 'group', module: 'module')
}
}
The way to force a dependency is with something like:
configurations.all {
resolutionStrategy {
eachDependency { DependencyResolveDetails dependencyResolveDetails ->
final requestedDependency = dependencyResolveDetails.requested
if (requestedDependency.group == 'org' && requestedDependency.name == 'name') {
force 'group:module:good_version'
}
}
}
}
In order to tie the two together, the resolutionStrategy must know which dependencies actually excluded the transitive dependency that will later be forced. How can this be done in a generic way (assuming there's a generic way to do the exclude)? If there isn't a way to tie the two together, is there a different way to achieve the end goal?

Answer 1

First, abstract the dependencies so they look something like:
dependencies {
compile dep('org:name')
}
The dep function can then be defined in a way which will take care of the automatic exclusions:
final rev = [
'group:module': 'good_version'
'org:name': 'version']
ext.rev = { m ->
rev[m]
}
final dep = { m ->
"${m}:${ext.rev(m)}"
}
final forcedTransitiveDeps = [
'org:name': [
dep('group:module')]].withDefault({[]})
ext.forcedTransitiveDeps = { m ->
forcedTransitiveDeps[m]
}
ext.dep = { m ->
if (!forcedTransitiveDeps.containsKey(m)) {
project.dependencies.create(dep(m))
} else {
project.configure(
project.dependencies.create(dep(m)),
{
forcedTransitiveDeps[m].each { dependency ->
final dependencyParts = dependency.split(':')
exclude(group: dependencyParts[0], module: dependencyParts[1])
}
})
}
}
Finally, to re-introduce and force the dependencies:
subprojects { subproject ->
subproject.afterEvaluate {
subproject.configurations.all { Configuration configuration ->
final dependencies = configuration.getDependencies()
final forcedDependencies = (dependencies.collect { dependency ->
forcedTransitiveDeps("${dependency.group}:${dependency.name}")
}).flatten()
if (!forcedDependencies.isEmpty()) {
logger.info("Forcing ${subproject} dependencies on ${forcedDependencies} as per `ext.forcedTransitiveDeps`.")
dependencies.addAll(forcedDependencies.collect { forcedDependency ->
subproject.dependencies.create(forcedDependency)
})
}
}
}
}