.chezmoiignore doesn't distinguish between !* and !*/

[ja1den]

Description

.chezmoiignore doesn't distinguish between !* and !*/.
The former should exclude all files, while the latter should only exclude directories.
Currently, both are treated as excluding all files.

This comes from the SO link in #261, which links to this answer that explains it more clearly.

Steps to Reproduce

Create a file .chezmoignore with the following content:

*
!*/

Running chezmoi managed should return no results (i.e., be empty).
Currently, it will return all possible results (i.e., the * and the !*/ lines cancel out).

Additional context

I need this to work in order to set up opt-in dotfile management, rather than opt-out.

The ideal workflow would be as follows:

By default, no files will be managed, preventing unnecessary configuration from being copied / templated.

To opt-in to managing a file, add a corresponding line to the .chezmoignore.

*
!*/

!.bashrc
!.config/starship.toml

Running chezmoi managed should return .bashrc and .config/starship.toml (assuming both exist).

[twpayne]

The syntax of .chezmoiignore files is different to .gitignore. From memory, the reason for this is that chezmoi needs finer grain control than .gitignore provides. Specifically, with .chezmoiignore you can ignore a directory but not its subdirectory. StackOverflow answers about .gitignore do not apply to .chezmoiignore.

chezmoi already has opt-in dotfile management: run chezmoi add on the files you want chezmoi to manage, all other files are ignored. As a helper, the chezmoi managed and chezmoi unmanaged commands list managed and unmanaged files and directories respectively. You do not need a .chezmoiignore file for opt-in dotfile management.

[bradenhilton]

@twpayne I could be wrong, but I think "opt-in" in this instance is referring to source->destination and not destination->source, so I don't think chezmoi add is valid here. There is also no "opt-out" equivalent as remove and forget both remove the target from the source state.

That said, wouldn't the example above work if it was

**

!.bashrc
!.config/starship.toml

instead?

[ja1den]

For clarity, I only want configuration to be applied when the corresponding binary is installed on the system.

So, for example:

# something that ignores everything by default

# Bash
{{- if lookPath "bash" }}
!.bashrc
!.bash_profile
{{- end }}

# Paru
{{- if lookPath "paru" }}
!.config
!.config/paru
{{- end }}

# ...

Having something like this would mean I can just install a new package, run chezmoi apply, and I'm good to go (assuming I already have a configuration for said package).

@bradenhilton

That said, wouldn't the example above work if it was

**

!.bashrc
!.config/starship.toml

instead?

This does exactly what I need. Thank you.

[bradenhilton]

@ja1den While that might be true right now, I don't think it's entirely correct.

@twpayne Does this look as expected to you?

❯ tree $(chezmoi source-path) /F
.
│  .chezmoi.toml.tmpl
│  .chezmoiignore
├──.chezmoitemplates
│  └──powershell
│        profile.ps1
├──Documents
│  ├──PowerShell
│  │     Microsoft.PowerShell_profile.ps1.tmpl
│  └──WindowsPowerShell
│        Microsoft.PowerShell_profile.ps1.tmpl
└──private_dot_config
   ├──powershell
   │     Microsoft.PowerShell_profile.ps1.tmpl
   └──scoop
         modify_config.json.ps1.tmpl

❯ Get-Content "$(chezmoi source-path)/.chezmoiignore"
**

