build.gradle

import org.gradle.api.tasks.testing.logging.TestExceptionFormat
import org.gradle.api.tasks.testing.logging.TestLogEvent
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

import java.time.Duration

plugins {
  alias(libs.plugins.spotless)
  alias(libs.plugins.docker)
}

tasks.register("compileAll") {
  group = "build"
  description = "Compiles all Java and Kotlin sources, including tests, across all projects."
}

// to allow to have unused vars/imports,etc for faster debugging/prototyping
// instead of deleting and re-adding code all the time
def allowCompilationWarnings = System.getenv('LINEA_DEV_ALLOW_WARNINGS') != null

spotless {
  predeclareDeps()
}

spotlessPredeclare {
  groovyGradle {
    greclipse("4.35")
  }
  java {
    removeUnusedImports()
    googleJavaFormat(libs.versions.googleJavaFormat.get())
  }
  kotlin {
    ktlint(libs.versions.ktlint.get().toString())
        .editorConfigOverride([
          'ktlint_standard_discouraged-comment-location': 'disabled',
          'ktlint_standard_property-naming': 'disabled',
          'ktlint_standard_function-naming': 'disabled',
          'ktlint_standard_function-signature': 'disabled',
        ])
  }
}

allprojects {
  // Aggregate every Java/Kotlin compile task (main + tests, all source sets) into root :compileAll.
  afterEvaluate { proj ->
    proj.tasks.withType(JavaCompile).all { compileTask ->
      rootProject.tasks.named("compileAll").configure { dependsOn(compileTask) }
    }
    proj.tasks.withType(KotlinCompile).all { compileTask ->
      rootProject.tasks.named("compileAll").configure { dependsOn(compileTask) }
    }
  }

  repositories {
    mavenCentral()
    mavenLocal()
  }

  apply plugin: 'java' // do not add kotlin plugin here, it will add unnecessary Kotlin runtime dependencies
  apply plugin: 'jacoco'

  // Override JUnit version from Besu BOM to ensure Java 25 compatibility
  configurations.configureEach { cfg ->
    resolutionStrategy.eachDependency { details ->
      if (details.requested.group in [
            'org.junit.platform',
            'org.junit.jupiter',
            'org.junit'
          ]) {
        def junitVersion = details.requested.group == 'org.junit.platform' ?
            "${libs.versions.junitPlatform.get()}" : "${libs.versions.junit.get()}"
        details.useVersion(junitVersion)
        details.because('Java 25 requires JUnit 5.13+ for ASM compatibility')
      }

      if (!cfg.name.toLowerCase().contains('spotless')
          && !cfg.name.toLowerCase().contains('ktlint')
          && details.requested.group in [
            'org.hyperledger.besu',
            'org.hyperledger.besu.internal'
          ] &&
          (!details.requested.version || details.requested.version.trim().isEmpty())) {
        details.useVersion(rootProject.ext.resolveBesuVersion())
        details.because('Versionless Besu dependencies are aligned to the lazily resolved Besu version') // e.g. jvm-libs:linea:besu-libs
      }
    }
  }

  tasks.withType(KotlinCompile).configureEach {
    compilerOptions {
      allWarningsAsErrors = !allowCompilationWarnings
    }
  }

  tasks.withType(JavaCompile).configureEach {
    options.encoding = 'UTF-8'
    options.deprecation = true
    options.compilerArgs.addAll([
      '-parameters',
      '-Xlint:cast',
      '-Xlint:overloads',
      '-Xlint:divzero',
      '-Xlint:finally',
      '-Xlint:static',
      '-Xlint:deprecation',
      '-Xlint:unchecked',
      '-Xlint:rawtypes',
      '-Werror'
    ])
    if (allowCompilationWarnings) {
      options.compilerArgs.remove('-Werror')
    }

    if (project.path.contains("testing-tools")) {
      // testing tools have 100+ errors because of this
      // skipping them for now
      options.compilerArgs.remove('-Xlint:rawtypes')
    }
  }

  jacoco {
    toolVersion = libs.versions.jacoco.get()
    if (project.tasks.findByName('integrationTest')) {
      applyTo integrationTest
    }
    if (project.tasks.findByName('acceptanceTest')) {
      applyTo acceptanceTest
    }
    if (project.tasks.findByName('acceptanceTests')) {
      applyTo acceptanceTests
    }
  }

  jacocoTestReport {
    dependsOn test
  }

  tasks.withType(Javadoc).configureEach {
    exclude '**/generated/**'
  }

  tasks.withType(Test).configureEach {
    testLogging {
      events = [
        //TestLogEvent.STARTED,
        //TestLogEvent.PASSED,
        TestLogEvent.FAILED,
        TestLogEvent.SKIPPED,
        TestLogEvent.STANDARD_ERROR
      ]
      exceptionFormat TestExceptionFormat.FULL
      showCauses true
      showExceptions true
      showStackTraces true
      // set showStandardStreams if you need to see test logs
      showStandardStreams false
    }
    systemProperty("L1_RPC_URL", "http://localhost:8445")
    systemProperty("L2_RPC_URL", "http://localhost:8545")
    systemProperty("L1_GENESIS", "docker/config/l1-node/el/genesis.json")
    systemProperty("L2_GENESIS", "docker/config/linea-local-dev-genesis-PoA-besu.json")

    systemProperties["junit.jupiter.execution.timeout.default"] = "5 m" // 5 minutes
    systemProperties["junit.jupiter.execution.parallel.enabled"] = true
    systemProperties["junit.jupiter.execution.parallel.mode.default"] = "concurrent"
    systemProperties["junit.jupiter.execution.parallel.mode.classes.default"] = "concurrent"
    maxParallelForks = Math.max(Runtime.runtime.availableProcessors(), 9)
  }

  tasks.withType(Test).matching { it.name == 'integrationTest' }.configureEach {
    outputs.cacheIf { false }
    outputs.upToDateWhen { false }
  }

  afterEvaluate { subproject ->
    if (hasJavaOrKotlinPlugins(subproject)) {
      subproject.apply plugin: 'com.diffplug.spotless'

      subproject.spotless {
        if (hasKotlinPlugin(subproject)) {
          kotlin {
            // by default the target is every '.kt' and '.kts` file in the java sourcesets
            //ktfmt()
            ktlint(libs.versions.ktlint.get().toString())
                .editorConfigOverride([
                  'ktlint_standard_discouraged-comment-location': 'disabled',
                  'ktlint_standard_property-naming': 'disabled',
                  'ktlint_standard_function-naming': 'disabled',
                  'ktlint_standard_function-signature': 'disabled',
                  // 'ktlint_function_signature_rule_force_multiline_when_parameter_count_greater_or_equal_than': '1'
                ])
          }
        }
        // spotless check applied to build.gradle (groovy) files
        groovyGradle {
          target '*.gradle'
          greclipse("4.35")
          leadingTabsToSpaces(2)
          endWithNewline()
        }

        java {
          target 'src/**/*.java'
          // Do not use 'targetExclude' with wildcard patterns, it will add minutes to the build
          removeUnusedImports()
          trimTrailingWhitespace()
          endWithNewline()
          googleJavaFormat(libs.versions.googleJavaFormat.get())
        }

        // Below this line are currently only license header tasks
        // format 'groovy', { target '**/src/*/groovy/**/*.groovy' }
        // format 'bash', { target '**/*.sh' }
        // format 'sol', { target '**/*.sol' }
      }
    }
  }
}

