build.gradle

import static java.nio.charset.StandardCharsets.UTF_8

import java.nio.file.Files
import java.util.zip.ZipEntry
import java.util.zip.ZipInputStream
import java.util.zip.ZipOutputStream
import org.objectweb.asm.ClassReader
import org.objectweb.asm.ClassWriter
import org.objectweb.asm.tree.ClassNode

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

buildscript {
    String rootGroupId = project.ext.rootGroupId = "name.remal.gradle-plugins.${rootProject.name}"
    String rootArtifactId = project.ext.rootArtifactId = rootProject.name
    String rootSnapshotVersion = project.ext.rootSnapshotVersion = '4-SNAPSHOT'
    dependencies {
        //classpath("$rootGroupId:$rootArtifactId:$rootSnapshotVersion") { version { strictly(rootSnapshotVersion) } }
        classpath 'name.remal.gradle-plugins.toolkit:build-logic:0.69.8'
        classpath 'de.undercouch:gradle-download-task:5.6.0'
        classpath 'com.tisonkun.os:os-detector-core:0.6.0'
        classpath 'io.github.classgraph:classgraph:4.8.179'

        classpath platform("org.ow2.asm:asm-bom:9.7.1")
        classpath 'org.ow2.asm:asm-tree'
    }
    repositories {
        mavenCentral()
        gradlePluginPortal()
    }

    project.ext.rootBuildscriptClasspathVersionOf = { String notation ->
        String version = project.buildscript.configurations.classpath
            .resolvedConfiguration
            .lenientConfiguration
            .allModuleDependencies
            .find { "${it.moduleGroup}:${it.moduleName}" == notation }
            ?.moduleVersion
        if (version == null) {
            throw new GradleException("Classpath dependency version can't be found for '${notation}'")
        }
        return version
    }.memoize()
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

allprojects {
    group = project.rootGroupId
    version = project.rootSnapshotVersion
}

apply plugin: 'name.remal.toolkit.build-logic'

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

allprojects {
    pluginManager.withPlugin('name.remal.sonarlint') {
        sonarLint {
            boolean hasCurrentSnapshotBuildscriptDependency = rootProject.buildscript.configurations.classpath.dependencies
                .any { "${it.group}:${it.name}:${it.version}" == "$rootGroupId:$rootArtifactId:$rootSnapshotVersion" }
            if (hasCurrentSnapshotBuildscriptDependency) {
                fork.enabled = false
            }
        }
    }
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

project.registerCrossCompileDependencyInfo(
    [
        name: 'sonarlint',
        maxVersionNumbers: 3,
        dependencyNotations: [
            'org.sonarsource.sonarlint.core:sonarlint-core',
        ],
    ]
)

allprojects {
    pluginManager.withPlugin('java') {
        dependencies {
            relocateClasses 'name.remal.gradle-plugins.toolkit:toolkit'

            optional 'name.remal.gradle-api:gradle-api'
        }
    }
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

apply plugin: 'java-gradle-plugin'
apply plugin: 'name.remal.classes-relocation'
apply plugin: 'name.remal.generate-sources'

dependencies {
    relocateClasses 'com.tisonkun.os:os-detector-core:0.6.0'

    optional 'org.sonarsource.sonarlint.core:sonarlint-core:10.12.1.79852'
}

gradlePlugin {
    plugins {
        'name.remal.sonarlint' {
            id = 'name.remal.sonarlint'
            implementationClass = 'name.remal.gradle_plugins.sonarlint.SonarLintPlugin'
            displayName = 'SonarLint'
            description = property('repository-description')
        }
    }
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

tasks.named('generateJava') {
    Provider<MavenPublication> publication = provider { publishing.publications.withType(MavenPublication).pluginMaven }
    Provider<String> group = provider { publication.get().groupId }
    Provider<String> artifactId = provider { publication.get().artifactId }
    Provider<String> version = provider { publication.get().version }
    inputs.property('groupId', group)
    inputs.property('artifactId', artifactId)
    inputs.property('version', version)
    classFile(project.calculateBaseJavaPackage(), 'SonarLintPluginBuildInfo') {
        it.writePackage()
        it.println("")
        it.writeBlock("interface ${it.simpleName}") {
            it.println("String SONARLINT_PLUGIN_ID = \"${it.escapeJava(gradlePlugin.plugins.names.first())}\";")
            it.println("String SONARLINT_PLUGIN_GROUP = \"${it.escapeJava(group.get())}\";")
            it.println("String SONARLINT_PLUGIN_ARTIFACT_ID = \"${it.escapeJava(artifactId.get())}\";")
            it.println("String SONARLINT_PLUGIN_VERSION = \"${it.escapeJava(version.get())}\";")
        }
    }
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

Configuration allSonarArtifactsConf = project.configurations.create('allSonarArtifacts')

Map<String, String> nonReproducibleSonarDependencyVersions = new TreeMap<>().asSynchronized()
allSonarArtifactsConf.resolutionStrategy.eachDependency { DependencyResolveDetails details ->
    ModuleVersionSelector target = details.target

    String version = target.version
    if (version == null) {
        return
    }
    boolean isNotReproducible = version.endsWith('-SNAPSHOT') || ['(', '[', ']', ')'].any { version.contains(it) }
    if (!isNotReproducible) {
        return
    }

    String id = "${target.group}:${target.name}".toString()
    nonReproducibleSonarDependencyVersions.put(id, version)
}

Closure<Configuration> createSonarArtifactsConfiguration = { String name, boolean addToIndirectApi = true ->
    return project.configurations.create(name) { Configuration conf ->
        conf.transitive = false
        conf.extendsFrom = []
        conf.dependencies.all { Dependency dep ->
            allSonarArtifactsConf.dependencies.add(dep.copy())

            if (dep instanceof ModuleDependency) {
                dep.transitive = false
            }
            if (dep instanceof ExternalDependency) {
                dep.version { strictly(dep.version) }
            }
        }

        if (addToIndirectApi) {
            project.configurations.indirectApi.extendsFrom(conf)
        }
    }
}

createSonarArtifactsConfiguration('sonarCoreArtifacts')
createSonarArtifactsConfiguration('sonarPluginArtifacts')

dependencies {
    // Core:
    sonarCoreArtifacts 'org.sonarsource.sonarlint.core:sonarlint-core:10.12.1.79852'


    // Plugins:
    // See full list of supported plugins here: https://github.com/SonarSource/sonarlint-intellij/blob/master/gradle/libs.versions.toml
    sonarPluginArtifacts 'org.sonarsource.java:sonar-java-symbolic-execution-plugin:8.8.0.37665'
    sonarPluginArtifacts 'org.sonarsource.java:sonar-java-plugin:8.8.0.37665'
    sonarPluginArtifacts 'org.sonarsource.javascript:sonar-javascript-plugin:10.20.0.29356'
    //sonarPluginArtifacts 'org.sonarsource.php:sonar-php-plugin:3.39.0.12526' // PHP projects are unlikely built with Gradle
    //sonarPluginArtifacts 'org.sonarsource.python:sonar-python-plugin:4.23.0.17664' // Python projects are unlikely built with Gradle
    sonarPluginArtifacts 'org.sonarsource.kotlin:sonar-kotlin-plugin:2.22.0.5972'
    //sonarPluginArtifacts 'org.sonarsource.slang:sonar-ruby-plugin:1.17.1.134' // Ruby projects are unlikely built with Gradle
    sonarPluginArtifacts 'org.sonarsource.html:sonar-html-plugin:3.18.0.5605'
    sonarPluginArtifacts 'org.sonarsource.xml:sonar-xml-plugin:2.12.0.5749'
    //sonarPluginArtifacts 'org.sonarsource.sonarlint.omnisharp:sonarlint-omnisharp-plugin:1.25.0.100205' // OmniSharp projects are unlikely built with Gradle
    sonarPluginArtifacts 'org.sonarsource.text:sonar-text-plugin:2.20.0.5038'
    //sonarPluginArtifacts 'org.sonarsource.slang:sonar-go-plugin:1.17.1.145' // Go projects are unlikely built with Gradle
    sonarPluginArtifacts 'org.sonarsource.iac:sonar-iac-plugin:1.40.0.13983'
    //sonarPluginArtifacts 'com.sonarsource.cpp:sonar-cfamily-plugin:6.60.0.76379' // C++ projects are unlikely built with Gradle
    //sonarPluginArtifacts 'org.sonarsource.dotnet:sonar-csharp-plugin:10.2.0.103721' // C# projects are unlikely built with Gradle
    //sonarPluginArtifacts 'com.sonarsource.dotnet:sonar-csharp-enterprise-plugin:10.2.0.103721' // C# projects are unlikely built with Gradle
    sonarPluginArtifacts 'org.sonarsource.slang:sonar-scala-plugin:1.18.0.266'
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

project.ext.DownloadTask = Class.forName('de.undercouch.gradle.tasks.download.Download')
apply from: 'build-nodejs.gradle'
apply from: 'build-languages.gradle'

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

tasks.named('generateJava') { Task task ->
    inputs.files(allSonarArtifactsConf).withPropertyName(allSonarArtifactsConf.name + 'Conf').optional()

    classFile(project.calculateBaseJavaPackage(), 'SonarDependencies') {
        it.writePackage()
        it.println("")
        it.writeStaticImport("lombok.AccessLevel", "PRIVATE")
        it.println("")
        it.writeImport("com.google.common.collect.ImmutableMap")
        it.writeImport("java.util.Map")
        it.writeImport("lombok.NoArgsConstructor")
        it.writeImport("lombok.val")
        it.println("")
        it.println("@NoArgsConstructor(access = PRIVATE)")
        it.writeBlock("abstract class ${it.simpleName}") {
            it.println("")
            it.println("private static final Map<String, SonarDependency> MAPPING = ImmutableMap.<String, SonarDependency>builder()")
            configurations.sonarCoreArtifacts.dependencies.forEach { Dependency dep ->
                it.println("    .put(\"${it.escapeJava(dep.name)}\", SonarDependency.builder()")
                it.println("        .type(SonarDependencyType.CORE)")
                it.println("        .group(\"${it.escapeJava(dep.group)}\")")
                it.println("        .name(\"${it.escapeJava(dep.name)}\")")
                it.println("        .version(\"${it.escapeJava(dep.version)}\")")
                it.println("        .build()")
                it.println("    )")
            }
            configurations.sonarPluginArtifacts.dependencies.forEach { Dependency dep ->
                it.println("    .put(\"${it.escapeJava(dep.name)}\", SonarDependency.builder()")
                it.println("        .type(SonarDependencyType.PLUGIN)")
                it.println("        .group(\"${it.escapeJava(dep.group)}\")")
                it.println("        .name(\"${it.escapeJava(dep.name)}\")")
                it.println("        .version(\"${it.escapeJava(dep.version)}\")")
                it.println("        .build()")
                it.println("    )")
            }
            it.println("    .build();")

            it.println("")
            it.writeBlock("public static Map<String, SonarDependency> getSonarDependencies()") {
                it.println("return MAPPING;")
            }

            it.println("")
            it.writeBlock("public static SonarDependency getSonarDependency(String id)") {
                it.println("val dependency = getSonarDependencies().get(id);")
                it.writeBlock("if (dependency == null)") {
                    it.println("throw new IllegalStateException(\"Sonar dependency is not registered: \" + id);")
                }
                it.println("return dependency;")
            }
        }
    }

    classFile(project.calculateBaseJavaPackage(), 'ResolvedNonReproducibleSonarDependencies') {
        it.writePackage()
        it.println("")
        it.writeStaticImport("lombok.AccessLevel", "PRIVATE")
        it.println("")
        it.writeImport("com.google.common.collect.ImmutableMap")
        it.writeImport("java.util.Map")
        it.writeImport("javax.annotation.Nullable")
        it.writeImport("lombok.NoArgsConstructor")
        it.println("")
        it.println("@NoArgsConstructor(access = PRIVATE)")
        it.writeBlock("abstract class ${it.simpleName}") {
            it.println("")
            it.println("private static final Map<String, SonarDependency> MAPPING = ImmutableMap.<String, SonarDependency>builder()")
            allSonarArtifactsConf.resolvedConfiguration.lenientConfiguration.allModuleDependencies.forEach { ResolvedDependency dep ->
                String depId = "${dep.moduleGroup}:${dep.moduleName}".toString()
                String nonReproducibleVersion = nonReproducibleSonarDependencyVersions[depId]
                if (nonReproducibleVersion != null) {
                    it.println("    .put(\"${it.escapeJava("${depId}:${nonReproducibleVersion}")}\", SonarDependency.builder()")
                    it.println("        .type(SonarDependencyType.OTHER)")
                    it.println("        .group(\"${it.escapeJava(dep.moduleGroup)}\")")
                    it.println("        .name(\"${it.escapeJava(dep.moduleName)}\")")
                    it.println("        .version(\"${it.escapeJava(dep.moduleVersion)}\")")
                    it.println("        .build()")
                    it.println("    )")
                }
            }
            it.println("    .build();")

            it.println("")
            it.writeBlock("public static Map<String, SonarDependency> getResolvedNonReproducibleSonarDependencies()") {
                it.println("return MAPPING;")
            }

            it.println("")
            it.println("@Nullable")
            it.writeBlock("public static SonarDependency getResolvedNonReproducibleSonarDependency(String notation)") {
                it.println("return getResolvedNonReproducibleSonarDependencies().get(notation);")
            }
        }
    }
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

tasks.named('processReadme') {
    readmeFileProcessors.add(
        { File readmeFile ->
            String content = readmeFile.getText('UTF-8')

            content = content.replaceAll(
                /<!--\s*(sonar-plugins-list)\s*-->[\s\S]*?<!--\s*\/\s*\1\s*-->/
            ) {
                String tag = it[1]
                logger.lifecycle('  Handling {}', tag)
                StringBuilder listContent = new StringBuilder()

                Map<String, String> languageDocPaths = [
                    'js': 'javascript',
                    'ts': 'typescript',
                ]

                rootProject.pluginLanguageInfos.get()
                    .toSorted { it.key }
                    .forEach { info ->
                        String languageDocPath = languageDocPaths[info.key] ?: info.key
                        URL url = new URL("https://rules.sonarsource.com/${languageDocPath}/")
                        HttpURLConnection connection = url.openConnection()
                        connection.useCaches = false
                        connection.connectTimeout = 5_000
                        connection.readTimeout = 60_000
                        connection.connect()
                        try {
                            int responseCode = connection.responseCode
                            if (responseCode == 200) {
                                listContent.append("\n* [${info.name}]($url)")
                            } else if (responseCode == 404) {
                                listContent.append("\n* ${info.name}")
                            } else {
                                throw new GradleException("$url returned unexpected status: $responseCode")
                            }

                        } finally {
                            connection.disconnect()
                        }
                    }

                return "<!--$tag-->\n$listContent\n\n<!--/$tag-->"
            }

            readmeFile.setText(content, 'UTF-8')
        }
    )
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

allprojects {
    /*
    if (gradle.startParameter.taskNames.isEmpty()
        || gradle.startParameter.taskNames == ['processIdeaSettings']
        || gradle.startParameter.taskNames == ['dependencies']
        || gradle.startParameter.taskNames == ['help']
    ) {
        return
    }
    */

    Attribute<String> artifactType = Attribute.of('artifactType', String)
    Attribute<Boolean> unprocessedSonar = Attribute.of('unprocessedSonar', Boolean)
    dependencies {
        attributesSchema {
            attribute(unprocessedSonar)
        }
        artifactTypes.getByName('jar') {
            attributes.attribute(unprocessedSonar, false)
        }
    }

    configurations
        .matching { !it.name.startsWith('sonar') }
        .matching { !it.name.startsWith('allSonar') }
        .all { Configuration conf ->
            if (conf.state != Configuration.State.UNRESOLVED
                || !conf.canBeResolved
            ) {
                return
            }

            Closure<Boolean> isSonarGroup = { String group ->
                return group == 'org.sonarsource'
                    || group.startsWith('org.sonarsource.')
            }

            conf.dependencies.withType(ExternalModuleDependency).configureEach { ExternalModuleDependency dep ->
                if (isSonarGroup(dep.group)) {
                    dep.exclude(group: 'com.google.guava')
                }
            }

            conf.resolutionStrategy.dependencySubstitution { DependencySubstitutions substitutions ->
                substitutions.all { DependencySubstitution substitution ->
                    if (!(substitution.requested instanceof ModuleComponentSelector)) {
                        return
                    }

                    ModuleComponentSelector requested = (ModuleComponentSelector) substitution.requested
                    if (isSonarGroup(requested.group)) {
                        ComponentSelector target = substitutions.variant(requested) { VariantSelectionDetails details ->
                            details.attributes {
                                attribute(unprocessedSonar, true)
                            }
                        }
                        substitution.useTarget(target)
                    }
                }
            }
        }

    dependencies {
        registerTransform(ProcessSonar) {
            from.attribute(unprocessedSonar, false).attribute(artifactType, 'jar')
            to.attribute(unprocessedSonar, true).attribute(artifactType, 'jar')
        }
    }
}

abstract class ProcessSonar implements TransformAction<ProcessSonarParameters> {

    interface ProcessSonarParameters extends TransformParameters {}

    @InputArtifact
    abstract Provider<FileSystemLocation> getInputArtifact()

    @Override
    void transform(TransformOutputs outputs) {
        File file = inputArtifact.get().asFile
        //println file
        File outputFile = outputs.file(file.name)
        if (outputFile.exists() && outputFile.lastModified() >= rootProject.buildFile.lastModified()) {
            return
        }

        Files.createDirectories(outputFile.parentFile.toPath())
        new ZipInputStream(new FileInputStream(file), UTF_8).withCloseable { ZipInputStream inputStream ->
            new ZipOutputStream(new FileOutputStream(outputFile), UTF_8).withCloseable { ZipOutputStream outputStream ->
                while (true) {
                    ZipEntry zipEntry = inputStream.nextEntry
                    if (zipEntry == null) {
                        break
                    }

                    if (zipEntry.directory) {
                        continue
                    }

                    if (zipEntry.name.contains('/shaded/')) {
                        continue
                    }

                    if (!zipEntry.name.contains('sonar')
                        && !zipEntry.name.startsWith('META-INF/')
                    ) {
                        continue
                    }

                    outputStream.putNextEntry(zipEntry)

                    if (!zipEntry.name.endsWith('.class')) {
                        outputStream << inputStream
                        continue
                    }

                    if (!zipEntry.name.startsWith('org/sonarsource/')
                        && !zipEntry.name.startsWith('org/sonar/')
                    ) {
                        outputStream << inputStream
                        continue
                    }


                    ClassNode classNode = new ClassNode()
                    new ClassReader(inputStream).accept(classNode, 0)

                    Closure processDeprecatedAnnotations = { node ->
                        // remove parameters of @Deprecated
                        node.visibleAnnotations
                            ?.findAll { it.desc == 'Ljava/lang/Deprecated;' && it.values?.size() }
                            ?.forEach {
                                it.values = []
                                //println classNode.name
                            }
                    }
                    processDeprecatedAnnotations(classNode)
                    classNode.fields?.forEach { processDeprecatedAnnotations(it) }
                    classNode.methods?.forEach { processDeprecatedAnnotations(it) }

                    ClassWriter classWriter = new ClassWriter(0)
                    classNode.accept(classWriter)

                    outputStream << classWriter.toByteArray()
                }
            }
        }
    }

}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

allprojects {
    dependencies.components {
        withModule('org.sonarsource.git.blame:git-files-blame', TargetJvmVersionRule) { params(8) }
    }
}

@CacheableRule
abstract class TargetJvmVersionRule implements ComponentMetadataRule {

    final Integer jvmVersion

    @Inject
    TargetJvmVersionRule(Integer jvmVersion) {
        this.jvmVersion = jvmVersion
    }

    void execute(ComponentMetadataContext context) {
        context.details.allVariants {
            attributes {
                attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, jvmVersion)
            }
        }
    }

    @Override
    String toString() {
        return "${getClass().simpleName}[$jvmVersion]"
    }

}