enola 0.5.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 689fed2c591f5809d780118557d16abb71dd2c16ae81e71382fbeee1cb70001e
-  data.tar.gz: c7c4671e4d4c153f8f0f6db9f9395a6670681a1006581c5faecf2b196170cc30
+  metadata.gz: 0f5c39f1dcc7577ecde43a125b51c74b640ec8f10ce6d38e4008bec02d7e8df6
+  data.tar.gz: 3a56415c6823950a6e115dbbe1b282f564e609211ee65609ef39b7e5daa35f15
 SHA512:
-  metadata.gz: b4a72e0931b1f110f482062fa8e2627f59adfac7add1592ea1c8ef22e5bc4f6f7fc5c4ae851cf7534c50997ec8fc3cd2928e3e84a0e3bc841f9f22ee87933d85
-  data.tar.gz: 7f5cd2dc8f9b69897c095c54e95d4c9d58913607de47ca71789fa3eb8d419811d5d2c5393cc6abed7630e2f35314b6c76b61836beff63fa012761eaa0f27c4e7
+  metadata.gz: 9f2727a63a05b9aee2c24023014d7363c1b2fac11e4ad4cea85473d14bb4534fe769d5ff6e6c3ee6b71fd2a853cadd0d2dc67b72772d5188c2a63b7e05a5c033
+  data.tar.gz: 98734b4d06a0867d8808f023e59276d6c1b8e9dec27703078c5ae98f8dd02a2bd2add19606f42d4442f914b21818839af4bb5717448af5180aafd5ebb88453ca

data/CHANGELOG.md

@@ -1,3 +1,38 @@
+## enola 0.5.2, enola-rb 0.5.2, munola 0.5.2 and munola-rb 0.5.2 (2026-08-23)
+
+Rubydex is off in the config these gems write, and named in a comment beside
+the reason. The release each gem drives carries a walk that can fail to
+return: a constant reference spanning lines could be treated as its own
+predecessor, so a tree with vendored gems could snapshot for twenty-six
+minutes and several gigabytes without finishing. Two of the three Rails trees
+it was tried on did exactly that.
+
+The fix exists and is not yet in a published enola, so the default cannot
+depend on it. Prism is unaffected and stays on: it parses a monolith in 13.7
+seconds. Uncommenting the two lines brings Rubydex back for anyone who wants
+it deliberately, and the default returns the moment the binary each gem drives
+carries the fix.
+
+## enola 0.5.1 (2026-08-23)
+
+The resolver no longer probes its own binstub. It read a candidate's first 512
+bytes looking for the marker RubyGems writes, and a real binstub carries a
+`/bin/sh` + `ruby -x` preamble holding the interpreter's absolute path, which puts
+that marker around byte 580 — outside the window. So the guard missed every
+RubyGems-generated binstub, the wrapper ran itself, and running itself has no
+bottom: `enola --version` on a cold cache spawned Ruby processes until it was
+killed. The whole file is read now, capped at 64 KiB so a released binary is never
+slurped only to be rejected, and `Gem.bin_path` is recognised beside
+`Gem.activate_bin_path`. A probe also marks its child's environment, and a resolver
+that sees the marker declines to look at PATH at all, so the recursion is bounded
+by construction rather than by how well a heuristic reads a file.
+
+The marker is written where it is spawned: every probe passes it into the child,
+so a wrapper reached under another name leaves PATH alone instead of probing in
+turn. That bound is what covers the wrappers the content check cannot see, a
+version manager's shim among them, which carries none of the markers a binstub
+does. Reported and fixed by dejo1307 in #1.
+
 ## munola 0.4.4.2 and munola-rb 0.4.4.2 (2026-08-23)
 
 munola follows the channel it drives. Its binary is now cut from the stable

data/lib/enola/config.rb

@@ -20,9 +20,11 @@ module Enola
 
     def self.render(ruby: Providers.ruby)
       <<~YAML
-        # Written by the enola gem; edit freely. Both providers are on by default:
-        # Prism runs under the Ruby that runs the gem, Rubydex is built into the
-        # binary and fetched once. Remove one to leave it out of the graph.
+        # Written by the enola gem; edit freely. Prism is on by default and runs
+        # under the Ruby that runs the gem. Rubydex is left off: the release this
+        # gem drives has a walk that can fail to return on a tree with vendored
+        # gems, fixed but not yet in a published enola. Uncomment it to run it
+        # anyway, and expect a snapshot that may not finish.
         repo: .
         repos:
           - .