task jacocoRootReport(type: JacocoReport) {
  // Define a project list will all subprojects excluding 'tracer' (TODO: fix to include tracer)
  def reportProjects = subprojects.findAll { subproject ->
    // Get the path of the subproject relative to the root dir (e.g., "tracer/lib-a")
    def relativePath = rootProject.relativePath(subproject.projectDir)
    // Include only if the path does NOT start with "tracer"
    return !relativePath.startsWith('tracer')
  }

  additionalSourceDirs.from files(reportProjects.sourceSets.main.allSource.srcDirs)
  sourceDirectories.from files(reportProjects.sourceSets.main.allSource.srcDirs)
  classDirectories.from files(reportProjects.sourceSets.main.output)

  // Exclude the tracer folder from the execution data scan (TODO: fix to include tracer)
  executionData.from fileTree(dir: '.', includes: ['**/jacoco/*.exec'], excludes: ['tracer/**'])
  reports {
    xml.required = true
    // xml.enabled = true FIXME: deprecated, breaking latest versions of gradle.
    csv.required = true
    html.outputLocation = file("build/reports/jacocoHtml")
  }
  onlyIf = { true }
}

dockerCompose {
  localStack {
    startedServices = [
      "postgres",
      "sequencer",
      "maru",
      "l1-node-genesis-generator",
      "l2-genesis-initialization",
      "l1-el-node",
      "l1-cl-node",
      // For debug
      // "l1-blockscout",
      // "l2-blockscout"
    ]
    composeAdditionalArgs = [
      "--profile",
      "l1",
      "--profile",
      "l2"
    ]
    useComposeFiles = [
      "${project.rootDir.path}/docker/compose-tracing-v2.yml"
    ]
    waitForHealthyStateTimeout = Duration.ofMinutes(3)
    waitForTcpPorts = false
    stopContainers = false
    removeOrphans = true
    // this is to avoid recreating the containers
    // specially l1-node-genesis-generator which corrupts the state if run more than once
    // without cleaning the volumes
    noRecreate = true
    projectName = "docker"
  }

  localStackPostgresDbOnly {
    startedServices = ["postgres"]
    useComposeFiles = [
      "${project.rootDir.path}/docker/compose-tracing-v2.yml"
    ]
    waitForHealthyStateTimeout = Duration.ofMinutes(3)
    stopContainers = false
    waitForTcpPorts = true
    removeOrphans = true
    noRecreate = true
    projectName = "docker"
  }

  localStackForStateRecovery {
    startedServices = [
      "postgres",
      "sequencer",
      "l1-node-genesis-generator",
      "l1-el-node",
      "l1-cl-node",
      "blobscan-api",
      "blobscan-indexer",
      "redis",
    ]
    composeAdditionalArgs = [
      "--profile",
      "l1",
      "--profile",
      "l2",
      "--profile",
      "staterecovery"
    ]
    useComposeFiles = [
      "${project.rootDir.path}/docker/compose-tracing-v2-staterecovery-extension.yml"
    ]
    waitForHealthyStateTimeout = Duration.ofMinutes(3)
    waitForTcpPorts = false
    removeOrphans = true
    stopContainers = false
    // this is to avoid recreating the containers
    // specially l1-node-genesis-generator which corrupts the state if run more than once
    // without cleaning the volumes
    noRecreate = true
    projectName = "docker"
  }
}

