mbeditor 0.12.8 → 0.13.0

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

@@ -67,6 +67,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.
+        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 +97,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,

data/app/services/mbeditor/js_members_service.rb

@@ -18,6 +18,8 @@ module Mbeditor
     def initialize(symbol, workspace_root)
       @symbol         = symbol.to_s
       @workspace_root = workspace_root.to_s.chomp("/")
+      # Compiled once: this is matched against every line of search output.
+      @member_regex   = /#{Regexp.escape(@symbol)}\.(?:prototype\.)?([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=/
     end
 
     def call
@@ -50,8 +52,7 @@ module Mbeditor
         snippet  = m[3].strip
         next unless abs_path.start_with?(@workspace_root)
 
-        s = Regexp.escape(@symbol)
-        member_match = snippet.match(/#{s}\.(?:prototype\.)?([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=/)
+        member_match = snippet.match(@member_regex)
         next unless member_match
 
         name = member_match[1]

data/app/services/mbeditor/js_program_service.rb

@@ -83,8 +83,8 @@ module Mbeditor
         skipped = []
         total   = 0
 
-        each_candidate(root) do |rel, abs|
-          if File.size(abs) > MAX_FILE_BYTES
+        each_candidate(root) do |rel, abs, stat|
+          if stat.size > MAX_FILE_BYTES
             skipped << { path: rel, reason: "larger than #{MAX_FILE_BYTES} bytes" }
             next
           end
@@ -127,12 +127,16 @@ module Mbeditor
             abs = File.join(dir, name)
             rel = abs.delete_prefix(root).delete_prefix("/")
             next if m.excluded?(rel)
-            next if File.symlink?(abs)
 
-            if File.directory?(abs)
+            # One lstat answers symlink?, directory? and size — and lstat is
+            # exactly right here, since a symlink must not be followed.
+            stat = lstat(abs)
+            next if stat.nil? || stat.symlink?
+
+            if stat.directory?
               stack.push(abs)
             elsif name.match?(SOURCE_EXT) && !name.match?(MINIFIED_NAME)
-              yield rel, abs
+              yield rel, abs, stat
             end
           end
         end
@@ -144,6 +148,12 @@ module Mbeditor
         []
       end
 
+      def lstat(abs)
+        File.lstat(abs)
+      rescue SystemCallError
+        nil
+      end
+
       def matcher(root)
         ExclusionMatcher.new(exclusion_patterns, root: root)
       end

data/app/services/mbeditor/js_syntax_check_service.rb

@@ -218,6 +218,12 @@ module Mbeditor
       def scope_lint(workspace_root, source)
         return [] unless available? && Mbeditor.configuration.js_scope_lint != false
 
+        # Gathered before taking MUTEX: both walk the workspace under their own
+        # locks, and holding this one across them serialises every JS save
+        # behind whichever save is rebuilding the program.
+        program = JsProgramService.call(workspace_root.to_s)
+        globals = JsGlobalsService.call(workspace_root.to_s)
+
         MUTEX.synchronize do
           begin
             ctx = context
@@ -227,7 +233,7 @@ module Mbeditor
             @lint_helpers_loaded = true
             return [] unless ctx.eval("typeof __mbLint !== 'undefined'")
 
-            names = whitelist(ctx, workspace_root)
+            names = whitelist(ctx, program, globals)
             findings = ctx.eval("__mbLint.lint(#{source.to_json}, #{names.to_json}, #{MAX_SCOPE_FINDINGS})")
 
             @checks_run = (@checks_run || 0) + 1
@@ -268,6 +274,13 @@ module Mbeditor
       end
 
       def reset_context!
+        # Dropping the reference leaks the V8 isolate until the GC finalizer
+        # runs; dispose releases it now.
+        begin
+          @context&.dispose
+        rescue StandardError
+          nil
+        end
         @context = nil
         @checks_run = 0
         @lint_helpers_loaded = false
@@ -278,12 +291,11 @@ module Mbeditor
       # plus the browser and React layers. Per-file declaration names are
       # cached by content digest, so a steady-state save re-parses only the
       # files that changed since the last lint.
-      def whitelist(ctx, workspace_root)
+      def whitelist(ctx, program, globals)
         names = []
         @decl_cache ||= {}
         live = {}
 
-        program = JsProgramService.call(workspace_root.to_s)
         Array(program[:files]).each do |f|
           digest = f[:content].hash
           entry = @decl_cache[f[:path]]
@@ -293,7 +305,6 @@ module Mbeditor
         end
         @decl_cache = live
 
-        globals = JsGlobalsService.call(workspace_root.to_s)
         names.concat(Array(globals[:symbols]).map { |s| s[:name].to_s })
 
         (names + BROWSER_GLOBALS + REACT_GLOBALS).uniq

data/app/services/mbeditor/process_runner.rb

@@ -8,7 +8,13 @@ module Mbeditor
 
     class TimeoutError < StandardError; end
 
-    def call(cmd, timeout: nil, env: {}, stdin_data: nil, chdir: nil)
+    CHUNK_BYTES = 64 * 1024
+    private_constant :CHUNK_BYTES
+
+    # +max_bytes+ bounds how much of each stream is kept in memory (nil =
+    # unbounded). Anything past the cap is still read and discarded — stopping
+    # would block the child on a full pipe and hang the wait below.
+    def call(cmd, timeout: nil, env: {}, stdin_data: nil, chdir: nil, max_bytes: nil)
       out = +""
       err = +""
       exit_status = nil
@@ -21,28 +27,52 @@ module Mbeditor
         stdin.write(stdin_data) if stdin_data
         stdin.close
 
-        timer = if timeout
-          Thread.new do
-            sleep timeout
-            timed_out = true
-            Process.kill("-KILL", wait_thr.pid)
-          rescue Errno::ESRCH
-            nil
+        out_thread = Thread.new { out = read_capped(stdout, max_bytes) }
+        err_thread = Thread.new { err = read_capped(stderr, max_bytes) }
+
+        # A deadline join rather than a timer thread: a timer racing normal
+        # exit could flag a timeout (and SIGKILL a recycled pid) after the
+        # process had already succeeded. The reader threads above keep the
+        # pipes drained meanwhile, so this cannot deadlock.
+        if timeout
+          deadline  = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+          timed_out = !wait_thr.join(timeout)
+
+          # A grandchild that inherited the pipe holds it open after the child
+          # exits, so the unbounded joins below could outlive the process
+          # itself. Bound them by the same deadline the timer thread enforced.
+          remaining = [deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC), 0].max
+          overrun   = !out_thread.join(remaining) || !err_thread.join(remaining)
+
+          if timed_out || overrun
+            begin
+              Process.kill("-KILL", wait_thr.pid)
+            rescue Errno::ESRCH
+              nil
+            end
           end
         end
 
