action.Pijul.ExpertRecord.text=Record (Expert Mode)...

record.author=&Author:

record.author=&Author:
record.expert.mode.title=Record (Expert Mode)
expert.mode.button.record=Record
expert.mode.button.cancel=Cancel
expert.mode.notification.group.id=Expert mode
expert.mode.notification.title=Record (expert mode)
expert.mode.notification.success=Successfully recorded changes. New revision: <tt>{0}</tt>.
expert.mode.notification.failure=Failed to record changes with exit code <bold>{0}</bold> and message: <tt>{1}</tt>.

<!--
    Dracon - An IntelliJ-Pijul integration.
    Copyright 2021 JonathanxD <jhrldev@gmail.com>
    Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
    The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-->

    <depends>org.toml.lang</depends>

        <completion.contributor language="TOML" implementationClass="com.github.jonathanxd.dracon.completion.PijulCompletionContributor" />

        <action id="Pijul.ExpertRecord" class="com.github.jonathanxd.dracon.actions.PijulExpertRecord"/>

            <reference ref="CheckinFiles"/>
            <reference ref="CheckinProject"/>
            <reference ref="Pijul.ExpertRecord"/>
            <separator/>
            <reference ref="Compare.SameVersion"/>
            <reference ref="Compare.Selected"/>

import com.intellij.openapi.vcs.ProjectLevelVcsManager

        if (!Pijul.isUnderPijul(virtualFile))

        if (!Pijul.isUnderPijul(virtualFile) || isIdeaRoot(virtualFile))

            status.result ?: FileStatus.UNKNOWN

            status.result

        }
    }
    fun isIdeaRoot(virtualFile: VirtualFile): Boolean {
        val root = ProjectLevelVcsManager.getInstance(project).getVcsRootFor(virtualFile)
        if (root != null) {
            return root == virtualFile || virtualFile.toNioPath().toAbsolutePath().toString().startsWith(
                root.toNioPath().toAbsolutePath().resolve(".idea").toString()
            )
        } else {
            return false

import com.intellij.openapi.util.io.FileUtilRt

import com.intellij.openapi.vfs.VirtualFile

    val tempDir = FileUtilRt.createTempDirectory("dracon_diffs-", revisionHash)
    val tmpTarget = tempDir.toPath()

    val tmpTarget = Paths.get(project.baseDir.path, ".idea", "dracon_diffs", revisionHash)
    if (Files.exists(tmpTarget)) {
        Files.walk(tmpTarget).use { walk ->
            walk.sorted(Comparator.reverseOrder())
                .map(Path::toFile)
                .forEach(File::delete)
        }
    }
    Files.createDirectories(tmpTarget)

    return Files.readString(tmpTarget.resolve(filePath))

    val relativeToRoot = filePath.subpath(root.nameCount, filePath.nameCount)
    try {
        return Files.readString(tmpTarget.resolve(relativeToRoot))
    } finally {
        FileUtilRt.delete(tempDir)
    }

import com.intellij.openapi.vcs.LocalFilePath

import com.intellij.openapi.vcs.history.VcsFileRevisionEx

import com.intellij.vcs.log.VcsUser
import java.nio.file.Files

                           val author_: String?,

                           val authors: List<VcsUser>,

                           val branch: String?) : VcsFileRevision {

                           val branch: String?,
                            val deleted: Boolean) : VcsFileRevisionEx(), Comparable<PijulVcsFileRevision> {

                author_: String?,

                authors: List<VcsUser>,

                branch: String?): this(project, vcsRoot, Paths.get(filePath.path).relativeTo(vcsRoot), revision, author_, message, branch)

                branch: String?,
                deleted: Boolean): this(project, vcsRoot, Paths.get(filePath.path).relativeTo(vcsRoot), revision, authors, message, branch, deleted)

    override fun getAuthor(): String? = this.author_

    override fun getAuthor(): String? = this.authors.map { it.name }.firstOrNull()

    override fun getAuthorEmail(): String? =
        this.authors.map { it.email }.firstOrNull()
    override fun getCommitterName(): String? = this.author
    override fun getCommitterEmail(): String? = this.authorEmail
    override fun getPath(): FilePath =
        LocalFilePath(this.filePath, Files.isDirectory(this.filePath))
    override fun getAuthorDate(): Date? = Date.from(this.revision.timestamp.toInstant())
    override fun isDeleted(): Boolean = this.deleted
    override fun compareTo(other: PijulVcsFileRevision): Int =
        this.revision.timestamp.compareTo(other.revision.timestamp)

