build.gradle

import java.util.regex.Pattern
import java.util.regex.Matcher

plugins {
    id 'com.diffplug.spotless' version '8.4.0'
}

group = 'com.toedter'
version = '3.1.1-SNAPSHOT'

// Apply Spotless to all subprojects
subprojects {
    apply plugin: 'com.diffplug.spotless'

    spotless {
        java {
            target 'src/**/*.java'
            googleJavaFormat('1.17.0').reflowLongStrings()
            removeUnusedImports()
            endWithNewline()
            trimTrailingWhitespace()
            licenseHeaderFile rootProject.file('license-header.txt'), 'package '
        }
    }

    // Run spotless check before build
    tasks.named('check') {
        dependsOn 'spotlessCheck'
    }
}

// Root-level misc formatting
spotless {
    format 'misc', {
        target '*.gradle', '*.md', '.gitignore'

        trimTrailingWhitespace()
        leadingTabsToSpaces(2)
        endWithNewline()
    }
}

// Task to install git hooks
tasks.register('installGitHooks') {
    description = 'Install Git hooks for pre-commit formatting'
    group = 'git hooks'

    doLast {
        def hooksDir = file("${rootProject.rootDir}/.git/hooks")
        if (!hooksDir.exists()) {
            hooksDir.mkdirs()
        }

        // Pre-commit hook
        def preCommitHook = file("${hooksDir}/pre-commit")
        preCommitHook.text = """#!/bin/sh
# Auto-format code before commit
echo "Running Spotless code formatter..."
./gradlew spotlessApply --quiet

# Add all formatted files back to staging (not just Java)
# Add all formatted files back to staging (not just Java)
git diff --name-only | xargs -r git add

echo "Code formatting complete!"
"""
        preCommitHook.setExecutable(true)

        // Commit-msg hook for commit message validation
        def commitMsgHook = file("${hooksDir}/commit-msg")
        commitMsgHook.text = '''#!/bin/sh
# Validate commit message format
# Expected format: type(scope): subject
# Example: feat(api): add new endpoint

commit_msg=$(cat "$1")

# Regex for conventional commits
pattern="^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\\([a-z0-9-]+\\))?!?: [a-z].{2,72}$"

if ! echo "$commit_msg" | grep -qE "$pattern"; then
    echo "ERROR: Invalid commit message format!"
    echo ""
    echo "Commit message must follow Conventional Commits format:"
    echo "  type(scope): subject"
    echo ""
    echo "Types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert"
    echo ""
    echo "Example: feat(api): add new JSON:API endpoint"
    echo "Example: fix(serializer): resolve null pointer exception"
    exit 1
fi
'''
        commitMsgHook.setExecutable(true)

        println "Git hooks installed successfully!"
        println "  - pre-commit: Auto-format code with Spotless"
        println "  - commit-msg: Validate conventional commit messages"
    }
}


// Run installGitHooks after project evaluation
afterEvaluate {
    // Skip git hooks warning in GitHub Actions
    def isGitHubActions = System.getenv('GITHUB_ACTIONS') != null

    if (!isGitHubActions) {
        def hooksDir = file("${rootProject.rootDir}/.git/hooks")
        def preCommitHook = file("${hooksDir}/pre-commit")

        if (!preCommitHook.exists()) {
            println ""
            println "⚠️  Git hooks not installed!"
            println "   Run './gradlew installGitHooks' to set up automatic code formatting and commit linting"
            println ""
        }
    }
}

// Extension to store computed version information
class VersionInfo {
    String currentVersion
    String previousRelease
    String nextRelease
    String nextSnapshot
    String bump
    int commitCount
    String lastTag
}

ext.versionInfo = null