-        out_thread = Thread.new { out = stdout.read }
-        err_thread = Thread.new { err = stderr.read }
         out_thread.join
         err_thread.join
-
         exit_status = wait_thr.value
-        timer&.kill
       end
 
       raise TimeoutError, "process timed out after #{timeout}s" if timed_out
 
       { stdout: out, stderr: err, exit_status: exit_status }
     end
+
+    def read_capped(io, max_bytes)
+      return io.read.to_s unless max_bytes
+
+      buf = +""
+      while (chunk = io.read(CHUNK_BYTES))
+        buf << chunk if buf.bytesize < max_bytes
+      end
+      # IO#read with a length returns binary; IO#read without one applies the
+      # default external encoding, and callers expect the latter.
+      buf.force_encoding(Encoding.default_external)
+    end
   end
 end

data/app/services/mbeditor/ri_definition_service.rb

@@ -30,6 +30,10 @@ module Mbeditor
       Struct Set Time File IO Exception Proc Method NilClass
     ].freeze
 
+    # Keyed by symbol, so a long session accumulates one entry per name ever
+    # hovered. Cleared wholesale at the cap — the next lookups just re-run ri.
+    MAX_CACHE_ENTRIES = 500
+
     @cache = {}
     @mutex = Mutex.new
 
@@ -39,7 +43,10 @@ module Mbeditor
         return cached unless cached.nil?
 
         result = new(symbol).call
-        @mutex.synchronize { @cache[symbol] = result }
+        @mutex.synchronize do
+          @cache.clear if @cache.size >= MAX_CACHE_ENTRIES
+          @cache[symbol] = result
+        end
         result
       end