mbeditor 0.12.9 → 0.13.1

data/app/services/mbeditor/editor_state_service.rb

@@ -22,18 +22,13 @@ module Mbeditor
     end
 
     def read_state
-      path = workspace_path
-      return {} unless File.exist?(path)
-      JSON.parse(File.read(path))
+      read_json(workspace_path)
     rescue JSON::ParserError, Errno::ENOENT
       {}
     end
 
     def read_branch_state(branch)
-      path = branch_states_path
-      return {} unless File.exist?(path)
-      all = JSON.parse(File.read(path))
-      all[branch] || {}
+      read_json(branch_states_path)[branch] || {}
     rescue JSON::ParserError, Errno::ENOENT
       {}
     end
@@ -44,17 +39,14 @@ module Mbeditor
       raise PayloadTooLargeError, "State payload too large" if payload_json.bytesize > STATE_MAX_BYTES
       path = branch_states_path
       FileUtils.mkdir_p(path.dirname)
-      File.open(path, File::RDWR | File::CREAT) do |f|
-        lock_exclusive!(f)
-        existing = f.size > 0 ? JSON.parse(f.read) : {}
+      with_lock(path) do
+        existing = read_json(path)
         # Auto-save fires on a timer even with no changes; skip the full-file
         # rewrite when this branch's entry is already identical.
-        break if existing[branch] == JSON.parse(payload_json)
+        next if existing[branch] == JSON.parse(payload_json)
 
         existing[branch] = state
-        f.truncate(0)
-        f.rewind
-        f.write(existing.to_json)
+        atomic_write(path, existing.to_json)
       end
       nil
     end
@@ -63,10 +55,9 @@ module Mbeditor
       path = branch_states_path
       return [] unless File.exist?(path)
       pruned = []
-      File.open(path, File::RDWR) do |f|
-        lock_exclusive!(f)
+      with_lock(path) do
         all = begin
-          JSON.parse(f.read)
+          read_json(path)
         rescue JSON::ParserError => e
           Rails.logger.error("[mbeditor] EditorStateService#prune_branch_states: discarding corrupt branch_states JSON at #{path}: #{e.message}")
           {}
@@ -74,9 +65,7 @@ module Mbeditor
         pruned = all.keys - active_branches
         if pruned.any?
           pruned.each { |b| all.delete(b) }
-          f.truncate(0)
-          f.rewind
-          f.write(all.to_json)
+          atomic_write(path, all.to_json)
         end
       end
       pruned
@@ -87,17 +76,38 @@ module Mbeditor
       raise PayloadTooLargeError, "State payload too large" if payload.bytesize > STATE_MAX_BYTES
       path = workspace_path
       FileUtils.mkdir_p(path.dirname)
-      File.open(path, File::RDWR | File::CREAT) do |f|
-        lock_exclusive!(f)
-        f.truncate(0)
-        f.rewind
-        f.write(payload)
-      end
+      with_lock(path) { atomic_write(path, payload) }
       nil
     end
 
     private
 
+    # Readers take no lock at all: every write lands by rename, so a read sees
+    # either the whole previous file or the whole new one — never the empty
+    # window a truncate-then-write leaves, which readers swallowed as {}.
+    def read_json(path)
+      return {} unless File.exist?(path)
+
+      raw = File.read(path)
+      raw.empty? ? {} : JSON.parse(raw)
+    end
+
+    def atomic_write(path, payload)
+      tmp = "#{path}.tmp"
+      File.write(tmp, payload)
+      File.rename(tmp, path)
+    end
+
+    # The lock sits on a sidecar file, not on the state file: the state file is
+    # replaced by rename, so a lock held on the inode it had before the write
+    # would exclude nobody afterwards.
+    def with_lock(path)
+      File.open("#{path}.lock", File::RDWR | File::CREAT) do |f|
+        lock_exclusive!(f)
+        yield
+      end
+    end
+
     # Acquire an exclusive lock without blocking forever. Retries the
     # non-blocking flock until @lock_timeout elapses, then raises so the caller
     # fails fast instead of pinning a worker on a stuck holder.

