Jonathan/Dracon - Change A7IL6I3VCB3F3QMYQFPXBL33DN5XDGGQPZIBZRHYSQBSIUBBFQJQC

More files to support .ignore

Created by Jonathan on April 4, 2021

A7IL6I3VCB3F3QMYQFPXBL33DN5XDGGQPZIBZRHYSQBSIUBBFQJQC

Dependencies

In channels

main

Change contents

Insertion in src/main/resources/META-INF/plugin.xml at line 31 [3.1490]

[2.9510]

        <vcsRepositoryCreator implementation="com.github.jonathanxd.dracon.repository.PijulRepositoryCreator"/>
        <vcsRepositoryInitializer implementation="com.github.jonathanxd.dracon.repository.PijulRepositoryInit"/>
        <vcs.ignoredFilesHolder implementation="com.github.jonathanxd.dracon.ignore.PijulIgnoredFileHolderProvider"/>
        <ignoredFileContentProvider implementation="com.github.jonathanxd.dracon.ignore.PijulIgnoredFileContentProvider"/>

Insertion in src/main/kotlin/com/github/jonathanxd/dracon/vfs/PijulVirtualFileStatusProvider.kt at line 14 [6.151]
[4.1956]
[5.0]
```
import com.github.jonathanxd.dracon.context.PijulVcsContext
import com.github.jonathanxd.dracon.ignore.IgnoreUtil
```

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/vfs/PijulVirtualFileStatusProvider.kt at line 45 [6.151]

B:BD[7.250] → [8.1183:1209]

            status.result

[7.250]

[7.298]

            if (status.result == FileStatus.UNKNOWN && isIgnored(virtualFile)) {
                FileStatus.IGNORED
            } else {
                status.result
            }

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/vfs/PijulVirtualFileStatusProvider.kt at line 51 [6.151]

B:BD[7.315] → [5.193:210]

            null

[7.315]

[8.1210]

            if (isIgnored(virtualFile)) {
                FileStatus.IGNORED
            } else {
                null
            }

Insertion in src/main/kotlin/com/github/jonathanxd/dracon/vfs/PijulVirtualFileStatusProvider.kt at line 59 [6.151]

[4.2430]

    fun isIgnored(virtualFile: VirtualFile) =
        IgnoreUtil.ignoredFiles(this.project.service<PijulVcsContext>().root, emptyList())
            .any { it == Paths.get(VcsUtil.getFilePath(virtualFile).path) }

File addition: repository (----------)
[6.107]

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

[0.1127]

package com.github.jonathanxd.dracon.repository
import com.github.jonathanxd.dracon.PijulVcs
import com.github.jonathanxd.dracon.pijulVcs
import com.intellij.dvcs.repo.AbstractRepositoryManager
import com.intellij.openapi.components.Service
import com.intellij.openapi.components.service
import com.intellij.openapi.project.Project
@Service
class PijulRepositoryManager(project: Project) : AbstractRepositoryManager<PijulRepository>(
    pijulVcs(project), ".pijul"
) {
    override fun getRepositories(): MutableList<PijulRepository> =
        this.getRepositories(PijulRepository::class.java)
    override fun isSyncEnabled(): Boolean =
        true
}

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

[0.1127]

package com.github.jonathanxd.dracon.repository
import com.github.jonathanxd.dracon.PijulVcs
import com.github.jonathanxd.dracon.pijul.Pijul
import com.github.jonathanxd.dracon.pijul.SuccessStatusCode
import com.github.jonathanxd.dracon.pijul.pijul
import com.intellij.dvcs.repo.Repository
import com.intellij.dvcs.repo.VcsRepositoryCreator
import com.intellij.openapi.Disposable
import com.intellij.openapi.project.Project
import com.intellij.openapi.project.ProjectManager
import com.intellij.openapi.vcs.VcsException
import com.intellij.openapi.vcs.VcsKey
import com.intellij.openapi.vfs.VirtualFile
import com.intellij.vcs.VcsRepositoryInitializer
import java.io.File
class PijulRepositoryInit : VcsRepositoryInitializer {
    override fun initRepository(rootDir: File) {
        val project = ProjectManager.getInstance().defaultProject
        val result = pijul(project).init(project, rootDir.toPath())
        if (result.statusCode !is SuccessStatusCode) {
            throw VcsException(result.toString())
        }
    }
    override fun getSupportedVcs(): VcsKey =
        PijulVcs.KEY
}

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

