com.autonomousapps.tasks.RedundantKaptAlertTask.kt Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of dependency-analysis-gradle-plugin Show documentation

Analyzes dependency usage in Android and JVM projects

There is a newer version: 2.0.2

Show newest version

@file:Suppress("UnstableApiUsage")

package com.autonomousapps.tasks

import com.autonomousapps.TASK_GROUP_DEP
import com.autonomousapps.advice.PluginAdvice
import com.autonomousapps.internal.AnnotationProcessor
import com.autonomousapps.internal.utils.*
import org.gradle.api.DefaultTask
import org.gradle.api.file.RegularFileProperty
import org.gradle.api.provider.Property
import org.gradle.api.tasks.*
import org.gradle.workers.WorkAction
import org.gradle.workers.WorkParameters
import org.gradle.workers.WorkerExecutor
import javax.inject.Inject

/**
 * Takes as input (1) declaredProcs and (2) unused procs. Runs only if kotlin-kapt has been applied.
 * If it determines there are either (1) no procs declared or (2) no _used_ procs declared, suggests
 * removing kapt.
 */
@CacheableTask
abstract class RedundantKaptAlertTask @Inject constructor(
  private val workerExecutor: WorkerExecutor
) : DefaultTask() {

  init {
    group = TASK_GROUP_DEP
    description = "Produces a report indicating if kapt is redundant"
  }

  @get:Input
  abstract val kapt: Property

  @get:PathSensitive(PathSensitivity.NONE)
  @get:InputFile
  abstract val declaredProcs: RegularFileProperty

  @get:PathSensitive(PathSensitivity.NONE)
  @get:InputFile
  abstract val unusedProcs: RegularFileProperty

  @get:OutputFile
  abstract val output: RegularFileProperty

  @TaskAction fun action() {
    workerExecutor.noIsolation().submit(RedundantKaptAlertWorkAction::class.java) {
      kapt.set([email protected])
      declaredProcs.set([email protected])
      unusedProcs.set([email protected])
      output.set([email protected])
    }
  }
}

interface RedundantKaptAlertParameters : WorkParameters {
  val kapt: Property
  val declaredProcs: RegularFileProperty
  val unusedProcs: RegularFileProperty
  val output: RegularFileProperty
}

abstract class RedundantKaptAlertWorkAction : WorkAction {

  private val logger = getLogger()

  override fun execute() {
    val outputFile = parameters.output.getAndDelete()

    val pluginAdvice = if (!parameters.kapt.get()) {
      // kapt is not applied
      emptySet()
    } else {
      // kapt is applied
      val declaredProcs = parameters.declaredProcs.fromJsonSet()
      val unusedProcs = parameters.unusedProcs.fromJsonSet()

      if (declaredProcs.isEmpty() || (declaredProcs - unusedProcs).isEmpty()) {
        // kapt is applied but unused
        setOf(PluginAdvice.redundantKapt())
      } else {
        // kapt is applied and used
        emptySet()
      }
    }

    if (pluginAdvice.isNotEmpty()) {
      val adviceString = pluginAdvice.joinToString(prefix = "- ", separator = "\n- ") {
        "${it.redundantPlugin}, because ${it.reason}"
      }
      logger.debug("Redundant plugins that should be removed:\n$adviceString")
    }

    outputFile.writeText(pluginAdvice.toJson())
  }
}