Jonathan/Dracon - Change Q35OTML226J2HZLHOCPV5OY6ZUM2XU4RZBE5E3GDWVHVFASHFEJAC

Remove use of coroutines, which was blocking IntelliJ UI in larger repositories Improvements for bigger repositories, now Dracon caches the changes that happened in a revision in a file, so everytime Dracon needs to query the changes of a revision, it loads directly from memory instead of doing a full-scan in Pijul repository. For tiny projects it is not a problem, but for medium ones it takes more than five minutes to scan the entire repository (and it was tested with a repo of only 700 records, however there was changes that had more than 60.000 lines). The cache file is saved in IntelliJ Data Path (project specific) and is compressed with gzip, so it will not use so much disk space (the cost worths the gains).

Created by Jonathan on April 2, 2021

Q35OTML226J2HZLHOCPV5OY6ZUM2XU4RZBE5E3GDWVHVFASHFEJAC

Dependencies

In channels

main

Change contents

Deletion in src/main/kotlin/com/github/jonathanxd/dracon/pijul/PijulExecution.kt at line 12 [3.4043]
B:BD[3.4087] → [3.4087:4124]
```
import kotlinx.coroutines.flow.Flow
```

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/pijul/PijulExecution.kt at line 14 [3.4043]

B:BD[3.4147] → [3.4147:4245]

    val regularStream: Flow<String>,
    val errorStream: Flow<String>,
    val status: Flow<Int>

[3.4147]

[3.4245]

    val regularStream: String,
    val errorStream: String,
    val status: Int

Insertion in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 4 [5.1965]
[4.2274]
[4.2274]
```
import com.google.gson.*
```
Insertion in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 7 [5.1965]
[6.61125]
[7.5891]
```
import java.io.Serializable
```

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 14 [5.1965]

B:BD[5.2152] → [6.61126:61206]

data class Author(val name: String?, val fullName: String?, val email: String?)

[5.2152]

[6.61206]

