specguard-ruby 0.3.18 → 0.3.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5df698ea1b4e7a3c769128feb51bb7dbf46e0b6f5eee5c74cb4d290ca9d04d11
-  data.tar.gz: 247e9962c2bf44d06511a161ed19bcb4168aeb48476f535fadacf8da905f583b
+  metadata.gz: 50dc4bf3c9b0b9c563cdff66cd57f43fe24b17bde2177c700fed2221a3e69f90
+  data.tar.gz: a95f8836a1121b5e6d71cf628290915e5fbf38c781c9c610a723bab5896e945d
 SHA512:
-  metadata.gz: c6befb4eb61b41cce78a5de0ddccd7eb09cee9cc7d8e58b429a43f95ad2113e965eb627f8225462b8f47ef2015e502eaa69bfc6b4f09f620bcedd0c7c8345520
-  data.tar.gz: 3a8df006b85851e865caff948b8cfc9d98c66abf39a8e5eb7b15f9860e428f27d07aab66b5a7c7ff24403fe1e806b36b70895329614128f43f801001b53d7a38
+  metadata.gz: 04b0bd2e271bccc2090f609013c241c0ebaa2bea877601611b4515359f0a8ed31079d2823d332d8a1b89ba31985aa3eca1a4996e6c115e5107902d97b81f26d4
+  data.tar.gz: f83b0134fae75d22af014af313c0b74108362a6671fab1a6d62f428739ecdabd585f553c7536a0833c4ef138fd25f267a484db87f684970468fad5e4a05866f3

data/lib/specguard/rspec/cli.rb

@@ -40,6 +40,29 @@ module SpecGuard
     # caught. Ctrl-C must stay Ctrl-C; mapping it to "the linter is broken"
     # would be its own small lie.
     #
+    # `Errno::EPIPE` is the same lie arriving by the shell's ordinary
+    # end-of-pipe. `specguard-lint … | head`, a quitting pager, a CI log
+    # tailer that stopped reading — none of these are the linter failing, and
+    # the run itself is correct: the verdict was computed and the reader
+    # simply stopped listening. Left in the bands it fabricates a 2 two
+    # different ways (SPGD-1288): a mid-report EPIPE reaches the backstop and
+    # reads as `internal error:`; and because `Open3.capture3` flushes THIS
+    # process's buffered stdout while setting up the validator child, the
+    # same EPIPE can surface from inside {ValidatorBackend::Runner#run},
+    # whose `SystemCallError` rescue — written for a child that cannot
+    # execute — re-wraps it as a `ValidatorError`, accusing the configured
+    # backend of a fault that does not exist. {Runner#run} passes the EPIPE
+    # through as itself, and the rescue below it here, placed ahead of both
+    # bands so it dominates them, yields the code the run had already
+    # computed: the contract's own guarantee, that the exit code reports the
+    # annotations, survives a truncated pipe. When the EPIPE fires before
+    # that computation — the reader closing while the validator is still
+    # running — there is no computed code to yield and none may be invented:
+    # {EXIT_OK} stands, because nothing reached the reader and neither
+    # "malformed annotations" nor "the linter is broken" was measured. This
+    # is a decision about what the shell is told, recorded here for the same
+    # reason the one above is.
+    #
     # == All failures, not the first
     #
     # SPGD-12 §1 step 4 says the linter "exits 1 on the *first* malformed
@@ -163,6 +186,17 @@ module SpecGuard
                        json: options[:json], ok: code == EXIT_OK)
 
         code
+      rescue Errno::EPIPE
+        # The pipe's reader stopped listening — `| head`, a quitting pager, a
+        # CI log tailer. The run is correct and its verdict stands; yield it
+        # rather than the backstop's "the tool is broken". `code` is nil when
+        # the EPIPE fired before the verdict was computed (the reader closed
+        # while the validator was still running), and then {EXIT_OK} stands:
+        # a bare `code` would be nil, `exit(nil)` in bin/specguard-lint
+        # raises TypeError and hands the shell 1 — the code this contract
+        # has already spent on "malformed annotations". See the class
+        # comment.
+        code || EXIT_OK
       rescue UsageError, ValidatorError => e
         @stderr.puts "specguard-lint: error: #{e.message}"
         EXIT_MISUSE

