Add partial Configuration Cache compatibility

src/main/groovy/com/netflix/nebula/lint/GradleLintInfoBrokerAction.groovy

@@ -1,31 +1,42 @@
 package com.netflix.nebula.lint
 
+import com.netflix.nebula.lint.plugin.ProjectInfo
 import groovy.transform.Canonical
-import org.gradle.api.Project
+import org.gradle.api.Plugin
+import org.gradle.api.Task
 
 @Canonical
 class GradleLintInfoBrokerAction extends GradleLintViolationAction {
-    Project project
+    Plugin nebulaInfoBroker
+    ProjectInfo projectInfo
+
+
+    GradleLintInfoBrokerAction(Task task){
+        this.projectInfo = ProjectInfo.from(task)
+        task.project.getPlugins().withId('nebula.info-broker') { plugin ->
+            nebulaInfoBroker = plugin
+        }
+    }
 
     @Override
     void lintFinished(Collection<GradleViolation> violations) {
-        project.getPlugins().withId('nebula.info-broker') {
+        nebulaInfoBroker?.tap{
             def reportItems = violations.collect { buildReportItem(it) }
             it.addReport('gradleLintViolations', reportItems)
         }
     }
 
     @Override
     void lintFixesApplied(Collection<GradleViolation> violations) {
-        project.getPlugins().withId('nebula.info-broker') {
+        nebulaInfoBroker?.tap {
             def reportItems = violations.findAll { !it.fixes.any { it.reasonForNotFixing } }
                     .collect { buildReportItem(it) }
             it.addReport('fixedGradleLintViolations', reportItems)
         }
     }
 
     LintReportItem buildReportItem(GradleViolation v) {
-        def buildFilePath = project.rootDir.toURI().relativize(v.file.toURI()).toString()
+        def buildFilePath = projectInfo.rootDir.toURI().relativize(v.file.toURI()).toString()
         new LintReportItem(buildFilePath, v.rule.name, v.rule.getPriority() as String,
                 v.lineNumber ?: -1, v.sourceLine ?: 'unspecified', v.message ?: "")
     }

src/main/groovy/com/netflix/nebula/lint/GradleLintPatchAction.groovy

@@ -16,6 +16,7 @@
 
 package com.netflix.nebula.lint
 
+import com.netflix.nebula.lint.plugin.ProjectInfo
 import com.netflix.nebula.lint.plugin.UnexpectedLintRuleFailureException
 import groovy.transform.Canonical
 import org.apache.commons.lang.StringUtils
@@ -30,12 +31,22 @@ import static java.nio.file.Files.readSymbolicLink
 @Canonical
 class GradleLintPatchAction extends GradleLintViolationAction {
     Project project
+    ProjectInfo projectInfo
+
+    GradleLintPatchAction(Project project) {
+        this.project = project
+
+    }
+
+    GradleLintPatchAction(ProjectInfo projectInfo) {
+        this.projectInfo = projectInfo
+    }
 
     static final String PATCH_NAME = 'lint.patch'
 
     @Override
     void lintFinished(Collection<GradleViolation> violations) {
-        File buildDir = project.layout.buildDirectory.asFile.getOrElse(new File(project.projectDir, "build"))
+        File buildDir = projectInfo ? projectInfo.buildDirectory : project.layout.buildDirectory.asFile.getOrElse(new File(project.projectDir, "build"))
         buildDir.mkdirs()
         try {
             def patch = patch(violations*.fixes.flatten() as List<GradleLintFix>)
@@ -252,7 +263,7 @@ Exception: ${e.getMessage()}
             if (i > 0)
                 combinedPatch += '\n'
 
-            def relativePath = project.rootDir.toPath().relativize(file.toPath()).toString()
+            def relativePath = projectInfo? projectInfo.rootDir.toPath().relativize(file.toPath()).toString() : project.rootDir.toPath().relativize(file.toPath()).toString()
             def diffHeader = """\
                 ${diffHintsWithMargin(relativePath, patchType, fileMode)}
                 |--- ${patchType == Create ? '/dev/null' : 'a/' + relativePath}

src/main/groovy/com/netflix/nebula/lint/plugin/AppliedFilesAstVisitor.groovy

@@ -12,17 +12,18 @@ import org.gradle.api.Project
  */
 class AppliedFilesAstVisitor extends ClassCodeVisitorSupport {
 
-    Project project
+    ProjectInfo projectInfo
+
     List<File> appliedFiles = new ArrayList()
     Map<String, String> projectVariablesMapping
 
-    AppliedFilesAstVisitor(Project project) {
-        this.project = project
+    AppliedFilesAstVisitor(ProjectInfo projectInfo) {
+        this.projectInfo = projectInfo
         projectVariablesMapping = [
-                "\$projectDir" : project.projectDir.toString(),
-                "\$project.projectDir" : project.projectDir.toString(),
-                "\$rootDir" : project.rootDir.toString(),
-                "\$project.rootDir" : project.rootDir.toString(),
+                "\$projectDir" : projectInfo.projectDir.toString(),
+                "\$project.projectDir" : projectInfo.projectDir.toString(),
+                "\$rootDir" : projectInfo.rootDir.toString(),
+                "\$project.rootDir" : projectInfo.rootDir.toString(),
         ]
     }
 
@@ -32,9 +33,9 @@ class AppliedFilesAstVisitor extends ClassCodeVisitorSupport {
             def projectVariable = projectVariablesMapping.find {from.contains(it.key) }
             if (projectVariable) {
                 def absolutePath = from.replaceAll("\\$projectVariable.key", projectVariable.value)
-                appliedFiles.addAll(SourceCollector.getAllFiles(new File(absolutePath), project))
+                appliedFiles.addAll(SourceCollector.getAllFiles(new File(absolutePath), projectInfo))
             } else {
-                appliedFiles.addAll(SourceCollector.getAllFiles(new File(project.projectDir, from), project))
+                appliedFiles.addAll(SourceCollector.getAllFiles(new File(projectInfo.projectDir, from), projectInfo))
             }
         }
     }

src/main/groovy/com/netflix/nebula/lint/plugin/FixGradleLintTask.groovy

@@ -24,7 +24,9 @@ import com.netflix.nebula.lint.StyledTextService
 import org.eclipse.jgit.api.ApplyCommand
 import org.gradle.api.DefaultTask
 import org.gradle.api.GradleException
+import org.gradle.api.Task
 import org.gradle.api.provider.ListProperty
+import org.gradle.api.provider.Property
 import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.Internal
 import org.gradle.api.tasks.Optional
@@ -46,28 +48,44 @@ abstract class FixGradleLintTask extends DefaultTask implements VerificationTask
     @Internal
     GradleLintInfoBrokerAction infoBrokerAction
 
+    @Internal
+    GradleLintPatchAction patchAction
+
+    @Internal
+    abstract Property<ProjectTree> getProjectTree()
+
+    @Internal
+    ProjectInfo getProjectInfo() {
+        return projectTree.get().baseProject
+    }
 
     FixGradleLintTask() {
-        infoBrokerAction = new GradleLintInfoBrokerAction(project)
+        projectTree.set(project.provider {ProjectTree.from(this) })
+        infoBrokerAction = new GradleLintInfoBrokerAction(this)
+        patchAction = new GradleLintPatchAction(getProjectInfo())
         userDefinedListeners.convention([])
         outputs.upToDateWhen { false }
         group = 'lint'
+        try {
+            def method = Task.getMethod("notCompatibleWithConfigurationCache")
+            method.invoke(this)
+        } catch (NoSuchMethodException ignore) {
+        }
     }
 
     @TaskAction
     void lintCorrections() {
-        //TODO: address Invocation of Task.project at execution time has been deprecated.
         DeprecationLogger.whileDisabled {
-            def violations = new LintService().lint(project, false).violations
+            def violations = new LintService().lint(projectTree.get(), false).violations
                     .unique { v1, v2 -> v1.is(v2) ? 0 : 1 }
 
-            (userDefinedListeners.get() + infoBrokerAction + new GradleLintPatchAction(project)).each {
+            (userDefinedListeners.get() + infoBrokerAction + patchAction).each {
                 it.lintFinished(violations)
             }
 
-            def patchFile = new File(project.layout.buildDirectory.asFile.get(), GradleLintPatchAction.PATCH_NAME)
+            def patchFile = new File(getProjectInfo().buildDirectory, GradleLintPatchAction.PATCH_NAME)
             if (patchFile.exists()) {
-                new ApplyCommand(new NotNecessarilyGitRepository(project.projectDir)).setPatch(patchFile.newInputStream()).call()
+                new ApplyCommand(new NotNecessarilyGitRepository(projectInfo.projectDir)).setPatch(patchFile.newInputStream()).call()
             }
 
             (userDefinedListeners.get() + infoBrokerAction + consoleOutputAction()).each {
@@ -97,7 +115,7 @@ abstract class FixGradleLintTask extends DefaultTask implements VerificationTask
                 violations.groupBy { it.file }.each { buildFile, projectViolations ->
 
                     projectViolations.each { v ->
-                        String buildFilePath = project.rootDir.toURI().relativize(v.file.toURI()).toString()
+                        String buildFilePath = projectTree.get().baseProject.rootDir.toURI().relativize(v.file.toURI()).toString()
                         def unfixed = v.fixes.findAll { it.reasonForNotFixing != null }
                         if (v.fixes.empty) {
                             textOutput.withStyle(Yellow).text('needs fixing'.padRight(15))

src/main/groovy/com/netflix/nebula/lint/plugin/GradleLintReportTask.groovy

@@ -57,9 +57,17 @@ abstract class GradleLintReportTask extends DefaultTask implements VerificationT
     @Internal
     final NamedDomainObjectContainer<LintReport> reports
 
+    @Internal
+    abstract Property<ProjectInfo> getProjectInfo()
+
+    @Internal
+    abstract Property<ProjectTree> getProjectTree()
+
     @Inject
     GradleLintReportTask(ObjectFactory objects) {
-        projectName = objects.property(String).convention(project.name)
+        projectInfo.convention(projectTree.map {it.baseProject })
+        projectTree.set(project.provider { ProjectTree.from(this) })
+        projectName = objects.property(String).convention(projectInfo.get().name)
         reportsDir = objects.directoryProperty()
         reports =
                 objects.domainObjectContainer(
@@ -90,7 +98,7 @@ abstract class GradleLintReportTask extends DefaultTask implements VerificationT
         DeprecationLogger.whileDisabled {
             if (reports.any { it.required.isPresent() && it.required.get()}) {
                 def lintService = new LintService()
-                def results = lintService.lint(project, false)
+                def results = lintService.lint(projectTree.get(), false)
                 filterOnlyFixableViolations(results)
                 def violationCount = results.violations.size()
                 def textOutput = new StyledTextService(getServices())
@@ -101,7 +109,7 @@ abstract class GradleLintReportTask extends DefaultTask implements VerificationT
 
                 reports.each {
                     if(it.required.isPresent() && it.required.get()) {
-                        it.write(new AnalysisContext(ruleSet: lintService.ruleSet(project)), results)
+                        it.write(new AnalysisContext(ruleSet: lintService.ruleSet(projectTree.get())), results)
                     }
                 }
 
@@ -142,7 +150,7 @@ abstract class GradleLintReportTask extends DefaultTask implements VerificationT
 
     void filterOnlyFixableViolations(Results results) {
         if (reportOnlyFixableViolations.isPresent() && reportOnlyFixableViolations.get()) {
-            new GradleLintPatchAction(project).lintFinished(results.violations)
+            new GradleLintPatchAction(projectInfo.get()).lintFinished(results.violations)
             List<Violation> toRemove = results.violations.findAll {
                 it.fixes.size() == 0 || it.fixes.any { it.reasonForNotFixing != null }
             }

src/main/groovy/com/netflix/nebula/lint/plugin/LintGradleTask.groovy

@@ -15,18 +15,21 @@
  */
 package com.netflix.nebula.lint.plugin
 
+import com.google.common.annotations.VisibleForTesting
 import com.netflix.nebula.lint.*
 import org.gradle.api.DefaultTask
 import org.gradle.api.GradleException
+import org.gradle.api.Project
 import org.gradle.api.Task
-import org.gradle.api.provider.ListProperty
 import org.gradle.api.provider.Property
 import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.Internal
 import org.gradle.api.tasks.Optional
 import org.gradle.api.tasks.TaskAction
 import org.gradle.internal.deprecation.DeprecationLogger
 
+import java.util.function.Supplier
+
 import static com.netflix.nebula.lint.StyledTextService.Styling.*
 
 abstract class LintGradleTask extends DefaultTask {
@@ -45,9 +48,27 @@ abstract class LintGradleTask extends DefaultTask {
     @Input
     abstract Property<File> getProjectRootDir()
 
+    @Input
+    abstract Property<ProjectTree> getProjectTree()
+
+    @Input
+    abstract Property<ProjectInfo> getProjectInfo()
+
+    @Internal
+    GradleLintInfoBrokerAction infoBrokerAction
+
+    @Internal
+    GradleLintPatchAction patchAction
+
+
     LintGradleTask() {
         failOnWarning.convention(false)
         onlyCriticalRules.convention(false)
+        projectTree.set(project.provider {ProjectTree.from(this) })
+        projectInfo.convention(projectTree.map(ProjectTree::getBaseProject))
+        projectRootDir.set(project.rootDir)
+        infoBrokerAction = new GradleLintInfoBrokerAction(this)
+        patchAction = new GradleLintPatchAction(getProjectInfo().get())
         group = 'lint'
         try {
             def method = Task.getMethod("notCompatibleWithConfigurationCache")
@@ -58,12 +79,11 @@ abstract class LintGradleTask extends DefaultTask {
 
     @TaskAction
     void lint() {
-        //TODO: address Invocation of Task.project at execution time has been deprecated.
         DeprecationLogger.whileDisabled {
-            def violations = new LintService().lint(project, onlyCriticalRules.get()).violations
+            def violations = new LintService().lint(projectTree.get(), onlyCriticalRules.get()).violations
                     .unique { v1, v2 -> v1.is(v2) ? 0 : 1 }
 
-            (getListeners() + new GradleLintPatchAction(project) + new GradleLintInfoBrokerAction(project) + consoleOutputAction).each {
+            (getListeners() + patchAction + infoBrokerAction + consoleOutputAction).each {
                 it.lintFinished(violations)
             }
         }
@@ -139,3 +159,81 @@ abstract class LintGradleTask extends DefaultTask {
         }
     }
 }
+/**
+ * A CC-compatible projection of project data.
+ */
+class ProjectInfo implements Serializable{
+    String name
+    String path
+    File rootDir
+    File buildFile
+    File projectDir
+    File buildDirectory
+    GradleLintExtension extension
+    Map<String, Object> properties
+    Supplier<Project> projectSupplier
+
+    static ProjectInfo from(Task task, Project subproject) {
+        String subprojectPath = subproject.path
+        return build(subproject, { task.project.project(subprojectPath) })
+    }
+
+    static ProjectInfo from(Task task) {
+        return build(task.project, task::getProject)
+    }
+
+    @VisibleForTesting
+    private static ProjectInfo build(Project project, Supplier<Project> projectSupplier) {
+        GradleLintExtension extension =
+                project.extensions.findByType(GradleLintExtension) ?:
+                project.rootProject.extensions.findByType(GradleLintExtension)
+        Map<String, Object> properties = [:]
+        if (project.hasProperty('gradleLint.rules')) {
+            properties['gradleLint.rules'] = project.property('gradleLint.rules')
+        }
+        if (project.hasProperty('gradleLint.excludedRules')) {
+            properties['gradleLint.excludedRules'] = project.property('gradleLint.excludedRules')
+        }
+
+        return new ProjectInfo(
+                name:project.name,
+                path:project.path,
+                rootDir:project.rootDir,
+                buildFile: project.buildFile,
+                projectDir:project.projectDir,
+                extension: extension,
+                properties: properties,
+                projectSupplier: projectSupplier,
+                buildDirectory : project.buildDir
+        )
+
+    }
+
+
+}
+
+class ProjectTree{
+    List<ProjectInfo> allProjects
+
+    ProjectTree(List<ProjectInfo> allProjects){
+        this.allProjects = allProjects
+    }
+
+    /**
+     * Returns the base project this tree was built from.
+     */
+    ProjectInfo getBaseProject() {
+        return allProjects.head()
+    }
+
+    /**
+     * Build a project tree based on the given task's project.
+     *
+     * @return a project tree reflecting information and the structure of the given task's project
+     */
+    static from(Task task) {
+        def baseProject = task.project
+        List<ProjectInfo> projectInfos = [ProjectInfo.from(task)] + baseProject.subprojects.collect { Project p -> ProjectInfo.from(task, p) }
+        return new ProjectTree(projectInfos)
+    }
+}