data class Author(val name: String?, val fullName: String?, val email: String?): Serializable

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 24 [5.1965]
B:BD[6.61466] → [6.61466:61468]
```
)
```
[6.61466]
[5.2153]
```
): Serializable
```
Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 34 [5.1965]
B:BD[6.61585] → [6.61585:61587]
```
)
```
[6.61585]
[5.2155]
```
): Serializable
```
Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 36 [5.1965]
B:BD[5.2156] → [6.61588:61615]
```
sealed class IntOrAsterisk
```
[5.2156]
[5.2156]
```
sealed class IntOrAsterisk: Serializable
```
Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 41 [5.1965]
B:BD[6.61718] → [6.61718:61754]
```
object Asterisk : IntOrAsterisk() {
```
[6.61718]
[6.61754]
```
object Asterisk : IntOrAsterisk(), Serializable {
```
Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 48 [5.1965]
B:BD[6.61940] → [6.61940:61994]
```
data class IndexInt(val index: Int) : IntOrAsterisk()
```
[6.61940]
[6.61994]
```
data class IndexInt(val index: Int) : IntOrAsterisk(), Serializable
```
Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 50 [5.1965]
B:BD[6.61995] → [6.61995:62023]
```
enum class DependencyType {
```
[6.61995]
[6.62023]
```
enum class DependencyType: Serializable {
```
Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 73 [5.1965]
B:BD[6.62311] → [6.62311:62331]
```
sealed class Hunk {
```
[6.62311]
[6.62331]
```
sealed class Hunk: Serializable {
```
Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 97 [5.1965]
B:BD[6.62810] → [8.13914:13940]
```
): Hunk(), HunkWithPath {
```
[6.62810]
[8.13940]
```
): Hunk(), HunkWithPath, Serializable {
```
Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 113 [5.1965]
B:BD[6.63117] → [8.14117:14143]
```
): Hunk(), HunkWithPath {
```
[6.63117]
[8.14143]
```
): Hunk(), HunkWithPath, Serializable {
```
Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 128 [5.1965]
B:BD[6.63430] → [8.14210:14236]
```
): Hunk(), HunkWithPath {
```
[6.63430]
[8.14236]
```
): Hunk(), HunkWithPath, Serializable {
```
Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 141 [5.1965]
B:BD[6.63695] → [8.14303:14329]
```
): Hunk(), HunkWithPath {
```
[6.63695]
[8.14329]
```
): Hunk(), HunkWithPath, Serializable {
```
Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 156 [5.1965]
B:BD[6.64019] → [8.14395:14421]
```
): Hunk(), HunkWithPath {
```
[6.64019]
[8.14421]
```
): Hunk(), HunkWithPath, Serializable {
```
Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 171 [5.1965]
B:BD[6.64352] → [8.14488:14514]
```
): Hunk(), HunkWithPath {
```
[6.64352]
[8.14514]
```
): Hunk(), HunkWithPath, Serializable {
```
Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 185 [5.1965]
B:BD[6.64642] → [8.14581:14607]
```
): Hunk(), HunkWithPath {
```
[6.64642]
[8.14607]
```
): Hunk(), HunkWithPath, Serializable {
```
Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 200 [5.1965]
B:BD[6.64957] → [8.14674:14700]
```
): Hunk(), HunkWithPath {
```
[6.64957]
[8.14700]
```
): Hunk(), HunkWithPath, Serializable {
```
Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 215 [5.1965]
B:BD[6.65294] → [8.14767:14793]
```
): Hunk(), HunkWithPath {
```
[6.65294]
[8.14793]
```
): Hunk(), HunkWithPath, Serializable {
```
Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 225 [5.1965]
B:BD[6.65485] → [6.65485:65520]
```
data class Meta(val plain: String)
```
[6.65485]
[6.65520]
```
data class Meta(val plain: String): Serializable
```
Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 232 [5.1965]
B:BD[6.65698] → [6.65698:65733]
```
data class Flag(val plain: String)
```
[6.65698]
[6.65733]
```
data class Flag(val plain: String): Serializable
```
Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 236 [5.1965]
B:BD[6.65780] → [6.65780:65804]
```
    val new: IntRange?,
```
[6.65780]
[6.65804]
```
    val new: Range?,
```
Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 238 [5.1965]
∅:D[6.65831] → [5.2463:2465]
B:BD[5.2463] → [5.2463:2465]
```
)
```
[6.65831]
[5.2465]
```
): Serializable
data class Range(val start: Int, val end: Int): Serializable
```
Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 246 [5.1965]
B:BD[6.65983] → [6.65983:66057]
```
fun IntRange.intRangeAsSource() = "IntRange(${this.first}, ${this.last})"
```
[6.65983]
[5.2466]
```
fun Range.intRangeAsSource() = "Range(${this.start}, ${this.end})"
```
Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 248 [5.1965]
B:BD[5.2467] → [6.66058:66080]
```
enum class HunkType {
```
[5.2467]
[6.66080]
```
enum class HunkType: Serializable {
```
Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 264 [5.1965]
B:BD[6.66404] → [6.66404:66470]
```
data class LineChange(val type: LineChangeType, val data: String)
```
[6.66404]
[6.66470]
```
data class LineChange(val type: LineChangeType, val data: String): Serializable
```
Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 266 [5.1965]
B:BD[6.66471] → [6.66471:66519]
```
enum class LineChangeType(val symbol: String) {
```
[6.66471]
[6.66519]
```
enum class LineChangeType(val symbol: String): Serializable {
```
Insertion in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 284 [5.1965]
[5.2518]
[5.2518]
```
val MULTI_LINE_MESSAGE_PATTERN = Regex("message = '''(.*)'''", RegexOption.DOT_MATCHES_ALL)
```

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 309 [5.1965]

B:BD[5.2731] → [5.2731:2799]

    val message = MESSAGE_PATTERN.find(this)?.groupValues?.get(1)!!

[5.2731]