data/lib/specguard/rspec/ingest_cli.rb

@@ -49,6 +49,20 @@ module SpecGuard
     # `Interrupt`, `SignalException` and `SystemExit` are deliberately not
     # caught. Ctrl-C halfway through a 40-line file must stay Ctrl-C.
     #
+    # `Errno::EPIPE` joins them, and for the shell's side of the same reason
+    # (SPGD-1288). A truncated report — `--list` into `head`, a CI log
+    # tailer that stopped reading — is not this tool failing:
+    # the deliveries all happened and the per-line verdicts are in hand, and
+    # the reader simply stopped listening. Left to the backstop it is a
+    # fabricated 2 with an `internal error:` line — on `--list`, a 0 → 2
+    # flip on a clean listing. So the rescue below catches it ahead of the
+    # bands and yields the code the run had already computed: {#exit_code}
+    # over the results when they exist, {EXIT_OK} when the pipe closed
+    # before any verdict did — the `--list` path builds none, and a run that
+    # reported nothing has no verdict for an exit code to carry. On the
+    # delivery path a truncated report that exits 2 is exiting with its
+    # legitimate `:undelivered` code, not the backstop's.
+    #
     # == Where the line between 1 and 2 actually falls
     #
     # Not where {Transport::Result} draws it. That struct answers `:rejected`
@@ -402,6 +416,15 @@ module SpecGuard
 
         report(source, results, json: options.json)
         exit_code(results)
+      rescue Errno::EPIPE
+        # The report's reader stopped listening — `| head`, a quitting pager,
+        # a CI log tailer. The deliveries happened and the per-line verdicts
+        # are in hand, so the code is the run's own, recomputed from
+        # `results`, not the backstop's "the tool is broken". `results` is
+        # nil on the `--list` path, which builds none, and when the pipe
+        # closed before any delivery was made; then {EXIT_OK} stands. See
+        # the class comment.
+        results ? exit_code(results) : EXIT_OK
       rescue UsageError => e
         @stderr.puts "specguard-ingest: error: #{e.message}"
         EXIT_MISUSE

data/lib/specguard/rspec/validator_backend.rb

@@ -1154,6 +1154,20 @@ module SpecGuard
 
           check_status(status, stderr)
           parse_document(stdout, stderr)
+        rescue Errno::EPIPE
+          # An EPIPE here is about THIS process's own stdout, not the child:
+          # `Open3.capture3` flushes the parent's buffered output while
+          # setting up the child, and when the reader of that pipe — `| head`,
+          # a quitting pager, a CI log tailer — has gone, it is that flush
+          # which raises. The rescue below was written for a child that
+          # cannot execute; re-wrapping this one would report "the validator
+          # could not be executed", accusing the configured backend of a
+          # fault that does not exist, and {CLI}'s EPIPE band — which sits
+          # ahead of its `ValidatorError` band precisely for this — would
+          # never see the exception at all. So it propagates as itself.
+          # Every OTHER `SystemCallError` keeps the rescue below: ENOENT,
+          # EACCES, ENOEXEC and E2BIG remain validator failures and exit 2.
+          raise
         rescue SystemCallError => e
           # ENOENT/EACCES between #verify! and here (a binary deleted or
           # chmod'ed mid-run), ENOEXEC for a file that is not a program, E2BIG

data/lib/specguard/version.rb

@@ -7,5 +7,5 @@
 # framework-scoped version constant a lie, so the number moved here and the
 # rspec module now points at it for back-compat.
 module SpecGuard
-  VERSION = "0.3.18"
+  VERSION = "0.3.19"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: specguard-ruby
 version: !ruby/object:Gem::Version
-  version: 0.3.18
+  version: 0.3.19
 platform: ruby
 authors:
 - specguard Agent
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-19 00:00:00.000000000 Z
+date: 2026-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json