specguard-ruby 0.3.9 → 0.3.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6266c2bcd8775838ab93bbb3963cb007465575ee038f67490161fa64e10e982e
-  data.tar.gz: 7799e565338f59d3a76b4b19e19a0877dd172072e772e8cc81909f5d040d3ec7
+  metadata.gz: c7d1dfb3eb7af542eee8c1202dae06dd0d9c3981f5415d12875037c9a9067944
+  data.tar.gz: 9d785e02b70ea9e06b0d0cf55ce31cbb1d67c841ea36fb0b7f3c7217a8f20304
 SHA512:
-  metadata.gz: 3e811640885a89c54dec7bd69702ca429b0f28f5bfdd7c76fd049d15621da4ce0b48323af914448236877f9bc40df78df642232cda89dbfef5a0adcd85612ed7
-  data.tar.gz: 28e11252d3051943734247a9878a50680ee719cff789a1ea53da11041574529ed5d9e3761c5445f33b84b0ae42994ae121d35895ec6c0f33fd2c8045163c329e
+  metadata.gz: 3d5ae9e309ae02ea33679223f712d04edf7c9e06aab22f011fde61484f2f3c8d2c992b02b792caceeb934b63136734840cdd01d0dbe62619b695dd09c3ceb238
+  data.tar.gz: 3d3f373483219a5cdbeecdf639065bd99cb90dd648acf4bd75174ae9eba6adefcfc94a6458577480bb526dc636d88b139a4742cda3c12269a320bd5e7f994a3f

data/README.md

@@ -58,7 +58,16 @@ bundle exec specguard-lint             # one-off audit: every *_spec.rb
 the default branch** (`origin/HEAD`, then `origin/main`/`origin/master`, then
 their local names) — never a bare working-tree-vs-index `git diff`, which is
 empty on a clean checkout. `--changed=<base>` overrides the base for pipelines