data/app/services/mbeditor/exclusion_matcher.rb

@@ -87,24 +87,26 @@ module Mbeditor
     # case is folded. Defaults to the resolved workspace root.
     def initialize(patterns, root: nil)
       @fold_case = self.class.case_insensitive_filesystem?(root || WorkspaceRootResolver.call)
-      @patterns  = patterns.map { |pattern| normalize(pattern.to_s) }.reject(&:empty?)
+      normalized = patterns.map { |pattern| normalize(pattern.to_s) }.reject(&:empty?)
+      # Split by shape once: a path pattern is compared against the whole
+      # relative path, a bare name against its segments. This runs per file of
+      # a workspace walk, so neither the split nor the basename belongs in the
+      # per-pattern loop.
+      @path_patterns, @name_patterns = normalized.partition { |pattern| pattern.include?("/") }
     end
 
     def excluded?(relative_path)
       rel = normalize(relative_path.to_s)
-      @patterns.any? { |pattern| matches?(pattern, rel) }
+      return true if @path_patterns.any? { |pattern| rel == pattern || rel.start_with?("#{pattern}/") }
+      return false if @name_patterns.empty?
+
+      segments = rel.split("/")
+      basename = File.basename(rel)
+      @name_patterns.any? { |pattern| basename == pattern || segments.include?(pattern) }
     end
 
     private
 
-    def matches?(pattern, rel)
-      if pattern.include?("/")
-        rel == pattern || rel.start_with?("#{pattern}/")
-      else
-        File.basename(rel) == pattern || rel.split("/").include?(pattern)
-      end
-    end
-
     # "/" is ASCII and survives both steps, so the caller can normalize a whole
     # path in one pass and split it afterwards.
     def normalize(str)

data/app/services/mbeditor/file_operation_service.rb

@@ -18,7 +18,7 @@ module Mbeditor
     def save(path, content)
       raise FileTooLargeError if content.bytesize > MAX_FILE_SIZE_BYTES
 
-      File.write(path, content)
+      atomic_write(path, content)
       { ok: true, path: relative_path(path) }
     end
 
@@ -36,10 +36,15 @@ module Mbeditor
 
     def rename(old_path, new_path)
       raise PathNotFoundError unless File.exist?(old_path)
-      raise TargetExistsError if File.exist?(new_path)
+      # A case-only rename on a case-insensitive filesystem (macOS) reports the
+      # target as existing because it IS the source.
+      same_file = File.identical?(old_path, new_path)
+      raise TargetExistsError if File.exist?(new_path) && !same_file
 
       FileUtils.mkdir_p(File.dirname(new_path))
-      FileUtils.mv(old_path, new_path)
+      # FileUtils.mv refuses a "same file" move, so the case-only rename goes
+      # straight to rename(2); everything else keeps mv's cross-device fallback.
+      same_file ? File.rename(old_path, new_path) : FileUtils.mv(old_path, new_path)
       { ok: true, oldPath: relative_path(old_path), path: relative_path(new_path), name: File.basename(new_path) }
     end
 
@@ -61,6 +66,36 @@ module Mbeditor
 
     private
 
+    # Write through a temp file in the same directory and rename over the
+    # target: a truncate-then-write loses the file outright if the process dies
+    # mid-save. The symlink is resolved first — renaming onto the link itself
+    # would replace it with a regular file, and linked-in files are supported.
+    def atomic_write(path, content)
+      target = link_target(path)
+      tmp = File.join(File.dirname(target), ".#{File.basename(target)}.mbeditor-tmp")
+      mode = File.stat(target).mode & 0o7777 if File.exist?(target)
+      File.write(tmp, content)
+      File.chmod(mode, tmp) if mode
+      File.rename(tmp, target)
+    rescue StandardError
+      FileUtils.rm_f(tmp) if tmp
+      raise
+    end
+
+    def link_target(path)
+      return path.to_s unless File.symlink?(path)
+
+      begin
+        File.realpath(path)
+      rescue SystemCallError
+        # realpath refuses a dangling link, but a save through one still has to
+        # create the file it names — the same thing File.write did.
+        File.expand_path(File.readlink(path), File.dirname(path))
+      end
+    rescue SystemCallError
+      path.to_s
+    end
+
     def relative_path(path)
       Pathname(path).relative_path_from(@workspace_root).to_s
     end

