build.gradle

import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform

plugins {
    id 'application'
    id 'checkstyle'
    id 'idea'
    id 'jacoco'
    id 'java'
    id 'com.github.johnrengelman.shadow' version '7.1.2'
    id 'com.liferay.node' version '7.2.18'
    id 'com.github.psxpaul.execfork' version '0.2.0'
    id 'com.palantir.git-version' version '0.13.0'
}

OperatingSystem os = DefaultNativePlatform.currentOperatingSystem;

mainClassName = 'reposense.RepoSense'

node.download = false // The Liferay Node Gradle Plugin will use the system PATH to find the Node/npm executable.

sourceCompatibility = JavaVersion.VERSION_11
targetCompatibility = JavaVersion.VERSION_11

repositories {
    mavenCentral()
}

configurations {
    systemtestImplementation.extendsFrom testImplementation
    systemtestRuntime.extendsFrom testRuntime
}

dependencies {
    String jUnitVersion = '5.8.2'
    implementation  group: 'com.google.code.gson' ,name: 'gson', version:'2.9.0'
    implementation  group: 'net.freeutils', name: 'jlhttp', version: '2.6'
    implementation  group: 'net.sourceforge.argparse4j', name: 'argparse4j', version: '0.9.0'
    implementation  group: 'org.apache.ant', name: 'ant', version: '1.10.12'
    implementation  group: 'org.apache.commons', name: 'commons-csv', version: '1.9.0'
    implementation  group: 'org.fusesource.jansi', name: 'jansi', version: '2.4.0'
    implementation group: 'com.fasterxml.jackson.dataformat', name: 'jackson-dataformat-yaml', version: '2.17.0'

    testImplementation group: 'org.junit.jupiter', name: 'junit-jupiter-api', version: jUnitVersion
    testImplementation group: 'org.junit.jupiter', name: 'junit-jupiter-engine', version: jUnitVersion
}

sourceSets {
    systemtest {
        compileClasspath += main.output + test.output
        runtimeClasspath += main.output + test.output
        java.srcDir file('src/systemtest/java')
        resources.srcDir file('src/systemtest/resources')
    }
}

def installFrontend = tasks.register('installFrontend', com.liferay.gradle.plugins.node.tasks.ExecutePackageManagerTask) {
    description 'Installs frontend dependencies using npm ci to ensure reproducible builds.'
    workingDir 'frontend/'
    args = ['ci']
}

def buildFrontend = tasks.register('buildFrontend', com.liferay.gradle.plugins.node.tasks.ExecutePackageManagerTask) {
    description 'Builds the frontend assets for production using npm run devbuild.'
    dependsOn installFrontend
    workingDir 'frontend/'
    args = ['run', 'devbuild']
}

def zipReport = tasks.register('zipReport', Zip) {
    description 'Bundles the compiled frontend assets into a ZIP archive for inclusion in the backend resources.'
    dependsOn buildFrontend
    from 'frontend/build/'
    archiveBaseName = 'templateZip'
    destinationDirectory = file('src/main/resources')
}

def copyCypressConfig = tasks.register('copyCypressConfig', Copy) {
    description 'Copies the config files used by the backend to generate the test report for Cypress testing into an isolated working directory'
    from 'frontend/cypress/config'
    into 'build/serveTestReport/exampleconfig'
}

def copyMainClasses = tasks.register('copyMainClasses', Copy) {
    description 'Copies the backend classes used to generate the test report for Cypress testing into an isolated working directory'
    dependsOn classes
    from 'build/classes/java/main'
    into 'build/serveTestReport/java/main'
}

def compileJava = tasks.compileJava

tasks.named("processSystemtestResources").configure {
    description 'Processes system test resources, allowing duplicate files to be included.'
    duplicatesStrategy = DuplicatesStrategy.INCLUDE
}

tasks.run.dependsOn(zipReport);

run {
    //the second arguments indicates the default value associated with the property.
    description 'Executes RepoSense with specified command-line arguments after building the frontend and packaging resources.'
    tasks.compileJava.mustRunAfter(zipReport)
    args System.getProperty('args', '').split()
    systemProperty "version", getRepoSenseVersion()
}

checkstyle {
    toolVersion = '9.3'
    getConfigDirectory().set(file("$rootProject.projectDir/config/checkstyle"))
}

