specguard-ruby 0.3.15 → 0.3.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3475a2dc3666fdebc75d6c75f47589bd8d92fa22a1caf57f3a13e4d6082ce58a
-  data.tar.gz: f2c122923ced904d8ccc6c08c8ff93c013a40361a494523f3c4209e5605e0797
+  metadata.gz: b2ae5e6b5a9750e2317709c9c5b4582d7237385e35a627cf03319087de12ed1f
+  data.tar.gz: 67733aa5aa6735a51e1e68097892da247b0c023e3a3bf09533e7f21e5abde790
 SHA512:
-  metadata.gz: 80bb44b49402facf181703f2aee6faf94e3d42b55ab88182ad94056a43ed127ded3db724f8c68fc90a461dd79939cd29703277e3d4ea19783e94ee5bd4ab56f2
-  data.tar.gz: fb8deaf26aaea6e3d5e94fbfdf07ac66aa51a50f2292398e49accbefc34a4b1bf768733d026d1d2340a380a610c32af585aa95a8380677f12b0721b5fa2b3f3a
+  metadata.gz: 8aa45d1483899e69fbe71d5f819cc404db8086265fbda3566ab68e550544c9439d19014fb3b440b14a3065a339601015ff542e8f57da16a829685d9858403e0e
+  data.tar.gz: 4d0e70b0efe28ee9ae91362d29b4502a7c6ae53073b9857fc4ec295eed1cf588cfb9d5a6c507005944f2319644ec84821123a03a92bc9604a6f12d6bade8fb14

data/README.md

@@ -60,7 +60,7 @@ directory names, so `spec/vendor_helpers/` is still yours. A bundled Rails tree
 (`bundle install --deployment` → `vendor/bundle/`) ships thousands of third-party gem
 specs; the walk neither reports on them nor fails over their annotations, and the
 zero-annotation coverage note counts only files you wrote — the same material
-`--changed` keeps out via `.gitignore`. When the fence removed files, the
+`--changed` fences out with the same directory list. When the fence removed files, the
 `checked N spec files` line says how many (`skipping M in dependency or build
 directories`); a file named explicitly on the command line is always checked.
 
