ksmt/buildSrc/src/main/kotlin/Publications.kt at 00a837c3c302bc0240195d50480bd1cf305b33d4 · UnitTestBot/ksmt · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
import gradle.kotlin.dsl.accessors._a772fae24f61b6fdfe5e797ccdf7ddf5.publishing
import gradle.kotlin.dsl.accessors._a772fae24f61b6fdfe5e797ccdf7ddf5.signing
import groovy.util.Node
import org.gradle.api.Project
import org.gradle.api.artifacts.Dependency
import org.gradle.api.artifacts.DependencySet
import org.gradle.api.artifacts.ProjectDependency
import org.gradle.api.publish.maven.MavenPublication
import org.gradle.api.tasks.bundling.Jar
import org.gradle.kotlin.dsl.get
import org.gradle.kotlin.dsl.register

fun MavenPublication.addKsmtPom() {
    pom {
        packaging = "jar"
        name.set("io.ksmt")
        description.set("Kotlin API for various SMT solvers")
        url.set("https://www.ksmt.io/")

        licenses {
            license {
                name.set("The Apache License, Version 2.0")
                url.set("https://www.apache.org/licenses/LICENSE-2.0.txt")
            }
        }

        issueManagement {
            url.set("https://github.com/UnitTestBot/ksmt/issues")
        }

        scm {
            connection.set("scm:git:https://github.com/UnitTestBot/ksmt.git")
            developerConnection.set("scm:git:https://github.com/UnitTestBot/ksmt.git")
            url.set("https://github.com/UnitTestBot/ksmt")
        }

        developers {
            developer {
                id.set("saloed")
                name.set("Valentyn Sobol")
                email.set("vo.sobol@mail.ru")
            }

            developer {
                id.set("CaelmBleidd")
                name.set("Alexey Menshutin")
                email.set("alex.menshutin99@gmail.com")
            }
        }
    }
}

fun MavenPublication.generateMavenMetadata(project: Project) {
    project.tasks.getByName("generateMetadataFileForMavenPublication") {
        mustRunAfter(project.tasks.named("jar"))
    }
}

fun MavenPublication.signKsmtPublication(project: Project) = with(project) {
    signing {
        val gpgKey = project.stringProperty("mavenSignGpgKey")?.removeSurrounding("\"")
        val gpgPassword = project.stringProperty("mavenSignGpgPassword")

        if (gpgKey != null && gpgPassword != null) {
            useInMemoryPgpKeys(gpgKey, gpgPassword)
            sign(this@signKsmtPublication)
        }
    }
}

fun MavenPublication.addSourcesAndJavadoc(project: Project) {
    artifact(project.tasks["kotlinSourcesJar"])
    artifact(project.tasks["dokkaJavadocJar"])
}

fun MavenPublication.addEmptyArtifact(project: Project): Unit = with(project) {
    artifact(generateEmptyJar())
    artifact(generateEmptyJar("sources"))
    artifact(generateEmptyJar("javadoc"))
}

fun MavenPublication.addMavenDependencies(
    dependencies: DependencySet,
    dependencyFilter: (MavenPublication) -> Boolean = { true }
) {
    pom.withXml {
        val dependenciesNode: Node = asNode().appendNode("dependencies")
        dependencies.forEach {
            addDependencyPublications(dependenciesNode, it, dependencyFilter)
        }
    }
}

private fun addDependencyPublications(node: Node, dependency: Dependency, dependencyFilter: (MavenPublication) -> Boolean) {
    val project = (dependency as? ProjectDependency)?.dependencyProject ?: return
    project.publishing.publications.filterIsInstance<MavenPublication>().filter(dependencyFilter).forEach {
        val dependencyNode = node.appendNode("dependency")
        addMavenPublicationDependency(dependencyNode, it)
    }
}

private fun addMavenPublicationDependency(node: Node, publication: MavenPublication) {
    node.appendNode("groupId", publication.groupId)
    node.appendNode("artifactId", publication.artifactId)
    node.appendNode("version", publication.version)
}

private fun Project.generateEmptyJar(classifier: String = "") =
    tasks.register<Jar>("$name-$classifier-empty-jar") {
        archiveClassifier.set(classifier)
    }