ci: Switch core to bleep

.github/workflows/ci.yml

@@ -12,85 +12,15 @@ jobs:
     steps:
       - uses: actions/checkout@v3 
       - uses: coursier/cache-action@v6
-      - uses: coursier/[email protected]
-        with:
-          jvm: temurin:1.17
-          apps: mill
-      - run: mill mill.scalalib.scalafmt.ScalafmtModule/checkFormatAll __.sources
+      - uses: bleep-build/[email protected]
+      - run: bleep fmt --check
 
   unit-tests:
-    strategy: 
-      matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
-    runs-on: ${{ matrix.os }}
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
       - uses: coursier/cache-action@v6
-      - uses: actions/setup-java@v3
-        with:
-          distribution: 'temurin'
-          java-version: |
-            17
-            19
+      - uses: bleep-build/[email protected]
       - run: mkdir reports
       - name: Core tests
-        run: |
-          ./mill core.compile
-          ./mill core.test
-        env: 
-          JAVA_HOME: ${{ env.JAVA_HOME_17_X64}}
-
-      - run: |
-          ./mill core.scoverage.xmlReport
-          cp out/core/scoverage/xmlReport.dest/scoverage.xml reports/core-coverage.xml
-        env: 
-          JAVA_HOME: ${{ env.JAVA_HOME_17_X64}}
-
-
-
-      - name: Java 17 Implementation test
-        run: |
-          ./mill j17.compile
-          ./mill j17.test
-        env: 
-          JAVA_HOME: ${{ env.JAVA_HOME_17_X64}}
-
-      - run: |
-          ./mill j17.scoverage.xmlReport
-          cp out/j17/scoverage/xmlReport.dest/scoverage.xml reports/java17-coverage.xml 
-
-        env: 
-          JAVA_HOME: ${{ env.JAVA_HOME_17_X64}}
-
-      - name: Java 19 Implementation test
-        run: |
-          ./mill j19.compile
-          ./mill j19.test 
-
-      - run: |
-          ./mill j19.scoverage.xmlReport 
-          cp out/j19/scoverage/xmlReport.dest/scoverage.xml reports/java19-coverage.xml
-
-      - name: Runtime 17 implementation tests 
-        run: ./mill runtime.test 
-        env: 
-          JAVA_HOME: ${{ env.JAVA_HOME_17_X64 }}
-
-      - run: |
-          ./mill runtime.scoverage.xmlReport 
-          cp out/runtime/scoverage/xmlReport.dest/scoverage.xml reports/java-17-runtime-coverage.xml
-
-        env: 
-          JAVA_HOME: ${{ env.JAVA_HOME_17_X64 }}
-
-      - name: Runtime 19 implementation tests 
-        run: ./mill runtime.test
-      - run: |
-          ./mill runtime.scoverage.xmlReport
-          cp out/runtime/scoverage/xmlReport.dest/scoverage.xml reports/java-19-runtime-coverage.xml
-
-      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v3 
-        with:
-          directory: reports
-          flags: ${{ matrix.os }}
+        run: bleep test core-tests

bleep.yaml

@@ -0,0 +1,52 @@
+$schema: https://raw.githubusercontent.com/oyvindberg/bleep/master/schema.json
+$version: 0.0.2
+jvm:
+  name: temurin:1.17
+projects:
+  core:
+    dependencies: org.scala-lang::scala3-staging:3.3.0
+    extends: 
+      - template-common
+
+
+  core-tests:
+    dependencies: 
+      - org.scalameta::munit:1.0.0-M7
+      - org.scalameta::munit-scalacheck:1.0.0-M7
+    dependsOn: core
+    extends: 
+      - template-common
+    isTestProject: true
+  my-scripts:
+    extends:
+      - template-common
+    dependencies: 
+      - build.bleep::bleep-plugin-dynver:${BLEEP_VERSION}
+      - org.scoverage::scalac-scoverage-reporter:2.0.10
+      - org.scoverage::scalac-scoverage-domain:2.0.10
+      - org.scoverage::scalac-scoverage-serializer:2.0.10
+
+scripts:
+  my-publish-local: my-scripts/fr.hammons.slinc.scripts.PublishLocal
+  scoverage-report: my-scripts/fr.hammons.slinc.scripts.ScoverageReport
+#     main: fr.hammons.slinc.scripts.PublishLocal
+#     project: scripts
+
+templates:
+  template-common:
+    platform:
+      name: jvm
+    scala: 
+      version: 3.3.0
+      options: 
+        - -deprecation
+        - -Wunused:all
+        - -feature
+        - -unchecked
+        - -Xcheck-macros
+        - -Xprint-suspension
+        - -Yexplicit-nulls
+        - -Ysafe-init
+        - -source:future
+        - -Ykind-projector
+        - -Vprofile

core/src/fr/hammons/slinc/jitc/OptimizableFn.scala → core/src/scala/fr/hammons/slinc/jitc/OptimizableFn.scala

@@ -12,13 +12,12 @@ class OptimizableFn[F](
 )(optimized: JitCompiler => F):
   private val _fn: AtomicReference[F] = AtomicReference(f(inst))
   val uuid = UUID.randomUUID().nn
-  private val _optFn: AtomicReference[F] = AtomicReference(
+  private val _optFn: AtomicReference[F] =
     if inst.getCount() >= limit then
       var opt: F | Null = null
       optimizer.jitC(uuid, jitCompiler => opt = optimized(jitCompiler))
-      opt
-    else null
-  )
+      AtomicReference(opt.nn)
+    else AtomicReference()
 
   def get: F =
     val optFn = _optFn.getOpaque()