import com.github.jonathanxd.dracon.log.FileDelHunk
import com.github.jonathanxd.dracon.log.HunkWithPath

import com.intellij.vcs.log.impl.VcsUserImpl

                    it.authors.map { it.name }.firstOrNull(),

                    it.authors.map { VcsUserImpl(it.name ?: "", it.email ?: "") }.filter { it.name.isNotEmpty() },

                    currentChannel

                    currentChannel,
                    false

                partner.acceptRevision(
                    PijulVcsFileRevision(
                        this.project,
                        root.toNioPath(),
                        path,
                        PijulRevisionNumber(it.changeHash, it.date),
                        it.authors.map { it.name }.firstOrNull(),
                        it.message,
                        currentChannel

                it.hunks.filterIsInstance<HunkWithPath>().groupBy {
                    it.resolvePath(root.toNioPath())
                }.forEach { path, hunks ->
                    val deleted = hunks.any { it is FileDelHunk }
                    partner.acceptRevision(
                        PijulVcsFileRevision(
                            this.project,
                            root.toNioPath(),
                            path,
                            PijulRevisionNumber(it.changeHash, it.date),
                            it.authors.map { VcsUserImpl(it.name ?: "", it.email ?: "") }.filter { it.name.isNotEmpty() },
                            it.message,
                            currentChannel,
                            deleted
                        )

                )

                }

    }

    /*override fun createFromCachedData(
        cacheable: Boolean?,
        revisions: MutableList<out VcsFileRevision>,
        filePath: FilePath,
        currentRevision: VcsRevisionNumber?
    ): VcsAbstractHistorySession {
        TODO("Not yet implemented")

    override fun getBaseVersionContent(
        filePath: FilePath?,
        processor: Processor<in String>?,
        beforeVersionId: String?
    ): Boolean {
        TODO("Not yet implemented")
    }*/

            val rootAbsolute = root!!.toNioPath().toAbsolutePath()
            if (dir.path.startsWith(rootAbsolute.resolve(".pijul").toString()))
                continue;
            if (dir.path.startsWith(rootAbsolute.resolve(".idea").toString()))
                continue;
            if (!dir.path.startsWith(rootAbsolute.toString()))
                continue;
            if (!dir.path.startsWith(project.baseDir.toNioPath().toAbsolutePath().toString()))
                continue;

                        val path = Paths.get(dir.path, hunk.path)

                        val path = Paths.get(dir.path, hunk.resolvedPath)

                                PijulContentRevision(
                                    rootPath,
                                    filePath,
                                    head,
                                    this.project
                                ), CurrentContentRevision.create(filePath),

                                null, CurrentContentRevision.create(filePath),

                        val path = Paths.get(dir.path, hunk.path)

                        val path = Paths.get(dir.path, hunk.resolvedPath)

                                    filePath,

                                    path,

                                ), CurrentContentRevision.create(filePath),

                                ), null,

                        val path = Paths.get(dir.path, hunk.path)

                        val path = Paths.get(dir.path, hunk.resolvedPath)

                        val path = Paths.get(dir.path, hunk.path)

                        val path = Paths.get(dir.path, hunk.resolvedPath)

    override fun showChangesBetweenRevisions(
        path: FilePath,
        older: PijulVcsFileRevision,
        newer: PijulVcsFileRevision?
    ) {
        super.showChangesBetweenRevisions(path, older, newer)
    }

    @RequiresBackgroundThread
    fun recordToString(project: Project, root: Path): PijulOperationResult<String>

    @RequiresBackgroundThread
    fun recordFromString(project: Project, root: Path, record: String): PijulOperationResult<String>

