SarifFixAdapter

buildSrc/src/main/kotlin/com/saveourtool/sarifutils/buildutils/DiktatConfiguration.kt

@@ -27,10 +27,10 @@ fun Project.configureDiktat() {
                     "buildSrc/**/*.kts",
                     "*.kts"
                 )
-                exclude("build", "buildSrc/build")
+                exclude("build", "buildSrc/build", "src/**/resources/*")
             } else {
                 include("src/**/*.kt", "*.kts", "src/**/*.kts")
-                exclude("build/**")
+                exclude("build/**", "src/**/resources/*")
             }
         }
     }

fixpatches/build.gradle.kts

@@ -24,6 +24,7 @@ kotlin {
                 api(libs.okio)
                 implementation(libs.kotlinx.serialization.json)
                 implementation(libs.sarif4k)
+                implementation(libs.multiplatform.diff)
             }
         }
     }

fixpatches/src/commonMain/kotlin/com/saveourtool/sarifutils/cli/Main.kt

@@ -4,6 +4,7 @@
 
 package com.saveourtool.sarifutils.cli
 
+// TODO: remove main class
 fun main(args: Array<String>) {
     println("Welcome to Sarif Fix Patches!")
 }

fixpatches/src/commonMain/kotlin/com/saveourtool/sarifutils/cli/adapter/SarifFixAdapter.kt

@@ -0,0 +1,123 @@
+package com.saveourtool.sarifutils.cli.adapter
+
+import com.saveourtool.sarifutils.cli.config.FileReplacements
+import com.saveourtool.sarifutils.cli.config.RuleReplacements
+import com.saveourtool.sarifutils.cli.files.copyFileContent
+import com.saveourtool.sarifutils.cli.files.createTempDir
+import com.saveourtool.sarifutils.cli.files.fs
+import com.saveourtool.sarifutils.cli.files.readFile
+import com.saveourtool.sarifutils.cli.files.readLines
+import io.github.detekt.sarif4k.Replacement
+
+import io.github.detekt.sarif4k.Run
+import io.github.detekt.sarif4k.SarifSchema210
+import okio.Path
+import okio.Path.Companion.toPath
+
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.json.Json
+
+/**
+ * Adapter for applying sarif fix object replacements to the corresponding test files
+ *
+ * @param sarifFile path to the sarif file with fix object replacements
+ * @param testFiles list of the test file, to which above fixes need to be applied
+ */
+class SarifFixAdapter(
+    private val sarifFile: Path,
+    private val testFiles: List<Path>
+) {
+    private val tmpDir = fs.createTempDir(SarifFixAdapter::class.simpleName!!)
+
+    /**
+     * Main entry for processing and applying fixes from sarif file into the test files
+     *
+     * @return list of processed files
+     */
+    fun process(): List<Path?> {
+        val sarifSchema210: SarifSchema210 = Json.decodeFromString(
+            fs.readFile(sarifFile)
+        )
+        // A run object describes a single run of an analysis tool and contains the output of that run.
+        val processedFiles = sarifSchema210.runs.flatMapIndexed { index, run ->
+            val runReplacements: List<RuleReplacements?> = extractFixObjects(run)
+            if (runReplacements.isEmpty()) {
+                // TODO: Use logging library
+                println("Run #$index have no fix object section!")
+                emptyList()
+            } else {
+                applyReplacementsToFiles(runReplacements, testFiles)
+            }
+        }
+        return processedFiles
+    }
+
+    /**
+     * @param run describes a single run of an analysis tool, and contains the reported output of that run
+     * @return list of replacements for all files from single [run]
+     */
+    fun extractFixObjects(run: Run): List<RuleReplacements?> {
+        if (!run.isFixObjectExist()) {
+            return emptyList()
+        }
+        // A result object describes a single result detected by an analysis tool.
+        // Each result is produced by the evaluation of a rule.
+        return run.results?.map { result ->
+            // A fix object represents a proposed fix for the problem indicated by the result.
+            // It specifies a set of artifacts to modify.
+            // For each artifact, it specifies regions to remove, and provides new content to insert.
+            result.fixes?.flatMap { fix ->
+                fix.artifactChanges.map { artifactChange ->
+                    // TODO: What if uri is not provided? Could it be?
+                    val filePath = artifactChange.artifactLocation.uri!!.toPath()
+                    val replacements = artifactChange.replacements
+                    FileReplacements(filePath, replacements)
+                }
+            } ?: emptyList()
+        } ?: emptyList()
+    }
+
+    private fun Run.isFixObjectExist(): Boolean = this.results?.any { result ->
+        result.fixes != null
+    } ?: false
+
+    @Suppress("UnusedPrivateMember")
+    private fun applyReplacementsToFiles(runReplacements: List<RuleReplacements?>?, testFiles: List<Path>): List<Path?> = runReplacements?.flatMap { ruleReplacements ->
+        ruleReplacements?.mapNotNull { fileReplacements ->
+            val testFile = testFiles.find {
+                it.toString().contains(fileReplacements.filePath.toString())
+            }
+            if (testFile == null) {
+                println("Couldn't find appropriate test file on the path ${fileReplacements.filePath}, which provided in Sarif!")
+                null
+            } else {
+                applyChangesToFile(testFile, fileReplacements.replacements)
+            }
+        } ?: emptyList()
+    } ?: emptyList()
+
+    private fun applyChangesToFile(testFile: Path, replacements: List<Replacement>): Path {
+        val testFileCopy = tmpDir.resolve(testFile.name)
+        fs.copyFileContent(testFile, testFileCopy)
+        val fileContent = fs.readLines(testFileCopy).toMutableList()
+
+        replacements.forEach { replacement ->
+            val startLine = replacement.deletedRegion.startLine!!.toInt() - 1
+            val startColumn = replacement.deletedRegion.startColumn!!.toInt() - 1
+            val endColumn = replacement.deletedRegion.endColumn!!.toInt() - 1
+            val insertedContent = replacement.insertedContent?.text
+
+            insertedContent?.let {
+                fileContent[startLine] = fileContent[startLine].replaceRange(startColumn, endColumn, it)
+            } ?: run {
+                fileContent[startLine] = fileContent[startLine].removeRange(startColumn, endColumn)
+            }
+        }
+        fs.write(testFileCopy) {
+            fileContent.forEach {
+                write((it + "\n").encodeToByteArray())
+            }
+        }
+        return testFileCopy
+    }
+}