idea {
    module {
        sourceSets.systemtest.allSource.srcDirs.each { srcDir -> module.testSourceDirs += srcDir }
    }
}

test {
    description 'Runs unit tests with JUnit Jupiter, ensuring individual components function as expected.'
    environment("REPOSENSE_ENVIRONMENT", "TEST")

    testLogging {
        events 'passed', 'skipped', 'failed'
        showStandardStreams = true
    }

    doFirst {
        deleteReposAddressDirectory()
    }

    useJUnitPlatform()

    doLast {
        deleteReposAddressDirectory()
    }
}

tasks.shadowJar.dependsOn(zipReport);

shadowJar {
    description 'Assembles a fat JAR including all dependencies and frontend assets for distribution.'
    tasks.compileJava.mustRunAfter(zipReport)
    tasks.processResources.mustRunAfter(zipReport)
    archiveFileName = 'RepoSense.jar'
    destinationDirectory = file("${buildDir}/jar/")

    manifest {
        attributes 'Implementation-Version': getRepoSenseVersion()
    }
}

tasks.register('lintFrontend', com.liferay.gradle.plugins.node.tasks.ExecutePackageManagerTask) {
    description 'Analyzes frontend code with ESLint to enforce coding standards and identify potential issues.'
    dependsOn installFrontend
    workingDir 'frontend/'
    args = ['run', 'lint']
}

def checkstyleMain = tasks.checkstyleMain {
    description 'Applies Checkstyle code style checks to the main Java source code.'
}

def checkstyleTest = tasks.checkstyleTest {
    description 'Applies Checkstyle code style checks to the test Java source code.'
}

def checkstyleSystemtest = tasks.checkstyleSystemtest {
    description 'Applies Checkstyle code style checks to the system test Java source code.'
}

tasks.register('checkstyleAll', Checkstyle) {
    description 'Aggregates all Checkstyle checks (main, test, systemtest) into a single task for convenience.'
    dependsOn checkstyleMain, checkstyleTest, checkstyleSystemtest
    tasks.checkstyleTest.mustRunAfter('checkstyleMain')
    tasks.checkstyleSystemtest.mustRunAfter('checkstyleTest')
}

tasks.register('environmentalChecks', Exec) {
    description 'Runs OS-specific environment checks to ensure compatibility with RepoSense build processes.'
    workingDir 'config/checks/'
    if (os.isWindows()){
        commandLine 'cmd', '/c', 'run-checks.bat'
    } else {
        commandLine 'sh', './run-checks.sh'
    }
}

tasks.register('systemtest', Test) {
    description 'Executes system tests to validate end-to-end functionality and integration scenarios.'
    testClassesDirs = sourceSets.systemtest.output.classesDirs
    classpath = sourceSets.systemtest.runtimeClasspath
    environment("REPOSENSE_ENVIRONMENT", "TEST")

    testLogging {
        events 'passed', 'skipped', 'failed'
        showStandardStreams = true
    }

    doFirst {
        deleteReposAddressDirectory()
    }

    useJUnitPlatform()

    doLast {
        deleteReposAddressDirectory()
    }
}

def serveTestReportInBackground = tasks.register('serveTestReportInBackground', com.github.psxpaul.task.JavaExecFork) {
    description 'Creates a background server process for the test report that is to be used by Cypress'
    dependsOn zipReport, compileJava, processResources, copyCypressConfig, copyMainClasses
    tasks.compileJava.mustRunAfter(zipReport)
    tasks.processResources.mustRunAfter(zipReport)
    workingDir = 'build/serveTestReport'
    main = mainClassName
    classpath = sourceSets.main.runtimeClasspath
    args = ['--config', './exampleconfig', '--since', 'd1', '--view', '-A', '-t', 'UTC']
    String versionJvmArgs = '-Dversion=' + getRepoSenseVersion()
    jvmArgs = [ versionJvmArgs ]
    waitForPort = 9000
}

def installCypress = tasks.register('installCypress', com.liferay.gradle.plugins.node.tasks.ExecutePackageManagerTask) {
    description 'Installs Cypress and its dependencies for frontend testing using npm ci.'
    workingDir 'frontend/cypress/'
    args = ['ci']
}

