Grunt 1.x src globs warn but do not fail on zero-match patterns

Short answer

Do not use nonull or --force as the failure mechanism. In Grunt 1.x, a zero-match src glob is normally expanded to an empty list and only warned about. To make a specific target fail, add a small guard task for that target that expands the same glob and calls grunt.fail.warn when the list is empty. Keep nonull off and do not pass --force in CI. This assumes Grunt 1.x; confirm with npx grunt --version.

There is no built-in documented flag that means “fail if zero matches.” The documented primitives are glob expansion, nonull, grunt.fail.warn/grunt.fail.fatal, and option merging.

What is confirmed vs. likely

Confirmed by documented behavior: nonull: true keeps the literal pattern instead of dropping it, so downstream file operations usually receive a path that does not exist and produce a file-not-found error. That is an indirect failure, not a Grunt-level zero-match failure.

Likely in practice: --force makes a green CI run more likely even when source files are missing, because it suppresses the warning/failure path. Treat it as a mask, not a validator.

Also confirmed: task and target options are deep-merged, but arrays such as src are replaced, not concatenated. Therefore failure behavior must be scoped per target when the globs differ.

Recommended combination

• nonull: leave false unless a task explicitly documents that it wants the literal pattern.
• --force: omit for validation runs. If another target requires it, use grunt.fail.fatal in the guard, accepting that it stops the run.
• Option scoping: put src on the target that needs strict checking; put guard options on that target or task, not globally.

Should the task fail explicitly?

For CI-critical inputs, yes. An empty source set usually means a typo, a missing build step, or a wrong branch. For optional targets, a warning may be enough. Explicit failure should be applied only where an empty set makes the build invalid.

Minimal guard pattern

module.exports = function (grunt) {
  grunt.initConfig({
    guard: {
      options: { failOnEmpty: true },
      strict: { src: ['build/**/*.js'] }
    }
  });

  grunt.registerMultiTask('guard', 'Fail when src matches nothing', function () {
    var files = grunt.file.expand(this.data.src);
    if (files.length === 0) {
      if (this.options().failOnEmpty) {
        grunt.fail.warn('No files matched for ' + this.target);
      } else {
        grunt.log.warn('No files matched for ' + this.target);
      }
    }
  });
};

Run the target directly in CI. If the guard must run before another task, register it as a dependency or call grunt.task.run from the consuming task.

Verification

1. Point the guard at a directory that does not exist.
2. Run npx grunt guard:strict and check the exit status.
3. Run npx grunt guard:strict --force to confirm the mask behavior.
4. Set failOnEmpty: false on one target to verify other targets still warn without aborting.

If the failing target is a third-party plugin task that expands src itself, tell me which task it is; that changes whether nonull is safe or whether the guard must wrap the plugin call.