Merge pull request #141 from nebula-plugins/bring-back-ivy-resolved-d…

…ependencies

Go back to use our own resolved versions reader for ivy - temporary change

build.gradle

@@ -327,3 +327,7 @@ gradleTest.dependsOn(jar)
 gradleTest.doFirst {
     project.version = project.version.toString()
 }
+
+
+targetCompatibility = JavaVersion.VERSION_1_8
+sourceCompatibility = JavaVersion.VERSION_1_8

src/main/groovy/nebula/plugin/publishing/ivy/AbstractResolvedDependenciesPlugin.groovy

@@ -0,0 +1,65 @@
+package nebula.plugin.publishing.ivy
+
+import groovy.transform.Memoized
+import org.gradle.api.GradleException
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.artifacts.ConfigurationContainer
+import org.gradle.api.artifacts.ModuleVersionIdentifier
+import org.gradle.api.artifacts.component.ModuleComponentSelector
+import org.gradle.api.artifacts.result.ResolvedDependencyResult
+
+abstract class AbstractResolvedDependenciesPlugin implements Plugin<Project> {
+    ModuleVersionIdentifier selectedModuleVersion(Project project, String scope, String group, String name) {
+        def exclude
+        try {
+            exclude = project.configurations.getByName(scope).excludeRules.find {
+                it.group == group && it.module == name
+            }
+        } catch (e) {
+            // leave exclude null in case of unknown configuration
+        }
+        if (exclude) {
+            throw new GradleException("Direct dependency \"${group}:${name}\" is excluded, delete direct dependency or stop excluding it")
+        }
+
+        ResolvedDependencyResult result = lookupDependency(project, scope, group, name)
+
+        Map<String, String> scoping = [compile: 'runtime', provided: 'compileOnly']
+
+        if (!result && scoping[scope]) {
+            result = lookupDependency(project, scoping[scope], group, name)
+        }
+
+        result?.selected?.moduleVersion
+    }
+
+    private ResolvedDependencyResult lookupDependency(Project project, String scope, String group, String name) {
+        def resolvedDependencies = resolvedDependencyByConfiguration(project)[scope]
+        def result = resolvedDependencies.find { r ->
+            def requested = r.requested
+            (requested instanceof ModuleComponentSelector) &&
+                    (requested.group == group) &&
+                    (requested.module == name)
+        }
+        result
+    }
+
+    @Memoized
+    Map<String, Set<? extends ResolvedDependencyResult>> resolvedDependencyByConfiguration(Project project) {
+        ConfigurationContainer configurations = project.configurations
+        Map<String, Set<? extends ResolvedDependencyResult>> dependencyMap = [:]
+        dependencyMap['runtime'] = resolvedDependencies(configurations.runtimeClasspath)
+        dependencyMap['compile'] = resolvedDependencies(configurations.compileClasspath)
+        dependencyMap['compileOnly'] = resolvedDependencies(configurations.compileOnly)
+        dependencyMap['test'] = resolvedDependencies(configurations.testRuntimeClasspath)
+        return dependencyMap
+    }
+
+    Set<? extends ResolvedDependencyResult> resolvedDependencies(Configuration configuration) {
+        configuration.incoming.resolutionResult.allDependencies.findAll {
+            it instanceof ResolvedDependencyResult
+        } as Set<? extends ResolvedDependencyResult>
+    }
+}

src/main/groovy/nebula/plugin/publishing/ivy/IvyResolvedDependenciesPlugin.groovy

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2019 Netflix, Inc.
+ * Copyright 2015-2017 Netflix, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,32 +15,94 @@
  */
 package nebula.plugin.publishing.ivy
 
-import nebula.plugin.publishing.verification.DirectDependenciesVerifier
-import org.gradle.api.Plugin
 import org.gradle.api.Project
+import org.gradle.api.XmlProvider
+import org.gradle.api.artifacts.ModuleVersionIdentifier
+import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy.DefaultVersionComparator
+import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy.DefaultVersionSelectorScheme
+import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy.ExactVersionSelector
+import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy.VersionSelector
+import org.gradle.api.plugins.JavaBasePlugin
 import org.gradle.api.publish.ivy.IvyPublication
 
 /**
  * Replaces first order dependencies with the selected versions when publishing.
  */
-class IvyResolvedDependenciesPlugin implements Plugin<Project> {
+class IvyResolvedDependenciesPlugin extends AbstractResolvedDependenciesPlugin {
     @Override
     void apply(Project project) {
         project.plugins.apply IvyBasePublishPlugin
 
         project.afterEvaluate {
-            DirectDependenciesVerifier.verify(project)
             project.publishing {
                 publications {
                     withType(IvyPublication) {
-                        versionMapping {
-                            allVariants {
-                                fromResolutionResult()
+                        descriptor.withXml { XmlProvider xml ->
+                            project.plugins.withType(JavaBasePlugin) {
+                                def dependencies = xml.asNode()?.dependencies?.dependency
+                                dependencies?.each { Node dep ->
+                                    String scope = dep.@conf
+                                    String group = dep.@org
+                                    String name = dep.@name
+
+                                    if (scope == 'compile->default') {
+                                        scope = 'compile'
+                                    }
+
+                                    if (scope == 'provided->default' || scope == 'runtime->default') {
+                                        scope = 'runtime'
+                                    }
+
+                                    if (scope == 'test->default') {
+                                        scope = 'test'
+                                    }
+
+                                    if (scope.contains('->')) {
+                                        scope = scope.split('->')[0]
+                                    }
+
+                                    def mvid = selectedModuleVersion(project, scope, group, name)
+                                    if (!mvid) {
+                                        return  // continue loop if a dependency is not found in dependencyMap
+                                    }
+
+                                    if (dep.@rev) {
+                                        def version = dep.@rev as String
+                                        VersionSelector selector = parseSelector(version)
+                                        setVersionConstraint(selector, version, dep, mvid)
+                                    } else {
+                                        //no requested version we use selected
+                                        dep.@rev = mvid.version
+                                    }
+                                    updateReplacedModules(mvid, group, name, dep)
+                                }
                             }
                         }
                     }
                 }
             }
         }
     }
+
+    private VersionSelector parseSelector(String version) {
+        def scheme = new DefaultVersionSelectorScheme(new DefaultVersionComparator())
+        def selector = scheme.parseSelector(version)
+        selector
+    }
+
+    private void setVersionConstraint(VersionSelector selector, String version, Node dep, ModuleVersionIdentifier selected) {
+        if (!(selector instanceof ExactVersionSelector)) {
+            //requested dynamic version will be replaced by specific selected
+            dep.@revConstraint = version
+            dep.@rev = selected.version
+        }
+    }
+
+    private void updateReplacedModules(ModuleVersionIdentifier mvid, String group, String name, Node dep) {
+        if (mvid.group != group || mvid.name != name) {
+            dep.@org = mvid.group
+            dep.@name = mvid.name
+            dep.@rev = mvid.version
+        }
+    }
 }