Merge pull request #13 from rspieldenner/opt_out

Tests for cycles

Author: rspieldenner

CHANGELOG.md

@@ -1,4 +1,4 @@
-1.2.0 / 2016/04/06
+1.2.0 / 2016/04/11
 ==================
 - Allow opt out of rules for shared company wide rules that apply to your project, e.g. there is a common align rule for a:foo and a:bar and you produce them
 - Performance improvement if there are multiple align rules

src/functionalTest/groovy/nebula/plugin/resolutionrules/AlignRulesMultiprojectSpec.groovy

@@ -66,7 +66,7 @@ class AlignRulesMultiprojectSpec extends IntegrationSpec {
         // project b depends on a
         new File(bDir, 'build.gradle') << '''\
             dependencies {
-                project(':a')
+                compile project(':a')
             }
         '''.stripIndent()
 
@@ -96,4 +96,32 @@ class AlignRulesMultiprojectSpec extends IntegrationSpec {
         then:
         noExceptionThrown()
     }
+
+    def 'cycle like behavior'() {
+        rulesJsonFile << '''\
+            {
+                "deny": [], "reject": [], "substitute": [], "replace": [],
+                "align": [
+                ]
+            }
+        '''.stripIndent()
+
+        new File(aDir, 'build.gradle') << '''\
+            dependencies {
+                testCompile project(':b')
+            }
+        '''.stripIndent()
+
+        new File(bDir, 'build.gradle') << '''\
+            dependencies {
+                compile project(':a')
+            }
+        '''.stripIndent()
+
+        when:
+        def results = runTasksSuccessfully(':a:dependencies', ':b:dependencies', 'assemble')
+
+        then:
+        noExceptionThrown()
+    }
 }

src/functionalTest/groovy/nebula/plugin/resolutionrules/AlignRulesPluginInteractionSpec.groovy

@@ -234,4 +234,136 @@ class AlignRulesPluginInteractionSpec extends IntegrationSpec {
         then:
         result.standardOutput.contains '\\--- test.a:a:1.+ -> 1.42.2\n'
     }
+
+    def 'publishing, provided, and dependency-recommender interacting with resolution-rules'() {
+        def graph = new DependencyGraphBuilder()
+                .addModule('test.a:a:1.42.2')
+                .addModule('test.a:b:1.2.1')
+                .build()
+        def mavenrepo = new GradleDependencyGenerator(graph, "${projectDir}/testrepogen")
+        mavenrepo.generateTestMavenRepo()
+
+        def rulesJsonFile = new File(projectDir, 'rules.json')
+
+        rulesJsonFile << '''\
+            {
+                "deny": [], "reject": [], "substitute": [], "replace": [],
+                "align": [
+                    {
+                        "name": "testNebula",
+                        "group": "test.nebula",
+                        "reason": "Align test.nebula dependencies",
+                        "author": "Example Person <person@example.org>",
+                        "date": "2016-03-17T20:21:20.368Z"
+                    }
+                ]
+            }
+        '''.stripIndent()
+
+        buildFile << """\
+            buildscript {
+                repositories { jcenter() }
+
+                dependencies {
+                    classpath 'com.netflix.nebula:nebula-dependency-recommender:3.1.0'
+                    classpath 'com.netflix.nebula:nebula-publishing-plugin:4.4.4'
+                    classpath 'com.netflix.nebula:gradle-extra-configurations-plugin:3.0.3'
+                }
+            }
+
+            apply plugin: 'nebula.dependency-recommender'
+            apply plugin: 'nebula.maven-publish'
+            ${applyPlugin(ResolutionRulesPlugin)}
+            apply plugin: 'java'
+            apply plugin: 'nebula.provided-base'
+
+
+            repositories {
+                ${mavenrepo.mavenRepositoryBlock}
+            }
+
+            dependencyRecommendations {
+               map recommendations: ['test.a:a': '1.42.2', 'test.a:b': '1.2.1']
+            }
+
+            dependencies {
+                resolutionRules files('$rulesJsonFile')
+                compile 'test.a:a'
+                provided 'test.a:b'
+            }
+        """.stripIndent()
+
+        when:
+        def result = runTasksSuccessfully('dependencies', '--configuration', 'compile')
+
+        then:
+        result.standardOutput.contains '+--- test.a:a: -> 1.42.2\n'
+        result.standardOutput.contains '\\--- test.a:b: -> 1.2.1\n'
+    }
+
+    @spock.lang.Ignore
+    def 'cycle like behavior'() {
+        def graph = new DependencyGraphBuilder()
+                .addModule('test.nebula:c:1.42.2')
+                .addModule('test.nebula:d:1.2.1')
+                .build()
+        def mavenrepo = new GradleDependencyGenerator(graph, "${projectDir}/testrepogen")
+        mavenrepo.generateTestMavenRepo()
+
+        def rulesJsonFile = new File(projectDir, 'rules.json')
+
+        rulesJsonFile << '''\
+            {
+                "deny": [], "reject": [], "substitute": [], "replace": [],
+                "align": [
+                ]
+            }
+        '''.stripIndent()
+
+        buildFile << """\
+            buildscript {
+                repositories { jcenter() }
+
+                dependencies {
+                    classpath 'com.netflix.nebula:nebula-publishing-plugin:4.4.4'
+                    classpath 'com.netflix.nebula:gradle-extra-configurations-plugin:3.0.3'
+                }
+            }
+            subprojects {
+                apply plugin: 'nebula.maven-publish'
+                apply plugin: 'nebula.provided-base'
+                ${applyPlugin(ResolutionRulesPlugin)}
+                apply plugin: 'java'
+
+
+
+                repositories {
+                    ${mavenrepo.mavenRepositoryBlock}
+                }
+
+                dependencies {
+                    resolutionRules files('$rulesJsonFile')
+                }
+            }
+        """.stripIndent()
+
+        def aDir = addSubproject('a', '''\
+            dependencies {
+                compile 'test.nebula:c:1.+'
+                testCompile project(':b')
+            }
+        '''.stripIndent())
+        def bDir = addSubproject('b', '''\
+            dependencies {
+                compile 'test.nebula:d:[1.0.0, 2.0.0)'
+                compile project(':a')
+            }
+        '''.stripIndent())
+
+        when:
+        def results = runTasksSuccessfully(':a:dependencies', ':b:dependencies', 'assemble')
+
+        then:
+        noExceptionThrown()
+    }
 }