data/app/services/mbeditor/file_tree_service.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "digest"
+
 module Mbeditor
   class FileTreeService
     MUTEX = Mutex.new
@@ -26,6 +28,26 @@ module Mbeditor
       data
     end
 
+    # The tree already serialized, plus a digest of that body, memoized inside
+    # the same cache entry. /files is polled every 10s and the payload is ~1 MB,
+    # so the digest is what turns an unchanged poll into a 304.
+    def self.cached_json(workspace_root)
+      root = workspace_root.to_s
+      data = build(root)
+
+      MUTEX.synchronize do
+        entry = (@cache ||= {})[root]
+        return entry[:json] if entry && entry[:json] && entry[:data].equal?(data)
+
+        # to_json, not JSON.generate: `render json:` used ActiveSupport's
+        # encoder, and the body must stay byte-identical.
+        body = data.to_json
+        payload = { body: body, digest: Digest::SHA1.hexdigest(body) }
+        entry[:json] = payload if entry
+        payload
+      end
+    end
+
     def self.invalidate(workspace_root)
       MUTEX.synchronize do
         @cache ||= {}
@@ -49,14 +71,20 @@ module Mbeditor
         rel  = "" if rel == workspace_root
         is_excl = matcher.excluded?(rel)
 
-        if File.directory?(full) && !File.symlink?(full)
+        # One lstat instead of directory?/symlink?/size — three stats per entry
+        # over a whole tree. lstat does not follow, so a symlink is never a
+        # folder here, exactly as the directory?-and-not-symlink? test intended;
+        # a symlinked file still reports its *target's* size, as it always did.
+        st = (File.lstat(full) rescue nil)
+
+        if st&.directory?
           children = is_excl ? [] : traverse(full, workspace_root, matcher, max_depth: max_depth, depth: depth + 1)
           node = { name: name, type: "folder", path: rel, children: children }
           node[:excluded] = true if is_excl
           node
         else
           node = { name: name, type: "file", path: rel }
-          node[:size] = (File.size(full) rescue nil) unless is_excl
+          node[:size] = ((st&.symlink? ? File.size(full) : st&.size) rescue nil) unless is_excl
           node[:excluded] = true if is_excl
           node
         end

data/app/services/mbeditor/git_combined_diff_service.rb

@@ -33,17 +33,27 @@ module Mbeditor
     private
 
     def local_diff
-      out, status = GitService.run_git(repo_path, "diff", "HEAD")
+      out, status = git_diff("HEAD")
       status.success? ? cap_diff(out) : ""
     end
 
+    # --no-color/--no-ext-diff on every invocation: a host gitconfig with
+    # color.ui = always, or a diff.external driver, otherwise feeds escape
+    # codes or foreign output into the viewer's parser. max_bytes stops a
+    # pathological diff being fully materialised just for cap_diff to throw
+    # most of it away.
+    def git_diff(*revs)
+      GitService.run_git(repo_path, "diff", "--no-color", "--no-ext-diff", *revs,
+                         max_bytes: MAX_DIFF_BYTES)
+    end
+
     def branch_diff
       branch = GitService.current_branch(repo_path)
       base_sha, ref = GitService.find_branch_base(repo_path, branch)
 
       if base_sha.present?
         @base_ref = ref
-        out, status = GitService.run_git(repo_path, "diff", "#{base_sha}..HEAD")
+        out, status = git_diff("#{base_sha}..HEAD")
         return status.success? ? cap_diff(out) : ""
       end
 