@@ -76,7 +76,11 @@ paths (scratch directories, vendored code, build output) never enter the
 selection — and untracked files obey the same scoping as diffed ones, so an
 untracked spec outside the current directory is counted as outside, not
 checked. When the untracked leg contributed, the `checked N spec files changed
-since <base>` line says `including M untracked`.
+since <base>` line says `including M untracked`. `--changed` applies the same
+dependency/build directory fence to everything it selects: a tracked file is
+never subject to `.gitignore`, so the diff leg needs the fence regardless —
+and when the fence removed files, the selection line says how many
+(`skipping M in dependency or build directories`).
 In a **shallow** checkout — the default depth-1 `git clone`
 behind `actions/checkout@v4` — the merge base with the default branch is not
 in the clone's history, so the derived base is HEAD itself and the selection

data/lib/specguard/rspec/cli.rb

@@ -263,15 +263,15 @@ module SpecGuard
       # "the machine reads the provenance the human does" a property of the
       # code rather than a promise two copies could drift apart on.
       #
-      # The `:all` count names its fence: `FileSelector.select_all` refuses
-      # dependency/build directories (`file_selector.rb`
-      # `SKIPPED_DIRECTORIES`), and a fence that actually removed files says
+      # The fence count names its fence: both selection modes apply
+      # `FileSelector`'s `SKIPPED_DIRECTORIES` (the default walk and
+      # `--changed` alike), and a fence that actually removed files says
       # how many — the narrowing must never be silent. The clause is
       # count-gated exactly like the untracked one, so a run whose fence
       # removed nothing prints byte-identically to before the fence existed.
       def selection_line(selection)
         untracked = selection.mode == :changed ? selection.stats&.untracked.to_i : 0
-        skipped = selection.mode == :all ? selection.skipped : 0
+        skipped = selection.skipped.to_i
         "specguard-lint: checked #{selection.count} spec file#{'s' unless selection.count == 1}" \
           "#{" changed since #{selection.base}" if selection.mode == :changed}" \
           "#{" under #{Dir.pwd}" if selection.mode == :all}" \
@@ -320,28 +320,40 @@ module SpecGuard
           "#{stats.changed} file#{'s' unless stats.changed == 1} changed against #{base}, " \
             "none matching *_spec.rb or *_test.rb"
         else
-          changed_excluded_reason(stats, base)
+          changed_excluded_reason(stats, base, selection.skipped)
         end
       end
 
-      # `outside_root` and `unreadable` are independent counters over disjoint
-      # branches of the same partition (`file_selector.rb`), so both can be
-      # positive at once. Naming only the first one found is the failure the
+      # `outside_root`, `unreadable` and the directory-fence count are
+      # independent counters over disjoint branches of the same partition
+      # (`file_selector.rb`), so any two of them can be positive at once.
+      # Naming only the first one found is the failure the
       # comment above forbids: the reader does the arithmetic, sees that
       # `spec_matches - outside_root` files are unaccounted for, and concludes
       # they were checked. They were not — the selection is empty. So the
-      # clauses are additive, and a selection emptied by both causes says so.
-      def changed_excluded_reason(stats, base)
+      # clauses are additive, and a selection emptied by several causes says
+      # so.
+      def changed_excluded_reason(stats, base, skipped)
         matched = "#{stats.spec_matches} changed spec file#{'s' unless stats.spec_matches == 1} against #{base}"
 
-        # Nothing outside the root: `unreadable` is then the only filter left
-        # that can have emptied the selection, so it needs no count of its own.
-        return "#{matched} could not be read" unless stats.outside_root.positive?
-
-        reason = "#{matched}, but #{stats.outside_root} #{stats.outside_root == 1 ? 'is' : 'are'} " \
-                 "outside #{Dir.pwd} (--changed selects only files under the current directory)"
-        reason += " and #{stats.unreadable} could not be read" if stats.unreadable.positive?
-        reason
+        if stats.outside_root.positive?
+          reason = "#{matched}, but #{stats.outside_root} #{stats.outside_root == 1 ? 'is' : 'are'} " \
+                   "outside #{Dir.pwd} (--changed selects only files under the current directory)"
+          reason += " and #{stats.unreadable} could not be read" if stats.unreadable.positive?
+          reason += " and #{skipped} in dependency or build directories" if skipped.positive?
+          reason
+        elsif stats.unreadable.positive? && skipped.positive?
+          "#{matched} could not be read and #{skipped} in dependency or build directories"
+        elsif skipped.positive?
+          # Every matching file the diff produced was fenced: the shape
+          # {all_fenced_reason} uses, in this mode's vocabulary.
+          "#{matched}, all in dependency or build directories"
+        else
+          # Nothing outside the root and nothing fenced: `unreadable` is then
+          # the only filter left that can have emptied the selection, so it
+          # needs no count of its own.
+          "#{matched} could not be read"
+        end
       end
 
       # The FAIL block, in the shape `bin/validate-intent --source` emits: two

data/lib/specguard/rspec/file_selector.rb

@@ -16,13 +16,16 @@ module SpecGuard
     # diff names paths, not directories, and a changed test file is a test
     # file wherever the author put it.
     #
-    # The default walk also carries a fixed directory fence
-    # ({SKIPPED_DIRECTORIES}): dependency, build-output, scratch and VCS
-    # directories are never selected, so a bundled tree's `vendor/bundle/`
-    # gem specs are neither reported on nor failed over — third-party code
-    # the user did not write. `--changed` draws the same boundary from
-    # `.gitignore` (`--exclude-standard`) for free; the walk, which must keep
-    # working outside a repository, carries it as a name list instead.
+    # Both modes carry a fixed directory fence ({SKIPPED_DIRECTORIES}):
+    # dependency, build-output, scratch and VCS directories are never
+    # selected, so a bundled tree's `vendor/bundle/` gem specs are neither
+    # reported on nor failed over — third-party code the user did not write.
+    # The walk, which must keep working outside a repository, carries the
+    # boundary as a name list; `--changed` applies the same name list to the
+    # paths git hands back, because a tracked file is never subject to
+    # `.gitignore` and the diff leg therefore has no fence of its own.
+    # `--exclude-standard` additionally removes ignored *untracked* paths —
+    # it stacks with the name list in `--changed` and is no substitute for it.
     #
     # == Why `--changed` is not `git diff --name-only`
     #
@@ -111,8 +114,12 @@ module SpecGuard
     # the toplevel so its repo-root-relative output flows through the same
     # scoping as the diff's (from a subdirectory `ls-files` emits
     # cwd-relative paths, which would defeat it). `--exclude-standard` is the
-    # boundary: `.gitignore`d paths — scratch directories, vendored code, build
-    # output — never enter the selection. The two legs are disjoint by
+    # untracked leg's boundary: `.gitignore`d paths — scratch directories,
+    # vendored code, build output — never enter through it. It is a second
+    # removal, not the selection's only fence: ignored *tracked* paths still
+    # arrive on the diff leg (git never applies ignore rules to tracked
+    # files), which is why the {SKIPPED_DIRECTORIES} fence applies to the
+    # union as a whole. The two legs are disjoint by
     # construction (an untracked path is never a diff path), so the union
     # cannot double-count; {Stats.untracked} says how many of the selected
     # files arrived via the untracked leg, and the empty-reason ladder's
@@ -149,11 +156,14 @@ module SpecGuard
       #   * `tmp` — Rails' scratch directory (caches, pids, sockets).
       #   * `log` — Rails' log directory.
       #
-      # `--changed` gets this boundary for free — `--exclude-standard` keeps
-      # `.gitignore`d paths (scratch directories, vendored code, build output)
-      # out of its untracked leg. The walk has no git to ask, because it must
-      # keep working outside a repository exactly where `--changed` correctly
-      # refuses, so it carries the boundary as a name list instead. The list
+      # `--changed` applies this same list itself: a tracked file is never
+      # subject to `.gitignore`, so `--exclude-standard` — which keeps
+      # `.gitignore`d paths (scratch directories, vendored code, build
+      # output) out of the untracked leg alone — cannot fence the diff leg
+      # and is an additional removal, never a substitute. The walk has no
+      # git to ask, because it must keep working outside a repository exactly
+      # where `--changed` correctly refuses, so it carries the boundary as a
+      # name list too. The list
       # is matched against whole directory SEGMENTS of the root-relative path
       # (see {skipped_directory?}), never as a substring — `spec/vendor_helpers/`
       # is project code — and never against the absolute path.
@@ -193,16 +203,18 @@ module SpecGuard
 
       # What a selection produced, plus enough context to report it honestly.
       #
-      # `skipped` is the fence count for the `:all` mode ({SKIPPED_DIRECTORIES}),
-      # defaulted to 0 so every other construction site is untouched. It
+      # `skipped` is the {SKIPPED_DIRECTORIES} fence count, carried by BOTH
+      # selection modes — `:all`'s walk and `:changed`'s union alike; an
+      # `:explicit` selection bypasses the fence and always reads 0 —
+      # defaulted to 0 so every construction site is untouched. It
       # deliberately rides `Selection` rather than a new `Stats` member:
       # `Stats` is documented as the `--changed` empty-reason ladder ("why an
-      # empty `--changed` selection is empty") and the fence is neither
-      # `--changed`-bound nor an emptiness explanation — it is report context
-      # for a selection that may be perfectly full. `Selection` is what this
-      # file already uses to carry per-mode context (`base`, `note`, `stats`
-      # are all `--changed`-only and defaulted the same way), so the count
-      # follows that precedent instead of widening `Stats`'s contract.
+      # empty `--changed` selection is empty") and the fence is not an
+      # emptiness explanation — it is report context for a selection that may
+      # be perfectly full. `Selection` is what this file already uses to
+      # carry per-mode context (`base`, `note`, `stats` are all
+      # `--changed`-only and defaulted the same way), so the count follows
+      # that precedent instead of widening `Stats`'s contract.
       Selection = Data.define(:files, :mode, :base, :note, :stats, :skipped) do
         def initialize(files:, mode:, base: nil, note: nil, stats: nil, skipped: 0)
           super
@@ -276,20 +288,23 @@ module SpecGuard
         # consult it (a failed diff, a thin base note).
         is_shallow = shallow_probe(root)
 
-        files, stats = changed_files(resolved, root, is_shallow)
+        files, stats, skipped = changed_files(resolved, root, is_shallow)
 
         Selection.new(files: files, mode: :changed, base: resolved,
-                      note: base_note(resolved, base_kind, root, is_shallow), stats: stats)
+                      note: base_note(resolved, base_kind, root, is_shallow), stats: stats,
+                      skipped: skipped)
       end
 
       # Resolves git's repo-root-relative output into paths relative to `root`,
-      # dropping (and counting) everything the two scoping rules exclude. The
+      # dropping (and counting) everything the scoping rules and the
+      # {SKIPPED_DIRECTORIES} fence exclude. The
       # name set is the union of the diff leg and the untracked leg; each name
       # is tagged with its leg so {Stats.untracked} can attribute the selected
       # files the diff never saw. The legs are disjoint by construction (an
       # untracked path is never a diff path), so the plain union cannot
       # double-count and needs no dedup.
-      # @return [[Array<String>, Stats]]
+      # @return [[Array<String>, Stats, Integer]] the selected files, the
+      #   filter stats, and how many files the directory fence removed.
       def changed_files(base, root, is_shallow)
         names = diff_names(base, root, is_shallow).map { |name| [name, false] }
 
@@ -307,6 +322,7 @@ module SpecGuard
         outside = 0
         unreadable = 0
         untracked = 0
+        skipped = 0
         specs.each do |(name, was_untracked)|
           absolute = prefix + name
           relative = strip_prefix(absolute, root_prefix)
@@ -314,6 +330,16 @@ module SpecGuard
             outside += 1
           elsif !File.file?(absolute)
             unreadable += 1
+          elsif skipped_directory?(relative)
+            # The same {SKIPPED_DIRECTORIES} fence {select_all} applies,
+            # decided on the root-relative path at the same grain. It sits
+            # after the scoping arms so it counts a different exclusion and
+            # never perturbs `outside_root`/`unreadable`; because the union
+            # is already materialized here, one placement covers BOTH legs —
+            # the diff leg (where `.gitignore` cannot act, git never applies
+            # ignore rules to tracked files) and the untracked leg on a
+            # repository that does not ignore its vendored tree.
+            skipped += 1
           else
             files << relative
             untracked += 1 if was_untracked
@@ -322,7 +348,8 @@ module SpecGuard
 
         [files.sort,
          Stats.new(changed: names.length, spec_matches: specs.length,
-                   outside_root: outside, unreadable: unreadable, untracked: untracked)]
+                   outside_root: outside, unreadable: unreadable, untracked: untracked),
+         skipped]
       end
 
       # `--diff-filter=d` drops deleted paths — `git diff --name-only` lists

data/lib/specguard/rspec.rb

@@ -33,10 +33,11 @@ module SpecGuard
     # without re-deriving the distinction from an error message.
     class UsageError < Error; end
 
-    # The opt-in Go validator backend could not produce a verdict — the binary
-    # named by `SPECGUARD_VALIDATE_INTENT` is missing, will not execute, exited
-    # with a code that is not a verdict, or emitted something this cannot read
-    # as a report.
+    # The Go validator backend could not produce a verdict — the binary named
+    # by `SPECGUARD_VALIDATE_INTENT`, or the default binary the backend
+    # resolves when that is blank, is missing, will not execute, exited with a
+    # code that is not a verdict, or emitted something this cannot read as a
+    # report.
     #
     # Typed separately from {UsageError} because the two are different
     # accusations ("you invoked me wrongly" vs "the tool I was told to use is

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.15"
+  VERSION = "0.3.17"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: specguard-ruby
 version: !ruby/object:Gem::Version
-  version: 0.3.15
+  version: 0.3.17
 platform: ruby
 authors:
 - specguard Agent