name.remal.gradle_plugins.dsl.extensions.org.gradle.api.Task.kt Maven / Gradle / Ivy

Go to download
package name.remal.gradle_plugins.dsl.extensions

import com.google.common.annotations.VisibleForTesting
import name.remal.KotlinAllOpen
import name.remal.Ordered
import name.remal.copyOnWriteListOf
import name.remal.uncheckedCast
import org.gradle.api.Task
import java.util.concurrent.atomic.AtomicLong

val Task.dependencies: Set get() = taskDependencies.getDependencies(this)

val Task.isInTaskGraph: Boolean get() = project.gradle.taskGraph.hasTask(this)


private val noSourcePropertySuffix = AtomicLong(0)
fun  T.noSourceIf(noSourceIfSpec: (task: T) -> Boolean) {
    doSetup(Int.MAX_VALUE) {
        if (noSourceIfSpec(it)) {
            it.inputs.files()
                .withPropertyName("\$noSourceIf_${noSourcePropertySuffix.incrementAndGet()}")
                .skipWhenEmpty()
        }
    }
}

fun Task.dependsOnAllprojectsTasks(allprojectsTaskName: String, condition: (task: Task) -> Boolean = { true }) {
    project.allprojects { proj ->
        proj.tasks.all(allprojectsTaskName) {
            if (this !== it && condition(it)) {
                if (!it.dependsOn.contains(this)) {
                    this.dependsOn(it)
                }
            }
        }
    }
}

fun Task.shouldRunAfterAllprojectsTasks(allprojectsTaskName: String, condition: (task: Task) -> Boolean = { true }) {
    project.allprojects { proj ->
        proj.tasks.all(allprojectsTaskName) {
            if (this !== it && condition(it)) {
                this.shouldRunAfter(it)
            }
        }
    }
}

fun Task.mustRunAfterAllprojectsTasks(allprojectsTaskName: String, condition: (task: Task) -> Boolean = { true }) {
    project.allprojects { proj ->
        proj.tasks.all(allprojectsTaskName) {
            if (this !== it && condition(it)) {
                this.mustRunAfter(it)
            }
        }
    }
}

fun  T.doSetup(order: Int = 0, configureAction: (task: T) -> Unit) {
    val actionsContainer: SetupActionsContainer = this.extensions.getOrCreate(
        SetupActionsContainer::class.java,
        { onlyIf { executeSetupActions(); true } }
    )

    actionsContainer.actions.add(object : SetupAction() {
        override fun getOrder() = order
        override fun setupImpl(task: Task) = configureAction(task.uncheckedCast())
    })
}

@VisibleForTesting
internal fun Task.executeSetupActions() {
    val actionsContainer = this.extensions.findByType(SetupActionsContainer::class.java) ?: return
    actionsContainer.actions.sorted().forEach { it.setup(this) }
}


private val setupActionsCount = AtomicLong(0)

private abstract class SetupAction : Ordered {

    abstract fun setupImpl(task: Task)

    @Volatile
    var wasExecuted: Boolean = false

    fun setup(task: Task) {
        if (!wasExecuted) {
            synchronized(this) {
                if (!wasExecuted) {
                    wasExecuted = true
                    setupImpl(task)
                }
            }
        }
    }

    private val actionIndex = setupActionsCount.getAndIncrement()

    override fun compareTo(other: SetupAction): Int {
        super.compareTo(other).let { if (0 != it) return it }
        actionIndex.compareTo(other.actionIndex).let { if (0 != it) return it }
        return 0
    }

}

@KotlinAllOpen
private class SetupActionsContainer {
    val actions = copyOnWriteListOf()
}


fun Task.logTrace(message: String) {
    if (logger.isTraceEnabled) logger.trace("Task $name: $message")
}

fun Task.logTrace(message: String, vararg objects: Any?) {
    if (logger.isTraceEnabled) logger.trace("Task $name: $message", *objects)
}

fun Task.logTrace(message: String, throwable: Throwable) {
    if (logger.isTraceEnabled) logger.trace("Task $name: $message", throwable)
}

fun Task.logDebug(message: String) {
    if (logger.isDebugEnabled) logger.debug("Task $name: $message")
}

fun Task.logDebug(message: String, vararg objects: Any?) {
    if (logger.isDebugEnabled) logger.debug("Task $name: $message", *objects)
}

fun Task.logDebug(message: String, throwable: Throwable) {
    if (logger.isDebugEnabled) logger.debug("Task $name: $message", throwable)
}

fun Task.logInfo(message: String) {
    if (logger.isInfoEnabled) logger.info("Task $name: $message")
}

fun Task.logInfo(message: String, vararg objects: Any?) {
    if (logger.isInfoEnabled) logger.info("Task $name: $message", *objects)
}

fun Task.logInfo(message: String, throwable: Throwable) {
    if (logger.isInfoEnabled) logger.info("Task $name: $message", throwable)
}

fun Task.logWarn(message: String) {
    if (logger.isWarnEnabled) logger.warn("Task $name: $message")
}

fun Task.logWarn(message: String, vararg objects: Any?) {
    if (logger.isWarnEnabled) logger.warn("Task $name: $message", *objects)
}

fun Task.logWarn(message: String, throwable: Throwable) {
    if (logger.isWarnEnabled) logger.warn("Task $name: $message", throwable)
}

fun Task.logError(message: String) {
    if (logger.isErrorEnabled) logger.error("Task $name: $message")
}

fun Task.logError(message: String, vararg objects: Any?) {
    if (logger.isErrorEnabled) logger.error("Task $name: $message", *objects)
}

fun Task.logError(message: String, throwable: Throwable) {
    if (logger.isErrorEnabled) logger.error("Task $name: $message", throwable)
}