How to map one path to another non-default path in chezmoi?

[jbwfu]

I am currently trying to configure file management on Windows, and I want to manage the file WindowsPowerShell/Microsoft.PowerShell_profile.ps1, which is located at the path [Environment]::GetFolderPath("MyDocuments"). By default, this path is located in $HOME\Documents.
This means I cannot correctly use chezmoi to manage this file, as my Documents path is not always consistent across different Windows systems.

Does chezmoi provide any functionality to specify where a certain path should be mapped?

[bradenhilton]

The functionality you mentioned does not yet exist. It is currently being considered for v3, but v3 may also never happen. See #2673 for a general overview.

Currently, the way I would achieve this would be to make your PowerShell profile a template in .chezmoitemplates, then place that template in every target path permutation, then use .chezmoiignore to exclude the paths that aren't needed on each of your machines.

This method is not perfect, but you may still find it useful.

Here is how I currently handle my PowerShell profile for both Windows PowerShell (powershell.exe) and the cross-platform PowerShell (pwsh.exe) on both Windows and UNIX-like platforms:

.local/share/chezmoi/.chezmoitemplates/powershell/profile.ps1

function Test-IsInteractive {
    $commandLineArgs = [System.Environment]::GetCommandLineArgs()

    # True if VS Code shell integration is sourced: . "...\Microsoft VS Code\...\shellIntegration.ps1"
    # This is done in the integrated terminal
    if ($commandLineArgs -match '\.\s*\u0022.*vs\s*code.*shellIntegration\.ps1\u0022') {
        return $true
    }

    # False if the command line arguments contain any non-interactive parameters
    if ($commandLineArgs -imatch '-noni(?:n(?:t(?:e(?:r(?:a(?:c(?:t(?:i(?:ve?)?)?)?)?)?)?)?)?)?') {
        return $false
    }

    return [System.Environment]::UserInteractive
}

if (Test-IsInteractive) {
    function Get-ScoopOutdated { & scoop update --quiet; & scoop status }
    Set-Alias -Name 'scoop-outdated' -Value Get-ScoopOutdated

    function Invoke-ScoopUpdate { & scoop update --all --quiet; & scoop cache rm --all; & scoop cleanup --all }
    Set-Alias -Name 'scoop-update' -Value Invoke-ScoopUpdate

    Set-Alias -Name 'cm' -Value 'chezmoi'
    Set-Alias -Name 'cz' -Value 'chezmoi'

    Set-Alias -Name 'gdl' -Value 'gallery-dl'
    Set-Alias -Name 'gallerydl' -Value 'gallery-dl'
    Set-Alias -Name 'g-dl' -Value 'gallery-dl'

    Set-Alias -Name 'ytdl' -Value 'yt-dlp'
    Set-Alias -Name 'ytdlp' -Value 'yt-dlp'

    $starship = [System.IO.Path]::Combine([System.IO.Path]::GetDirectoryName($PROFILE), 'starship.ps1')
    . $starship

    $psReadLineModule = Get-Module -Name PSReadLine -ListAvailable | Sort-Object Version -Descending | Select-Object -First 1
    if ($psReadLineModule) {
        Import-Module -Name PSReadLine -ErrorAction SilentlyContinue

        $addCommandToHistory = {
            param (
                [string]$Command
            )

            switch ($Command) {
                (
                    {
                        ($_ -contains '--help') -or
                        ($_ -contains '-h') -or
                        ($_ -contains '-?') -or
                        ($_ -match 'help$') -or
                        ($_ -match '^[gG]et-[hH]elp[ ]+.+')
                    }
                ) {
                    return $false
                }
                default { return $true }
            }
        }

        @{
            EditMode            = 'Windows'
            PredictionSource    = 'History'
            HistoryNoDuplicates = $true
            AddToHistoryHandler = $addCommandToHistory
            Colors              = @{
                InlinePrediction = [System.ConsoleColor]::DarkGray
            }
        } | ForEach-Object { Set-PSReadLineOption @_ }
    }

    @(
        {
            Import-Module -Name posh-git -ErrorAction SilentlyContinue
        }
    ) | ForEach-Object { Register-EngineEvent -SourceIdentifier PowerShell.OnIdle -MaxTriggerCount 1 -Action $_ } | Out-Null

    Invoke-Expression (& { (zoxide init powershell | Out-String) })
}

.local/share/chezmoi/Documents/PowerShell/Microsoft.PowerShell_profile.ps1.tmpl

# chezmoi:template:left-delimiter=#{{
#{{- includeTemplate "powershell/profile.ps1" . | trim }}

.local/share/chezmoi/Documents/WindowsPowerShell/Microsoft.PowerShell_profile.ps1.tmpl

# chezmoi:template:left-delimiter=#{{
$OutputEncoding = [System.Text.UTF8Encoding]::new()

