.stoopignore

For reads that can't change the result, and output nobody needs to keep. One pattern per line.

A peregrine half hidden in valley fog.

What it does

A path that matches is left out of the proof entirely. Reading it doesn't count as an input, and writing it doesn't make it an output that must stay in place. Patterns come from .stoopignore at the repository root, from --ignore PATTERN, and from a short built-in list.

Ignore with care. Every pattern is a promise that changes there can't change the command's result. When in doubt, leave it out: the cost of a pattern you didn't need is a rerun; the cost of one you shouldn't have written is a skip that hides a failure.

Syntax

# a name with no slash matches that component anywhere
node_modules
# a path with a slash is anchored to the root and covers everything under it
reports/junit.xml
# an absolute path does the same outside the repository
/opt/hostedtoolcache/cache-stats
# * stays inside one component, ** crosses them, ? is one character
docs/**/generated
*.log
  • Blank lines and lines starting with # are skipped.
  • A trailing / is ignored, so build/ and build are the same pattern.
  • Paths inside the repository are matched relative to its root.

Always ignored

These never count, because they change on every run or describe the machine rather than the work:

/proc  /sys  /dev  /run  /tmp  /var/tmp  /var/run
/etc/resolv.conf  /etc/hosts  /etc/hostname  /etc/mtab
.stoop

Common entries

PatternWhy
reports/junit.xmlA test report the run writes. Without it, the report would be an output that must still exist for a skip.
coverageCoverage output, for the same reason.
.gitOnly if a command reads .git and the read can't change its result. By default a .git read means the run is not recorded, because a skip could hide a history change.

Don't ignore a dependency directory like node_modules just because it is big. If the command reads it, a change there can change the result.