tasks.register('cypress', com.liferay.gradle.plugins.node.tasks.ExecutePackageManagerTask) {
    description 'Runs Cypress tests in debug mode for interactive troubleshooting and test development.'
    dependsOn installCypress, serveTestReportInBackground
    tasks.serveTestReportInBackground.mustRunAfter(installCypress)

    workingDir = file('frontend/cypress/')
    args = ["run-script", "debug"]
}

tasks.register('frontendTest', com.liferay.gradle.plugins.node.tasks.ExecutePackageManagerTask) {
    description 'Executes Cypress end-to-end tests; runs in headless CI mode if the "ci" property is specified.'
    dependsOn installCypress, serveTestReportInBackground
    tasks.serveTestReportInBackground.mustRunAfter(installCypress)

    workingDir = file('frontend/cypress/')
    args = ["run-script", "tests"]

    // Run tests in CI without slow motion
    if (project.hasProperty('ci')) {
        args = ["run-script", "ci"]
    }
}

tasks.withType(Copy) {
    includeEmptyDirs = true
}

jacoco {
    toolVersion = "0.8.7"
}

jacocoTestReport {
    reports {
        html.required = true
        xml.required = true
        csv.required = false
        html.destination file("${buildDir}/jacocoHtml")
    }

    executionData systemtest, frontendTest
}

tasks.register('coverage', JacocoReport) {
    description 'Consolidates coverage data from unit, system, and frontend tests into a comprehensive report.'
}

coverage.configure {
    sourceDirectories.from files(sourceSets.main.allSource.srcDirs)
    classDirectories.from files(sourceSets.main.output)
    executionData.from files(jacocoTestReport.executionData)

    afterEvaluate {
        classDirectories.from files(classDirectories.files.collect {
            fileTree(dir: it, exclude: ['**/*.jar'])
        })
    }

    reports {
        html.required = true
        xml.required = true
    }
}

String getRepoSenseVersion() {
    String repoSenseVersion = project.property("version")
    if (repoSenseVersion.equals("unspecified")) {
        repoSenseVersion = versionDetails().commitDistance == 0 ? versionDetails().lastTag : versionDetails().gitHash
    }
    return repoSenseVersion
}

def syncFrontendPublic = tasks.register('syncFrontendPublic', Sync) {
    description 'Synchronizes generated report JSON files into the frontend public directory for development access.'
    from 'reposense-report'
    into 'frontend/public/'
    include '**/*.json'
    includeEmptyDirs = false
    preserve {
        include 'index.html'
        include 'favicon.ico'
        include 'title.md'
    }
}

def macHotReloadFrontend = tasks.register('macHotReloadFrontend', Exec) {
    description 'Starts the frontend development server with hot-reloading capabilities on macOS.'
    dependsOn installFrontend
    onlyIf {os.isMacOsX()}
    workingDir 'frontend/'
    commandLine 'npm', 'run', 'serveOpen'
}

def windowsHotReloadFrontend = tasks.register('windowsHotReloadFrontend', Exec) {
    description 'Starts the frontend development server with hot-reloading capabilities on Windows.'
    dependsOn installFrontend
    onlyIf {os.isWindows()}
    workingDir 'frontend/'
    commandLine 'cmd','/c', 'START', '"hotreload RepoSense frontend"', 'npm', 'run', 'serveOpen'
}

def linuxHotReloadFrontend = tasks.register('linuxHotReloadFrontend', Exec) {
    description 'Starts the frontend development server with hot-reloading capabilities on Linux.'
    dependsOn installFrontend
    onlyIf {os.isLinux()}
    workingDir 'frontend/'
    commandLine 'npm', 'run', 'serveOpen'
}

tasks.register('hotReloadFrontend') {
    description 'Orchestrates frontend hot-reloading by syncing reports and starting the dev server based on the OS.'
    dependsOn syncFrontendPublic
    finalizedBy windowsHotReloadFrontend
    finalizedBy macHotReloadFrontend
    finalizedBy linuxHotReloadFrontend
}
// End of hot reload Tasks

void deleteReposAddressDirectory() {
    final String REPOS_ADDRESS = "repos"
    def reposDirectory = new File(REPOS_ADDRESS)
    reposDirectory.deleteDir()
}

defaultTasks 'clean', 'build', 'systemtest', 'frontendTest', 'coverage'