import java.nio.file.Path

    fun resolvePath(root: Path): Path =
        root.resolve(this.resolvedPath)

    fun message(@PropertyKey(resourceBundle = BUNDLE) key: String, vararg params: Any): @Nls String {

    @Nls
    fun message(@PropertyKey(resourceBundle = BUNDLE) key: String, vararg params: Any): String {

import com.github.jonathanxd.dracon.pijul.pijul

import com.intellij.openapi.diagnostic.logger

import com.intellij.vcsUtil.VcsUtil
import java.io.File
import java.io.IOException
import java.nio.file.*
import java.nio.file.attribute.BasicFileAttributes

import java.nio.file.Files
import java.nio.file.Path
import java.nio.file.Paths

import kotlin.io.path.relativeTo
import java.util.Comparator

                project: Project): this(root, Paths.get(filePath.path).relativeTo(root), revision, project)

                project: Project): this(root, Paths.get(filePath.path), revision, project)

import com.github.jonathanxd.dracon.context.PijulVcsContext

import com.intellij.openapi.components.service

import com.intellij.openapi.util.io.FileUtilRt

import java.nio.file.StandardOpenOption
import java.util.*

        }
    }
    override fun recordToString(
        project: Project,
        root: Path
    ): PijulOperationResult<String> {
        val arguments = mutableListOf("record")
        val uuid = UUID.randomUUID().toString()
        val tempFile = createCopieTempFile(uuid)
        val operation = this.createPainlessExecPijulWithCopieOperation(
            this.project,
            root,
            tempFile,
            CopieMode.TO,
            arguments
        )
        return this.doExecutionWithMapperEvenFailed("record", operation) {
            val data = Files.readString(tempFile, Charsets.UTF_8)
            deleteCopieTempDir(uuid)
            data
        }
    }
    override fun recordFromString(project: Project, root: Path, record: String): PijulOperationResult<String> {
        val arguments = mutableListOf("record")
        val uuid = UUID.randomUUID().toString()
        val tempFile = createCopieTempFile(uuid)
        Files.writeString(tempFile, record, Charsets.UTF_8, StandardOpenOption.CREATE_NEW)
        val operation = this.createPainlessExecPijulWithCopieOperation(
            this.project,
            root,
            tempFile,
            CopieMode.FROM,
            arguments
        )
        return this.doExecutionWithMapper("record", operation) {
            deleteCopieTempDir(uuid)
            it

        val ctx = project.service<PijulVcsContext>()

        val filePath = Paths.get(file.path).relativeTo(rootPath)

        val filePath = ctx.resolveUnderVcs(file)
        val isRootPath = ctx.isRootPath(filePath)
        val filePathAsStr = ctx.resolveRelativeToRoot(filePath)

                            if (filePath.toString().equals(hunk.resolvedPath, ignoreCase = true)) {
                                if (hunk is FileAddHunk) {
                                    isAdd = true
                                }

                            val hunkPath = hunk.resolvePath(rootPath)
                            if (isRootPath) {

                            } else {
                                if (Files.isDirectory(filePath)) {
                                    if (hunkPath == filePath) {
                                        if (hunk is FileAddHunk) {
                                            isAdd = true
                                        }
                                        shouldConsume = true
                                    } else if (hunkPath.startsWith(filePath)) {
                                        shouldConsume = true
                                    }
                                } else {
                                    if (hunkPath == filePath) {
                                        if (hunk is FileAddHunk) {
                                            isAdd = true
                                        }
                                        shouldConsume = true
                                    }
                                }

                    filePath.toString().equals(it.resolvedPath, ignoreCase = true)

                    val resolved = it.resolvePath(root)
                    filePath == resolved

        }
    }
    fun <T> doExecutionWithMapperEvenFailed(name: String,
                                  execution: PijulExecution,
                                  regularStreamStringMapper: (String) -> T?): PijulOperationResult<T> {
        val status = runBlocking(Dispatchers.IO) {
            execution.status.first()
        }
        return if (status == 0) {
            val std = runBlocking(Dispatchers.IO) {
                execution.regularStream.toList().joinToString("\n")
            }
            PijulOperationResult(name, SuccessStatusCode, regularStreamStringMapper(std))
        } else {
            val error = runBlocking(Dispatchers.IO) {
                execution.errorStream.toList().joinToString("\n")
            }
            PijulOperationResult(name, NonZeroExitStatusCode(status, error), regularStreamStringMapper(""))

                                         dir: Path,
                                         args: List<String>): PijulExecution {

                                                 dir: Path,
                                                 args: List<String>): PijulExecution {
        val process = ProcessBuilder()
            .command(listOf(this.findPijul()) + args)
            .directory(dir.toFile())
            .start()
        val input = process.inputStream
        val error = process.errorStream
        return PijulExecution(
            input.linesToFlow().onEach {
                draconConsoleWriter(project).logCommand("pijul", args, it)
            },
            error.linesToFlow().onEach {
                draconConsoleWriter(project).logCommandError("pijul", args, it)
            },
            flow {
                process.onExit().await()
                val exit = process.exitValue()
                if (exit == 0) {
                    draconConsoleWriter(project).logCommand("pijul", args, "<Exit status> $exit")
                } else {
                    draconConsoleWriter(project).logCommandError("pijul", args, "<Exit status> $exit")
                }
                emit(exit)
            }.flowOn(Dispatchers.IO)
        )
    }
    /**
     * 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 createPainlessExecPijulWithCopieOperation(project: Project,
                                                          dir: Path,
                                                          copiePath: Path,
                                                          copieMode: CopieMode,
                                                          args: List<String>): PijulExecution {

            .apply {
                when(copieMode) {
                    CopieMode.FROM -> environment()["COPIE_FROM"] = copiePath.toAbsolutePath().toString()
                    CopieMode.TO -> environment()["COPIE_TO"] = copiePath.toAbsolutePath().toString()
                }
                environment()["VISUAL"] = "copie"
                environment()["EDITOR"] = "copie"
            }

}

    fun createCopieTempFile(hash: String): Path {
        val tempDir = FileUtilRt.createTempDirectory("dracon_records-", hash).toPath()
        return tempDir.resolve("record")
    }
    fun deleteCopieTempDir(hash: String) {
        val tempDir = FileUtilRt.createTempDirectory("dracon_records-", hash).toPath()
        FileUtilRt.delete(tempDir.toFile())
    }
    enum class CopieMode {
        FROM,
        TO
    }
}
/**
 * Returns whether [resolvedPath] is a directory inside [this] [Path].
 *
 * @param root The root path for [this] [Path] and [resolvedPath].
 */
fun Path.isInside(root: Path, resolvedPath: String) =
    if (this == root) {
        true
    } else if (Files.isDirectory(this) && resolvedPath.startsWith(this.toString())) {
        true
    } else if (!Files.isDirectory(this)) {
        this.toString().equals(resolvedPath, ignoreCase = true)
    } else {
        false
    }
/**
 * Returns whether [this] path is equal the [path].
 */
fun String.isEqual(path: Path) =
    path.toString() == this
/**
 * Returns whether [this] path is equal the [path].
 */
fun String.isPathEqual(path: String) =
    this.removeTrailingSlash().equals(path.removeTrailingSlash(), ignoreCase = true)
fun String.removeTrailingSlash() =
    if (this.length > 1 && this.endsWith("/")) this.substring(0, this.length - 1)
    else this
/**
 * Returns whether [this] path is inside the [path].
 */
fun String.isInside(path: Path) =
    path.startsWith(this)

import com.intellij.openapi.fileEditor.FileEditorManager
import com.intellij.openapi.fileEditor.OpenFileDescriptor
import com.intellij.openapi.fileTypes.FileType
import com.intellij.openapi.fileTypes.FileTypeRegistry

import com.intellij.openapi.wm.WindowManager

import com.intellij.ui.EditorTextField
import com.intellij.psi.PsiDocumentManager

import com.intellij.psi.PsiElement
import com.intellij.psi.PsiFile
import com.intellij.testFramework.LightVirtualFile

        println(paths)

    setPlugins("org.toml.lang:0.2.144.3766-211")

        excludes.add("**/plugin.xml")