#{{ includeTemplate "powershell/profile.ps1" . | trim }}

.local/share/chezmoi/private_dot_config/powershell/Microsoft.PowerShell_profile.ps1.tmpl

# chezmoi:template:left-delimiter=#{{
#{{- includeTemplate "powershell/profile.ps1" . | trim }}

.local/share/chezmoi/.chezmoiignore

{{ if ne .chezmoi.os "windows" -}}
Documents/
Documents/**
{{- else -}}
.config/powershell/
.config/powershell/**
{{- end }}

You may be able to adapt this to your needs.

[jbwfu]

Thank you for your reply! Since the functionality is not yet supported, I plan to handle different paths by using symbolic links to redirect them to the default path (for example, linking /d/Documents to $HOME/Documents). This may be a more compromise solution, as it will not store multiple path templates for different devices in the dotfiles repository.

[jbwfu]

ChezMoi does not support creating folders within directory links on Windows systems?

Here is my implementation:

.chezmoidata/mappings.yaml

pathMappings:
  Documents:
    isSpecialFolder: true
    mappedPath: "MyDocuments"
    isDirectory: true

It should actually use Documents/WindowsPowerShell, but the corresponding script does not currently support it.

.chezmoiscripts/run_before_10_make_link_for_windows.ps1.tmpl

{{- if eq .chezmoi.os "windows" -}}
# This script reads path mappings from Chezmoi's .pathMappings and creates symbolic links.

function Create-SymbolicLink {
    param (
        [string]$Target, # The path to the target of the symbolic link
        [string]$Path # The path where the symbolic link will be created
    )

    Write-Host "Symbolic link created: $Target -> $Path"
    return

    if ($Path -eq $Target) {
        return
    }

    if (-Not (Test-Path $Target)) {
        Write-Warning "Source path does not exist: $Target"
        return
    }

    # Check if the parent directory exists, if not, create it
    $targetDirectory = Split-Path $Path -Parent
    if (-Not (Test-Path $targetDirectory)) {
        New-Item -ItemType Directory -Path $targetDirectory -Force
    }

    if (Test-Path $Path) {
        $tmpItem = Get-Item $Path

        if ($tmpItem.Attributes -band [System.IO.FileAttributes]::ReparsePoint) {
            # Check the target of the link
            if ($tmpItem.Target -eq $Target) {
                return
            } else {
                Write-Host "Path exists as a link, but the link target is not the specified source path. It will be overwritten."
                Remove-Item $Path -Force
            }
        } else {
            # If the path is not a link
            Write-Warning "Path already exists and is not a link: $Path"
            Write-Warning "Please manually remove the target directory and re-run the script."
            Exit 1
        }
    }

    # Create the symbolic link
    $command = "New-Item -ItemType SymbolicLink -Path '$Path' -Target '$Target' -ErrorAction Stop"
    Start-Process -FilePath "powershell.exe" -ArgumentList "-Command", $command -Verb RunAs
    Write-Host "Symbolic link created: $Target -> $Path"
}

# Function to replace environment variables in a string
function Replace-Variables {
    param (
        [string]$inputPath
    )

    $pattern = '\{(\w+)\}'
    $resultPath = [Regex]::Replace($inputPath, $pattern, {
        param($match)
        $varName = $match.Groups[1].Value
        $envValue = $envVars.$varName

        if ($null -ne $envValue) {
            return $envValue
        } else {
            Write-Warning "Environment variable '$varName' not found for '${inputPath}'"
            Exit 1
        }
    })
    return $resultPath
}

# Populate the hashtable with environment variables
$envVars = @{}
Get-ChildItem Env: | ForEach-Object {
    $envVars[$_.Name] = $_.Value
}

# Convert the JSON string to a PowerShell object
$pathMappings = ConvertFrom-Json -InputObject '{{ .pathMappings | toJson }}'

# Iterate through the path mappings
foreach ($mapping in $pathMappings.PSObject.Properties) {
    $isSpecialFolder = $mapping.Value.isSpecialFolder
    $mappedPath = $mapping.Value.mappedPath
    $isDirectory = $mapping.Value.isDirectory

    if ($isSpecialFolder) {
        $actualPath = [Environment]::GetFolderPath([System.Environment+SpecialFolder]::${mappedPath})
    } else {
        $actualPath = Replace-Variables $mappedPath
    }

    $chezmoiMappedPath = Join-Path -Path $Env:USERPROFILE -ChildPath $mapping.Name

    Create-SymbolicLink -Path $chezmoiMappedPath -Target $actualPath
}
{{- end -}}

when run chezmoi apply -v
output:

# Diff hidden
Symbolic link created: D:\Users\Documents -> C:\Users\cherry\Documents
chezmoi: Documents/WindowsPowerShell: C:/Users/cherry/Documents/WindowsPowerShell: unsupported file type 0o2000000: unknown type