[`filename-case`] Allow ignoring a directory segment without also skipping the filename check

[TitikshaBansal]

Real-world use case

This issue came out of a real GitLab project. Full context and the exact reproduction discussion here: gitlab-org/.../contributors-gitlab-com#556.

Short version: the project follows the Rails/Vite convention of putting Vue components under app/javascript/…. Since eslint-plugin-unicorn v65 the filename-case rule started validating directory segments too, so the lowercase app folder began failing PascalCase enforcement. The project shipped checkDirectories: false as a workaround (MR !2348), but that also disables directory casing checks everywhere else — the maintainer flagged this as unideal and asked whether a directory-only skip is possible. Investigation confirmed the current API can't express it, hence this issue.

Problem

The ignore option in unicorn/filename-case is a full early-return: if any path segment matches an ignore regex, both the directory-name check and the filename check are skipped for that file.

This makes it impossible to express the following (fairly common) use case: "validate PascalCase on all .vue files under app/javascript/, but don't complain that the app directory itself is lowercase."

The app/ folder name is a Rails / Vite convention and can't be renamed. Since v65, filename-case also validates directory names, so the only way to silence the false positive today is checkDirectories: false — which disables directory casing enforcement everywhere, not just for the app segment.

Reproduction

eslint.config.js:

{
  files: ['app/javascript/**/*.vue'],
  rules: {
    'unicorn/filename-case': ['error', {
      cases: { pascalCase: true },
      checkDirectories: true,
      ignore: [/^app$/],
    }],
  },
}

Create app/javascript/pages/badly-named.vue. Expected: rule flags the kebab-case filename. Actual: rule passes silently, because pathSegments.some(segment => ignore.some(re => re.test(segment))) matches on the app segment and returns before the filename is validated.

Relevant source (rules/filename-case.js):

if (pathSegments.some(segment => ignore.some(regexp => regexp.test(segment)))) {
    return;  // skips directory AND filename checks
}
if (isCheckDirectories) { /* ... */ }

Proposal

Introduce a way to exempt directory segments from casing enforcement without also skipping the filename check on files inside them. Two possible shapes:

Option A — new ignoreDirectories option.

'unicorn/filename-case': ['error', {
  checkDirectories: true,
  ignoreDirectories: [/^app$/],  // only skips the directory segment check
  ignore: [/* still a full-rule bypass, unchanged */],
}]

Backwards compatible; ignore semantics preserved.

Option B — change ignore to skip only the directory check when checkDirectories: true.

Cleaner API but a breaking change. Users relying on ignore as a whole-file bypass (per #1406's original intent) would need to migrate.

Option A seems safer.

Related

• [unicorn/filename-case] Ignore base on file path #1406 — original ignore feature: intent was whole-file exemption based on path, so today's behavior is consistent with that intent.
• Enforce directory casing in filename-case #686 — introduced checkDirectories.
• filename-case false positive for files inside __mocks__ directory #2642 — related but different: asked for a blanket "off" inside __mocks__; this issue asks for a directory-only skip that still validates filenames.

Happy to send a PR if the maintainers are open to Option A.

[ltickett]

Thank you for creating the issue @TitikshaBansal

Sorry if I missed it, but I didn’t see a reference to our project. I think it’s worth including it here to see the exact example/recreation steps you details above is a real world scenario https://gitlab.com/gitlab-org/developer-relations/contributor-success/contributors-gitlab-com/-/work_items/556

[TitikshaBansal]

Thank you for creating the issue @TitikshaBansal

Sorry if I missed it, but I didn’t see a reference to our project. I think it’s worth including it here to see the exact example/recreation steps you details above is a real world scenario https://gitlab.com/gitlab-org/developer-relations/contributor-success/contributors-gitlab-com/-/work_items/556

Great point, thanks @ltickett — I've added a "Real-world use case" section to the issue body linking contributors-gitlab-com#556 and the related MR !2348 so the reproduction context is right at the top.

[sindresorhus]

Thanks for raising this. For the linked project, an ESLint file override already handles this:

{
	files: ['app/javascript/**/*.vue'],
	rules: {
		'unicorn/filename-case': ['error', {
			cases: {pascalCase: true},
			checkDirectories: false,
		}],
	},
}

This preserves filename checking while allowing the existing directory structure. An ignoreDirectories option would only skip app and still report other directory names in the subtree. Could you share a case where this override is insufficient?

[TitikshaBansal]

Thanks for raising this. For the linked project, an ESLint file override already handles this:

{
files: ['app/javascript/**/*.vue'],
rules: {
'unicorn/filename-case': ['error', {
cases: {pascalCase: true},
checkDirectories: false,
}],
},
}
This preserves filename checking while allowing the existing directory structure. An ignoreDirectories option would only skip app and still report other directory names in the subtree. Could you share a case where this override is insufficient?

Thanks for the close look. You're right — I re-checked the linked project's tree and every subdirectory under app/javascript/ (common, pages, entrypoints, graphql, spec, stylesheets) is also lowercase. With pascalCase: true, ignoreDirectories: [/^app$/] would flag all of them, so it doesn't actually improve on the scoped checkDirectories: false override for this project.

The original ask was made on the assumption that only app was non-compliant, which turned out not to be the case. Let me confirm with the project maintainer whether they actually want to enforce PascalCase on the subtree — if not, the current override is optimal and this issue can be closed. I'll circle back either way.

[TitikshaBansal]

Following up — I checked with @ltickett (the project maintainer who raised the original discussion), and the answer to your question is yes: the project does want to enforce PascalCase across the subtree.

Concrete case:

• Goal: enforce pascalCase on filenames and directory names for all .vue files under app/javascript/.
• Constraint: the top-level app/ folder is externally mandated by Rails / Vite Ruby conventions (Vite's entrypoint resolution, ActiveSupport autoloading, etc.) and cannot be renamed.
• Plan: the maintainer intends to rename the current lowercase subdirs (common, pages, entrypoints, graphql, spec, stylesheets) to PascalCase to comply with the standard.
• Current workaround (checkDirectories: false): gives up directory-name enforcement entirely. A future PR could reintroduce a lowercase subdir (say app/javascript/utils/ because that's what a contributor is used to) with no lint error, and consistency degrades over time.
• With ignoreDirectories: [/^app$/]: the exact goal is expressible — app exempt as the one immovable segment, PascalCase enforced on every other directory in the subtree so drift can't sneak back in.

The workaround is fine as a short-term measure, but as a lint policy it's strictly weaker than what the project actually wants to enforce.

Happy to send a PR — the change is small (schema addition to both anyOf blocks, parse the option like ignore, skip matching segments in the checkDirectories loop, tests, docs). Let me know if Option A (ignoreDirectories) or Option B (change ignore semantics to skip only the directory check) is preferred.