@@ -56,7 +66,7 @@ module Mbeditor
       upstream = GitService.upstream_branch(repo_path)
       if GitService.base_branch?(branch) && upstream.present?
         @base_ref = upstream
-        out, status = GitService.run_git(repo_path, "diff", "#{upstream}..HEAD")
+        out, status = git_diff("#{upstream}..HEAD")
         return status.success? ? cap_diff(out) : ""
       end
 

data/app/services/mbeditor/git_commit_detail_service.rb

@@ -11,21 +11,33 @@ module Mbeditor
       @sha       = sha.to_s
     end
 
+    EMPTY = { "title" => "", "author" => "", "date" => "", "files" => [] }.freeze
+    private_constant :EMPTY
+
+    # Two spawns per commit click, not three: `git show --name-status` prints
+    # the pretty header then the raw name-status body. The numstat still needs
+    # its own call — asking for --name-status and --numstat together makes git
+    # emit only the former. --no-renames keeps a rename as the D+A pair the
+    # two-field parse below expects, rather than a three-field R100 record.
     def call
-      meta = fetch_meta
-      { "sha" => sha, "title" => meta["title"], "author" => meta["author"], "date" => meta["date"], "files" => fetch_files }
+      out, status = GitService.run_git(repo_path, "show", "--no-color", "--no-renames", "--name-status",
+                                       "--pretty=format:%s%x1f%an%x1f%aI", "--end-of-options", sha)
+      return EMPTY.merge("sha" => sha) unless status.success?
+
+      header, body = out.split("\n", 2)
+      fields = header.to_s.split("\x1f", 3)
+      { "sha" => sha, "title" => fields[0].to_s, "author" => fields[1].to_s, "date" => fields[2].to_s,
+        "files" => parse_files(body.to_s) }
     end
 
     private
 
-    def fetch_files
-      name_out, name_st = GitService.run_git(repo_path, "diff-tree", "--no-commit-id", "-r", "--name-status", sha)
-      return [] unless name_st.success?
-
-      num_out, num_st = GitService.run_git(repo_path, "diff-tree", "--no-commit-id", "-r", "--numstat", sha)
+    def parse_files(body)
+      num_out, num_st = GitService.run_git(repo_path, "show", "--no-color", "--no-renames", "--numstat",
+                                           "--pretty=format:", "--end-of-options", sha)
       numstat = num_st.success? ? GitService.parse_numstat(num_out) : {}
 
-      name_out.lines.filter_map do |line|
+      body.lines.filter_map do |line|
         parts = line.strip.split("\t", 2)
         next if parts.length < 2
 
@@ -34,13 +46,5 @@ module Mbeditor
         { "status" => parts[0].strip, "path" => path, "added" => stats[:added], "removed" => stats[:removed] }
       end
     end
-
-    def fetch_meta
-      out, status = GitService.run_git(repo_path, "log", "-1", "--pretty=format:%s%x1f%an%x1f%aI", sha)
-      return { "title" => "", "author" => "", "date" => "" } unless status.success?
-
-      fields = out.strip.split("\x1f", 3)
-      { "title" => fields[0].to_s, "author" => fields[1].to_s, "date" => fields[2].to_s }
-    end
   end
 end

data/app/services/mbeditor/git_diff_service.rb

@@ -53,8 +53,12 @@ module Mbeditor
     end
 
     # Return the file content at a given git ref, or "" if it doesn't exist.
+    #
+    # --end-of-options (git >= 2.24, safely assumable for dev tooling) stops the
+    # rev being read as a command-line option, e.g. `--output=/tmp/x`, on top of
+    # the caller-side ref validation.
     def file_at_ref(ref, path)
-      out, status = GitService.run_git(repo_path, "show", "#{ref}:#{path}")
+      out, status = GitService.run_git(repo_path, "show", "--end-of-options", "#{ref}:#{path}")
       return "" unless status.success?
 
       out