// Helper method to compute version information
def computeVersionInfo() {
    if (ext.versionInfo == null) {
        def info = new VersionInfo()
        info.currentVersion = project.version.toString()
        def (major, minor, patch) = info.currentVersion.replaceAll('-SNAPSHOT', '').tokenize('.').collect { it.toInteger() }

        // Get the last version tag (this is the previous release)
        info.lastTag = "git describe --tags --abbrev=0".execute().text.trim()
        info.previousRelease = info.lastTag.replaceAll('^v', '')

        // Analyze git commits since last tag
        def commits = "git log ${info.lastTag}..HEAD --pretty=format:%s".execute().text.split('\n').findAll { it.trim() }
        info.commitCount = commits.size()

        // Determine version bump based on commits since last tag
        info.bump = 'patch'
        if (commits.any { it =~ /^[^:]+!:|\bBREAKING CHANGE\b/ }) {
            info.bump = 'major'
        } else if (commits.any { it =~ /^feat[:(]/ }) {
            info.bump = 'minor'
        }

        // Apply the version bump
        switch (info.bump) {
            case 'major':
                major++
                minor = 0
                patch = 0
                break
            case 'minor':
                minor++
                patch = 0
                break
            case 'patch':
                patch++
                break
        }

        info.nextRelease = "${major}.${minor}.${patch}"
        info.nextSnapshot = "${major}.${minor}.${patch + 1}-SNAPSHOT"

        ext.versionInfo = info
    }
    return ext.versionInfo
}

tasks.register('showVersions') {
    description = 'Show current and next versions based on conventional commits'
    group = 'versioning'

    doLast {
        def info = computeVersionInfo()

        println """
 ╔════════════════════════════════════════════════════════════════
 ║ VERSION INFORMATION
 ╠════════════════════════════════════════════════════════════════
 ║ Previous Release:  ${info.previousRelease}
 ║ Current Snapshot:  ${info.currentVersion}
 ║ Next Release:      ${info.nextRelease}
 ║ Next Snapshot:     ${info.nextSnapshot}
 ║
 ║ Version Bump:      ${info.bump.toUpperCase()} (${info.commitCount} commits since ${info.lastTag})
 ╚════════════════════════════════════════════════════════════════
 """
    }
}

tasks.register('prepareRelease') {
    description = 'Prepare for a new release by updating all version references'
    group = 'versioning'
    dependsOn 'showVersions'

    doLast {
        def info = computeVersionInfo()

        println """
 ╔════════════════════════════════════════════════════════════════
 ║ PREPARING RELEASE
 ╠════════════════════════════════════════════════════════════════
 ║ Previous Release:  ${info.previousRelease}
 ║ Current Snapshot:  ${info.currentVersion}
 ║ → Next Release:    ${info.nextRelease}
 ║ → Next Snapshot:   ${info.nextSnapshot}
 ╠════════════════════════════════════════════════════════════════
 """

        def filesUpdated = 0
        def replacements = 0

        // Define files to update with version references
        def filesToUpdate = [
            'README.adoc',
            'build.gradle',
            'lib/build.gradle',
            'lib/src/main/asciidoc/setup.adoc',
            'lib/src/main/asciidoc/migration.adoc',
            'lib/src/main/asciidoc/configuration.adoc',
            'example/build.gradle'
        ]

        filesToUpdate.each { relativePath ->
            def file = rootProject.file(relativePath)
            if (!file.exists()) {
                println " ║ ⚠️  File not found: ${relativePath}"
                return
            }

            def originalContent = file.text
            def updatedContent = originalContent

            // Replace current snapshot with next snapshot
            updatedContent = updatedContent.replaceAll(
                Pattern.quote(info.currentVersion),
                Matcher.quoteReplacement(info.nextSnapshot)
            )

            // Replace previous release with next release
            updatedContent = updatedContent.replaceAll(
                Pattern.quote(info.previousRelease),
                Matcher.quoteReplacement(info.nextRelease)
            )

            if (updatedContent != originalContent) {
                file.text = updatedContent
                filesUpdated++
                println " ║ ✓ Updated: ${relativePath}"
            }
        }

        // Now update version in build.gradle files to next release (not snapshot)
        ['build.gradle', 'lib/build.gradle', 'example/build.gradle'].each { relativePath ->
            def file = rootProject.file(relativePath)
            if (!file.exists()) {
                println " ║ ⚠️  File not found: ${relativePath}"
                return
            }

            def originalContent = file.text
            def updatedContent = originalContent

            // Replace version = '<next snapshot>' with version = '<next release>'
            updatedContent = updatedContent.replaceAll(
                ~/version = ['"]${Pattern.quote(info.nextSnapshot)}['"]/,
                "version = '${info.nextRelease}'"
            )

            if (updatedContent != originalContent) {
                file.text = updatedContent
                replacements++
                println " ║ ✓ Set release version in: ${relativePath}"
            }
        }

        println """
 ╠════════════════════════════════════════════════════════════════
 ║ ✓ Updated ${filesUpdated} file(s)
 ║ ✓ Set release version in ${replacements} build.gradle file(s)
 ╚════════════════════════════════════════════════════════════════
 """
    }
}