fixpatches/src/commonMain/kotlin/com/saveourtool/sarifutils/cli/config/FileReplacements.kt

@@ -0,0 +1,15 @@
+package com.saveourtool.sarifutils.cli.config
+
+import io.github.detekt.sarif4k.Replacement
+import okio.Path
+
+typealias RuleReplacements = List<FileReplacements>
+
+/**
+ * @property filePath path to the file
+ * @property replacements list of artifact changes for this [file]
+ */
+data class FileReplacements(
+    val filePath: Path,
+    val replacements: List<Replacement>
+)

fixpatches/src/commonMain/kotlin/com/saveourtool/sarifutils/cli/files/FileUtils.kt

@@ -0,0 +1,72 @@
+/**
+ * Utility methods to work with file system
+ */
+
+package com.saveourtool.sarifutils.cli.files
+
+import okio.FileSystem
+import okio.Path
+import kotlin.random.Random
+
+expect val fs: FileSystem
+
+/**
+ * @param path a path to a file
+ * @return list of strings from the file
+ */
+fun FileSystem.readLines(path: Path): List<String> = this.read(path) {
+    generateSequence { readUtf8Line() }.toList()
+}
+
+/**
+ * @param path a path to a file
+ * @return string from the file
+ */
+fun FileSystem.readFile(path: Path): String = this.read(path) {
+    this.readUtf8()
+}
+
+/**
+ * Create file in [this] [FileSystem], denoted by [Path] [path]
+ *
+ * @param path path to a new file
+ * @return [path]
+ */
+fun FileSystem.createFile(path: Path): Path {
+    sink(path).close()
+    return path
+}
+
+/**
+ * Create a temporary directory
+ *
+ * @param prefix will be prepended to directory name
+ * @return a [Path] representing the created directory
+ */
+fun FileSystem.createTempDir(prefix: String = "sarifutils-tmp"): Path {
+    val dirName = "$prefix-${Random.nextInt()}"
+    return (FileSystem.SYSTEM_TEMPORARY_DIRECTORY / dirName).also {
+        createDirectory(it)
+    }
+}
+
+/**
+ * Copy file content from [from] into [into]
+ *
+ * @param [from] path to the file, from which content need to be copied
+ * @param [into] path to the file, into which content need to be copied
+ * @param mustCreate whether to create file on [into] path
+ */
+fun FileSystem.copyFileContent(
+    from: Path,
+    into: Path,
+    mustCreate: Boolean = false
+) {
+    fs.write(into, mustCreate) {
+        fs.readLines(from).forEach {
+            write(
+                (it + "\n").encodeToByteArray()
+            )
+        }
+    }
+}