data/app/services/mbeditor/git_info_service.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "timeout"
+
 module Mbeditor
   module GitInfoService
     module_function
@@ -16,19 +18,26 @@ module Mbeditor
       cached = cached_git_info(repo_path)
       return cached if cached
 
-      owner = nil
+      flight = nil
       GIT_INFO_MUTEX.synchronize do
         @git_info_flights ||= {}
-        owner = @git_info_flights[repo_path]
-        @git_info_flights[repo_path] = Thread.current unless owner
+        flight = @git_info_flights[repo_path]
+        @git_info_flights[repo_path] = Queue.new unless flight
       end
 
-      if owner
+      if flight
         # Another thread is already running the fan-out; don't duplicate it.
         stale = stale_git_info(repo_path)
         return stale if stale
 
-        owner.join(CACHE_TTL)
+        # The owner closes this queue when it is done, which releases every
+        # waiter at once. Waiting on the owner *thread* was the old mechanism,
+        # but a Puma pool thread never exits, so join always ran to CACHE_TTL.
+        begin
+          Timeout.timeout(CACHE_TTL) { flight.pop }
+        rescue Timeout::Error
+          nil
+        end
         return cached_git_info(repo_path) || stale_git_info(repo_path) ||
                { ok: false, error: "git info computation in progress" }
       end
@@ -36,7 +45,8 @@ module Mbeditor
       begin
         compute(repo_path)
       ensure
-        GIT_INFO_MUTEX.synchronize { @git_info_flights.delete(repo_path) }
+        done = GIT_INFO_MUTEX.synchronize { @git_info_flights.delete(repo_path) }
+        done&.close
       end
     end
 
@@ -47,8 +57,10 @@ module Mbeditor
       end
 
       # Wave 1: all independent git reads run in parallel
-      status_t   = Thread.new { safe_git(repo_path, "status", "--porcelain") }
-      numstat_t  = Thread.new { safe_git(repo_path, "diff", "--numstat", "HEAD") }
+      # -z on both: it is the only form that leaves paths with spaces or
+      # non-ASCII bytes unquoted, and the two lists are paired by path below.
+      status_t   = Thread.new { safe_git(repo_path, "status", "--porcelain", "-z") }
+      numstat_t  = Thread.new { safe_git(repo_path, "diff", "--numstat", "-z", "HEAD") }
       upstream_t = Thread.new { safe_git(repo_path, "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}") }
       base_t     = Thread.new { GitService.find_branch_base(repo_path, branch) }
 

data/app/services/mbeditor/git_line_diff_service.rb

@@ -32,11 +32,15 @@ module Mbeditor
     end
 
     def call
-      return untracked_result if untracked?
-
       output, status = GitService.run_git(
         repo_path, "diff", "--no-color", "--no-ext-diff", "-U0", "HEAD", "--", file_path
       )
+
+      # ls-files only distinguishes "no changes" from "never tracked", so it
+      # runs solely when the diff produced nothing. Asking first doubled the
+      # subprocess count on a path the editor polls every 10s.
+      return untracked_result if (!status.success? || output.empty?) && untracked?
+
       # A non-zero status here means the diff could not be produced at all (no
       # HEAD yet, path outside the repo). Report a clean file rather than
       # raising: line colouring is decoration, never a reason to fail a load.

data/app/services/mbeditor/git_service.rb

@@ -10,17 +10,19 @@ module Mbeditor
     module_function
 
     # Safe pattern for git ref names (branch, remote/branch, tag).
-    # Excludes @ to prevent reflog syntax like @{-1} or @{u}.
-    SAFE_GIT_REF = %r{\A[\w./-]+\z}
+    # Excludes @ to prevent reflog syntax like @{-1} or @{u}, and a leading -
+    # so a ref can never be read as a command-line option by the git it is
+    # interpolated into.
+    SAFE_GIT_REF = %r{\A(?!-)[\w./-]+\z}
 
     # Run an arbitrary git command inside +repo_path+.
     # Returns [stdout, Process::Status]. stderr is discarded to prevent git
     # diagnostic messages from leaking into the Rails server log.
     # Honors config.git_timeout (seconds) when set.
