class PijulVcsFileRevision(val project: Project,

class PijulVcsFileRevision constructor(val project: Project,

    project, entry.id, emptyList(), entry.commitTime, rootFile, entry.subject, entry.author,

    project, entry.id, emptyList() /*entry.getPijulParents()*/, entry.commitTime, rootFile, entry.subject, entry.author,

                // Use empty parents since Pijul hierarchy is not linear
                // this leads to a problem shown in the [pijul-log-tree.png] file.
                val parents = emptyList<Hash>()//it.parents

                        emptyList(),

                        parents,

    val path: String,
    val rootPath: String,

    val path: Filename,
    val rootPath: FileDir,

                this.rootPath == "/" -> this.path
                this.rootPath.endsWith("/") -> this.rootPath + this.path
                this.rootPath.isEmpty() -> this.path
                else -> this.rootPath + "/" + this.path

                this.rootPath.dir == "/" -> this.path.name
                this.rootPath.dir.endsWith("/") -> (this.rootPath + this.path).fullPath
                this.rootPath.dir.isEmpty() -> this.path.name
                else -> (this.rootPath + this.path).fullPath

    val path: String,

    val path: FilePath,

        get() = this.path

        get() = this.path.fullPath

    val path: String,

    val path: FilePath,

        get() = this.path

        get() = this.path.fullPath

    val older: String,
    val new: String,

    val older: FilePath,
    val new: FilePath,

        get() = this.new

        get() = this.new.fullPath

    val path: String,

    val path: FilePath,

        get() = this.path

        get() = this.path.fullPath

    val path: String,

    val path: FilePath,

        get() = this.path

        get() = this.path.fullPath

    val path: String,

    val path: FilePath,

        get() = this.path

        get() = this.path.fullPath

    val path: String,

    val path: FilePath,

        get() = this.path

        get() = this.path.fullPath

    val path: String,

    val path: FilePath,

        get() = this.path

        get() = this.path.fullPath

val HUNK_ZOMBIE_PATTERN = Regex("(\\d+)\\. Resurrecting zombie lines in (\"[^\"]+\"):(\\d+) (\\d+\\.\\d+)\\n?")

val CHANGE_PATTERN = Regex("([-+]) (.*)\\n?")

// Corner case: :D 9.1256 -> 4.12200:12305/9, B:BD 4.12200 -> 4.12200:12305/4

val FLAG_PATTERN = Regex("([BFD]+:[BFD]+ [^\\n]+)\\n?")

val FLAG_PATTERN = Regex("(([BFD]+:[BFD]+ [^\\n]+)|(:[BFD]+ [^\\n]+))\\n?")

                val fileOrPath = add.fileName
                val rootPath = add.path

                val fileOrPath = add.fileName.parseFilename()
                val rootPath = add.path.parseFileDir()

                val path = remove.fileName

                val path = remove.fileName.parseFilePath()

                val path = undel.fileName

                val path = undel.fileName.parseFilePath()

                val new = move.new
                val old = move.old

                val new = move.new.parseFilePath()
                val old = move.old.parseFilePath()

                val path = edit.file

                val path = edit.file.parseFilePath()

                val path = replacement.fileName

                val path = replacement.fileName.parseFilePath()

                val path = nameConflict.fileName

                val path = nameConflict.fileName.parseFilePath()

                val path = orderConflict.fileName

                val path = orderConflict.fileName.parseFilePath()

                val path = zombieLines.fileName

                val path = zombieLines.fileName.parseFilePath()

// Corner case: 120. File addition: "coroutine" in "src/main/kotlin/com/github/jonathanxd/dracon" +dx "binary"

    Regex("(?<changeNumber>\\d+)\\. File addition: (\"(?<file>.*)(?:\" )+)in (\"(?<path>.*)(?:\" )+)(\"(?<encoding>[^\"]+)\")(?<meta> [^ ]+)?\\n?")

    Regex("(?<changeNumber>\\d+)\\. File addition: (\"(?<file>.*)(?:\" )+)in (\"(?<path>.*)(?:\" )+)(?<mode>[^ ]+)?( ?\"(?<encoding>[^\"]+)\")(?<meta> [^ ]+)?\\n?")

// Corner case: 9. Moved: "src/main/kotlin/com/github/jonathanxd/dracon/handler" "handler" +dx 7.107

    Regex("(?<changeNumber>\\d+)\\. Moved: (\"(?<old>.*)(?:\" )+)(\"(?<new>.*)(?:\" )+)(?<inode>\\d+\\.\\d+)([^ ]+ )?( \"(?<encoding>[^\"]+)\")?([^ ]+ )?(?<meta>.*)\\n?")

    Regex("(?<changeNumber>\\d+)\\. Moved: (\"(?<old>.*)(?:\" )+)(\"(?<new>.*)(?:\" )+)((?<mode>[^ ]+) )?(?<inode>\\d+\\.\\d+)([^ ]+ )?( \"(?<encoding>[^\"]+)\")?([^ ]+ )?(?<meta>.*)\\n?")

    val mode: String? get() = matchResult.groups["mode"]?.value

    val mode: String? get() = matchResult.groups["mode"]?.value

package com.github.jonathanxd.dracon.log
import com.github.jonathanxd.dracon.cmd.removeTrailingSlash
@JvmInline
value class Filename(val name: String)
@JvmInline
value class FileDir(val dir: String)
@JvmInline
value class FilePath(val fullPath: String)
//\"src/test/kotlin/com/github/jonathanxd/dracon/test/DraconTest.kt\"
fun String.parseFilePath(): FilePath = FilePath(this.unescape())
fun String.parseFilename(): Filename = Filename(this.unescape())
fun String.parseFileDir(): FileDir = FileDir(this.unescape())
operator fun FileDir.plus(name: Filename) =
    FilePath(this.dir.resolve(name.name))
operator fun FileDir.plus(name: FilePath) =
    FilePath(this.dir.resolve(name.fullPath))
operator fun FilePath.plus(name: FilePath) =
    FilePath(this.fullPath.resolve(name.fullPath))
fun String.resolve(other: String) =
    "${this.removePathTrailingSlash()}/${other.removePathLeadingSlash()}"
const val ESCAPED_STRING_PREFIX = """\""""
fun String.unescape(): String =
    if (this.startsWith(ESCAPED_STRING_PREFIX) && this.endsWith(ESCAPED_STRING_PREFIX))
        this.substring(ESCAPED_STRING_PREFIX.length, this.length - ESCAPED_STRING_PREFIX.length)
    else this
private fun String.removePathTrailingSlash() =
    if (this.endsWith("/")) this.substring(0, this.lastIndex)
    else this
private fun String.removePathLeadingSlash() =
    if (this.startsWith("/")) this.substring(1, this.length)
    else this

    override val cache = DataCache<String, PijulRevisionNumber>(project, "revision")

    override val cache = ActorDataCache<String, PijulRevisionNumber>(project, "revision")

    override val cache = DataCache<String, PijulLogEntry>(project, "path_change")

    override val cache = ActorDataCache<String, PijulLogEntry>(project, "path_change")

    override val cache = DataCache<String, PijulLogEntry>(project, "change")

    override val cache = ActorDataCache<String, PijulLogEntry>(project, "change")

    override val cache = DataCache<String, CacheablePijulFileStatus>(this.project, "file_status")

    override val cache = ActorDataCache<String, CacheablePijulFileStatus>(this.project, "file_status")

        this.cache.lock()
        try {

        this.cache.withLock {

        } finally {
            this.cache.unlock()

const val DATA_CACHE_VERSION: Long = 2

const val DATA_CACHE_VERSION: Long = 3

// Do async, accept MISS while locked
// cache storage is very slow due to compression

                        return if (version != version) {

                        return if (version != this.version) {

    val cache: DataCache<K, V>

    val cache: ActorDataCache<K, V>
    /**
     * Executes an operation in [cache] using the **cache write lock**.
     *
     * This does not guarantee absolute lock over the file caching mechanism.
     */
    fun <R> withLock(f: () -> R): R =
        this.cache.withLock(f)

package com.github.jonathanxd.dracon.cache
import com.github.jonathanxd.dracon.coroutine.DRACON_SCHEDULER
import com.intellij.execution.process.mediator.util.blockingGet
import com.intellij.openapi.project.Project
import com.intellij.openapi.project.getProjectDataPath
import kotlinx.coroutines.*
import kotlinx.coroutines.channels.actor
import kotlinx.coroutines.channels.trySendBlocking
import java.io.ObjectInputStream
import java.io.ObjectOutputStream
import java.nio.file.Files
import java.nio.file.Path
import java.nio.file.StandardOpenOption
import java.time.Instant
import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.Executors
import java.util.concurrent.locks.ReentrantLock
import java.util.zip.GZIPInputStream
import java.util.zip.GZIPOutputStream
import kotlin.concurrent.withLock
/**
 * Denotes the current version of data cache, must be updated when data cache format changes.
 */
const val ACTOR_DATA_CACHE_VERSION: Long = 3
/**
 * Actor based data cache storage, with support to cache misses and falling back to default resolver,
 * this allows writes to on-file cached to lock without freezing IntelliJ IDEA (when request for data happens in UI-thread).
 */
class ActorDataCache<K, V>(val project: Project,
                     val name: String) {
    private val cachePath = project.getProjectDataPath("com.github.jonathanxd.dracon")
    private val cacheFile = cachePath.resolve("$name.gz")
    private val manager = ActorDataCacheManager<K, CachedValue<V>>(this.cacheFile, DATA_CACHE_VERSION)
    private val lock = ReentrantLock()
    private val updateExecutor = Executors.newSingleThreadExecutor()
    private val inMemory = ConcurrentHashMap<K, CachedValue<V>>()
    init {
        this.manager.load {
            inMemory.putAll(it)
        }
    }
    /**
     * Executes
     */
    fun <R> withLock(f: () -> R) = this.lock.withLock(f)
    fun unload(key: K) {
        this.lock.withLock {
            this.inMemory.remove(key)
        }
        writeToDisk()
    }
    fun queryOrLoad(key: K, compute: (K) -> V): V {
        return this.lock.withLock {
            if (!this.inMemory.containsKey(key)) {
                val computeEntry = CachedValue(Instant.now(), compute(key))
                this.inMemory[key] = computeEntry
                writeToDisk()
                computeEntry
            } else {
                this.inMemory[key]!!
            }.value
        }
    }
    fun <I> queryOrLoad(key: K,
                        compute: (K) -> I,
                        filter: (I) -> Boolean,
                        iMapper: (I) -> V,
                        vMapper: (V) -> I): I {
        return this.lock.withLock {
            if (!this.inMemory.containsKey(key)) {
                val computeEntry = compute(key)
                if (!filter(computeEntry)) {
                    return computeEntry
                }
                this.inMemory[key] = CachedValue(Instant.now(), iMapper(computeEntry!!))
                writeToDisk()
                computeEntry
            } else {
                vMapper(this.inMemory[key]!!.value)
            }
        }
    }
    /**
     * This call completes asynchronously.
     */
    private fun writeToDisk() {
        this.manager.write(this.inMemory)
    }
    /**
     * @see CacheService.invalidate
     */
    fun invalidate() {
        this.lock.withLock {
            this.inMemory.clear()
            this.writeToDisk()
        }
    }
    /**
     * @see CacheService.invalidate
     */
    fun invalidate(key: K) {
        this.lock.withLock {
            this.inMemory.remove(key)
            this.writeToDisk()
        }
    }
    /**
     * @see CacheService.updateCache
     */
    fun updateCache(key: K, newValueCompute: () -> V) {
        val instant = Instant.now()
        this.lock.withLock {
            val inMemoryValue = this.inMemory[key]
            if (inMemoryValue == null || inMemoryValue.instant.isBefore(instant)) {
                this.inMemory[key] = CachedValue(instant, newValueCompute())
            }
        }
    }
    /**
     * @see CacheService.updateCache
     */
    fun updateCache(keys: List<K>, newValueCompute: (K) -> V) {
        val instant = Instant.now()
        this.lock.withLock {
            for (key in keys) {
                val inMemoryValue = this.inMemory[key]
                if (inMemoryValue == null || inMemoryValue.instant.isBefore(instant)) {
                    this.inMemory[key] = CachedValue(instant, newValueCompute(key))
                }
            }
        }
    }
}
sealed class CacheCommand<K, V> {
    class CacheLoad<K, V>(val completion: CompletableDeferred<Map<K, V>?>): CacheCommand<K, V>()
    class CacheSave<K, V>(val data: Map<K, V>, val completion: CompletableDeferred<Unit>): CacheCommand<K, V>()
}
// Do async, accept MISS while locked
// cache storage is very slow due to compression
class ActorDataCacheManager<K, V>(val path: Path, val version: Long) {
    @Suppress("BlockingMethodInNonBlockingContext")
    private val loader = CoroutineScope(Dispatchers.IO).actor<CacheCommand<K, V>> {
        for (msg in channel) {
            when (msg) {
                is CacheCommand.CacheLoad<K, V> -> {
                    msg.completion.complete(if (!Files.exists(path)) {
                        null
                    } else {
                        try {
                            Files.newInputStream(path).use { stream ->
                                GZIPInputStream(stream).use { gz ->
                                    ObjectInputStream(gz).use { reader ->
                                        val version = reader.readLong()
                                        if (version != this@ActorDataCacheManager.version) {
                                            emptyMap()
                                        } else {
                                            reader.readObject() as Map<K, V>
                                        }
                                    }
                                }
                            }
                        } catch (t: Throwable) {
                            t.printStackTrace()
                            Files.delete(path)
                            null
                        }
                    })
                }
                is CacheCommand.CacheSave<K, V> -> {
                    Files.newOutputStream(path, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING).use { writer ->
                        GZIPOutputStream(writer).use { compress ->
                            ObjectOutputStream(compress).use { oos ->
                                oos.writeLong(this@ActorDataCacheManager.version)
                                oos.writeObject(msg.data)
                                msg.completion.complete(Unit)
                            }
                        }
                    }
                }
            }
        }
    }
    init {
        Files.createDirectories(this.path.parent)
    }
    fun load(onLoad: suspend (Map<K, V>) -> Unit) {
        CoroutineScope(DRACON_SCHEDULER).launch {
            val complete = CompletableDeferred<Map<K, V>?>()
            loader.send(CacheCommand.CacheLoad(complete))
            val load = complete.await()
            if (load != null) {
                onLoad(load)
            }
        }
    }
    fun write(data: Map<K, V>, onComplete: suspend () -> Unit = {}) {
        CoroutineScope(DRACON_SCHEDULER).launch {
            val complete = CompletableDeferred<Unit>()
            loader.send(CacheCommand.CacheSave(data, complete))
            complete.await()
            onComplete()
        }
    }
}

Dracon is in a heavily experimental state, and it depends on latest IDEA EAP build.

Dracon is in a heavily experimental state, and it depends on IntelliJ 212.5284.40.

### Dracon log history does not show related records
Dracon shows history like:
![](pijul-no-log-tree.png)
Instead of something link:
![](pijul-log-tree-would-be.png)
This is because the relation of Pijul patches are not linear, because of this, the following happens when
we try to correctly build the relation between records:
![](pijul-log-tree.png)