Detecting if a snapshot is needed / would be taken

[xpe]

How can a script detect if a snapshot is need (i.e. would be taken if one tried)?

Unlike quantum mechanics, I don't want measurement to change the state of the system ⚛️ ... so the command must not make any changes. 😜

Not Quite: jj util snapshot

I tried this with jj util snapshot:

> jj util snapshot
No snapshot needed.
> touch ALPHA
> jj util snapshot
Snapshot complete.

This suggests it could work, but I need to use --ignore-working-copy if I want to only detect the state.

> touch BETA
> jj util snapshot --ignore-working-copy
No snapshot needed.
> jj util snapshot
Snapshot complete.

You can see that jj util snapshot --ignore-working-copy does not provide what I want.

The newer flag --no-integrate-operation is closer but still does not do exactly what I want.

What Else?

What else should I try?

Why

I would like to be able to do something like this:

• jj new --if-dirty (my best flag name so far)
• or (I prefer this less) jj new --if-needed (I don't like this as much because it might be unclear what exactly "is needed" means.)

Documentation

> jj util snapshot --help
Snapshot the working copy if needed

Snapshots the working copy and updates the working-copy commit
if the working copy has changed since the last snapshot. Since
almost every command snapshots the working copy, there is very
little reason to run this command as a human; it is mostly
meant for scripts.

[xpe]

To answer this question: "Does the current working-copy commit modify any files relative to its parent(s)?", use:

jj log -r @ --no-graph -T empty

This returns one of the following strings:

• "true" if @ is empty
• "false" if @ contains changes

Note: when scripting, test the string, not the process exit status code. The status code will be 0 as long as jj jog completes successfully, independent of what the empty() template returns.

So for my use case, I only need to call jj new if "true" above.

Why does this work? According to Templates : Commit Type:

.empty() -> Boolean: True if the commit modifies no files.

[daeh]

My approach to this has been to compare the outputs of the published view (using --ignore-working-copy to avoid the snapshot) and an ephemeral prospective view (using --no-integrate-operation to avoid updating the op log). If they differ, a snapshot would change the revset.

published=$(jj --quiet --ignore-working-copy log --no-graph -r @ -T commit_id)
prospective=$(jj --quiet --no-integrate-operation log --no-graph -r @ -T commit_id)

### would snapshot update the revset? ###
[[ "$published" != "$prospective" ]]