{{ if eq .chezmoi.os "windows" }}
!Documents/**
!.config/scoop/**
{{ end }}

❯ chezmoi managed
Documents
Documents/PowerShell
Documents/PowerShell/Microsoft.PowerShell_profile.ps1
Documents/WindowsPowerShell
Documents/WindowsPowerShell/Microsoft.PowerShell_profile.ps1

❯ chezmoi ignored
.config

It also doesn't work with !.config/scoop/config.json.

[ja1den]

@bradenhilton

Does the following work for you?

**

{{ if eq .chezmoi.os "windows" }}
!Documents/**
!.config
!.config/scoop
!.config/scoop/**
{{ end }}

[ja1den]

I've noticed that while ** successfully ignores everything correctly, it breaks chezmoi unmanaged.

Here's what I have at the moment.

.chezmoiignore:

**

# Bash
{{- if lookPath "bash" }}
!.bashrc
!.bash_profile
{{- end }}

# Paru
{{- if lookPath "paru" }}
!.config
!.config/paru
{{- end }}

My system has bash installed, but not paru.

Here's what I'm seeing:

$ chezmoi managed
.bash_profile
.bashrc

$ chezmoi unmanaged

$ chezmoi ignored
.config
.config/paru

From what I can tell, chezmoi unmanaged should show something like the following:

$ chezmoi unmanaged
.bash_history
.bash_logout
.cache
.lesshst
Desktop
Documents
Downloads
...

[ja1den]

Thinking more, I believe this could be resolved by making it so .chezmoiignore only applies to files in the source state.

Thus, there would be three possibilities for how a file is managed:

1. The file is in the source state and is not in the .chezmoiignore (would be printed by chezmoi managed).
2. The file is in the source state and is in the .chezmoiignore (would be printed by chezmoi ignored).
3. The file is not in the source state (would be printed by chezmoi unmanaged).

This would also fix the fact that chezmoi adding a file that is ignored does nothing.

[halostatue]

I don’t think that will work for my usage of .chezmoiignore, but I agree with you that there’s some confusion on how ignoring works—and how it should work—and that’s problematic.

I’m going to shift this from an issue to a discussion thread.

[ja1den]

Can you explain how your usage of .chezmoiignore depends on ignoring files in the target state?

[twpayne]

.chezmoiignore uses paths in the target state for the explicit reason that they are stable, unlike source state paths. For example, adding or removing an attribute like private_ or executable_ changes the source path, but does not change the target path.

[ja1den]

That's not what I asked.

I'm talking specifically about ignoring files in the target state.

For example, if you have .bashrc in the .chezmoiignore, it applies to both dot_bashrc in the source state, and .bashrc in the target state. In my mind, the only practical application of .chezmoiignore is to ignore the dot_bashrc in the source state, to prevent it from being copied / templated. However, currently, having .bashrc in the .chezmoiignore prevents operations on both source state and target state files, meaning trying to do something like chezmoi add ~/.bashrc will result in nothing happening.

The only reason I can think of to ignore something in the target state is to prevent it from being accidentally added to the source state. However, I don't see how this is actually beneficial, given 'accidentally' adding things to the source state isn't really possible.

[twpayne]

The only reason I can think of to ignore something in the target state is to prevent it from being accidentally added to the source state. However, I don't see how this is actually beneficial, given 'accidentally' adding things to the source state isn't really possible.

.chezmoiignore is primarily used to prevent entries in the source state being manifested in the target state. This is beneficial.

[ja1den]

yep.

That's what I just said.

[halostatue]

I wonder if there might either be (a) special syntax in .chezmoiignore to indicate whether the ignore is in the source or the target (all of my .chezmoiignore are in the target) or (b) a different structure.

With respect to special syntax, I see a couple of possibilities. The first would be inline like .gitattributes:

# .chezmoiignore inline special syntax
.local/chezmoi/config/ type=target

{{ if eq .chezmoi.os "windows" }}
.bashrc type=source
{{ end }}

If unspecified, it would be the same as type=target.

The second possibility is to have some sort of directives that change the interpretation mode.

# .chezmoiignore directive special syntax
# chezmoi:ignore:type=target
.local/chemzoi/config/
.vim/

# chezmoi:ignore:type=source
{{ if eq .chezmoi.os "windows" }}
.bashrc
{{ end }}

Of those, I prefer the directive approach.

The other option is to maintain full backwards compatibility with the existing .chezmoiignore if it’s a file, but if it’s a directory, look for source and/or target files:

# .chezmoiignore/source
{{ if eq .chezmoi.os "windows" }}
.bashrc
{{ end }}

# .chezmoiignore/target
.local/chezmoi/config/

[ja1den]

This could work, but it might be cleaner to have it as a global configuration option, something like .ignore.sourceOnly, which would be false by default (to maintain the current functionality). This would remove the need for directives or a directory.

Alternatively, instead of having a directory, simply search for .source.chezmoiignore and .target.chezmoiignore in the same way .chezmoiignore is located currently.

[ja1den]

I've switched my repository to use .chezmoiignore as an ignore file, rather than trying to invert it, as it's just easier to reason about.

Thank you for your help.