[0.1127]

package com.github.jonathanxd.dracon.repository
import com.github.jonathanxd.dracon.PijulVcs
import com.github.jonathanxd.dracon.pijul.Pijul
import com.intellij.dvcs.repo.Repository
import com.intellij.dvcs.repo.VcsRepositoryCreator
import com.intellij.openapi.Disposable
import com.intellij.openapi.project.Project
import com.intellij.openapi.vcs.VcsKey
import com.intellij.openapi.vfs.VirtualFile
class PijulRepositoryCreator : VcsRepositoryCreator {
    override fun createRepositoryIfValid(
        project: Project,
        root: VirtualFile,
        parentDisposable: Disposable
    ): Repository? =
        if (Pijul.isUnderPijul(root)) PijulRepository(project, root, parentDisposable) else null
    override fun getVcsKey(): VcsKey = PijulVcs.KEY
}

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

[0.1127]

package com.github.jonathanxd.dracon.repository
import com.github.jonathanxd.dracon.PijulVcs
import com.github.jonathanxd.dracon.ignore.PijulLocalIgnoredFileHolder
import com.github.jonathanxd.dracon.pijul.pijul
import com.github.jonathanxd.dracon.pijulVcs
import com.intellij.dvcs.ignore.VcsIgnoredHolderUpdateListener
import com.intellij.dvcs.ignore.VcsRepositoryIgnoredFilesHolder
import com.intellij.dvcs.repo.Repository
import com.intellij.dvcs.repo.RepositoryImpl
import com.intellij.openapi.Disposable
import com.intellij.openapi.components.service
import com.intellij.openapi.project.Project
import com.intellij.openapi.util.Disposer
import com.intellij.openapi.vcs.AbstractVcs
import com.intellij.openapi.vcs.FilePath
import com.intellij.openapi.vcs.changes.ChangesViewI
import com.intellij.openapi.vcs.changes.ChangesViewManager
import com.intellij.openapi.vfs.VirtualFile
import org.jetbrains.annotations.NotNull
class PijulRepository(project: @NotNull Project, dir: @NotNull VirtualFile, parentDisposable: @NotNull Disposable) :
    RepositoryImpl(project, dir, parentDisposable) {
    private val vcs = pijulVcs(project)
    private val localIgnoredHolder: PijulLocalIgnoredFileHolder by lazy {
        PijulLocalIgnoredFileHolder(this, project.service())
    }
    init {
        localIgnoredHolder.setupListeners()
        Disposer.register(this, localIgnoredHolder)
        localIgnoredHolder.addUpdateStateListener(
            MyIgnoredHolderAsyncListener(
                getProject()
            )
        )
        update()
    }
    companion object {
        fun getInstance(
            root: VirtualFile,
            project: Project,
            parentDisposable: Disposable
        ): PijulRepository {
            val repository = PijulRepository(project, root, parentDisposable)
            return repository
        }
    }
    override fun getState(): Repository.State = Repository.State.NORMAL
    override fun getCurrentBranchName(): String? =
        pijul(this.project).channel(project, project.baseDir).result?.channels?.firstOrNull { it.current }?.name
    override fun getVcs(): AbstractVcs =
        this.vcs
    override fun getCurrentRevision(): String? =
        pijul(this.project).latestRevisionNumber(project, project.baseDir).result?.hash
    override fun update() {
    }
    fun getIgnoredFilesHolder(): VcsRepositoryIgnoredFilesHolder =
        this.localIgnoredHolder
    override fun toLogString(): String =
        "PijulRepository ${this.root}"
    private class MyIgnoredHolderAsyncListener(project: Project) :
        VcsIgnoredHolderUpdateListener {
        private val changesViewI: ChangesViewI
        private val project: Project
        override fun updateStarted() {
            changesViewI.scheduleRefresh()
        }
        override fun updateFinished(ignoredPaths: Collection<FilePath>, isFullRescan: Boolean) {
            if (project.isDisposed) return
            changesViewI.scheduleRefresh()
        }
        init {
            changesViewI = ChangesViewManager.getInstance(project)
            this.project = project
        }
    }
}