[5.2799]

    val messageSingleLine = MESSAGE_PATTERN.find(this)?.groupValues?.get(1)
    val messageMultiLine = MULTI_LINE_MESSAGE_PATTERN.find(this)?.groupValues?.get(1)

Insertion in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 318 [5.1965]
[6.68727]
[5.2989]
```
    val message = if (messageMultiLine != null) messageMultiLine else messageSingleLine
```

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 667 [5.1965]

B:BD[6.81325] → [6.81325:81429]

    return PijulLogEntry(hash, message, timestamp.parseAsLocalDateTime(), authors, dependencies, hunks)

[6.81325]

[6.81429]

    return PijulLogEntry(hash, message!!, timestamp.parseAsLocalDateTime(), authors, dependencies, hunks)

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 697 [5.1965]
B:BD[6.82473] → [6.82473:82517]
```
            IntRange(firstPart, secondPart)
```
[6.82473]
[6.82517]
```
            Range(firstPart, secondPart)
```
Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 941 [5.1965]
B:BD[4.2822] → [4.2822:2827]
```
    }
```
[4.2822]
```
    }
```
File move: editor (----------) → editor (d--x------)
BF:BFD[3.107] → [2.4394:4402]
[3.107]
[2.4403]

Insertion in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 13 [3.10972]

[3.11015]

[8.15017]

import com.github.jonathanxd.dracon.cache.HashKey
import com.github.jonathanxd.dracon.cache.HashMapCache
import com.github.jonathanxd.dracon.cache.PijulCache
import com.github.jonathanxd.dracon.cache.PijulLogEntryCache
import com.github.jonathanxd.dracon.cache.persist.DraconPersistentStateComponent

Insertion in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 68 [3.10972]

[3.12224]

    private val cache: PijulCache = HashMapCache()
    private val pijulLogEntryCache = PijulLogEntryCache(this.project)

Insertion in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 181 [3.10972]
[9.10608]
[9.10608]
```
                        this.reset(project, root)
```

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 342 [3.10972]

B:BD[9.11107] → [8.16544:16696]

∅:D[8.16696] → [5.4990:5031]