-    def run_git(repo_path, *args)
+    def run_git(repo_path, *args, max_bytes: nil)
       timeout_secs = Mbeditor.configuration.git_timeout&.to_i
       timeout = timeout_secs && timeout_secs > 0 ? timeout_secs : nil
-      result = ProcessRunner.call(["git", "-C", repo_path, *args], timeout: timeout)
+      result = ProcessRunner.call(["git", "-C", repo_path, *args], timeout: timeout, max_bytes: max_bytes)
       [result[:stdout], result[:exit_status]]
     rescue ProcessRunner::TimeoutError
       raise Timeout::Error, "git timed out after #{timeout_secs}s"
@@ -70,12 +72,18 @@ module Mbeditor
     def find_branch_base(repo_path, current_branch, candidates: nil)
       candidates ||= Mbeditor.configuration.base_branch_candidates
 
+      # One listing instead of a rev-parse per candidate: with six defaults
+      # that was up to twelve sequential spawns on a path the git panel polls.
+      refs_out, refs_st = run_git(repo_path, "for-each-ref", "--format=%(refname:short)",
+                                  "refs/heads", "refs/remotes")
+      return [nil, nil] unless refs_st.success?
+
+      existing = refs_out.split("\n").map(&:strip)
+
       candidates.each do |ref|
         short = ref.delete_prefix("origin/")
         next if short == current_branch || ref == current_branch
-
-        _o, st = run_git(repo_path, "rev-parse", "--verify", "--quiet", ref)
-        next unless st.success?
+        next unless existing.include?(ref)
 
         base_out, base_st = run_git(repo_path, "merge-base", "HEAD", ref)
         next unless base_st.success?
@@ -101,17 +109,34 @@ module Mbeditor
       candidates.any? { |ref| ref == current_branch || ref.delete_prefix("origin/") == current_branch }
     end
 
-    # Parse `git status --porcelain` output.
+    # Parse `git status --porcelain` output, in either the newline form or the
+    # NUL-delimited `-z` form.
+    #
+    # Only `-z` gives usable paths: without it git quotes anything containing a
+    # space or a non-ASCII byte (`"caf\303\251.rb"`) and writes a rename as
+    # `old -> new`, so the path came back unopenable and never matched numstat.
+    # In `-z` a rename/copy spans two records and the NEW name comes first.
+    #
     # Returns Array of { status: String, path: String }.
     def parse_porcelain_status(output)
-      output.lines.filter_map do |line|
-        next if line.length < 4
-
-        path = line[3..].to_s.strip
+      nul = output.include?("\0")
+      records = nul ? output.split("\0") : output.lines.map(&:chomp)
+
+      result = []
+      i = 0
+      while i < records.length
+        record = records[i]
+        i += 1
+        next if record.length < 4
+
+        status = record[0..1].strip
+        i += 1 if nul && status.start_with?("R", "C") # skip the old name
+        path = nul ? record[3..].to_s : record[3..].to_s.strip
         next if path.blank?
 
-        { status: line[0..1].strip, path: path }
+        result << { status: status, path: path }
       end
+      result
     end
 
     # Parse `git diff --name-status` output.
@@ -129,10 +154,15 @@ module Mbeditor
       end
     end
 
-    # Parse `git diff --numstat` output.
+    # Parse `git diff --numstat` output, in either the newline form or the
+    # NUL-delimited `-z` form (which is what pairs with `status --porcelain -z`,
+    # since only it leaves non-ASCII paths unquoted).
     # Returns Hash of path => { added: Integer, removed: Integer }.
     def parse_numstat(output)
