build.gradle

plugins {
    id 'com.gradle.plugin-publish' version '1.1.0'
    id "maven-publish"
    id 'java'
    id 'idea'
}

def currentBranch = ("git rev-parse --abbrev-ref HEAD").execute().inputStream.readLines().get(0)
if (currentBranch != "master") {
    version = project.version + "-dev"
} else {
    version = project.version
}
group = project.group

repositories {
    mavenCentral()
}

//using java 8 for compatibility with old projects
java.toolchain.languageVersion = JavaLanguageVersion.of(8)

dependencies {
    implementation gradleApi()
    implementation 'org.jetbrains:annotations:24.0.1'
    implementation 'org.eclipse.jgit:org.eclipse.jgit:5.13.1.202206130422-r'
    implementation 'com.google.code.gson:gson:2.10.1'
    //implementation 'com.google.guava:guava:31.1-jre'

    //enables java 17 features on java 8
    String jabelPlugin = 'com.github.bsideup.jabel:jabel-javac-plugin:1.0.0'
    compileOnly 'com.github.bsideup.jabel:jabel-javac-plugin:1.0.0'

    annotationProcessor jabelPlugin
    testAnnotationProcessor jabelPlugin
    testImplementation 'org.junit.jupiter:junit-jupiter:5.9.2'
}

configure([tasks.compileJava, tasks.compileTestJava]) {
    sourceCompatibility = 17 // for the IDE support
    options.release = 8

    javaCompiler = javaToolchains.compilerFor {
        languageVersion = JavaLanguageVersion.of(17)
    }
}

configure([tasks.javadoc]) {
    javadocTool.set(javaToolchains.javadocToolFor {
        languageVersion = JavaLanguageVersion.of(17)
    })
}

tasks.named('test') {
    useJUnitPlatform()
}

gradlePlugin {
    website = "https://github.com/Srdjan-V/LocalGitDependency"
    vcsUrl = "https://github.com/Srdjan-V/LocalGitDependency"

    plugins {
        localGitDependency {
            displayName = "Local Git Dependency Plugin"
            description = "Gradle plugin to clone projects with git and build them"
            tags.set(["java", "git", "dependency"])

            id = "io.github.srdjan-v.local-git-dependency"
            implementationClass = "io.github.srdjanv.localgitdependency.LocalGitDependencyPlugin"
        }

        modelInjection {
            displayName = "Local Git Dependency Model Injection Plugin"
            description = "Helper plugin for local git dependency"
            tags.set(["model", "java", "git", "dependency"])

            id = "io.github.srdjan-v.model-injection"
            implementationClass = "io.github.srdjanv.localgitdependency.injection.plugin.ModelInjectionPlugin"
        }

    }
}

import org.apache.tools.ant.filters.ReplaceTokens

task filterTokens(type: Sync) {

    inputs.property 'version', version

    from sourceSets.main.java
    filter(ReplaceTokens, tokens: [PLUGIN_VERSION: version.toString()])
    into "$buildDir/src/$sourceSets.main.name/$sourceSets.main.java.name"
}

compileJava.source = filterTokens.outputs

publishing {
    publications {
        pluginMaven(MavenPublication) {
            artifactId = 'local-git-dependency'
        }
    }
}

def publishPluginsChecks = tasks.register("publishPluginsChecks") {
    doLast {
        if (currentBranch != "master") {
            throw new RuntimeException("You can't publish to the gradle plugin portal if not on the master branch")
        }

        def projectVersion = project.version.toString().split("\\.")
        if (projectVersion.length != 3) {
            throw new RuntimeException("The project version must be composed of 3 numbers")
        }

        def versionTagArray = new ArrayList<Integer>()
        for (final def versionString in projectVersion) {
            try {
                versionTagArray.add(Integer.valueOf(versionString))
            } catch (NumberFormatException e) {
                throw new RuntimeException("Inappropriate character in project version string", e)
            }
        }

        def gitVersionTagArray = new ArrayList<Integer>()
        def gitStringTag = ("git describe --tags --abbrev=0").execute().inputStream.readLines().get(0)
        for (versionString in gitStringTag.substring(1, gitStringTag.length()).trim().split("\\.")) {
            gitVersionTagArray.add(Integer.valueOf(versionString))
        }

        def invalid = true
        def iterator = 0
        for (final def versionString in projectVersion) {
            if (versionTagArray.get(iterator) > gitVersionTagArray.get(iterator)) {
                invalid = false
                break
            }
            iterator++
        }

        if (invalid) {
            throw new RuntimeException("Current project version is the same or lower then the latest tag")
        }

        project.logger.lifecycle('Pushing tag {}', project.version)
        ("git tag v${project.version}").execute()
        ("git push --tags").execute()
    }
}

tasks.getByName("publishPlugins").configure {
    dependsOn publishPluginsChecks
}