File move: credit (----------) → credit (d--x------)
BF:BFD[6.3420] → [2.19685:19693]
[6.3420]
[2.19694]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/pijul/PijulOperationResult.kt at line 28 [6.3629]

B:BD[9.12980] → [9.12980:12981]

[9.12980]

    fun <Y> andThen(other: (R) -> PijulOperationResult<Y>): PijulOperationResult<Y> {
        return if (this.statusCode !is SuccessStatusCode) {
            this as PijulOperationResult<Y>
        } else {
            other(this.result!!)
        }
    }
    fun <Y> andThenValue(other: (R) -> Y): PijulOperationResult<Y> {
        return if (this.statusCode !is SuccessStatusCode) {
            this as PijulOperationResult<Y>
        } else {
            PijulOperationResult(operation, statusCode, other(this.result!!))
        }
    }
}
fun <R, Y> PijulOperationResult<List<R>>.mapEvery(f: (R) -> Y): PijulOperationResult<List<Y>> =
    this.map { it.map(f) }

Insertion in src/main/kotlin/com/github/jonathanxd/dracon/pijul/Pijul.kt at line 78 [6.4428]

[6.6586]


    @RequiresBackgroundThread
    fun init(project: Project, root: Path): PijulOperationResult<Unit>

Insertion in src/main/kotlin/com/github/jonathanxd/dracon/pijul/Pijul.kt at line 186 [6.4428]
[2.23017]
[6.6839]
```
    fun untrackedFiles(project: Project, root: Path): PijulOperationResult<List<Path>>
```
File move: lang (----------) → lang (d--x------)
BF:BFD[6.107] → [2.23270:23276]
[6.107]
[2.23277]
File move: ignore (----------) → ignore (d--x------)
BF:BFD[2.23277] → [2.23278:23286]
[2.23277]
[2.23287]
File move: ignore (----------) → ignore (d--x------)
BF:BFD[6.107] → [2.24023:24031]
[6.107]
[2.24032]

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

[2.24032]

package com.github.jonathanxd.dracon.ignore
import com.github.jonathanxd.dracon.context.PijulVcsContext
import com.github.jonathanxd.dracon.repository.PijulRepository
import com.github.jonathanxd.dracon.repository.PijulRepositoryManager
import com.intellij.dvcs.ignore.VcsRepositoryIgnoredFilesHolderBase
import com.intellij.openapi.components.service
import com.intellij.openapi.project.ProjectManager
import com.intellij.openapi.util.registry.Registry
import com.intellij.openapi.vcs.FilePath
import com.intellij.openapi.vcs.LocalFilePath
import com.intellij.openapi.vcs.VcsException
import java.nio.file.Files
import java.nio.file.Paths
import java.util.ArrayList
import java.util.HashSet
class PijulLocalIgnoredFileHolder(repository: PijulRepository, repositoryManager: PijulRepositoryManager) :
    VcsRepositoryIgnoredFilesHolderBase<PijulRepository>(repository, repositoryManager) {
    @Throws(VcsException::class)
    override fun requestIgnored(paths: Collection<FilePath>?): Set<FilePath> {
        val ctx = repository.project.service<PijulVcsContext>()
        val ignored: MutableSet<FilePath> = HashSet()
        ignored.addAll(
            IgnoreUtil.ignoredFiles(ctx.root, paths?.map { Paths.get(it.path) }.orEmpty())
                .map { LocalFilePath(it, Files.isDirectory(it)) }
        )
        return ignored
    }
    override fun scanTurnedOff(): Boolean {
        return false
    }
}

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

[2.24032]