-      (output || "").lines.each_with_object({}) do |line, map|
+      out = (output || "")
+      return parse_numstat_z(out) if out.include?("\0")
+
+      out.lines.each_with_object({}) do |line, map|
         parts = line.strip.split("\t", 3)
         next if parts.length < 3 || parts[0] == "-"
 
@@ -140,6 +170,26 @@ module Mbeditor
       end
     end
 
+    # In `-z` form a rename leaves the path field empty and follows the record
+    # with the old name then the new name, each NUL-terminated.
+    def parse_numstat_z(output)
+      records = output.split("\0")
+      map = {}
+      i = 0
+      while i < records.length
+        added, removed, path = records[i].split("\t", 3)
+        i += 1
+        if path.to_s.empty?
+          path = records[i + 1]
+          i += 2
+        end
+        next if path.nil? || added == "-"
+
+        map[path] = { added: added.to_i, removed: removed.to_i }
+      end
+      map
+    end
+
     # Parse compact `git log --pretty=format:%H%x1f%P%x1f%s%x1f%an%x1f%aI%x1e` output.
     # Returns Array of hashes with string keys.
     def self.parse_git_log_with_parents(raw_output)

data/app/services/mbeditor/js_definition_service.rb

@@ -27,6 +27,8 @@ module Mbeditor
       @symbol         = symbol.to_s
       @workspace_root = workspace_root.to_s.chomp("/")
       @parent         = parent.to_s.empty? ? nil : parent.to_s
+      # Compiled once: top_level? runs on every parsed result line.
+      @window_assign  = /\Awindow\.#{Regexp.escape(@symbol)}\s*=/
     end
 
     def call
@@ -126,7 +128,7 @@ module Mbeditor
     # top-level by grammar.
     def top_level?(indent, snippet)
       return true if indent.empty?
-      return true if snippet.match?(/\Awindow\.#{Regexp.escape(@symbol)}\s*=/)
+      return true if snippet.match?(@window_assign)
       return true if snippet.start_with?("export ")
 
       false

data/app/services/mbeditor/js_globals_service.rb

@@ -22,6 +22,17 @@ module Mbeditor
 
     IDENTIFIER = /[A-Za-z_$][A-Za-z0-9_$]*/
 
+    # Runtime globals no static scan can reach, for the same reason React and
+    # lodash can't be reached: a UMD bundle assigns its name through a closure
+    # parameter. react-rails ships `root["ReactRailsUJS"] = factory()` in the
+    # *gem's* lib/assets/javascripts/react_ujs.js — outside the workspace, so
+    # it is never scanned, and bracket-assigned to a parameter, so widening
+    # PATTERN to `IDENT["Str"] =` would not help and would declare thousands
+    # of junk names out of every minified bundle. Seeded like
+    # js_global_identifiers, so both consumers (the TS worker's ambient
+    # declarations and the babel scope lint's whitelist) get them.
+    KNOWN_RUNTIME_GLOBALS = %w[ReactRailsUJS].freeze
+
     # Minified bundles are the reason for both guards below.
     #
     # A minified file is one enormous line, and it usually opens with a
@@ -67,6 +78,13 @@ module Mbeditor
         symbols = {}
         truncated = false
 
+        # Seeded first so the cap can never drop them: they are the names the
+        # host app declared it needs, and appending them after the scan meant
+        # first(MAX_SYMBOLS) silently discarded every one on a big workspace.
+        (KNOWN_RUNTIME_GLOBALS + configured_identifiers).each do |name|
+          symbols[name] = { name: name, file: nil, line: nil, kind: "configured" }
+        end
+
         CodeSearchService.call(PATTERN, root).each do |raw|
           if symbols.length >= MAX_SYMBOLS
             truncated = true
@@ -90,10 +108,6 @@ module Mbeditor
           end
         end
 
-        configured_identifiers.each do |name|
-          symbols[name] ||= { name: name, file: nil, line: nil, kind: "configured" }
-        end
-
         {
           ok: true,
           generatedAt: Time.now.to_i,