Refuse Anything That Is Not a File or a Directory, Not Merely What Is Absent

Testing for existence covered a typo and nothing else. A FIFO, a socket,
and a device all exist and are neither a file nor a directory, and
`discover` reads each of them as `.`, so the run still scanned the caller's
directory while the rule set anchored on the argument's parent. The
invariant held for the case I pictured and not for its siblings.

The check now asks what the path is rather than whether it is there, which
covers both.

Two cases: the missing path, and a real FIFO created in the test, skipped
where `os.mkfifo` is unavailable.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: ptr727

scripts/prose_lint.py

@@ -1119,14 +1119,15 @@ def main(argv: list[str] | None = None) -> int:
     # Only a repository declares a model, so two of them refuse and anything else resolves to one anchor.
     # TestScanRootDecidesTheRuleSet carries the cases and the reason each one exists.
     scan_paths = a.paths or ['.']
-    # A path that does not exist is refused rather than absorbed.
-    # `discover` reads a non-file, non-directory argument as `.`, so a typo scanned the caller's directory while the rule set anchored on the missing path's parent.
-    absent = [p for p in scan_paths if not Path(p).exists()]
-    if absent:
+    # Anything that is not a file or a directory is refused rather than absorbed.
+    # `discover` reads such an argument as `.`, so it scanned the caller's directory while the rule set anchored on the argument's parent.
+    # Tested for what it is rather than for whether it exists, since a FIFO, a socket, and a device all exist and are none of the two.
+    unusable = [p for p in scan_paths if not (Path(p).is_file() or Path(p).is_dir())]
+    if unusable:
         # Quoted, since a path holding a space or a comma is unreadable in a bare comma-joined list.
-        print(f"error: requested path(s) do not exist: {quoted(absent)}. Refusing rather than "
-              'falling back to the current directory, which would scan one tree and choose the '
-              'rule set from another.', file=sys.stderr)
+        print(f"error: requested path(s) are not a file or a directory: {quoted(unusable)}. "
+              'Refusing rather than falling back to the current directory, which would scan one '
+              'tree and choose the rule set from another.', file=sys.stderr)
         return 2
     git_roots = {found for found in (repo_root(Path(p)) for p in scan_paths) if found}
     if len(git_roots) > 1:

scripts/test_prose_lint.py

@@ -12,6 +12,7 @@
 import contextlib
 import io
 import json
+import os
 import re
 import subprocess
 import sys
@@ -1866,7 +1867,20 @@ def test_a_path_that_does_not_exist_is_refused_rather_than_absorbed(self) -> Non
         with mock.patch.object(prose_lint, 'repo_root', return_value=''):
             self.assertEqual(2, prose_lint.main(
                 [str(self.tmp / 'no-such-dir'), '--check', 'home-path']))
-        self.assertIn('do not exist', self.err.getvalue())
+        self.assertIn('not a file or a directory', self.err.getvalue())
+
+    @unittest.skipUnless(hasattr(os, 'mkfifo'), 'mkfifo is POSIX only')
+    def test_a_path_that_exists_but_is_neither_a_file_nor_a_directory_is_refused(self) -> None:
+        """A FIFO, a socket, and a device all exist, and `discover` reads each of them as `.`.
+
+        Testing for existence therefore left the hole open on everything that is not a typo.
+        """
+        fifo = self.tmp / 'a-fifo'
+        os.mkfifo(fifo)
+        self.assertTrue(fifo.exists())
+        with mock.patch.object(prose_lint, 'repo_root', return_value=''):
+            self.assertEqual(2, prose_lint.main([str(fifo), '--check', 'home-path']))
+        self.assertIn('not a file or a directory', self.err.getvalue())
 
     def test_a_path_holding_a_space_or_comma_is_quoted_in_the_refusal(self) -> None:
         """Joined bare, one path with a comma in it reads as two paths and the message misleads."""