package com.github.jonathanxd.dracon.ignore
import com.github.jonathanxd.dracon.PijulVcs
import com.github.jonathanxd.dracon.pijulVcs
import com.github.jonathanxd.dracon.repository.PijulRepository
import com.github.jonathanxd.dracon.repository.PijulRepositoryManager
import com.intellij.dvcs.ignore.VcsIgnoredFilesHolderBase
import com.intellij.dvcs.ignore.VcsRepositoryIgnoredFilesHolder
import com.intellij.openapi.components.service
import com.intellij.openapi.project.Project
import com.intellij.openapi.vcs.AbstractVcs
import com.intellij.openapi.vcs.changes.ChangesViewRefresher
import com.intellij.openapi.vcs.changes.FileHolder
import com.intellij.openapi.vcs.changes.VcsIgnoredFilesHolder
class PijulIgnoredFileHolder(private val project: Project, val manager: PijulRepositoryManager) :
    VcsIgnoredFilesHolderBase<PijulRepository>(manager) {
    override fun getHolder(repository: PijulRepository): VcsRepositoryIgnoredFilesHolder {
        return repository.getIgnoredFilesHolder()
    }
    override fun copy(): FileHolder {
        return PijulIgnoredFileHolder(project, manager) // re-scan roots on refresh
    }
}
class PijulIgnoredFileHolderProvider(private val project: Project) : VcsIgnoredFilesHolder.Provider,
    ChangesViewRefresher {
    private val vcs = pijulVcs(project)
    private val manager by lazy {
        project.service<PijulRepositoryManager>()
    }
    override fun getVcs(): AbstractVcs {
        return vcs
    }
    override fun createHolder(): VcsIgnoredFilesHolder {
        return PijulIgnoredFileHolder(project, manager)
    }
    override fun refresh(project: Project) {
        manager.repositories.forEach { r -> r.getIgnoredFilesHolder().startRescan() }
    }
}

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

[2.24032]

