Implement comment tracking.

Author: nedtwigg

selfie-lib/src/commonMain/kotlin/com/diffplug/selfie/guts/CommentTracker.kt

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2024 DiffPlug
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.diffplug.selfie.guts
+
+import com.diffplug.selfie.ArrayMap
+
+internal expect class CAS<T> {
+  fun get(): T
+  fun updateAndGet(update: (T) -> T): T
+}
+
+internal expect fun <T> createCas(initial: T): CAS<T>
+
+/**
+ * Tracks whether a given file has a comment which allows it to be written to. Thread-safe on
+ * multithreaded platforms.
+ */
+class CommentTracker {
+  private enum class WritableComment {
+    NO_COMMENT,
+    ONCE,
+    FOREVER;
+    val writable: Boolean
+      get() = this != NO_COMMENT
+    val needsRemoval: Boolean
+      get() = this == ONCE
+  }
+  private val cache = createCas(ArrayMap.empty<Path, WritableComment>())
+  fun pathsWithOnce(): Iterable<Path> =
+      cache.get().mapNotNull { if (it.value == WritableComment.ONCE) it.key else null }
+  fun hasWritableComment(call: CallStack, layout: SnapshotFileLayout): Boolean {
+    val path = layout.sourcePathForCall(call.location) ?: return false
+    val comment = cache.get()[path]
+    return if (comment != null) {
+      comment.writable
+    } else {
+      val str = layout.fs.fileRead(path)
+      // TODO: there is a bug here due to string constants, and non-C file comments
+      val newComment =
+          if (str.contains("//selfieonce") || str.contains("// selfieonce")) {
+            WritableComment.ONCE
+          } else if (str.contains("//SEFLIEWRITE") || str.contains("// SELFIEWRITE")) {
+            WritableComment.FOREVER
+          } else {
+            WritableComment.NO_COMMENT
+          }
+      cache.updateAndGet { it.plus(path, newComment) }
+      newComment.writable
+    }
+  }
+}

selfie-lib/src/commonMain/kotlin/com/diffplug/selfie/guts/SourceFile.kt

@@ -80,6 +80,11 @@ class SourceFile(filename: String, content: String) {
           slice.subSequence(valueStart, slice.length - 1).toString(), language)
     }
   }
+  fun removeSelfieOnceComments() {
+    // TODO: there is a bug here due to string constants, and non-C file comments
+    contentSlice =
+        Slice(contentSlice.toString().replace("//selfieonce", "").replace("// selfieonce", ""))
+  }
   private fun findOnLine(toFind: String, lineOneIndexed: Int): Slice {
     val lineContent = contentSlice.unixLine(lineOneIndexed)
     val idx = lineContent.indexOf(toFind)

selfie-lib/src/jsMain/kotlin/com/diffplug/selfie/guts/CommentTracker.js.kt

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2024 DiffPlug
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.diffplug.selfie.guts
+
+internal actual fun <T> createCas(initial: T): CAS<T> = CAS(initial)
+
+internal actual class CAS<T>(var value: T) {
+  actual fun get() = value
+  actual fun updateAndGet(update: (T) -> T): T {
+    value = update(value)
+    return value
+  }
+}

selfie-lib/src/jvmMain/kotlin/com/diffplug/selfie/guts/CommentTracker.jvm.kt

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2024 DiffPlug
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.diffplug.selfie.guts
+
+import java.util.concurrent.atomic.AtomicReference
+
+internal actual fun <T> createCas(initial: T): CAS<T> = CAS(initial)
+
+internal actual class CAS<T>(value: T) {
+  val ref = AtomicReference(value)
+  actual fun get() = ref.get()
+  actual fun updateAndGet(update: (T) -> T): T = ref.updateAndGet(update)
+}

selfie-runner-junit5/src/main/kotlin/com/diffplug/selfie/junit5/SelfieTestExecutionListener.kt

@@ -17,13 +17,15 @@ package com.diffplug.selfie.junit5
 
 import com.diffplug.selfie.*
 import com.diffplug.selfie.guts.CallStack
+import com.diffplug.selfie.guts.CommentTracker
 import com.diffplug.selfie.guts.DiskWriteTracker
 import com.diffplug.selfie.guts.FS
 import com.diffplug.selfie.guts.InlineWriteTracker
 import com.diffplug.selfie.guts.LiteralValue
 import com.diffplug.selfie.guts.Path
 import com.diffplug.selfie.guts.SnapshotFileLayout
 import com.diffplug.selfie.guts.SnapshotStorage
+import com.diffplug.selfie.guts.SourceFile
 import java.nio.charset.StandardCharsets
 import java.nio.file.Files
 import java.util.concurrent.ConcurrentSkipListSet
@@ -75,16 +77,17 @@ internal object SnapshotStorageJUnit5 : SnapshotStorage {
   @JvmStatic fun initStorage(): SnapshotStorage = this
   override val fs = FSJava
   override val mode = calcMode()
-  override fun sourceFileHasWritableComment(call: CallStack): Boolean {
-    TODO("Not yet implemented")
-  }
 
   private class ClassMethod(val clazz: ClassProgress, val method: String)
   private val threadCtx = ThreadLocal<ClassMethod?>()
   private fun classAndMethod() =
       threadCtx.get()
           ?: throw AssertionError(
               "Selfie `toMatchDisk` must be called only on the original thread.")
+  override fun sourceFileHasWritableComment(call: CallStack): Boolean {
+    val cm = classAndMethod()
+    return cm.clazz.parent.commentTracker!!.hasWritableComment(call, cm.clazz.parent.layout)
+  }
   private fun suffix(sub: String) = if (sub == "") "" else "/$sub"
   override fun readDisk(sub: String, call: CallStack): Snapshot? {
     val cm = classAndMethod()
@@ -245,6 +248,7 @@ internal class ClassProgress(val parent: Progress, val className: String) {
 internal class Progress {
   val settings = SelfieSettingsAPI.initialize()
   val layout = SnapshotFileLayoutJUnit5(settings, SnapshotStorageJUnit5.fs)
+  var commentTracker: CommentTracker? = CommentTracker()
 
   private var progressPerClass = ArrayMap.empty<String, ClassProgress>()
   private fun forClass(className: String) = synchronized(this) { progressPerClass[className]!! }
@@ -286,6 +290,14 @@ internal class Progress {
     written.add(path)
   }
   fun finishedAllTests() {
+    val paths = commentTracker!!.pathsWithOnce()
+    commentTracker = null
+    for (path in paths) {
+      val source = SourceFile(layout.fs.name(path), layout.fs.fileRead(path))
+      source.removeSelfieOnceComments()
+      layout.fs.fileWrite(path, source.asString)
+    }
+
     val written =
         checkForInvalidStale.getAndSet(null)
             ?: throw AssertionError("finishedAllTests() was called more than once.")