my-scripts/src/scala/fr/hammons/slinc/scripts/AddCoverage.scala

@@ -0,0 +1,41 @@
+package fr.hammons.slinc.scripts
+
+import bleep.rewrites.BuildRewrite
+import bleep.model.BuildRewriteName
+import bleep.model.Build
+import bleep.model.CrossProjectName
+import bleep.model.Project
+import bleep.model.Options
+import bleep.PathOps
+import java.nio.file.Paths
+import java.nio.file.Files
+
+object AddCoverage extends BuildRewrite:
+  override val name: BuildRewriteName = BuildRewriteName("add-coverage")
+
+  override protected def newExplodedProjects(
+      oldBuild: Build
+  ): Map[CrossProjectName, Project] =
+    val buildTarget = Paths.get(".bleep").nn / "builds" / name.value / ".bloop"
+    oldBuild.explodedProjects
+      .map: (crossName, p) =>
+        if !p.isTestProject.getOrElse(false) then
+          val projectTarget =
+            buildTarget / crossName.value / "scoverage-reports"
+
+          Files.createDirectories(projectTarget)
+          crossName -> p.copy(scala =
+            p.scala.map(s =>
+              s.copy(options =
+                s.options.union(
+                  Options.parse(
+                    List(
+                      s"-coverage-out:${projectTarget.toFile().nn.getAbsoluteFile().nn.toString()}/"
+                    ),
+                    None
+                  )
+                )
+              )
+            )
+          )
+        else crossName -> p

my-scripts/src/scala/fr/hammons/slinc/scripts/PublishLocal.scala

@@ -0,0 +1,24 @@
+package fr.hammons.slinc.scripts
+
+import bleep.*
+import bleep.plugin.dynver.DynVerPlugin
+
+object PublishLocal extends BleepScript("PublishLocal"):
+  def run(started: Started, commands: Commands, args: List[String]): Unit = {
+    val dynVer = new DynVerPlugin(
+      baseDirectory = started.buildPaths.buildDir.toFile.nn,
+      dynverSonatypeSnapshots = true,
+      dynverTagPrefix = Some("")
+    )
+    val projects = started.build.explodedProjects.keys.toArray
+      .filter(projectsToPublish.include)
+
+    commands.publishLocal(
+      bleep.commands.PublishLocal.Options(
+        groupId = "build.bleep",
+        version = dynVer.version,
+        publishTarget = bleep.commands.PublishLocal.LocalIvy,
+        projects = projects
+      )
+    )
+  }

my-scripts/src/scala/fr/hammons/slinc/scripts/ScoverageReport.scala

@@ -0,0 +1,81 @@
+package fr.hammons.slinc.scripts
+
+import bleep.BleepScript
+import bleep.Started
+import bleep.Commands
+import bleep.rewrites.BuildRewrite
+import bleep.PathOps
+
+import scoverage.reporter.CoverageAggregator
+import scoverage.reporter.ScoverageXmlWriter
+import java.io.File
+import java.nio.file.Files
+import scala.jdk.CollectionConverters.*
+import scala.jdk.StreamConverters.*
+import java.nio.file.Paths
+
+object ScoverageReport extends BleepScript("ScoverageReport"):
+  override val rewrites: List[BuildRewrite] = List(AddCoverage)
+  def run(started: Started, commands: Commands, args: List[String]): Unit =
+
+    val testProjects = started.build.explodedProjects
+      .filter((_, p) => p.isTestProject.getOrElse(false))
+      .keySet
+      .toList
+
+    commands.compile(
+      started.build.explodedProjects.keys.toList
+    )
+
+    commands.test(
+      started.build.explodedProjects
+        .filter((_, p) => p.isTestProject.exists(identity))
+        .keys
+        .toList
+    )
+
+    val projectPaths = started.build.explodedProjects
+      .filter((_, p) => !p.isTestProject.getOrElse(false))
+      .map((cp, p) => started.buildPaths.project(cp, p))
+
+
+    projectPaths
+      .flatMap: p =>
+        Files
+          .list(p.targetDir / "scoverage-reports")
+          .nn
+          .toScala(List)
+      .filter(_.endsWith("scoverage.coverage"))
+      .foreach: df =>
+        val mod = Files
+          .readAllLines(df)
+          .nn
+          .asScala
+          .map: s =>
+            if s.startsWith("../") then 
+              started.buildPaths.buildDir.toAbsolutePath().nn.relativize(Paths.get(s.stripPrefix(".."))).nn.toString()
+            else s
+
+        Files.write(df, mod.mkString("\n").getBytes())
+
+    val coverage = projectPaths
+      .map(p => p.sourcesDirs.all -> p.targetDir / "scoverage-reports")
+      .map((sources, data) =>
+        (
+          sources,
+          data,
+          CoverageAggregator
+            .aggregate(
+              Seq(data.toFile().nn),
+              started.buildPaths.buildDir.toFile().nn
+            )
+        )
+      )
+
+    coverage.foreach: (sources, dataDir, coverage) =>
+      ScoverageXmlWriter(
+        sources.map(_.toFile().nn).toSeq,
+        dataDir.toFile().nn,
+        false,
+        None
+      ).write(coverage.get)

my-scripts/src/scala/fr/hammons/slinc/scripts/projectsToPublish.scala

@@ -0,0 +1,13 @@
+package fr.hammons.slinc.scripts
+
+import bleep.model
+
+object projectsToPublish {
+  // will publish these with dependencies
+  def include(crossName: model.CrossProjectName): Boolean =
+    crossName.name.value match {
+      case "core"                             => true
+      case name if name.startsWith("bleep-plugin") => true
+      case _                                       => false
+    }
+}