package com.github.jonathanxd.dracon.ignore
import com.github.jonathanxd.dracon.PijulVcs
import com.github.jonathanxd.dracon.pijul.Pijul
import com.github.jonathanxd.dracon.pijul.pijul
import com.intellij.openapi.diagnostic.logger
import com.intellij.openapi.project.Project
import com.intellij.openapi.util.Comparing
import com.intellij.openapi.util.NlsSafe
import com.intellij.openapi.util.io.FileUtil
import com.intellij.openapi.vcs.FilePath
import com.intellij.openapi.vcs.LocalFilePath
import com.intellij.openapi.vcs.VcsException
import com.intellij.openapi.vcs.VcsKey
import com.intellij.openapi.vcs.actions.VcsContextFactory
import com.intellij.openapi.vcs.changes.IgnoreSettingsType
import com.intellij.openapi.vcs.changes.IgnoredFileContentProvider
import com.intellij.openapi.vcs.changes.IgnoredFileDescriptor
import com.intellij.openapi.vcs.changes.IgnoredFileProvider
import com.intellij.openapi.vfs.VirtualFile
import com.intellij.vcsUtil.VcsUtil
import java.nio.file.Files
import java.nio.file.Paths
private val LOG = logger<PijulIgnoredFileContentProvider>()
class PijulIgnoredFileContentProvider(private val project: Project) : IgnoredFileContentProvider {
    override fun getSupportedVcs(): VcsKey = PijulVcs.KEY
    override fun getFileName() = ".ignore"
    override fun buildIgnoreFileContent(
        ignoreFileRoot: VirtualFile,
        ignoredFileProviders: Array<IgnoredFileProvider>
    ): String {
        if (!Pijul.isUnderPijul(ignoreFileRoot)) return ""
        val repoRoot = VcsUtil.getVcsRootFor(project, ignoreFileRoot)
        if (repoRoot == null || repoRoot != ignoreFileRoot) return ""
        val content = StringBuilder()
        val lineSeparator = System.lineSeparator()
        val untrackedFiles = getUntrackedFiles(repoRoot, VcsUtil.getFilePath(ignoreFileRoot))
        if (untrackedFiles.isEmpty()) return ""
        for (provider in ignoredFileProviders) {
            val ignoredFiles =
                provider.getIgnoredFiles(project).ignoreBeansToRelativePaths(ignoreFileRoot, untrackedFiles)
            if (ignoredFiles.isEmpty()) continue
            if (content.isNotEmpty()) {
                content.append(lineSeparator).append(lineSeparator)
            }
            val description = provider.ignoredGroupDescription
            if (description.isNotBlank()) {
                content.append(buildIgnoreGroupDescription(provider))
                content.append(lineSeparator)
            }
            content.append(ignoredFiles.joinToString(lineSeparator))
        }
        return content.toString()//if (content.isNotEmpty()) "syntax: glob$lineSeparator$lineSeparator$content" else ""
    }
    private fun getUntrackedFiles(root: VirtualFile, ignoreFileRoot: FilePath): Set<FilePath> =
        try {
            val rootPath = Paths.get(VcsUtil.getFilePath(root).path)
            HashSet(
                pijul(project).untrackedFiles(project, rootPath)
                    .result!!
                    .map {
                        LocalFilePath(it, Files.isDirectory(it))
                    }.filter {
                        isAncestor(ignoreFileRoot, it, true)
                    }
            )
        } catch (e: VcsException) {
            LOG.warn("Cannot get untracked files: ", e)
            emptySet()
        }
    fun isAncestor(ancestor: FilePath, file: FilePath, strict: Boolean): Boolean {
        var parent = if (strict) file.parentPath else file
        while (true) {
            if (parent == null) return false
            if (parent == ancestor) return true
            parent = parent.parentPath
        }
    }
    private fun Iterable<IgnoredFileDescriptor>.ignoreBeansToRelativePaths(
        ignoreFileRoot: VirtualFile,
        untrackedFiles: Set<FilePath>
    ): List<String> {
        val vcsRoot = VcsUtil.getVcsRootFor(project, ignoreFileRoot)
        val vcsContextFactory = VcsContextFactory.SERVICE.getInstance()
        return filter { ignoredBean ->
            when (ignoredBean.type) {
                IgnoreSettingsType.UNDER_DIR -> shouldIgnoreUnderDir(
                    ignoredBean,
                    untrackedFiles,
                    ignoreFileRoot,
                    vcsRoot,
                    vcsContextFactory
                )
                IgnoreSettingsType.FILE -> shouldIgnoreFile(
                    ignoredBean,
                    untrackedFiles,
                    ignoreFileRoot,
                    vcsRoot,
                    vcsContextFactory
                )
                IgnoreSettingsType.MASK -> shouldIgnoreByMask(ignoredBean, untrackedFiles)
            }
        }.map { ignoredBean ->
            when (ignoredBean.type) {
                IgnoreSettingsType.MASK -> ignoredBean.mask!!
                IgnoreSettingsType.UNDER_DIR -> buildIgnoreEntryContent(ignoreFileRoot, ignoredBean)
                IgnoreSettingsType.FILE -> buildIgnoreEntryContent(ignoreFileRoot, ignoredBean)
            }
        }
    }
    private fun shouldIgnoreUnderDir(
        ignoredBean: IgnoredFileDescriptor,
        untrackedFiles: Set<FilePath>,
        ignoreFileRoot: VirtualFile,
        vcsRoot: VirtualFile?,
        vcsContextFactory: VcsContextFactory
    ) =
        FileUtil.exists(ignoredBean.path)
                && untrackedFiles.any { FileUtil.isAncestor(ignoredBean.path!!, it.path, true) }
                && FileUtil.isAncestor(ignoreFileRoot.path, ignoredBean.path!!, false)
                && Comparing.equal(
            vcsRoot,
            VcsUtil.getVcsRootFor(project, vcsContextFactory.createFilePath(ignoredBean.path!!, true))
        )
    private fun shouldIgnoreFile(
        ignoredBean: IgnoredFileDescriptor,
        untrackedFiles: Set<FilePath>,
        ignoreFileRoot: VirtualFile,
        vcsRoot: VirtualFile?,
        vcsContextFactory: VcsContextFactory
    ) =
        FileUtil.exists(ignoredBean.path)
                && untrackedFiles.any { ignoredBean.matchesFile(it) }
                && FileUtil.isAncestor(ignoreFileRoot.path, ignoredBean.path!!, false)
                && Comparing.equal(
            vcsRoot,
            VcsUtil.getVcsRootFor(project, vcsContextFactory.createFilePath(ignoredBean.path!!, false))
        )
    private fun shouldIgnoreByMask(ignoredBean: IgnoredFileDescriptor, untrackedFiles: Set<FilePath>) =
        untrackedFiles.any { ignoredBean.matchesFile(it) }
    override fun buildUnignoreContent(ignorePattern: String) = throw UnsupportedOperationException()
    override fun buildIgnoreGroupDescription(ignoredFileProvider: IgnoredFileProvider) =
        prependCommentHashCharacterIfNeeded(ignoredFileProvider.ignoredGroupDescription)
    override fun buildIgnoreEntryContent(ignoreEntryRoot: VirtualFile, ignoredFileDescriptor: IgnoredFileDescriptor) =
        FileUtil.getRelativePath(ignoreEntryRoot.path, ignoredFileDescriptor.path!!, '/') ?: ""
    override fun supportIgnoreFileNotInVcsRoot() = false
    private fun prependCommentHashCharacterIfNeeded(description: @NlsSafe String): @NlsSafe String =
        if (description.startsWith("#")) description else "# $description"
}

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