B:BD[5.4990] → [5.4990:5031]

                val change = this.doExecutionWithMapper("change-$hash", this.createPainlessExecPijulOperation(project, root, listOf("change", hash))) {
                    it.parseChange(hash)

[9.11107]

[5.5031]


                val change = this.pijulLogEntryCache.queryOrCompute(hash) {
                    this.doExecutionWithMapper("change-$hash",
                        this.createPainlessExecPijulOperation(project, root, listOf("change", hash))
                    ) {
                        it.parseChange(hash)
                    }

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 409 [3.10972]

B:BD[8.17714] → [4.18948:19100]

∅:D[4.19100] → [8.17870:17911]

B:BD[8.17870] → [8.17870:17911]

                val change = this.doExecutionWithMapper("change-$hash", this.createPainlessExecPijulOperation(project, root, listOf("change", hash))) {
                    it.parseChange(hash)

[8.17714]

[8.17911]

                val change = this.pijulLogEntryCache.queryOrCompute(hash) {
                    this.doExecutionWithMapper("change-$hash",
                        this.createPainlessExecPijulOperation(project, root, listOf("change", hash))
                    ) {
                        it.parseChange(hash)
                    }

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 543 [3.10972]

B:BD[8.20085] → [8.20085:20176]

            else ChannelInfo(channels.map { PijulChannel(it[0] == '*', it.substring(1)) })

[8.20085]

[8.20176]

            else ChannelInfo(channels.filter { it.isNotEmpty() }.map { PijulChannel(it[0] == '*', it.substring(1)) })

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 548 [3.10972]

B:BD[3.13702] → [3.13702:13800]

        val status = runBlocking(Dispatchers.IO) {
            execution.status.first()
        }

[3.13702]

[3.13800]

        val status = execution.status

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 553 [3.10972]

B:BD[3.13916] → [3.13916:14050]

            val error = runBlocking(Dispatchers.IO) {
                execution.errorStream.toList().joinToString("\n")
            }

[3.13916]

[3.14050]

            val error = execution.errorStream

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 561 [3.10972]
B:BD[10.3971] → [10.3971:4059]
∅:D[10.4059] → [3.14133:14143]
B:BD[3.14133] → [3.14133:14143]
```
        val status = runBlocking(Dispatchers.IO) {
            execution.status.first()
        }
```
[10.3971]
[10.4060]
```
        val status = execution.status
```

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 564 [3.10972]

B:BD[10.4095] → [10.4095:4229]

            val std = runBlocking(Dispatchers.IO) {
                execution.regularStream.toList().joinToString("\n")
            }

[10.4095]

[10.4229]

            val std = execution.regularStream

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 568 [3.10972]

B:BD[10.4337] → [10.4337:4471]

            val error = runBlocking(Dispatchers.IO) {
                execution.errorStream.toList().joinToString("\n")
            }

[10.4337]

[10.4471]

            val error = execution.errorStream

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 577 [3.10972]

B:BD[7.9507] → [7.9507:9605]

        val status = runBlocking(Dispatchers.IO) {
            execution.status.first()
        }

[7.9507]

[7.9605]

        val status = execution.status

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 580 [3.10972]

B:BD[7.9640] → [7.9640:9774]

            val std = runBlocking(Dispatchers.IO) {
                execution.regularStream.toList().joinToString("\n")
            }

[7.9640]

[7.9774]

            val std = execution.regularStream

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 584 [3.10972]

B:BD[7.9882] → [7.9882:10016]

            val error = runBlocking(Dispatchers.IO) {
                execution.errorStream.toList().joinToString("\n")
            }

[7.9882]

[7.10016]

            val error = execution.errorStream

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 614 [3.10972]

B:BD[3.14610] → [3.14610:14690]

        val input = process.inputStream
        val error = process.errorStream

[3.14610]

[3.14690]

        val input = String(process.inputStream.readAllBytes(), Charsets.UTF_8)
        val error = String(process.errorStream.readAllBytes(), Charsets.UTF_8)

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 617 [3.10972]

B:BD[3.14691] → [3.14691:15048]

B:BD[3.15048] → [10.4705:4738]

∅:D[10.4738] → [3.15081:15128]

B:BD[3.15081] → [3.15081:15128]

        return PijulExecution(
            input.linesToFlow().onEach {
                draconConsoleWriter(project).logCommand("pijul", args, it)
            },
            error.linesToFlow().onEach {
                draconConsoleWriter(project).logCommandError("pijul", args, it)
            },
            flow {
                while (process.isAlive)
                    delay(delay)
                val exit = process.exitValue()

[3.14691]

[3.15128]

        input.split("\n").forEach {
            draconConsoleWriter(project).logCommand("pijul", args, it)
        }
        error.split("\n").forEach {
            draconConsoleWriter(project).logCommandError("pijul", args, it)
        }

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 625 [3.10972]

B:BD[3.15129] → [3.15129:15406]

                if (exit == 0) {
                    draconConsoleWriter(project).logCommand("pijul", args, "<Exit status> $exit")
                } else {
                    draconConsoleWriter(project).logCommandError("pijul", args, "<Exit status> $exit")
                }

[3.15129]

[3.15406]

        val exit = process.waitFor()
        if (exit == 0) {
            draconConsoleWriter(project).logCommand("pijul", args, "<Exit status> $exit")
        } else {
            draconConsoleWriter(project).logCommandError("pijul", args, "<Exit status> $exit")
        }

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 632 [3.10972]

B:BD[3.15407] → [3.15407:15471]

                emit(exit)
            }.flowOn(Dispatchers.IO)

[3.15407]

[3.15471]

        return PijulExecution(
            input,
            error,
            exit

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 660 [3.10972]

B:BD[7.10425] → [7.10425:10505]

        val input = process.inputStream
        val error = process.errorStream

[7.10425]

[7.10505]

        val input = String(process.inputStream.readAllBytes(), Charsets.UTF_8)
        val error = String(process.errorStream.readAllBytes(), Charsets.UTF_8)
        input.split("\n").forEach {
            draconConsoleWriter(project).logCommand("pijul", args, it)
        }
        error.split("\n").forEach {
            draconConsoleWriter(project).logCommandError("pijul", args, it)
        }
        val exit = process.waitFor()
        if (exit == 0) {
            draconConsoleWriter(project).logCommand("pijul", args, "<Exit status> $exit")
        } else {
            draconConsoleWriter(project).logCommandError("pijul", args, "<Exit status> $exit")
        }

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 679 [3.10972]

B:BD[7.10537] → [7.10537:10578]

            input.linesToFlow().onEach {

[7.10537]

[7.10578]

            input,
            error,
            exit
        )
    }
    /**
     * Creates a [PijulExecution] operation that could be executed at any time. This operation uses Kotlin Coroutines
     * and can be executed immediately through [doExecution] or through [doExecutionWithMapper].
     *
     * This implementation does not requires a delay value to be provided, like [createExecPijulOperation] does, instead
     * it uses the kotlin conversion from `CompletionStage` to `Coroutines` and awaits the process through [Process.onExit].
     *
     * [doExecution] and [doExecutionWithMapper] does execution by scheduling task to [Dispatchers.IO], instead of Main Thread,
     * offloading the Process execution handling to a different scheduler. However, mapping operation of [doExecutionWithMapper]
     * is not offloaded from the caller context.
     *
     */
    @RequiresBackgroundThread
    private fun <K: Any> createPainlessExecPijulOperationWithCache(project: Project,
                                                                   dir: Path,
                                                                   args: List<String>,
                                                                   key: K): PijulExecution {
        return this.cache.cache(key) {
            val process = ProcessBuilder()
                .command(listOf(this.findPijul()) + args)
                .directory(dir.toFile())
                .start()
            val input = String(process.inputStream.readAllBytes(), Charsets.UTF_8)
            val error = String(process.errorStream.readAllBytes(), Charsets.UTF_8)
            input.split("\n").forEach {

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 713 [3.10972]

B:BD[7.10653] → [7.10653:10709]

            },
            error.linesToFlow().onEach {

[7.10653]

[7.10709]

            }
            error.split("\n").forEach {

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 717 [3.10972]
B:BD[7.10789] → [7.10789:10864]
```
            },
            flow {
                process.onExit().await()
```
[7.10789]
[7.10864]
```
            }
```

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 719 [3.10972]

B:BD[7.10865] → [7.10865:11190]

                val exit = process.exitValue()
                if (exit == 0) {
                    draconConsoleWriter(project).logCommand("pijul", args, "<Exit status> $exit")
                } else {
                    draconConsoleWriter(project).logCommandError("pijul", args, "<Exit status> $exit")
                }

[7.10865]

[7.11190]

            val exit = process.waitFor()
            if (exit == 0) {
                draconConsoleWriter(project).logCommand("pijul", args, "<Exit status> $exit")
            } else {
                draconConsoleWriter(project).logCommandError("pijul", args, "<Exit status> $exit")
            }

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 726 [3.10972]

B:BD[7.11191] → [7.11191:11265]

                emit(exit)
            }.flowOn(Dispatchers.IO)
        )

[7.11191]

[7.11265]

            PijulExecution(
                input,
                error,
                exit
            )
        }

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 766 [3.10972]

B:BD[3.15488] → [8.22358:22438]

        val input = process.inputStream
        val error = process.errorStream

[3.15488]

[8.22438]

        val input = String(process.inputStream.readAllBytes(), Charsets.UTF_8)
        val error = String(process.errorStream.readAllBytes(), Charsets.UTF_8)

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 769 [3.10972]

B:BD[8.22439] → [8.22439:22797]

        return PijulExecution(
            input.linesToFlow().onEach {
                draconConsoleWriter(project).logCommand("pijul", args, it)
            },
            error.linesToFlow().onEach {
                draconConsoleWriter(project).logCommandError("pijul", args, it)
            },
            flow {
                process.onExit().await()

[8.22439]

[8.22797]

        input.split("\n").forEach {
            draconConsoleWriter(project).logCommand("pijul", args, it)
        }

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 773 [3.10972]

B:BD[8.22798] → [8.22798:22845]

                val exit = process.exitValue()

[8.22798]

[8.22845]

        error.split("\n").forEach {
            draconConsoleWriter(project).logCommandError("pijul", args, it)
        }

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 777 [3.10972]

B:BD[8.22846] → [8.22846:23123]

                if (exit == 0) {
                    draconConsoleWriter(project).logCommand("pijul", args, "<Exit status> $exit")
                } else {
                    draconConsoleWriter(project).logCommandError("pijul", args, "<Exit status> $exit")
                }

[8.22846]

[8.23123]

        val exit = process.waitFor()
        if (exit == 0) {
            draconConsoleWriter(project).logCommand("pijul", args, "<Exit status> $exit")
        } else {
            draconConsoleWriter(project).logCommandError("pijul", args, "<Exit status> $exit")
        }

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 784 [3.10972]

B:BD[8.23124] → [8.23124:23188]

                emit(exit)
            }.flowOn(Dispatchers.IO)

[8.23124]

[8.23188]

        return PijulExecution(
            input,
            error,
            exit

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 824 [3.10972]

B:BD[3.16113] → [2.10506:10586]

        val input = process.inputStream
        val error = process.errorStream

[3.16113]

[3.16870]

        val input = String(process.inputStream.readAllBytes(), Charsets.UTF_8)
        val error = String(process.errorStream.readAllBytes(), Charsets.UTF_8)

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 827 [3.10972]

B:BD[3.16871] → [2.10587:10945]

        return PijulExecution(
            input.linesToFlow().onEach {
                draconConsoleWriter(project).logCommand("pijul", args, it)
            },
            error.linesToFlow().onEach {
                draconConsoleWriter(project).logCommandError("pijul", args, it)
            },
            flow {
                process.onExit().await()

[3.16871]

        input.split("\n").forEach {
            draconConsoleWriter(project).logCommand("pijul", args, it)
        }

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 831 [3.10972]

B:BD[3.16872] → [2.10946:10993]

                val exit = process.exitValue()

[3.16872]

[3.17143]

        error.split("\n").forEach {
            draconConsoleWriter(project).logCommandError("pijul", args, it)
        }

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 835 [3.10972]

B:BD[3.17144] → [2.10994:11271]

                if (exit == 0) {
                    draconConsoleWriter(project).logCommand("pijul", args, "<Exit status> $exit")
                } else {
                    draconConsoleWriter(project).logCommandError("pijul", args, "<Exit status> $exit")
                }

[3.17144]

[3.17311]

        val exit = process.waitFor()
        if (exit == 0) {
            draconConsoleWriter(project).logCommand("pijul", args, "<Exit status> $exit")
        } else {
            draconConsoleWriter(project).logCommandError("pijul", args, "<Exit status> $exit")
        }

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 842 [3.10972]

B:BD[3.17312] → [2.11272:11336]

                emit(exit)
            }.flowOn(Dispatchers.IO)

[3.17312]

[2.11336]

        return PijulExecution(
            input,
            error,
            exit

File addition: cache (----------)
[3.107]
File addition: persist (----------)
[0.8571]

File addition: LogEntriesPersist.kt (----------)

[0.8582]

package com.github.jonathanxd.dracon.cache.persist
import com.github.jonathanxd.dracon.log.PijulLog
import com.github.jonathanxd.dracon.log.PijulLogEntry
import com.google.gson.Gson
import com.google.gson.GsonBuilder
import com.google.gson.reflect.TypeToken
import com.intellij.util.xmlb.annotations.Property
import java.io.ByteArrayInputStream
import java.io.ByteArrayOutputStream
import java.io.ObjectInputStream
import java.io.ObjectOutputStream
import java.util.*

File addition: DraconPersistentStateComponent.kt (----------)

[0.8582]

package com.github.jonathanxd.dracon.cache.persist
import com.github.jonathanxd.dracon.log.PijulLogEntry
import com.intellij.openapi.components.*
import com.intellij.util.xmlb.XmlSerializerUtil
import java.io.*
import java.nio.file.Files
import java.nio.file.Path
import java.nio.file.StandardOpenOption
import java.util.*
import java.util.zip.GZIPInputStream
import java.util.zip.GZIPOutputStream
@State(name = "DraconLogEntries", storages = [Storage(value = StoragePathMacros.CACHE_FILE)], reloadable = true)
@Service
class DraconPersistentStateComponent() : PersistentStateComponent<DraconPersistentStateComponent> {
    public var data: String? = null
    override fun getState() = this
    override fun loadState(state: DraconPersistentStateComponent) {
        XmlSerializerUtil.copyBean(state, this);
    }
}
fun String.toPijulLogEntries(): List<PijulLogEntry> {
    val decoded = Base64.getDecoder().decode(this)
    val reader = ObjectInputStream(ByteArrayInputStream(decoded))
    return reader.readObject() as List<PijulLogEntry>
}
fun createLogEntriesPersist(entries: List<PijulLogEntry>): String {
    val stream = ByteArrayOutputStream()
    val writer = ObjectOutputStream(stream)
    writer.writeObject(entries)
    writer.close()
    return Base64.getEncoder().encodeToString(stream.toByteArray())
}
fun Path.toPijulLogEntriesMap(): Map<String, PijulLogEntry> {
    Files.newInputStream(this).use { stream ->
        GZIPInputStream(stream).use { gz ->
            ObjectInputStream(gz).use { reader ->
                return reader.readObject() as Map<String, PijulLogEntry>
            }
        }
    }
}
fun String.toPijulLogEntriesMap(): Map<String, PijulLogEntry> {
    val decoded = Base64.getDecoder().decode(this)
    val reader = ObjectInputStream(GZIPInputStream(ByteArrayInputStream(decoded)))
    return reader.readObject() as Map<String, PijulLogEntry>
}
fun Path.createLogEntriesPersist(entries: Map<String, PijulLogEntry>) {
    Files.newOutputStream(this, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING).use { writer ->
        GZIPOutputStream(writer).use { compress ->
            ObjectOutputStream(compress).use {oos ->
                oos.writeObject(entries)
            }
        }
    }
}

File addition: PijulLogEntryCache.kt (----------)

[0.8571]

package com.github.jonathanxd.dracon.cache
import com.github.jonathanxd.dracon.cache.persist.createLogEntriesPersist
import com.github.jonathanxd.dracon.cache.persist.toPijulLogEntriesMap
import com.github.jonathanxd.dracon.log.PijulLogEntry
import com.github.jonathanxd.dracon.pijul.PijulOperationResult
import com.github.jonathanxd.dracon.pijul.SuccessStatusCode
import com.intellij.openapi.project.Project
import com.intellij.openapi.project.getProjectDataPath
import java.nio.file.Files
import java.util.concurrent.ConcurrentHashMap
@Suppress("UnstableApiUsage")
class PijulLogEntryCache(val project: Project) {
    private val map = ConcurrentHashMap<String, PijulLogEntry>()
    private val cachePath = project.getProjectDataPath("com.jonathanxd.dracon")
    private val cacheFile = cachePath.resolve("log.obj")
    init {
        Files.createDirectories(cachePath)
        if (Files.exists(this.cacheFile)) {
            try {
                this.map.putAll(this.cacheFile.toPijulLogEntriesMap())
            } catch (e: Throwable) {
                Files.delete(this.cacheFile)
            }
        }
    }
    fun queryOrCompute(hash: String, compute: () -> PijulOperationResult<PijulLogEntry>): PijulOperationResult<PijulLogEntry> {
        return if (!this.map.containsKey(hash)) {
            val computeEntry = compute()
            if (computeEntry.statusCode !is SuccessStatusCode) {
                return computeEntry
            }
            this.map[hash] = computeEntry.result!!
            this.cacheFile.createLogEntriesPersist(this.map)
            computeEntry
        } else {
            PijulOperationResult("change-$hash", SuccessStatusCode, this.map[hash])
        }
    }
}

File addition: PijulCache.kt (----------)

[0.8571]

@file:Suppress("UNCHECKED_CAST")
package com.github.jonathanxd.dracon.cache
import com.github.jonathanxd.dracon.pijul.PijulExecution
import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.Executors
/**
 * Some changes are so big that it takes a long time to retrieve, refreshing the view would cause
 * the entire change tree to be retrieved again from Pijul, taking a long time again, this cache tries to alleviate
 * this by caching the result of `Pijul` command.
 *
 * It in fact, does not cache the result of `pijul` command, it could cache anything, however an update function
 * must be provided when querying the cache. The update function must be a pure function and the function identity
 * must be tied to the `key`, in other words, the `key` is the identity of the function. This constraint must never be broken,
 * because [PijulCache] does no update stored functions, the function is stored only when there is no cache data for the `key`,
 * subsequent calls will ignore the provided function.
 */
interface PijulCache {
    /**
     * Retrieves cached value, or computes if absent.
     */
    fun <K: Any, V: Any> cache(key: K, updateFn: () -> V): V
    /**
     * Request the cache to be updated, it does not mean that the cache will be updated in the time this is invoked.
     */
    fun <K: Any> requestUpdate(key: K)
}
class HashMapCache : PijulCache {
    private val cache = ConcurrentHashMap<Any, Cache<*>>()
    private val updateExecutor = Executors.newCachedThreadPool()
    override fun <K: Any, V: Any> cache(key: K, updateFn: () -> V): V {
        return (this.cache.computeIfAbsent(key) {
            val update = updateFn()
            Cache(update, updateFn)
        } as Cache<V>).value
    }
    override fun <K : Any> requestUpdate(key: K) {
        val fn = this.cache[key]?.updateFn
        if (fn != null) {
            updateExecutor.submit {
                val updated = fn()
                this.cache[key] = Cache(updated, fn)
            }
        }
    }
}
data class HashKey(val hash: String)
data class Cache<V: Any>(var value: V, var updateFn: (() -> V)?)
data class CommandResult(val stdOut: String, val stdErr: String)

Dependencies

In channels

Change contents

Deletion in src/main/kotlin/com/github/jonathanxd/dracon/pijul/PijulExecution.kt at line 12 [3.4043]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/pijul/PijulExecution.kt at line 14 [3.4043]

Insertion in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 4 [5.1965]

Insertion in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 7 [5.1965]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 14 [5.1965]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 24 [5.1965]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 34 [5.1965]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 36 [5.1965]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 41 [5.1965]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 48 [5.1965]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 50 [5.1965]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 73 [5.1965]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 97 [5.1965]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 113 [5.1965]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 128 [5.1965]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 141 [5.1965]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 156 [5.1965]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 171 [5.1965]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 185 [5.1965]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 200 [5.1965]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 215 [5.1965]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 225 [5.1965]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 232 [5.1965]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 236 [5.1965]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 238 [5.1965]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 246 [5.1965]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 248 [5.1965]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 264 [5.1965]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 266 [5.1965]

Insertion in src/main/kotlin/com/github/jonathanxd/dracon/log/PijulLog.kt at line 284 [5.1965]