Introduce artifacts verifier verifyPublications task

Author: Sergey Mashkov

build.gradle

@@ -53,6 +53,7 @@ allprojects {
         apply from: rootProject.file("gradle/native.gradle")
 
         apply from: rootProject.file("gradle/publish.gradle")
+        apply from: rootProject.file('gradle/verifier.gradle')
     }
 
     kotlin {

gradle/publish.gradle

@@ -18,6 +18,7 @@ task stubJavadoc(type: Jar) {
 publishing {
     repositories {
         maven { url = 'https://kotlin.bintray.com/kotlinx' }
+        maven { name = "testLocal"; url = "$rootProject.buildDir/m2"}
     }
     publications.all {
         pom.withXml(configureMavenCentralMetadata)

gradle/verifier.gradle

@@ -0,0 +1,162 @@
+import groovy.io.FileType
+import groovy.json.JsonSlurper
+import org.xml.sax.ErrorHandler
+import org.xml.sax.SAXException
+import org.xml.sax.SAXParseException
+
+task cleanPublications(type: Delete) {
+    delete new File(rootProject.buildDir, 'm2')
+}
+
+def isBadTextNode(node) {
+    return node == null || node.size() != 1 || !node.text().trim()
+}
+
+def isEmptyTagList(node) {
+    return node == null || node.size() == 0
+}
+
+def verifyArtifact(File versionDir, List<File> files, String ext) {
+    if (files.count { it.name.toLowerCase().endsWith(ext) } == 0) {
+        throw new GradleException("No $ext artifact found at $versionDir")
+    }
+}
+
+def validatePom(File file) {
+    def parser = new XmlSlurper(false, true, false)
+    def errors = []
+
+    parser.errorHandler = new ErrorHandler() {
+
+        @Override
+        void warning(SAXParseException exception) throws SAXException {
+        }
+
+        @Override
+        void error(SAXParseException exception) throws SAXException {
+            errors += exception
+        }
+
+        @Override
+        void fatalError(SAXParseException exception) throws SAXException {
+            errors += exception
+        }
+    }
+
+    def xml = parser.parse(file)
+
+    if (!errors.isEmpty()) {
+        throw errors[0]
+    }
+
+    if (isBadTextNode(xml.name)) {
+        errors += ['<name> tag is missing']
+    }
+
+    if (isBadTextNode(xml.description)) {
+        errors += ['<description> tag is missing']
+    }
+
+    if (isBadTextNode(xml.url)) {
+        errors += ['<url> tag is missing']
+    }
+
+    def licenses = xml.licenses.license
+    if (isEmptyTagList(licenses)) {
+        errors += 'No licenses specified'
+    } else if (licenses.any { isBadTextNode(it.name) || isBadTextNode(it.url) || isBadTextNode(it.distribution) }) {
+        errors += 'License section is incomplete'
+    }
+
+    def developers = xml.developers.developer
+    if (isEmptyTagList(developers)) {
+        errors += 'No developers specified'
+    } else if (developers.any { isBadTextNode(it.id) || isBadTextNode(it.name) || isBadTextNode(it.organization) || isBadTextNode(it.organizationUrl)}) {
+        errors += 'Developer section is incomplete'
+    }
+
+    def scm = xml.scm.url
+    if (isEmptyTagList(scm)) {
+        errors += 'No scm specified'
+    }
+
+    if (!errors.isEmpty()) {
+        throw new GradleException("Pom verification failed for $file.name: ${errors.join(', ')}")
+    }
+}
+
+String packaging(File moduleDir) {
+    def pomFile = moduleDir.listFiles()?.find { it.name.endsWith('.pom') }
+    if (pomFile == null || !pomFile.exists()) {
+        throw new GradleException("POM file is missing at $moduleDir")
+    }
+
+    def packaing = new XmlSlurper(false, true, false).parse(pomFile).packaging.text()
+    if (!packaing?.trim()) return 'jar'
+    return packaing
+}
+
+def kinds = kotlin.targets.collect { it.name }
+
+task verifyPublications(dependsOn: { [cleanPublications] + kinds.collect { "publish${it.capitalize()}PublicationToTestLocalRepository" } }) {
+    doLast {
+        def m2 = new File(rootProject.buildDir, 'm2')
+        def pomFiles = []
+        def moduleFiles = []
+
+        m2.eachFileRecurse(FileType.FILES) { child ->
+            if (child.name.toLowerCase() != 'maven-metadata.xml') {
+                def ext = child.name.split(/\./).last().toLowerCase()
+                switch (ext) {
+                    case 'pom':
+                        pomFiles += child
+                        break
+                    case 'module':
+                        moduleFiles += child
+                        break
+                }
+            }
+        }
+
+        pomFiles.each { File file ->
+            validatePom(file)
+        }
+
+        def groupDir = new File(m2, project.group.replaceAll(/\./, File.separator))
+        def verified = 0
+
+        groupDir.eachDir { artifactDir ->
+            def versionDir = new File(artifactDir, project.version)
+
+            if (versionDir.exists()) {
+                def files = versionDir.listFiles()?.findAll { it.isFile() } ?: []
+
+                def packaging = '.' + packaging(versionDir)
+                verifyArtifact(versionDir, files, packaging)
+                verifyArtifact(versionDir, files, '-javadoc.jar')
+                verifyArtifact(versionDir, files, '-sources.jar')
+                verifyArtifact(versionDir, files, '.module')
+
+                verified ++
+            }
+        }
+
+        if (verified == 0) {
+            throw new GradleException("No installed modules were found at $groupDir")
+        }
+
+        moduleFiles.each { File file ->
+            def moduleFile = new JsonSlurper().parse(file)
+
+            if (moduleFile.variants.name.isEmpty()) {
+                throw new GradleException("No variants found in module file $file")
+            }
+        }
+    }
+}
+
+tasks.whenTaskAdded { task ->
+    if (task.name.startsWith('publish') && task.name.endsWith('TestLocalRepository')) {
+        tasks.getByName('verifyPublications').dependsOn(task)
+    }
+}