[2.24032]

package com.github.jonathanxd.dracon.ignore
import java.nio.file.FileVisitOption
import java.nio.file.Files
import java.nio.file.Path
import kotlin.io.path.ExperimentalPathApi
import kotlin.io.path.relativeTo
import kotlin.streams.toList
object IgnoreUtil {
    @OptIn(ExperimentalPathApi::class)
    fun ignoredFiles(root: Path, paths: List<Path>): List<Path> {
        val ignore = root.resolve(".ignore")
        return if (Files.exists(ignore) && Files.isRegularFile(ignore)) {
            val lines = Files.readAllLines(ignore, Charsets.UTF_8)
            Files.walk(root, FileVisitOption.FOLLOW_LINKS)
                .filter {
                    paths.isEmpty() || paths.contains(it)
                }
                .filter {
                    val relative = it.toAbsolutePath().relativeTo(root).toString()
                    lines.any { line -> relative.startsWith(line) }
                }.toList()
        } else {
            emptyList()
        }
    }
}

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 46 [6.10972]
∅:D[10.8297] → [6.11877:11957]
B:BD[6.11877] → [6.11877:11957]
B:BD[6.11957] → [8.6437:6477]
```
import java.nio.file.Files
import java.nio.file.Path
import java.nio.file.Paths
import java.nio.file.StandardOpenOption
```
[6.11786]
[8.6477]
```
import java.nio.file.*
```
Insertion in src/main/kotlin/com/github/jonathanxd/dracon/cmd/PijulCmd.kt at line 50 [6.10972]
[7.2911]
[6.11957]
```
import kotlin.streams.toList
```

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

[9.15359]

[6.12492]


        return this.doExecution("init", execution)
    }
    @RequiresBackgroundThread
    override fun init(project: Project, root: Path): PijulOperationResult<Unit> {
        val execution = this.createExecPijulOperation(project, root, listOf("init", root.toString()))

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

[2.25695]

[4.11236]

    override fun untrackedFiles(project: Project, root: Path): PijulOperationResult<List<Path>> {
        return this.trackedFiles(project, root)
            .andThenValue { tracked ->
                Files.walk(root, FileVisitOption.FOLLOW_LINKS)
                    .filter { !tracked.contains(it) }
                    .toList()
            }
    }

File move: annotation (----------) → annotation (d--x------)
BF:BFD[6.107] → [2.40548:40560]
[6.107]
[2.40561]

More files to support .ignore

Dependencies

In channels

Change contents

Insertion in src/main/resources/META-INF/plugin.xml at line 31 [3.1490]

Insertion in src/main/kotlin/com/github/jonathanxd/dracon/vfs/PijulVirtualFileStatusProvider.kt at line 14 [6.151]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/vfs/PijulVirtualFileStatusProvider.kt at line 45 [6.151]

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/vfs/PijulVirtualFileStatusProvider.kt at line 51 [6.151]

Insertion in src/main/kotlin/com/github/jonathanxd/dracon/vfs/PijulVirtualFileStatusProvider.kt at line 59 [6.151]

File addition: repository (----------)

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

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

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

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

File move: credit (----------) → credit (d--x------)

Replacement in src/main/kotlin/com/github/jonathanxd/dracon/pijul/PijulOperationResult.kt at line 28 [6.3629]

Insertion in src/main/kotlin/com/github/jonathanxd/dracon/pijul/Pijul.kt at line 78 [6.4428]

Insertion in src/main/kotlin/com/github/jonathanxd/dracon/pijul/Pijul.kt at line 186 [6.4428]

File move: lang (----------) → lang (d--x------)

File move: ignore (----------) → ignore (d--x------)

File move: ignore (----------) → ignore (d--x------)

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

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

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

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

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

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

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

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

File move: annotation (----------) → annotation (d--x------)