@@ -32,8 +34,8 @@ module Enola
           - name: prism
             command: [#{ruby.inspect}, #{Providers.prism_script.inspect}]
             expected_version: "#{Providers.prism_version || '0.1.0'}"
-          - name: rubydex
-            expected_version: "#{Providers::RUBYDEX_EXPECTED_VERSION}"
+        # - name: rubydex
+        #   expected_version: "#{Providers::RUBYDEX_EXPECTED_VERSION}"
       YAML
     end
   end

data/lib/enola/probe.rb

@@ -6,12 +6,18 @@ module Enola
   class Probe
     SURFACES = %w[constraints providers check plan hook].freeze
 
+    # A probed binary may be this wrapper wearing another name. The marker
+    # travels into the child, where the resolver reads it and leaves PATH
+    # alone, so a probe cannot start another one.
+    PROBE_ENV = "ENOLA_RESOLVER_PROBE"
+    CHILD_ENV = {PROBE_ENV => "1"}.freeze
+
     def initialize(binary)
       @binary = binary
     end
 
     def version
-      out, status = Open3.capture2e(@binary, "--version")
+      out, status = Open3.capture2e(CHILD_ENV, @binary, "--version")
       return nil unless status.success?
 
       out[/\d+\.\d+\.\d+(?:[.-][\w.]+)?/]
@@ -23,7 +29,7 @@ module Enola
     # for --help); one it lacks is refused by the top-level dispatch by name.
     def capabilities
       SURFACES.to_h do |surface|
-        out, = Open3.capture2e(@binary, surface, "--help")
+        out, = Open3.capture2e(CHILD_ENV, @binary, surface, "--help")
         [surface.to_sym, !out.include?("unknown command \"#{surface}\"")]
       rescue SystemCallError
         [surface.to_sym, false]

data/lib/enola/resolver.rb

@@ -25,9 +25,19 @@ module Enola
 
     EXECUTABLE = File.expand_path("../../exe/enola", __dir__)
 
+    # A binstub is a script; the released binary is megabytes. The cap keeps the
+    # whole-file read cheap and means a real binary is never slurped to be rejected.
+    MAX_SCRIPT_BYTES = 64 * 1024
+
     private
 
     def matching_path_binary
+      # A probe runs the candidate, and the candidate may be this wrapper wearing
+      # another name. The marker travels into that child, and a resolver that finds
+      # it declines to look at PATH — so the recursion is bounded by construction
+      # rather than by how well the check below reads a file.
+      return [nil, nil] if ENV[Probe::PROBE_ENV]
+
       candidate = @path.split(File::PATH_SEPARATOR).map { |dir| File.join(dir, "enola") }
                        .find { |bin| File.executable?(bin) && !wrapper?(bin) }
       return [nil, nil] unless candidate
@@ -39,11 +49,18 @@ module Enola
     # Bundler puts this gem's own exe on PATH, and a rubygems binstub for the
     # gem looks like a binary too; probing either would run the wrapper inside
     # itself without end.
+    #
+    # The whole file is read, not a fixed head. RubyGems writes a /bin/sh + `ruby -x`
+    # polyglot preamble carrying the interpreter's absolute path, so the marker sits
+    # ~580 bytes in — past the 512 this used to read, which made the guard miss every
+    # real binstub and the wrapper probe itself without end.
     def wrapper?(bin)
       return true if File.realpath(bin) == File.realpath(EXECUTABLE)
+      return false if File.size(bin) > MAX_SCRIPT_BYTES
 
-      head = File.binread(bin, 512)
-      head.include?("Gem.activate_bin_path") || head.include?('require "enola"')
+      body = File.binread(bin)
+      body.include?("Gem.activate_bin_path") || body.include?("Gem.bin_path") ||
+        body.include?('require "enola"')
     rescue SystemCallError
       true
     end

data/lib/enola/version.rb

@@ -4,5 +4,5 @@ module Enola
   # The gem versions itself. UPSTREAM_VERSION names the enola release it
   # fetches and drives.
   UPSTREAM_VERSION = "0.4.4"
-  VERSION = "0.5.0"
+  VERSION = "0.5.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: enola
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.2
 platform: ruby
 authors:
 - Muhamed Isabegovic