• Home
• name.remal
• gradle-plugins-kotlin-dsl
• 1.0.167
• source code
• org.gradle.api.artifacts.repositories.ArtifactRepository.kt

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

name.remal.gradle_plugins.dsl.extensions.org.gradle.api.artifacts.repositories.ArtifactRepository.kt Maven / Gradle / Ivy

package name.remal.gradle_plugins.dsl.extensions

import name.remal.gradle_plugins.dsl.utils.DependencyNotation
import name.remal.gradle_plugins.dsl.utils.getGradleLogger
import name.remal.warn
import org.gradle.api.Action
import org.gradle.api.artifacts.repositories.ArtifactRepository

fun ArtifactRepository.includeGroup(group: String) = forContent { includeGroup(group) }
fun ArtifactRepository.includeGroupByRegex(groupRegex: String) = forContent { includeGroupByRegex(groupRegex) }
fun ArtifactRepository.includeModule(group: String, module: String) = forContent { includeModule(group, module) }
fun ArtifactRepository.includeModule(notation: DependencyNotation) = includeModule(notation.group, notation.module)
fun ArtifactRepository.includeModuleByRegex(groupRegex: String, moduleRegex: String) = forContent { includeModuleByRegex(groupRegex, moduleRegex) }
fun ArtifactRepository.includeVersion(group: String, module: String, version: String) = forContent { includeVersion(group, module, version) }
fun ArtifactRepository.includeVersion(notation: DependencyNotation) = includeVersion(notation.group, notation.module, notation.version)
fun ArtifactRepository.includeVersionByRegex(groupRegex: String, moduleRegex: String, versionRegex: String) = forContent { includeVersionByRegex(groupRegex, moduleRegex, versionRegex) }

fun ArtifactRepository.excludeGroup(group: String) = forContent { excludeGroup(group) }
fun ArtifactRepository.excludeGroupByRegex(groupRegex: String) = forContent { excludeGroupByRegex(groupRegex) }
fun ArtifactRepository.excludeModule(group: String, module: String) = forContent { excludeModule(group, module) }
fun ArtifactRepository.excludeModule(notation: DependencyNotation) = excludeModule(notation.group, notation.module)
fun ArtifactRepository.excludeModuleByRegex(groupRegex: String, moduleRegex: String) = forContent { excludeModuleByRegex(groupRegex, moduleRegex) }
fun ArtifactRepository.excludeVersion(group: String, module: String, version: String) = forContent { excludeVersion(group, module, version) }
fun ArtifactRepository.excludeVersion(notation: DependencyNotation) = excludeVersion(notation.group, notation.module, notation.version)
fun ArtifactRepository.excludeVersionByRegex(groupRegex: String, moduleRegex: String, versionRegex: String) = forContent { excludeVersionByRegex(groupRegex, moduleRegex, versionRegex) }


private class ArtifactRepositoryContent(private val delegate: Any) {

    companion object {
        private val logger = getGradleLogger(ArtifactRepositoryContent::class.java)
    }

    fun includeGroup(group: String) {
        try {
            delegate.javaClass.getMethod("includeGroup", String::class.java).apply {
                isAccessible = true
                invoke(delegate, group)
            }
        } catch (e: Exception) {
            logger.warn(e)
        }
    }

    fun includeGroupByRegex(groupRegex: String) {
        try {
            delegate.javaClass.getMethod("includeGroupByRegex", String::class.java).apply {
                isAccessible = true
                invoke(delegate, groupRegex)
            }
        } catch (e: Exception) {
            logger.warn(e)
        }
    }

    fun includeModule(group: String, module: String) {
        try {
            delegate.javaClass.getMethod("includeModule", String::class.java, String::class.java).apply {
                isAccessible = true
                invoke(delegate, group, module)
            }
        } catch (e: Exception) {
            logger.warn(e)
        }
    }

    fun includeModuleByRegex(groupRegex: String, moduleRegex: String) {
        try {
            delegate.javaClass.getMethod("includeModuleByRegex", String::class.java, String::class.java).apply {
                isAccessible = true
                invoke(delegate, groupRegex, moduleRegex)
            }
        } catch (e: Exception) {
            logger.warn(e)
        }
    }

    fun includeVersion(group: String, module: String, version: String) {
        try {
            delegate.javaClass.getMethod("includeVersion", String::class.java, String::class.java, String::class.java).apply {
                isAccessible = true
                invoke(delegate, group, module, version)
            }
        } catch (e: Exception) {
            logger.warn(e)
        }
    }

    fun includeVersionByRegex(groupRegex: String, moduleRegex: String, versionRegex: String) {
        try {
            delegate.javaClass.getMethod("includeVersionByRegex", String::class.java, String::class.java, String::class.java).apply {
                isAccessible = true
                invoke(delegate, groupRegex, moduleRegex, versionRegex)
            }
        } catch (e: Exception) {
            logger.warn(e)
        }
    }


    fun excludeGroup(group: String) {
        try {
            delegate.javaClass.getMethod("excludeGroup", String::class.java).apply {
                isAccessible = true
                invoke(delegate, group)
            }
        } catch (e: Exception) {
            logger.warn(e)
        }
    }

    fun excludeGroupByRegex(groupRegex: String) {
        try {
            delegate.javaClass.getMethod("excludeGroupByRegex", String::class.java).apply {
                isAccessible = true
                invoke(delegate, groupRegex)
            }
        } catch (e: Exception) {
            logger.warn(e)
        }
    }

    fun excludeModule(group: String, module: String) {
        try {
            delegate.javaClass.getMethod("excludeModule", String::class.java, String::class.java).apply {
                isAccessible = true
                invoke(delegate, group, module)
            }
        } catch (e: Exception) {
            logger.warn(e)
        }
    }

    fun excludeModuleByRegex(groupRegex: String, moduleRegex: String) {
        try {
            delegate.javaClass.getMethod("excludeModuleByRegex", String::class.java, String::class.java).apply {
                isAccessible = true
                invoke(delegate, groupRegex, moduleRegex)
            }
        } catch (e: Exception) {
            logger.warn(e)
        }
    }

    fun excludeVersion(group: String, module: String, version: String) {
        try {
            delegate.javaClass.getMethod("excludeVersion", String::class.java, String::class.java, String::class.java).apply {
                isAccessible = true
                invoke(delegate, group, module, version)
            }
        } catch (e: Exception) {
            logger.warn(e)
        }
    }

    fun excludeVersionByRegex(groupRegex: String, moduleRegex: String, versionRegex: String) {
        try {
            delegate.javaClass.getMethod("excludeVersionByRegex", String::class.java, String::class.java, String::class.java).apply {
                isAccessible = true
                invoke(delegate, groupRegex, moduleRegex, versionRegex)
            }
        } catch (e: Exception) {
            logger.warn(e)
        }
    }

}

private val contentMethod = ArtifactRepository::class.java.findCompatibleMethod("content", Action::class.java)
    ?.apply { isAccessible = true }

private fun ArtifactRepository.forContent(action: ArtifactRepositoryContent.() -> Unit) {
    contentMethod?.invoke(this, Action { delegate ->
        ArtifactRepositoryContent(delegate).apply(action)
    })
}