-that know better. In a **shallow** checkout — the default depth-1 `git clone`
+that know better. Selection also takes in **untracked** files: a brand-new
+spec that has not been `git add`ed is part of what the branch changed, whether
+or not the change is committed yet. One `git ls-files --others
+--exclude-standard` call per run is unioned with the diff — `.gitignore`d
+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`.
+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
 comes up empty: it still exits `0`, but its stderr note (and `--json`

data/lib/specguard/rspec/cli.rb

@@ -228,14 +228,23 @@ module SpecGuard
       # `summary.files`. The warnings are diagnostics about the linter rather
       # than findings, so they stay on stderr exactly as they are — a run that
       # selected nothing is still loud, in both renderers.
+      #
+      # The `--changed` count names its provenance: files can reach the
+      # selection through the untracked leg (`file_selector.rb`), and "changed
+      # since <base>" alone over-claims for a file the diff never saw. When
+      # the untracked leg contributed, the line says how many — the same
+      # `stats.untracked` the selection carries, so the clause can only ever
+      # name files this run actually checked.
       def report_selection(selection, json:)
         if selection.empty?
           @stderr.puts "specguard-lint: warning: selected 0 spec files — #{empty_reason(selection)}"
           @stderr.puts "specguard-lint: warning: #{selection.note}" if selection.note
         elsif !json
+          untracked = selection.mode == :changed ? selection.stats&.untracked.to_i : 0
           @stdout.puts "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}"
+                       "#{" under #{Dir.pwd}" if selection.mode == :all}" \
+                       "#{" including #{untracked} untracked" if untracked.positive?}"
         end
       end
 

data/lib/specguard/rspec/file_selector.rb

@@ -87,10 +87,32 @@ module SpecGuard
     # quotes and all, which no longer names a file — an accented spec file would
     # be silently dropped and then misreported as "nothing changed".
     #
-    # Known limitation: `git diff` cannot see **untracked** files, so a brand
-    # new spec file that has not been `git add`ed is not selected. In CI (a
-    # clean checkout of a commit) that cannot arise; locally the loud empty
-    # selection is what surfaces it.
+    # == Untracked files are selected too
+    #
+    # `git diff` cannot see a file that has never been `git add`ed — but "what
+    # this branch changed, whether or not the change is committed yet" covers a
+    # never-added file, and a mode that silently skipped it would ride the
+    # branch's newest spec past the gate: in the mixed shape every real working
+    # tree has (a tracked edit somewhere, the new spec still untracked), the
+    # selection was non-empty without the new file, so the loud-empty machinery
+    # never fired and the defect shipped behind a checked-count reporting
+    # success.
+    #
+    # So the `--changed` name set is a union: the diff's paths plus ONE
+    # `git ls-files --others --exclude-standard -z` call per selection, run at
+    # 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
+    # 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
+    # "nothing changed against <base>" can now only fire when the working tree
+    # is genuinely clean. That `ls-files` call is the untracked leg's entire
+    # added cost, and it is scoped to this mode — the "zero new git
+    # invocations on the full-clone happy path" property SPGD-1035 established
+    # belongs to the lazy shallow probe alone, not to `--changed` as a whole.
     module FileSelector
       # `test/**/*_test.rb` rather than `**/*_test.rb`: the `test/` directory
       # is where both Rails and Minitest itself put Minitest files, and
@@ -112,9 +134,13 @@ module SpecGuard
 
       # Why an empty `--changed` selection is empty. Every count is a filter
       # this class applied, in the order it applied them, so the CLI can name
-      # the real cause instead of guessing at the last one.
-      Stats = Data.define(:changed, :spec_matches, :outside_root, :unreadable) do
-        def initialize(changed: 0, spec_matches: 0, outside_root: 0, unreadable: 0)
+      # the real cause instead of guessing at the last one. The exception is
+      # `untracked`, which filters nothing: it counts the selected files that
+      # arrived via the untracked leg, so the report can say where a file the
+      # diff never saw came from (an untracked spec outside `root` is counted
+      # in `outside_root`, not here — this names files the run checked).
+      Stats = Data.define(:changed, :spec_matches, :outside_root, :unreadable, :untracked) do
+        def initialize(changed: 0, spec_matches: 0, outside_root: 0, unreadable: 0, untracked: 0)
           super
         end
       end
@@ -178,20 +204,31 @@ module SpecGuard
       end
 
       # Resolves git's repo-root-relative output into paths relative to `root`,
-      # dropping (and counting) everything the two scoping rules exclude.
+      # dropping (and counting) everything the two scoping rules 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]]
       def changed_files(base, root, is_shallow)
-        names = diff_names(base, root, is_shallow)
-        specs = names.select { |name| CHANGED_PATTERNS.any? { |pattern| File.fnmatch?(pattern, name) } }
+        names = diff_names(base, root, is_shallow).map { |name| [name, false] }
 
         top = toplevel(root)
+        names += untracked_names(top.empty? ? root : top).map { |name| [name, true] }
+
+        specs = names.select { |(name, _)|
+          CHANGED_PATTERNS.any? { |pattern| File.fnmatch?(pattern, name) }
+        }
+
         prefix = directory_prefix(top.empty? ? root : top)
         root_prefix = directory_prefix(real_path(root))
 
         files = []
         outside = 0
         unreadable = 0
-        specs.each do |name|
+        untracked = 0
+        specs.each do |(name, was_untracked)|
           absolute = prefix + name
           relative = strip_prefix(absolute, root_prefix)
           if relative.nil?
@@ -200,12 +237,13 @@ module SpecGuard
             unreadable += 1
           else
             files << relative
+            untracked += 1 if was_untracked
           end
         end
 
         [files.sort,
          Stats.new(changed: names.length, spec_matches: specs.length,
-                   outside_root: outside, unreadable: unreadable)]
+                   outside_root: outside, unreadable: unreadable, untracked: untracked)]
       end
 
       # `--diff-filter=d` drops deleted paths — `git diff --name-only` lists
@@ -233,6 +271,26 @@ module SpecGuard
         out.split("\0").reject(&:empty?)
       end
 
+      # The untracked leg of `--changed`: every file git does not track, minus
+      # what `--exclude-standard` excludes (`.gitignore`, `.git/info/exclude`,
+      # the global excludes file). Run at the toplevel, where `ls-files` emits
+      # repo-root-relative paths — from a subdirectory it emits cwd-relative
+      # ones, which would break the root-scoping the diff leg's output goes
+      # through. `-z` for the same reason as {diff_names}: NUL-separated and
+      # never `core.quotePath`-quoted. Without `--directory` git lists the
+      # files inside an untracked directory rather than the directory itself,
+      # which is what the suffix filter wants. `ls-files` reads the working
+      # tree and the index only — no history — so the leg works in a shallow
+      # clone where the diff base barely exists. A failure degrades to an
+      # empty leg rather than failing the run: the repository was already
+      # verified, the tracked diff above remains the primary evidence, and a
+      # half-readable working tree must not kill a gate that would otherwise
+      # check every tracked spec.
+      def untracked_names(chdir)
+        out, ok = git(%w[ls-files --others --exclude-standard -z], chdir)
+        ok ? out.split("\0").reject(&:empty?) : []
+      end
+
       # The repository's top level — what `git diff`'s paths are relative to.
       # Empty when git cannot say, in which case the caller falls back to `root`
       # (the top level *is* root for the common case of running from there).
@@ -308,9 +366,12 @@ module SpecGuard
       # Memoized per-run `git rev-parse --is-shallow-repository` probe.
       # SPGD-1035: shallowness is consulted only in the branches where it
       # changes the message (a derived base of HEAD, a failed diff), so the
-      # full-clone happy path makes zero new git invocations and the memo caps
-      # the probe at one per run. An unreadable answer (old git without the
-      # flag) reads as not shallow, keeping today's messages exactly.
+      # probe makes zero new git invocations of its own on the full-clone
+      # happy path, and the memo caps it at one per run. (That zero is the
+      # probe's, not the mode's: the untracked leg adds its one `ls-files`
+      # call to every `--changed` selection, whatever the clone's depth.) An
+      # unreadable answer (old git without the flag) reads as not shallow,
+      # keeping today's messages exactly.
       # @return [Proc] zero-argument; true iff git reports a shallow repository
       def shallow_probe(root)
         cached = nil

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.9"
+  VERSION = "0.3.10"
 end

metadata

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