src/main/groovy/nebula/plugin/resolutionrules/Rules.groovy

@@ -200,29 +200,29 @@ class AlignRules implements ProjectConfigurationRule {
             return
         }
 
-        def detached = configuration.copyRecursive()
-        def artifacts
-        if (detached.resolvedConfiguration.hasError()) {
-            project.logger.info('Cannot resolve all dependencies to align')
-            artifacts = detached.resolvedConfiguration.lenientConfiguration.getArtifacts()
-        } else {
-            artifacts = detached.resolvedConfiguration.resolvedArtifacts.collect { it.moduleVersion }
-        }
+        configuration.resolutionStrategy { ResolutionStrategy rs ->
+            def detached = configuration.copyRecursive()
+            def artifacts
+            if (detached.resolvedConfiguration.hasError()) {
+                project.logger.info('Cannot resolve all dependencies to align')
+                artifacts = detached.resolvedConfiguration.lenientConfiguration.getArtifacts()
+            } else {
+                artifacts = detached.resolvedConfiguration.resolvedArtifacts.collect { it.moduleVersion }
+            }
 
-        def selectedVersion = [:]
-        aligns.each { AlignRule align ->
-            if (align.shouldNotBeSkipped(extension)) {
-                def matches = artifacts.findAll { ResolvedModuleVersion dep -> align.resolvedMatches(dep) }
-                def versions = matches.collect { ResolvedModuleVersion dep -> dep.id.version }.toUnique()
-                def comparator = new DefaultVersionComparator().asStringComparator()
-                def alignedVersion = versions.max { a, b -> comparator.compare(a, b) }
-                if (alignedVersion) {
-                    selectedVersion[align] = alignedVersion
+            def selectedVersion = [:]
+            aligns.each { AlignRule align ->
+                if (align.shouldNotBeSkipped(extension)) {
+                    def matches = artifacts.findAll { ResolvedModuleVersion dep -> align.resolvedMatches(dep) }
+                    def versions = matches.collect { ResolvedModuleVersion dep -> dep.id.version }.toUnique()
+                    def comparator = new DefaultVersionComparator().asStringComparator()
+                    def alignedVersion = versions.max { a, b -> comparator.compare(a, b) }
+                    if (alignedVersion) {
+                        selectedVersion[align] = alignedVersion
+                    }
                 }
             }
-        }
 
-        configuration.resolutionStrategy { ResolutionStrategy rs ->
             rs.eachDependency { DependencyResolveDetails details ->
                 def foundMatch = selectedVersion.find { AlignRule rule, String version -> rule.dependencyMatches(details) }
                 if (foundMatch) {