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)
val Task.isRequested: Boolean get() = project.gradle.startParameter.taskNames.any { name == it }
val Task.isParentProjectTaskWithSameNameInGraph: Boolean get() = project.parents.any { it.tasks.findByName(name)?.isInTaskGraph == true }
val Task.isThereTaskWithSameNameInGraphBefore: Boolean get() = project.gradle.taskGraph.allTasks.filter { it.name == name }.indexOf(this) >= 1


fun Task.skipIfOffline() {
    onlyIf {
        if (project.gradle.startParameter.isOffline) {
            logWarn("Skip because Gradle is running in offline mode")
            return@onlyIf false
        }
        return@onlyIf true
    }
}


private val noSourcePropertySuffix = AtomicLong(0)
fun  T.noSourceIf(noSourceIfSpec: (task: T) -> Boolean) {
    doSetup {} // we want to register setup actions first
    onlyIf {
        if (noSourceIfSpec(this)) {
            it.inputs.files()
                .withPropertyName("\$noSourceIf_${noSourcePropertySuffix.incrementAndGet()}")
                .skipWhenEmpty()
        }
        return@onlyIf true
    }
}


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

    actionsContainerTask.actions.add(object : TaskSetupAction() {
        override fun getOrder() = order
        override fun setup(task: Task) = configureAction(task.uncheckedCast())
    })
}

fun  T.doSetup(configureAction: (task: T) -> Unit) = doSetup(0, configureAction)

fun  T.doSetupIf(order: Int, condition: (task: T) -> Boolean, configureAction: (task: T) -> Unit) = doSetup(order) {
    if (condition(it)) {
        configureAction(it)
    }
}

fun  T.doSetupIf(condition: (task: T) -> Boolean, configureAction: (task: T) -> Unit) = doSetupIf(0, condition, configureAction)


fun  T.doSetupAndAfterEvaluate(order: Int, configureAction: (task: T) -> Unit) {
    project.afterEvaluateOrNow(order) { _ -> configureAction(this) }
    doSetup(order, configureAction)
}

fun  T.doSetupAndAfterEvaluate(configureAction: (task: T) -> Unit) {
    project.afterEvaluateOrNow { _ -> configureAction(this) }
    doSetup(configureAction)
}

fun  T.doSetupIfAndAfterEvaluate(order: Int, condition: (task: T) -> Boolean, configureAction: (task: T) -> Unit) {
    project.afterEvaluateOrNow(order) { _ -> if (condition(this)) configureAction(this) }
    doSetupIf(order, condition, configureAction)
}

fun  T.doSetupIfAndAfterEvaluate(condition: (task: T) -> Boolean, configureAction: (task: T) -> Unit) {
    project.afterEvaluateOrNow { _ -> if (condition(this)) configureAction(this) }
    doSetupIf(condition, configureAction)
}


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


private abstract class TaskSetupAction : Ordered {

    companion object {
        private val setupActionNextIndex = AtomicLong(Long.MIN_VALUE)
    }

    abstract fun setup(task: Task)

    private val actionIndex = setupActionNextIndex.getAndIncrement()

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

}

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