// Pull only the images required by `startedServices` of the `localStack` compose stack.
// Useful in CI to retry the (sometimes flaky) Docker Hub pull in isolation, without
// rerunning the integration test.
tasks.register("composePullLocalStackStartedImages", Exec) {
  group = 'docker'
  description = "Pull only the startedServices images for the 'localStack' compose stack."
  workingDir rootDir
  doFirst {
    def settings = dockerCompose.localStack
    def fileArgs = settings.useComposeFiles.get().collectMany { ['-f', it.toString()] }
    def additionalArgs = settings.composeAdditionalArgs.get()
    def services = settings.startedServices.get()
    commandLine(['docker', 'compose'] + fileArgs + additionalArgs + ['pull'] + services)
  }
}

// Seed the gitignored runtime deny-list before any compose-up so the sequencer's
// bind-mount finds a regular file (not an auto-created directory) on fresh checkouts.
// Delegates to the Makefile target so Make and Gradle stay in lockstep.
def seedSequencerDenyList = tasks.register("seedSequencerDenyList", Exec) {
  workingDir rootDir
  commandLine 'make', 'seed-deny-list'
}
tasks.matching { it.name.endsWith("ComposeUp") }.configureEach {
  dependsOn(seedSequencerDenyList)
}

static Boolean hasKotlinPlugin(Project proj) {
  return proj.plugins.hasPlugin("org.jetbrains.kotlin.jvm")
}

static Boolean hasJavaPlugin(Project proj) {
  return (proj.plugins.hasPlugin("java") || proj.plugins.hasPlugin("java-library"))
}

static Boolean hasJavaOrKotlinPlugins(Project proj) {
  return (hasKotlinPlugin(proj) || hasJavaPlugin(proj))
}